Core Dump Stack Trace via Function Fingerprints
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for generating stack traces during program termination require debugging symbols, which are large and often not available at the time of termination, leading to slow downloads and potential security risks when uploading core dumps.
Innovation Solution
A core dump-level stack trace mechanism that generates a fingerprint of functions from a recorded program state without using debugging symbols, allowing for identification of duplicate termination causes on both client and server sides, thus avoiding the need for large symbol downloads and sensitive data transmission.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If debugging symbols are downloaded to generate stack traces, then stack trace generation is enabled, but network bandwidth is consumed and time is lost during download
Solution Approach 1:
The system pre-generates and stores function fingerprints in the binary executable file during the compilation or linking phase, before the program runs. This preliminary action eliminates the need to download debugging symbols later, as the essential identification data is already embedded in the executable.
Solution Approach 2:
The invention extracts only the essential function identification information (fingerprints) from the full debugging symbols and embeds it directly into the binary. This extraction approach retains the necessary functionality for stack trace generation while removing the bulk of the symbol data that would consume network bandwidth and download time.
2Reliability
If core dumps are uploaded for analysis, then termination analysis is enabled, but sensitive information may be transmitted
Solution Approach 1:
The system extracts only the function fingerprint information from the core dump and transmits this minimal data for analysis. This extraction eliminates sensitive information from the transmission while retaining the essential data needed for termination cause identification, thus resolving the security concern.
Solution Approach 2:
Instead of transmitting the actual core dump containing sensitive data, the system creates and transmits a simplified copy containing only function fingerprints. This copy serves the analysis purpose without exposing sensitive information that would be present in a full core dump.
3Productivity
If debugging symbols are distributed with program binaries, then stack trace generation is immediate, but the distribution package size increases significantly
Solution Approach 1:
The invention extracts only the essential function identification data (fingerprints) from the complete debugging symbols and embeds it in the binary. This extraction reduces the size of distributed packages from megabytes or gigabytes to much smaller embedded structures, while maintaining immediate stack trace generation capability.
Solution Approach 2:
The function fingerprints embedded in the binary serve multiple purposes: they enable stack trace generation, support termination analysis, and provide function identification without requiring separate debugging symbol files. This multi-functionality eliminates the need for large separate symbol distributions.
Data Source
AI summary
A system and a method for providing a core dump-level stack trace. In one example, the method includes receiving, by a processing device, a recorded state of a program, the recorded state including a base address of the program and a stack frame including an executable address for a call instruction of a function of the program; determining, by the processing device, a list of functions in view of the recorded state of the program, and creating, by the processing device, a stack trace in view of the list of functions without using debugging symbols.