| // Copyright (c) 2010 Google Inc. |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| // crash_report.mm: Convert the contents of a minidump into a format that |
| // looks more like Apple's CrashReporter format |
| |
| #include <unistd.h> |
| |
| #include <mach/machine.h> |
| #include <mach-o/arch.h> |
| |
| #include <string> |
| |
| #include <Foundation/Foundation.h> |
| |
| #include "common/scoped_ptr.h" |
| #include "google_breakpad/processor/basic_source_line_resolver.h" |
| #include "google_breakpad/processor/call_stack.h" |
| #include "google_breakpad/processor/code_module.h" |
| #include "google_breakpad/processor/minidump.h" |
| #include "google_breakpad/processor/minidump_processor.h" |
| #include "google_breakpad/processor/process_state.h" |
| #include "google_breakpad/processor/stack_frame_cpu.h" |
| #include "google_breakpad/processor/system_info.h" |
| #include "processor/pathname_stripper.h" |
| #include "processor/simple_symbol_supplier.h" |
| |
| #include "on_demand_symbol_supplier.h" |
| |
| using std::string; |
| |
| using google_breakpad::BasicSourceLineResolver; |
| using google_breakpad::CallStack; |
| using google_breakpad::CodeModule; |
| using google_breakpad::CodeModules; |
| using google_breakpad::Minidump; |
| using google_breakpad::MinidumpProcessor; |
| using google_breakpad::OnDemandSymbolSupplier; |
| using google_breakpad::PathnameStripper; |
| using google_breakpad::ProcessState; |
| using google_breakpad::scoped_ptr; |
| using google_breakpad::StackFrame; |
| using google_breakpad::StackFramePPC; |
| using google_breakpad::StackFrameX86; |
| using google_breakpad::SystemInfo; |
| |
| typedef struct { |
| NSString *minidumpPath; |
| NSString *searchDir; |
| NSString *symbolSearchDir; |
| BOOL printThreadMemory; |
| } Options; |
| |
| //============================================================================= |
| static int PrintRegister(const char *name, u_int32_t value, int sequence) { |
| if (sequence % 4 == 0) { |
| printf("\n"); |
| } |
| printf("%6s = 0x%08x ", name, value); |
| return ++sequence; |
| } |
| |
| //============================================================================= |
| static void PrintStack(const CallStack *stack, const string &cpu) { |
| size_t frame_count = stack->frames()->size(); |
| char buffer[1024]; |
| for (size_t frame_index = 0; frame_index < frame_count; ++frame_index) { |
| const StackFrame *frame = stack->frames()->at(frame_index); |
| const CodeModule *module = frame->module; |
| printf("%2zu ", frame_index); |
| |
| if (module) { |
| // Module name (20 chars max) |
| strcpy(buffer, PathnameStripper::File(module->code_file()).c_str()); |
| int maxStr = 20; |
| buffer[maxStr] = 0; |
| printf("%-*s", maxStr, buffer); |
| |
| strcpy(buffer, module->version().c_str()); |
| buffer[maxStr] = 0; |
| |
| printf("%-*s",maxStr, buffer); |
| |
| u_int64_t instruction = frame->instruction; |
| |
| // PPC only: Adjust the instruction to match that of Crash reporter. The |
| // instruction listed is actually the return address. See the detailed |
| // comments in stackwalker_ppc.cc for more information. |
| if (cpu == "ppc" && frame_index) |
| instruction += 4; |
| |
| printf(" 0x%08llx ", instruction); |
| |
| // Function name |
| if (!frame->function_name.empty()) { |
| printf("%s", frame->function_name.c_str()); |
| if (!frame->source_file_name.empty()) { |
| string source_file = PathnameStripper::File(frame->source_file_name); |
| printf(" + 0x%llx (%s:%d)", |
| instruction - frame->source_line_base, |
| source_file.c_str(), frame->source_line); |
| } else { |
| printf(" + 0x%llx", instruction - frame->function_base); |
| } |
| } |
| } |
| printf("\n"); |
| } |
| } |
| |
| //============================================================================= |
| static void PrintRegisters(const CallStack *stack, const string &cpu) { |
| int sequence = 0; |
| const StackFrame *frame = stack->frames()->at(0); |
| if (cpu == "x86") { |
| const StackFrameX86 *frame_x86 = |
| reinterpret_cast<const StackFrameX86*>(frame); |
| |
| if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_EIP) |
| sequence = PrintRegister("eip", frame_x86->context.eip, sequence); |
| if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_ESP) |
| sequence = PrintRegister("esp", frame_x86->context.esp, sequence); |
| if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_EBP) |
| sequence = PrintRegister("ebp", frame_x86->context.ebp, sequence); |
| if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_EBX) |
| sequence = PrintRegister("ebx", frame_x86->context.ebx, sequence); |
| if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_ESI) |
| sequence = PrintRegister("esi", frame_x86->context.esi, sequence); |
| if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_EDI) |
| sequence = PrintRegister("edi", frame_x86->context.edi, sequence); |
| if (frame_x86->context_validity == StackFrameX86::CONTEXT_VALID_ALL) { |
| sequence = PrintRegister("eax", frame_x86->context.eax, sequence); |
| sequence = PrintRegister("ecx", frame_x86->context.ecx, sequence); |
| sequence = PrintRegister("edx", frame_x86->context.edx, sequence); |
| sequence = PrintRegister("efl", frame_x86->context.eflags, sequence); |
| } |
| } else if (cpu == "ppc") { |
| const StackFramePPC *frame_ppc = |
| reinterpret_cast<const StackFramePPC*>(frame); |
| |
| if ((frame_ppc->context_validity & StackFramePPC::CONTEXT_VALID_ALL) == |
| StackFramePPC::CONTEXT_VALID_ALL) { |
| sequence = PrintRegister("srr0", frame_ppc->context.srr0, sequence); |
| sequence = PrintRegister("srr1", frame_ppc->context.srr1, sequence); |
| sequence = PrintRegister("cr", frame_ppc->context.cr, sequence); |
| sequence = PrintRegister("xer", frame_ppc->context.xer, sequence); |
| sequence = PrintRegister("lr", frame_ppc->context.lr, sequence); |
| sequence = PrintRegister("ctr", frame_ppc->context.ctr, sequence); |
| sequence = PrintRegister("mq", frame_ppc->context.mq, sequence); |
| sequence = PrintRegister("vrsave", frame_ppc->context.vrsave, sequence); |
| |
| sequence = 0; |
| char buffer[5]; |
| for (int i = 0; i < MD_CONTEXT_PPC_GPR_COUNT; ++i) { |
| sprintf(buffer, "r%d", i); |
| sequence = PrintRegister(buffer, frame_ppc->context.gpr[i], sequence); |
| } |
| } else { |
| if (frame_ppc->context_validity & StackFramePPC::CONTEXT_VALID_SRR0) |
| sequence = PrintRegister("srr0", frame_ppc->context.srr0, sequence); |
| if (frame_ppc->context_validity & StackFramePPC::CONTEXT_VALID_GPR1) |
| sequence = PrintRegister("r1", frame_ppc->context.gpr[1], sequence); |
| } |
| } |
| |
| printf("\n"); |
| } |
| |
| static void PrintModules(const CodeModules *modules) { |
| if (!modules) |
| return; |
| |
| printf("\n"); |
| printf("Loaded modules:\n"); |
| |
| u_int64_t main_address = 0; |
| const CodeModule *main_module = modules->GetMainModule(); |
| if (main_module) { |
| main_address = main_module->base_address(); |
| } |
| |
| unsigned int module_count = modules->module_count(); |
| for (unsigned int module_sequence = 0; |
| module_sequence < module_count; |
| ++module_sequence) { |
| const CodeModule *module = modules->GetModuleAtSequence(module_sequence); |
| assert(module); |
| u_int64_t base_address = module->base_address(); |
| printf("0x%08llx - 0x%08llx %s %s%s %s\n", |
| base_address, base_address + module->size() - 1, |
| PathnameStripper::File(module->code_file()).c_str(), |
| module->version().empty() ? "???" : module->version().c_str(), |
| main_module != NULL && base_address == main_address ? |
| " (main)" : "", |
| module->code_file().c_str()); |
| } |
| } |
| |
| static void ProcessSingleReport(Options *options, NSString *file_path) { |
| string minidump_file([file_path fileSystemRepresentation]); |
| BasicSourceLineResolver resolver; |
| string search_dir = options->searchDir ? |
| [options->searchDir fileSystemRepresentation] : ""; |
| string symbol_search_dir = options->symbolSearchDir ? |
| [options->symbolSearchDir fileSystemRepresentation] : ""; |
| scoped_ptr<OnDemandSymbolSupplier> symbol_supplier( |
| new OnDemandSymbolSupplier(search_dir, symbol_search_dir)); |
| scoped_ptr<MinidumpProcessor> |
| minidump_processor(new MinidumpProcessor(symbol_supplier.get(), &resolver)); |
| ProcessState process_state; |
| scoped_ptr<Minidump> dump(new google_breakpad::Minidump(minidump_file)); |
| |
| if (!dump->Read()) { |
| fprintf(stderr, "Minidump %s could not be read\n", dump->path().c_str()); |
| return; |
| } |
| if (minidump_processor->Process(dump.get(), &process_state) != |
| google_breakpad::PROCESS_OK) { |
| fprintf(stderr, "MinidumpProcessor::Process failed\n"); |
| return; |
| } |
| |
| const SystemInfo *system_info = process_state.system_info(); |
| string cpu = system_info->cpu; |
| |
| // Convert the time to a string |
| u_int32_t time_date_stamp = process_state.time_date_stamp(); |
| struct tm timestruct; |
| gmtime_r(reinterpret_cast<time_t*>(&time_date_stamp), ×truct); |
| char timestr[20]; |
| strftime(timestr, 20, "%Y-%m-%d %H:%M:%S", ×truct); |
| printf("Date: %s GMT\n", timestr); |
| |
| printf("Operating system: %s (%s)\n", system_info->os.c_str(), |
| system_info->os_version.c_str()); |
| printf("Architecture: %s\n", cpu.c_str()); |
| |
| if (process_state.crashed()) { |
| printf("Crash reason: %s\n", process_state.crash_reason().c_str()); |
| printf("Crash address: 0x%llx\n", process_state.crash_address()); |
| } else { |
| printf("No crash\n"); |
| } |
| |
| int requesting_thread = process_state.requesting_thread(); |
| if (requesting_thread != -1) { |
| printf("\n"); |
| printf("Thread %d (%s)\n", |
| requesting_thread, |
| process_state.crashed() ? "crashed" : |
| "requested dump, did not crash"); |
| PrintStack(process_state.threads()->at(requesting_thread), cpu); |
| } |
| |
| // Print all of the threads in the dump. |
| int thread_count = static_cast<int>(process_state.threads()->size()); |
| const std::vector<google_breakpad::MemoryRegion*> |
| *thread_memory_regions = process_state.thread_memory_regions(); |
| |
| for (int thread_index = 0; thread_index < thread_count; ++thread_index) { |
| if (thread_index != requesting_thread) { |
| // Don't print the crash thread again, it was already printed. |
| printf("\n"); |
| printf("Thread %d\n", thread_index); |
| PrintStack(process_state.threads()->at(thread_index), cpu); |
| google_breakpad::MemoryRegion *thread_stack_bytes = |
| thread_memory_regions->at(thread_index); |
| if (options->printThreadMemory) { |
| thread_stack_bytes->Print(); |
| } |
| } |
| } |
| |
| // Print the crashed registers |
| if (requesting_thread != -1) { |
| printf("\nThread %d:", requesting_thread); |
| PrintRegisters(process_state.threads()->at(requesting_thread), cpu); |
| } |
| |
| // Print information about modules |
| PrintModules(process_state.modules()); |
| } |
| |
| //============================================================================= |
| static void Start(Options *options) { |
| NSFileManager *manager = [NSFileManager defaultManager]; |
| NSString *minidump_path = options->minidumpPath; |
| BOOL is_dir = NO; |
| BOOL file_exists = [manager fileExistsAtPath:minidump_path |
| isDirectory:&is_dir]; |
| if (file_exists && is_dir) { |
| NSDirectoryEnumerator *enumerator = |
| [manager enumeratorAtPath:minidump_path]; |
| NSString *current_file = nil; |
| while ((current_file = [enumerator nextObject])) { |
| NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; |
| if ([[current_file pathExtension] isEqualTo:@"dmp"]) { |
| printf("Attempting to process report: %s\n", |
| [current_file cStringUsingEncoding:NSASCIIStringEncoding]); |
| NSString *full_path = |
| [minidump_path stringByAppendingPathComponent:current_file]; |
| ProcessSingleReport(options, full_path); |
| } |
| [pool release]; |
| } |
| } else if (file_exists) { |
| ProcessSingleReport(options, minidump_path); |
| } |
| } |
| |
| //============================================================================= |
| static void Usage(int argc, const char *argv[]) { |
| fprintf(stderr, "Convert a minidump to a crash report. Breakpad symbol " |
| "files will be used (or created if missing) in /tmp.\n" |
| "If a symbol-file-search-dir is specified, any symbol " |
| "files in it will be used instead of being loaded from " |
| "modules on disk.\n" |
| "If modules cannot be found at the paths stored in the " |
| "minidump file, they will be searched for at " |
| "<module-search-dir>/<path-in-minidump-file>.\n"); |
| fprintf(stderr, "Usage: %s [-s module-search-dir] [-S symbol-file-search-dir] " |
| "minidump-file\n", argv[0]); |
| fprintf(stderr, "\t-s: Specify a search directory to use for missing modules\n" |
| "\t-S: Specify a search directory to use for symbol files\n" |
| "\t-t: Print thread stack memory in hex\n" |
| "\t-h: Usage\n" |
| "\t-?: Usage\n"); |
| } |
| |
| //============================================================================= |
| static void SetupOptions(int argc, const char *argv[], Options *options) { |
| extern int optind; |
| char ch; |
| |
| while ((ch = getopt(argc, (char * const *)argv, "S:s:ht?")) != -1) { |
| switch (ch) { |
| case 's': |
| options->searchDir = [[NSFileManager defaultManager] |
| stringWithFileSystemRepresentation:optarg |
| length:strlen(optarg)]; |
| break; |
| |
| case 'S': |
| options->symbolSearchDir = [[NSFileManager defaultManager] |
| stringWithFileSystemRepresentation:optarg |
| length:strlen(optarg)]; |
| break; |
| |
| case 't': |
| options->printThreadMemory = YES; |
| break; |
| case 'h': |
| case '?': |
| Usage(argc, argv); |
| exit(1); |
| break; |
| } |
| } |
| |
| if ((argc - optind) != 1) { |
| fprintf(stderr, "%s: Missing minidump file\n", argv[0]); |
| Usage(argc, argv); |
| exit(1); |
| } |
| |
| options->minidumpPath = [[NSFileManager defaultManager] |
| stringWithFileSystemRepresentation:argv[optind] |
| length:strlen(argv[optind])]; |
| } |
| |
| //============================================================================= |
| int main (int argc, const char * argv[]) { |
| NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; |
| Options options; |
| |
| bzero(&options, sizeof(Options)); |
| SetupOptions(argc, argv, &options); |
| Start(&options); |
| [pool release]; |
| |
| return 0; |
| } |