// Copyright (c) 2006, 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. // minidump_dump.cc: Print the contents of a minidump file in somewhat // readable text. // // Author: Mark Mentovai #include <stdio.h> #include <string.h> #include "common/scoped_ptr.h" #include "google_breakpad/processor/minidump.h" #include "processor/logging.h" namespace { using google_breakpad::Minidump; using google_breakpad::MinidumpThreadList; using google_breakpad::MinidumpModuleList; using google_breakpad::MinidumpMemoryInfoList; using google_breakpad::MinidumpMemoryList; using google_breakpad::MinidumpException; using google_breakpad::MinidumpAssertion; using google_breakpad::MinidumpSystemInfo; using google_breakpad::MinidumpMiscInfo; using google_breakpad::MinidumpBreakpadInfo; static void DumpRawStream(Minidump *minidump, uint32_t stream_type, const char *stream_name, int *errors) { uint32_t length = 0; if (!minidump->SeekToStreamType(stream_type, &length)) { return; } printf("Stream %s:\n", stream_name); if (length == 0) { printf("\n"); return; } std::vector<char> contents(length); if (!minidump->ReadBytes(&contents[0], length)) { ++*errors; BPLOG(ERROR) << "minidump.ReadBytes failed"; return; } size_t current_offset = 0; while (current_offset < length) { size_t remaining = length - current_offset; // Printf requires an int and direct casting from size_t results // in compatibility warnings. uint32_t int_remaining = remaining; printf("%.*s", int_remaining, &contents[current_offset]); char *next_null = reinterpret_cast<char *>( memchr(&contents[current_offset], 0, remaining)); if (next_null == NULL) break; printf("\\0\n"); size_t null_offset = next_null - &contents[0]; current_offset = null_offset + 1; } printf("\n\n"); } static bool PrintMinidumpDump(const char *minidump_file) { Minidump minidump(minidump_file); if (!minidump.Read()) { BPLOG(ERROR) << "minidump.Read() failed"; return false; } minidump.Print(); int errors = 0; MinidumpThreadList *thread_list = minidump.GetThreadList(); if (!thread_list) { ++errors; BPLOG(ERROR) << "minidump.GetThreadList() failed"; } else { thread_list->Print(); } MinidumpModuleList *module_list = minidump.GetModuleList(); if (!module_list) { ++errors; BPLOG(ERROR) << "minidump.GetModuleList() failed"; } else { module_list->Print(); } MinidumpMemoryList *memory_list = minidump.GetMemoryList(); if (!memory_list) { ++errors; BPLOG(ERROR) << "minidump.GetMemoryList() failed"; } else { memory_list->Print(); } MinidumpException *exception = minidump.GetException(); if (!exception) { BPLOG(INFO) << "minidump.GetException() failed"; } else { exception->Print(); } MinidumpAssertion *assertion = minidump.GetAssertion(); if (!assertion) { BPLOG(INFO) << "minidump.GetAssertion() failed"; } else { assertion->Print(); } MinidumpSystemInfo *system_info = minidump.GetSystemInfo(); if (!system_info) { ++errors; BPLOG(ERROR) << "minidump.GetSystemInfo() failed"; } else { system_info->Print(); } MinidumpMiscInfo *misc_info = minidump.GetMiscInfo(); if (!misc_info) { ++errors; BPLOG(ERROR) << "minidump.GetMiscInfo() failed"; } else { misc_info->Print(); } MinidumpBreakpadInfo *breakpad_info = minidump.GetBreakpadInfo(); if (!breakpad_info) { // Breakpad info is optional, so don't treat this as an error. BPLOG(INFO) << "minidump.GetBreakpadInfo() failed"; } else { breakpad_info->Print(); } MinidumpMemoryInfoList *memory_info_list = minidump.GetMemoryInfoList(); if (!memory_info_list) { ++errors; BPLOG(ERROR) << "minidump.GetMemoryInfoList() failed"; } else { memory_info_list->Print(); } DumpRawStream(&minidump, MD_LINUX_CMD_LINE, "MD_LINUX_CMD_LINE", &errors); DumpRawStream(&minidump, MD_LINUX_ENVIRON, "MD_LINUX_ENVIRON", &errors); DumpRawStream(&minidump, MD_LINUX_LSB_RELEASE, "MD_LINUX_LSB_RELEASE", &errors); DumpRawStream(&minidump, MD_LINUX_PROC_STATUS, "MD_LINUX_PROC_STATUS", &errors); DumpRawStream(&minidump, MD_LINUX_CPU_INFO, "MD_LINUX_CPU_INFO", &errors); DumpRawStream(&minidump, MD_LINUX_MAPS, "MD_LINUX_MAPS", &errors); return errors == 0; } } // namespace int main(int argc, char **argv) { BPLOG_INIT(&argc, &argv); if (argc != 2) { fprintf(stderr, "usage: %s <file>\n", argv[0]); return 1; } return PrintMinidumpDump(argv[1]) ? 0 : 1; }