summaryrefslogtreecommitdiffstats
path: root/toolkit/crashreporter/google-breakpad/src/processor/minidump.cc
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/crashreporter/google-breakpad/src/processor/minidump.cc')
-rw-r--r--toolkit/crashreporter/google-breakpad/src/processor/minidump.cc4989
1 files changed, 4989 insertions, 0 deletions
diff --git a/toolkit/crashreporter/google-breakpad/src/processor/minidump.cc b/toolkit/crashreporter/google-breakpad/src/processor/minidump.cc
new file mode 100644
index 000000000..1e1d386df
--- /dev/null
+++ b/toolkit/crashreporter/google-breakpad/src/processor/minidump.cc
@@ -0,0 +1,4989 @@
+// 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.
+
+// minidump.cc: A minidump reader.
+//
+// See minidump.h for documentation.
+//
+// Author: Mark Mentovai
+
+#include "google_breakpad/processor/minidump.h"
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stddef.h>
+#include <string.h>
+#include <time.h>
+
+#ifdef _WIN32
+#include <io.h>
+#else // _WIN32
+#include <unistd.h>
+#endif // _WIN32
+
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <vector>
+
+#include "processor/range_map-inl.h"
+
+#include "common/scoped_ptr.h"
+#include "common/stdio_wrapper.h"
+#include "google_breakpad/processor/dump_context.h"
+#include "processor/basic_code_module.h"
+#include "processor/basic_code_modules.h"
+#include "processor/logging.h"
+
+namespace google_breakpad {
+
+
+using std::istream;
+using std::ifstream;
+using std::numeric_limits;
+using std::vector;
+
+// Returns true iff |context_size| matches exactly one of the sizes of the
+// various MDRawContext* types.
+// TODO(blundell): This function can be removed once
+// http://code.google.com/p/google-breakpad/issues/detail?id=550 is fixed.
+static bool IsContextSizeUnique(uint32_t context_size) {
+ int num_matching_contexts = 0;
+ if (context_size == sizeof(MDRawContextX86))
+ num_matching_contexts++;
+ if (context_size == sizeof(MDRawContextPPC))
+ num_matching_contexts++;
+ if (context_size == sizeof(MDRawContextPPC64))
+ num_matching_contexts++;
+ if (context_size == sizeof(MDRawContextAMD64))
+ num_matching_contexts++;
+ if (context_size == sizeof(MDRawContextSPARC))
+ num_matching_contexts++;
+ if (context_size == sizeof(MDRawContextARM))
+ num_matching_contexts++;
+ if (context_size == sizeof(MDRawContextARM64))
+ num_matching_contexts++;
+ if (context_size == sizeof(MDRawContextMIPS))
+ num_matching_contexts++;
+ return num_matching_contexts == 1;
+}
+
+//
+// Swapping routines
+//
+// Inlining these doesn't increase code size significantly, and it saves
+// a whole lot of unnecessary jumping back and forth.
+//
+
+
+// Swapping an 8-bit quantity is a no-op. This function is only provided
+// to account for certain templatized operations that require swapping for
+// wider types but handle uint8_t too
+// (MinidumpMemoryRegion::GetMemoryAtAddressInternal).
+static inline void Swap(uint8_t* value) {
+}
+
+
+// Optimization: don't need to AND the furthest right shift, because we're
+// shifting an unsigned quantity. The standard requires zero-filling in this
+// case. If the quantities were signed, a bitmask whould be needed for this
+// right shift to avoid an arithmetic shift (which retains the sign bit).
+// The furthest left shift never needs to be ANDed bitmask.
+
+
+static inline void Swap(uint16_t* value) {
+ *value = (*value >> 8) |
+ (*value << 8);
+}
+
+
+static inline void Swap(uint32_t* value) {
+ *value = (*value >> 24) |
+ ((*value >> 8) & 0x0000ff00) |
+ ((*value << 8) & 0x00ff0000) |
+ (*value << 24);
+}
+
+
+static inline void Swap(uint64_t* value) {
+ uint32_t* value32 = reinterpret_cast<uint32_t*>(value);
+ Swap(&value32[0]);
+ Swap(&value32[1]);
+ uint32_t temp = value32[0];
+ value32[0] = value32[1];
+ value32[1] = temp;
+}
+
+
+// Given a pointer to a 128-bit int in the minidump data, set the "low"
+// and "high" fields appropriately.
+static void Normalize128(uint128_struct* value, bool is_big_endian) {
+ // The struct format is [high, low], so if the format is big-endian,
+ // the most significant bytes will already be in the high field.
+ if (!is_big_endian) {
+ uint64_t temp = value->low;
+ value->low = value->high;
+ value->high = temp;
+ }
+}
+
+// This just swaps each int64 half of the 128-bit value.
+// The value should also be normalized by calling Normalize128().
+static void Swap(uint128_struct* value) {
+ Swap(&value->low);
+ Swap(&value->high);
+}
+
+// Swapping signed integers
+static inline void Swap(int32_t* value) {
+ Swap(reinterpret_cast<uint32_t*>(value));
+}
+
+static inline void Swap(MDLocationDescriptor* location_descriptor) {
+ Swap(&location_descriptor->data_size);
+ Swap(&location_descriptor->rva);
+}
+
+
+static inline void Swap(MDMemoryDescriptor* memory_descriptor) {
+ Swap(&memory_descriptor->start_of_memory_range);
+ Swap(&memory_descriptor->memory);
+}
+
+
+static inline void Swap(MDGUID* guid) {
+ Swap(&guid->data1);
+ Swap(&guid->data2);
+ Swap(&guid->data3);
+ // Don't swap guid->data4[] because it contains 8-bit quantities.
+}
+
+static inline void Swap(MDSystemTime* system_time) {
+ Swap(&system_time->year);
+ Swap(&system_time->month);
+ Swap(&system_time->day_of_week);
+ Swap(&system_time->day);
+ Swap(&system_time->hour);
+ Swap(&system_time->minute);
+ Swap(&system_time->second);
+ Swap(&system_time->milliseconds);
+}
+
+static inline void Swap(MDXStateFeature* xstate_feature) {
+ Swap(&xstate_feature->offset);
+ Swap(&xstate_feature->size);
+}
+
+static inline void Swap(MDXStateConfigFeatureMscInfo* xstate_feature_info) {
+ Swap(&xstate_feature_info->size_of_info);
+ Swap(&xstate_feature_info->context_size);
+ Swap(&xstate_feature_info->enabled_features);
+
+ for (size_t i = 0; i < MD_MAXIMUM_XSTATE_FEATURES; i++) {
+ Swap(&xstate_feature_info->features[i]);
+ }
+}
+
+static inline void Swap(uint16_t* data, size_t size_in_bytes) {
+ size_t data_length = size_in_bytes / sizeof(data[0]);
+ for (size_t i = 0; i < data_length; i++) {
+ Swap(&data[i]);
+ }
+}
+
+//
+// Character conversion routines
+//
+
+
+// Standard wide-character conversion routines depend on the system's own
+// idea of what width a wide character should be: some use 16 bits, and
+// some use 32 bits. For the purposes of a minidump, wide strings are
+// always represented with 16-bit UTF-16 chracters. iconv isn't available
+// everywhere, and its interface varies where it is available. iconv also
+// deals purely with char* pointers, so in addition to considering the swap
+// parameter, a converter that uses iconv would also need to take the host
+// CPU's endianness into consideration. It doesn't seems worth the trouble
+// of making it a dependency when we don't care about anything but UTF-16.
+static string* UTF16ToUTF8(const vector<uint16_t>& in,
+ bool swap) {
+ scoped_ptr<string> out(new string());
+
+ // Set the string's initial capacity to the number of UTF-16 characters,
+ // because the UTF-8 representation will always be at least this long.
+ // If the UTF-8 representation is longer, the string will grow dynamically.
+ out->reserve(in.size());
+
+ for (vector<uint16_t>::const_iterator iterator = in.begin();
+ iterator != in.end();
+ ++iterator) {
+ // Get a 16-bit value from the input
+ uint16_t in_word = *iterator;
+ if (swap)
+ Swap(&in_word);
+
+ // Convert the input value (in_word) into a Unicode code point (unichar).
+ uint32_t unichar;
+ if (in_word >= 0xdc00 && in_word <= 0xdcff) {
+ BPLOG(ERROR) << "UTF16ToUTF8 found low surrogate " <<
+ HexString(in_word) << " without high";
+ return NULL;
+ } else if (in_word >= 0xd800 && in_word <= 0xdbff) {
+ // High surrogate.
+ unichar = (in_word - 0xd7c0) << 10;
+ if (++iterator == in.end()) {
+ BPLOG(ERROR) << "UTF16ToUTF8 found high surrogate " <<
+ HexString(in_word) << " at end of string";
+ return NULL;
+ }
+ uint32_t high_word = in_word;
+ in_word = *iterator;
+ if (in_word < 0xdc00 || in_word > 0xdcff) {
+ BPLOG(ERROR) << "UTF16ToUTF8 found high surrogate " <<
+ HexString(high_word) << " without low " <<
+ HexString(in_word);
+ return NULL;
+ }
+ unichar |= in_word & 0x03ff;
+ } else {
+ // The ordinary case, a single non-surrogate Unicode character encoded
+ // as a single 16-bit value.
+ unichar = in_word;
+ }
+
+ // Convert the Unicode code point (unichar) into its UTF-8 representation,
+ // appending it to the out string.
+ if (unichar < 0x80) {
+ (*out) += static_cast<char>(unichar);
+ } else if (unichar < 0x800) {
+ (*out) += 0xc0 | static_cast<char>(unichar >> 6);
+ (*out) += 0x80 | static_cast<char>(unichar & 0x3f);
+ } else if (unichar < 0x10000) {
+ (*out) += 0xe0 | static_cast<char>(unichar >> 12);
+ (*out) += 0x80 | static_cast<char>((unichar >> 6) & 0x3f);
+ (*out) += 0x80 | static_cast<char>(unichar & 0x3f);
+ } else if (unichar < 0x200000) {
+ (*out) += 0xf0 | static_cast<char>(unichar >> 18);
+ (*out) += 0x80 | static_cast<char>((unichar >> 12) & 0x3f);
+ (*out) += 0x80 | static_cast<char>((unichar >> 6) & 0x3f);
+ (*out) += 0x80 | static_cast<char>(unichar & 0x3f);
+ } else {
+ BPLOG(ERROR) << "UTF16ToUTF8 cannot represent high value " <<
+ HexString(unichar) << " in UTF-8";
+ return NULL;
+ }
+ }
+
+ return out.release();
+}
+
+// Return the smaller of the number of code units in the UTF-16 string,
+// not including the terminating null word, or maxlen.
+static size_t UTF16codeunits(const uint16_t *string, size_t maxlen) {
+ size_t count = 0;
+ while (count < maxlen && string[count] != 0)
+ count++;
+ return count;
+}
+
+static inline void Swap(MDTimeZoneInformation* time_zone) {
+ Swap(&time_zone->bias);
+ // Skip time_zone->standard_name. No need to swap UTF-16 fields.
+ // The swap will be done as part of the conversion to UTF-8.
+ Swap(&time_zone->standard_date);
+ Swap(&time_zone->standard_bias);
+ // Skip time_zone->daylight_name. No need to swap UTF-16 fields.
+ // The swap will be done as part of the conversion to UTF-8.
+ Swap(&time_zone->daylight_date);
+ Swap(&time_zone->daylight_bias);
+}
+
+static void ConvertUTF16BufferToUTF8String(const uint16_t* utf16_data,
+ size_t max_length_in_bytes,
+ string* utf8_result,
+ bool swap) {
+ // Since there is no explicit byte length for each string, use
+ // UTF16codeunits to calculate word length, then derive byte
+ // length from that.
+ size_t max_word_length = max_length_in_bytes / sizeof(utf16_data[0]);
+ size_t word_length = UTF16codeunits(utf16_data, max_word_length);
+ if (word_length > 0) {
+ size_t byte_length = word_length * sizeof(utf16_data[0]);
+ vector<uint16_t> utf16_vector(word_length);
+ memcpy(&utf16_vector[0], &utf16_data[0], byte_length);
+ scoped_ptr<string> temp(UTF16ToUTF8(utf16_vector, swap));
+ if (temp.get()) {
+ utf8_result->assign(*temp);
+ }
+ } else {
+ utf8_result->clear();
+ }
+}
+
+
+// For fields that may or may not be valid, PrintValueOrInvalid will print the
+// string "(invalid)" if the field is not valid, and will print the value if
+// the field is valid. The value is printed as hexadecimal or decimal.
+
+enum NumberFormat {
+ kNumberFormatDecimal,
+ kNumberFormatHexadecimal,
+};
+
+static void PrintValueOrInvalid(bool valid,
+ NumberFormat number_format,
+ uint32_t value) {
+ if (!valid) {
+ printf("(invalid)\n");
+ } else if (number_format == kNumberFormatDecimal) {
+ printf("%d\n", value);
+ } else {
+ printf("0x%x\n", value);
+ }
+}
+
+// Converts a time_t to a string showing the time in UTC.
+string TimeTToUTCString(time_t tt) {
+ struct tm timestruct;
+#ifdef _WIN32
+ gmtime_s(&timestruct, &tt);
+#else
+ gmtime_r(&tt, &timestruct);
+#endif
+
+ char timestr[20];
+ int rv = strftime(timestr, 20, "%Y-%m-%d %H:%M:%S", &timestruct);
+ if (rv == 0) {
+ return string();
+ }
+
+ return string(timestr);
+}
+
+
+//
+// MinidumpObject
+//
+
+
+MinidumpObject::MinidumpObject(Minidump* minidump)
+ : DumpObject(),
+ minidump_(minidump) {
+}
+
+
+//
+// MinidumpStream
+//
+
+
+MinidumpStream::MinidumpStream(Minidump* minidump)
+ : MinidumpObject(minidump) {
+}
+
+
+//
+// MinidumpContext
+//
+
+
+MinidumpContext::MinidumpContext(Minidump* minidump)
+ : DumpContext(),
+ minidump_(minidump) {
+}
+
+MinidumpContext::~MinidumpContext() {
+}
+
+bool MinidumpContext::Read(uint32_t expected_size) {
+ valid_ = false;
+
+ // Certain raw context types are currently assumed to have unique sizes.
+ if (!IsContextSizeUnique(sizeof(MDRawContextAMD64))) {
+ BPLOG(ERROR) << "sizeof(MDRawContextAMD64) cannot match the size of any "
+ << "other raw context";
+ return false;
+ }
+ if (!IsContextSizeUnique(sizeof(MDRawContextPPC64))) {
+ BPLOG(ERROR) << "sizeof(MDRawContextPPC64) cannot match the size of any "
+ << "other raw context";
+ return false;
+ }
+ if (!IsContextSizeUnique(sizeof(MDRawContextARM64))) {
+ BPLOG(ERROR) << "sizeof(MDRawContextARM64) cannot match the size of any "
+ << "other raw context";
+ return false;
+ }
+
+ FreeContext();
+
+ // First, figure out what type of CPU this context structure is for.
+ // For some reason, the AMD64 Context doesn't have context_flags
+ // at the beginning of the structure, so special case it here.
+ if (expected_size == sizeof(MDRawContextAMD64)) {
+ BPLOG(INFO) << "MinidumpContext: looks like AMD64 context";
+
+ scoped_ptr<MDRawContextAMD64> context_amd64(new MDRawContextAMD64());
+ if (!minidump_->ReadBytes(context_amd64.get(),
+ sizeof(MDRawContextAMD64))) {
+ BPLOG(ERROR) << "MinidumpContext could not read amd64 context";
+ return false;
+ }
+
+ if (minidump_->swap())
+ Swap(&context_amd64->context_flags);
+
+ uint32_t cpu_type = context_amd64->context_flags & MD_CONTEXT_CPU_MASK;
+ if (cpu_type == 0) {
+ if (minidump_->GetContextCPUFlagsFromSystemInfo(&cpu_type)) {
+ context_amd64->context_flags |= cpu_type;
+ } else {
+ BPLOG(ERROR) << "Failed to preserve the current stream position";
+ return false;
+ }
+ }
+
+ if (cpu_type != MD_CONTEXT_AMD64) {
+ // TODO: Fall through to switch below.
+ // http://code.google.com/p/google-breakpad/issues/detail?id=550
+ BPLOG(ERROR) << "MinidumpContext not actually amd64 context";
+ return false;
+ }
+
+ // Do this after reading the entire MDRawContext structure because
+ // GetSystemInfo may seek minidump to a new position.
+ if (!CheckAgainstSystemInfo(cpu_type)) {
+ BPLOG(ERROR) << "MinidumpContext amd64 does not match system info";
+ return false;
+ }
+
+ // Normalize the 128-bit types in the dump.
+ // Since this is AMD64, by definition, the values are little-endian.
+ for (unsigned int vr_index = 0;
+ vr_index < MD_CONTEXT_AMD64_VR_COUNT;
+ ++vr_index)
+ Normalize128(&context_amd64->vector_register[vr_index], false);
+
+ if (minidump_->swap()) {
+ Swap(&context_amd64->p1_home);
+ Swap(&context_amd64->p2_home);
+ Swap(&context_amd64->p3_home);
+ Swap(&context_amd64->p4_home);
+ Swap(&context_amd64->p5_home);
+ Swap(&context_amd64->p6_home);
+ // context_flags is already swapped
+ Swap(&context_amd64->mx_csr);
+ Swap(&context_amd64->cs);
+ Swap(&context_amd64->ds);
+ Swap(&context_amd64->es);
+ Swap(&context_amd64->fs);
+ Swap(&context_amd64->ss);
+ Swap(&context_amd64->eflags);
+ Swap(&context_amd64->dr0);
+ Swap(&context_amd64->dr1);
+ Swap(&context_amd64->dr2);
+ Swap(&context_amd64->dr3);
+ Swap(&context_amd64->dr6);
+ Swap(&context_amd64->dr7);
+ Swap(&context_amd64->rax);
+ Swap(&context_amd64->rcx);
+ Swap(&context_amd64->rdx);
+ Swap(&context_amd64->rbx);
+ Swap(&context_amd64->rsp);
+ Swap(&context_amd64->rbp);
+ Swap(&context_amd64->rsi);
+ Swap(&context_amd64->rdi);
+ Swap(&context_amd64->r8);
+ Swap(&context_amd64->r9);
+ Swap(&context_amd64->r10);
+ Swap(&context_amd64->r11);
+ Swap(&context_amd64->r12);
+ Swap(&context_amd64->r13);
+ Swap(&context_amd64->r14);
+ Swap(&context_amd64->r15);
+ Swap(&context_amd64->rip);
+ // FIXME: I'm not sure what actually determines
+ // which member of the union {flt_save, sse_registers}
+ // is valid. We're not currently using either,
+ // but it would be good to have them swapped properly.
+
+ for (unsigned int vr_index = 0;
+ vr_index < MD_CONTEXT_AMD64_VR_COUNT;
+ ++vr_index)
+ Swap(&context_amd64->vector_register[vr_index]);
+ Swap(&context_amd64->vector_control);
+ Swap(&context_amd64->debug_control);
+ Swap(&context_amd64->last_branch_to_rip);
+ Swap(&context_amd64->last_branch_from_rip);
+ Swap(&context_amd64->last_exception_to_rip);
+ Swap(&context_amd64->last_exception_from_rip);
+ }
+
+ SetContextFlags(context_amd64->context_flags);
+
+ SetContextAMD64(context_amd64.release());
+ } else if (expected_size == sizeof(MDRawContextPPC64)) {
+ // |context_flags| of MDRawContextPPC64 is 64 bits, but other MDRawContext
+ // in the else case have 32 bits |context_flags|, so special case it here.
+ uint64_t context_flags;
+ if (!minidump_->ReadBytes(&context_flags, sizeof(context_flags))) {
+ BPLOG(ERROR) << "MinidumpContext could not read context flags";
+ return false;
+ }
+ if (minidump_->swap())
+ Swap(&context_flags);
+
+ uint32_t cpu_type = context_flags & MD_CONTEXT_CPU_MASK;
+ scoped_ptr<MDRawContextPPC64> context_ppc64(new MDRawContextPPC64());
+
+ if (cpu_type == 0) {
+ if (minidump_->GetContextCPUFlagsFromSystemInfo(&cpu_type)) {
+ context_ppc64->context_flags |= cpu_type;
+ } else {
+ BPLOG(ERROR) << "Failed to preserve the current stream position";
+ return false;
+ }
+ }
+
+ if (cpu_type != MD_CONTEXT_PPC64) {
+ // TODO: Fall through to switch below.
+ // http://code.google.com/p/google-breakpad/issues/detail?id=550
+ BPLOG(ERROR) << "MinidumpContext not actually ppc64 context";
+ return false;
+ }
+
+ // Set the context_flags member, which has already been read, and
+ // read the rest of the structure beginning with the first member
+ // after context_flags.
+ context_ppc64->context_flags = context_flags;
+
+ size_t flags_size = sizeof(context_ppc64->context_flags);
+ uint8_t* context_after_flags =
+ reinterpret_cast<uint8_t*>(context_ppc64.get()) + flags_size;
+ if (!minidump_->ReadBytes(context_after_flags,
+ sizeof(MDRawContextPPC64) - flags_size)) {
+ BPLOG(ERROR) << "MinidumpContext could not read ppc64 context";
+ return false;
+ }
+
+ // Do this after reading the entire MDRawContext structure because
+ // GetSystemInfo may seek minidump to a new position.
+ if (!CheckAgainstSystemInfo(cpu_type)) {
+ BPLOG(ERROR) << "MinidumpContext ppc64 does not match system info";
+ return false;
+ }
+ if (minidump_->swap()) {
+ // context_ppc64->context_flags was already swapped.
+ Swap(&context_ppc64->srr0);
+ Swap(&context_ppc64->srr1);
+ for (unsigned int gpr_index = 0;
+ gpr_index < MD_CONTEXT_PPC64_GPR_COUNT;
+ ++gpr_index) {
+ Swap(&context_ppc64->gpr[gpr_index]);
+ }
+ Swap(&context_ppc64->cr);
+ Swap(&context_ppc64->xer);
+ Swap(&context_ppc64->lr);
+ Swap(&context_ppc64->ctr);
+ Swap(&context_ppc64->vrsave);
+ for (unsigned int fpr_index = 0;
+ fpr_index < MD_FLOATINGSAVEAREA_PPC_FPR_COUNT;
+ ++fpr_index) {
+ Swap(&context_ppc64->float_save.fpregs[fpr_index]);
+ }
+ // Don't swap context_ppc64->float_save.fpscr_pad because it is only
+ // used for padding.
+ Swap(&context_ppc64->float_save.fpscr);
+ for (unsigned int vr_index = 0;
+ vr_index < MD_VECTORSAVEAREA_PPC_VR_COUNT;
+ ++vr_index) {
+ Normalize128(&context_ppc64->vector_save.save_vr[vr_index], true);
+ Swap(&context_ppc64->vector_save.save_vr[vr_index]);
+ }
+ Swap(&context_ppc64->vector_save.save_vscr);
+ // Don't swap the padding fields in vector_save.
+ Swap(&context_ppc64->vector_save.save_vrvalid);
+ }
+
+ SetContextFlags(static_cast<uint32_t>(context_ppc64->context_flags));
+
+ // Check for data loss when converting context flags from uint64_t into
+ // uint32_t
+ if (static_cast<uint64_t>(GetContextFlags()) !=
+ context_ppc64->context_flags) {
+ BPLOG(ERROR) << "Data loss detected when converting PPC64 context_flags";
+ return false;
+ }
+
+ SetContextPPC64(context_ppc64.release());
+ } else if (expected_size == sizeof(MDRawContextARM64)) {
+ // |context_flags| of MDRawContextARM64 is 64 bits, but other MDRawContext
+ // in the else case have 32 bits |context_flags|, so special case it here.
+ uint64_t context_flags;
+
+ BPLOG(INFO) << "MinidumpContext: looks like ARM64 context";
+
+ if (!minidump_->ReadBytes(&context_flags, sizeof(context_flags))) {
+ BPLOG(ERROR) << "MinidumpContext could not read context flags";
+ return false;
+ }
+ if (minidump_->swap())
+ Swap(&context_flags);
+
+ scoped_ptr<MDRawContextARM64> context_arm64(new MDRawContextARM64());
+
+ uint32_t cpu_type = context_flags & MD_CONTEXT_CPU_MASK;
+ if (cpu_type == 0) {
+ if (minidump_->GetContextCPUFlagsFromSystemInfo(&cpu_type)) {
+ context_arm64->context_flags |= cpu_type;
+ } else {
+ BPLOG(ERROR) << "Failed to preserve the current stream position";
+ return false;
+ }
+ }
+
+ if (cpu_type != MD_CONTEXT_ARM64) {
+ // TODO: Fall through to switch below.
+ // http://code.google.com/p/google-breakpad/issues/detail?id=550
+ BPLOG(ERROR) << "MinidumpContext not actually arm64 context";
+ return false;
+ }
+
+ // Set the context_flags member, which has already been read, and
+ // read the rest of the structure beginning with the first member
+ // after context_flags.
+ context_arm64->context_flags = context_flags;
+
+ size_t flags_size = sizeof(context_arm64->context_flags);
+ uint8_t* context_after_flags =
+ reinterpret_cast<uint8_t*>(context_arm64.get()) + flags_size;
+ if (!minidump_->ReadBytes(context_after_flags,
+ sizeof(MDRawContextARM64) - flags_size)) {
+ BPLOG(ERROR) << "MinidumpContext could not read arm64 context";
+ return false;
+ }
+
+ // Do this after reading the entire MDRawContext structure because
+ // GetSystemInfo may seek minidump to a new position.
+ if (!CheckAgainstSystemInfo(cpu_type)) {
+ BPLOG(ERROR) << "MinidumpContext arm64 does not match system info";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ // context_arm64->context_flags was already swapped.
+ for (unsigned int ireg_index = 0;
+ ireg_index < MD_CONTEXT_ARM64_GPR_COUNT;
+ ++ireg_index) {
+ Swap(&context_arm64->iregs[ireg_index]);
+ }
+ Swap(&context_arm64->cpsr);
+ Swap(&context_arm64->float_save.fpsr);
+ Swap(&context_arm64->float_save.fpcr);
+ for (unsigned int fpr_index = 0;
+ fpr_index < MD_FLOATINGSAVEAREA_ARM64_FPR_COUNT;
+ ++fpr_index) {
+ // While ARM64 is bi-endian, iOS (currently the only platform
+ // for which ARM64 support has been brought up) uses ARM64 exclusively
+ // in little-endian mode.
+ Normalize128(&context_arm64->float_save.regs[fpr_index], false);
+ Swap(&context_arm64->float_save.regs[fpr_index]);
+ }
+ }
+ SetContextFlags(static_cast<uint32_t>(context_arm64->context_flags));
+
+ // Check for data loss when converting context flags from uint64_t into
+ // uint32_t
+ if (static_cast<uint64_t>(GetContextFlags()) !=
+ context_arm64->context_flags) {
+ BPLOG(ERROR) << "Data loss detected when converting ARM64 context_flags";
+ return false;
+ }
+
+ SetContextARM64(context_arm64.release());
+ } else {
+ uint32_t context_flags;
+ if (!minidump_->ReadBytes(&context_flags, sizeof(context_flags))) {
+ BPLOG(ERROR) << "MinidumpContext could not read context flags";
+ return false;
+ }
+ if (minidump_->swap())
+ Swap(&context_flags);
+
+ uint32_t cpu_type = context_flags & MD_CONTEXT_CPU_MASK;
+ if (cpu_type == 0) {
+ // Unfortunately the flag for MD_CONTEXT_ARM that was taken
+ // from a Windows CE SDK header conflicts in practice with
+ // the CONTEXT_XSTATE flag. MD_CONTEXT_ARM has been renumbered,
+ // but handle dumps with the legacy value gracefully here.
+ if (context_flags & MD_CONTEXT_ARM_OLD) {
+ context_flags |= MD_CONTEXT_ARM;
+ context_flags &= ~MD_CONTEXT_ARM_OLD;
+ cpu_type = MD_CONTEXT_ARM;
+ }
+ }
+
+ if (cpu_type == 0) {
+ if (minidump_->GetContextCPUFlagsFromSystemInfo(&cpu_type)) {
+ context_flags |= cpu_type;
+ } else {
+ BPLOG(ERROR) << "Failed to preserve the current stream position";
+ return false;
+ }
+ }
+
+ // Allocate the context structure for the correct CPU and fill it. The
+ // casts are slightly unorthodox, but it seems better to do that than to
+ // maintain a separate pointer for each type of CPU context structure
+ // when only one of them will be used.
+ switch (cpu_type) {
+ case MD_CONTEXT_X86: {
+ if (expected_size != sizeof(MDRawContextX86)) {
+ BPLOG(ERROR) << "MinidumpContext x86 size mismatch, " <<
+ expected_size << " != " << sizeof(MDRawContextX86);
+ return false;
+ }
+
+ scoped_ptr<MDRawContextX86> context_x86(new MDRawContextX86());
+
+ // Set the context_flags member, which has already been read, and
+ // read the rest of the structure beginning with the first member
+ // after context_flags.
+ context_x86->context_flags = context_flags;
+
+ size_t flags_size = sizeof(context_x86->context_flags);
+ uint8_t* context_after_flags =
+ reinterpret_cast<uint8_t*>(context_x86.get()) + flags_size;
+ if (!minidump_->ReadBytes(context_after_flags,
+ sizeof(MDRawContextX86) - flags_size)) {
+ BPLOG(ERROR) << "MinidumpContext could not read x86 context";
+ return false;
+ }
+
+ // Do this after reading the entire MDRawContext structure because
+ // GetSystemInfo may seek minidump to a new position.
+ if (!CheckAgainstSystemInfo(cpu_type)) {
+ BPLOG(ERROR) << "MinidumpContext x86 does not match system info";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ // context_x86->context_flags was already swapped.
+ Swap(&context_x86->dr0);
+ Swap(&context_x86->dr1);
+ Swap(&context_x86->dr2);
+ Swap(&context_x86->dr3);
+ Swap(&context_x86->dr6);
+ Swap(&context_x86->dr7);
+ Swap(&context_x86->float_save.control_word);
+ Swap(&context_x86->float_save.status_word);
+ Swap(&context_x86->float_save.tag_word);
+ Swap(&context_x86->float_save.error_offset);
+ Swap(&context_x86->float_save.error_selector);
+ Swap(&context_x86->float_save.data_offset);
+ Swap(&context_x86->float_save.data_selector);
+ // context_x86->float_save.register_area[] contains 8-bit quantities
+ // and does not need to be swapped.
+ Swap(&context_x86->float_save.cr0_npx_state);
+ Swap(&context_x86->gs);
+ Swap(&context_x86->fs);
+ Swap(&context_x86->es);
+ Swap(&context_x86->ds);
+ Swap(&context_x86->edi);
+ Swap(&context_x86->esi);
+ Swap(&context_x86->ebx);
+ Swap(&context_x86->edx);
+ Swap(&context_x86->ecx);
+ Swap(&context_x86->eax);
+ Swap(&context_x86->ebp);
+ Swap(&context_x86->eip);
+ Swap(&context_x86->cs);
+ Swap(&context_x86->eflags);
+ Swap(&context_x86->esp);
+ Swap(&context_x86->ss);
+ // context_x86->extended_registers[] contains 8-bit quantities and
+ // does not need to be swapped.
+ }
+
+ SetContextX86(context_x86.release());
+
+ break;
+ }
+
+ case MD_CONTEXT_PPC: {
+ if (expected_size != sizeof(MDRawContextPPC)) {
+ BPLOG(ERROR) << "MinidumpContext ppc size mismatch, " <<
+ expected_size << " != " << sizeof(MDRawContextPPC);
+ return false;
+ }
+
+ scoped_ptr<MDRawContextPPC> context_ppc(new MDRawContextPPC());
+
+ // Set the context_flags member, which has already been read, and
+ // read the rest of the structure beginning with the first member
+ // after context_flags.
+ context_ppc->context_flags = context_flags;
+
+ size_t flags_size = sizeof(context_ppc->context_flags);
+ uint8_t* context_after_flags =
+ reinterpret_cast<uint8_t*>(context_ppc.get()) + flags_size;
+ if (!minidump_->ReadBytes(context_after_flags,
+ sizeof(MDRawContextPPC) - flags_size)) {
+ BPLOG(ERROR) << "MinidumpContext could not read ppc context";
+ return false;
+ }
+
+ // Do this after reading the entire MDRawContext structure because
+ // GetSystemInfo may seek minidump to a new position.
+ if (!CheckAgainstSystemInfo(cpu_type)) {
+ BPLOG(ERROR) << "MinidumpContext ppc does not match system info";
+ return false;
+ }
+
+ // Normalize the 128-bit types in the dump.
+ // Since this is PowerPC, by definition, the values are big-endian.
+ for (unsigned int vr_index = 0;
+ vr_index < MD_VECTORSAVEAREA_PPC_VR_COUNT;
+ ++vr_index) {
+ Normalize128(&context_ppc->vector_save.save_vr[vr_index], true);
+ }
+
+ if (minidump_->swap()) {
+ // context_ppc->context_flags was already swapped.
+ Swap(&context_ppc->srr0);
+ Swap(&context_ppc->srr1);
+ for (unsigned int gpr_index = 0;
+ gpr_index < MD_CONTEXT_PPC_GPR_COUNT;
+ ++gpr_index) {
+ Swap(&context_ppc->gpr[gpr_index]);
+ }
+ Swap(&context_ppc->cr);
+ Swap(&context_ppc->xer);
+ Swap(&context_ppc->lr);
+ Swap(&context_ppc->ctr);
+ Swap(&context_ppc->mq);
+ Swap(&context_ppc->vrsave);
+ for (unsigned int fpr_index = 0;
+ fpr_index < MD_FLOATINGSAVEAREA_PPC_FPR_COUNT;
+ ++fpr_index) {
+ Swap(&context_ppc->float_save.fpregs[fpr_index]);
+ }
+ // Don't swap context_ppc->float_save.fpscr_pad because it is only
+ // used for padding.
+ Swap(&context_ppc->float_save.fpscr);
+ for (unsigned int vr_index = 0;
+ vr_index < MD_VECTORSAVEAREA_PPC_VR_COUNT;
+ ++vr_index) {
+ Swap(&context_ppc->vector_save.save_vr[vr_index]);
+ }
+ Swap(&context_ppc->vector_save.save_vscr);
+ // Don't swap the padding fields in vector_save.
+ Swap(&context_ppc->vector_save.save_vrvalid);
+ }
+
+ SetContextPPC(context_ppc.release());
+
+ break;
+ }
+
+ case MD_CONTEXT_SPARC: {
+ if (expected_size != sizeof(MDRawContextSPARC)) {
+ BPLOG(ERROR) << "MinidumpContext sparc size mismatch, " <<
+ expected_size << " != " << sizeof(MDRawContextSPARC);
+ return false;
+ }
+
+ scoped_ptr<MDRawContextSPARC> context_sparc(new MDRawContextSPARC());
+
+ // Set the context_flags member, which has already been read, and
+ // read the rest of the structure beginning with the first member
+ // after context_flags.
+ context_sparc->context_flags = context_flags;
+
+ size_t flags_size = sizeof(context_sparc->context_flags);
+ uint8_t* context_after_flags =
+ reinterpret_cast<uint8_t*>(context_sparc.get()) + flags_size;
+ if (!minidump_->ReadBytes(context_after_flags,
+ sizeof(MDRawContextSPARC) - flags_size)) {
+ BPLOG(ERROR) << "MinidumpContext could not read sparc context";
+ return false;
+ }
+
+ // Do this after reading the entire MDRawContext structure because
+ // GetSystemInfo may seek minidump to a new position.
+ if (!CheckAgainstSystemInfo(cpu_type)) {
+ BPLOG(ERROR) << "MinidumpContext sparc does not match system info";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ // context_sparc->context_flags was already swapped.
+ for (unsigned int gpr_index = 0;
+ gpr_index < MD_CONTEXT_SPARC_GPR_COUNT;
+ ++gpr_index) {
+ Swap(&context_sparc->g_r[gpr_index]);
+ }
+ Swap(&context_sparc->ccr);
+ Swap(&context_sparc->pc);
+ Swap(&context_sparc->npc);
+ Swap(&context_sparc->y);
+ Swap(&context_sparc->asi);
+ Swap(&context_sparc->fprs);
+ for (unsigned int fpr_index = 0;
+ fpr_index < MD_FLOATINGSAVEAREA_SPARC_FPR_COUNT;
+ ++fpr_index) {
+ Swap(&context_sparc->float_save.regs[fpr_index]);
+ }
+ Swap(&context_sparc->float_save.filler);
+ Swap(&context_sparc->float_save.fsr);
+ }
+ SetContextSPARC(context_sparc.release());
+
+ break;
+ }
+
+ case MD_CONTEXT_ARM: {
+ if (expected_size != sizeof(MDRawContextARM)) {
+ BPLOG(ERROR) << "MinidumpContext arm size mismatch, " <<
+ expected_size << " != " << sizeof(MDRawContextARM);
+ return false;
+ }
+
+ scoped_ptr<MDRawContextARM> context_arm(new MDRawContextARM());
+
+ // Set the context_flags member, which has already been read, and
+ // read the rest of the structure beginning with the first member
+ // after context_flags.
+ context_arm->context_flags = context_flags;
+
+ size_t flags_size = sizeof(context_arm->context_flags);
+ uint8_t* context_after_flags =
+ reinterpret_cast<uint8_t*>(context_arm.get()) + flags_size;
+ if (!minidump_->ReadBytes(context_after_flags,
+ sizeof(MDRawContextARM) - flags_size)) {
+ BPLOG(ERROR) << "MinidumpContext could not read arm context";
+ return false;
+ }
+
+ // Do this after reading the entire MDRawContext structure because
+ // GetSystemInfo may seek minidump to a new position.
+ if (!CheckAgainstSystemInfo(cpu_type)) {
+ BPLOG(ERROR) << "MinidumpContext arm does not match system info";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ // context_arm->context_flags was already swapped.
+ for (unsigned int ireg_index = 0;
+ ireg_index < MD_CONTEXT_ARM_GPR_COUNT;
+ ++ireg_index) {
+ Swap(&context_arm->iregs[ireg_index]);
+ }
+ Swap(&context_arm->cpsr);
+ Swap(&context_arm->float_save.fpscr);
+ for (unsigned int fpr_index = 0;
+ fpr_index < MD_FLOATINGSAVEAREA_ARM_FPR_COUNT;
+ ++fpr_index) {
+ Swap(&context_arm->float_save.regs[fpr_index]);
+ }
+ for (unsigned int fpe_index = 0;
+ fpe_index < MD_FLOATINGSAVEAREA_ARM_FPEXTRA_COUNT;
+ ++fpe_index) {
+ Swap(&context_arm->float_save.extra[fpe_index]);
+ }
+ }
+ SetContextARM(context_arm.release());
+
+ break;
+ }
+
+ case MD_CONTEXT_MIPS:
+ case MD_CONTEXT_MIPS64: {
+ if (expected_size != sizeof(MDRawContextMIPS)) {
+ BPLOG(ERROR) << "MinidumpContext MIPS size mismatch, "
+ << expected_size
+ << " != "
+ << sizeof(MDRawContextMIPS);
+ return false;
+ }
+
+ scoped_ptr<MDRawContextMIPS> context_mips(new MDRawContextMIPS());
+
+ // Set the context_flags member, which has already been read, and
+ // read the rest of the structure beginning with the first member
+ // after context_flags.
+ context_mips->context_flags = context_flags;
+
+ size_t flags_size = sizeof(context_mips->context_flags);
+ uint8_t* context_after_flags =
+ reinterpret_cast<uint8_t*>(context_mips.get()) + flags_size;
+ if (!minidump_->ReadBytes(context_after_flags,
+ sizeof(MDRawContextMIPS) - flags_size)) {
+ BPLOG(ERROR) << "MinidumpContext could not read MIPS context";
+ return false;
+ }
+
+ // Do this after reading the entire MDRawContext structure because
+ // GetSystemInfo may seek minidump to a new position.
+ if (!CheckAgainstSystemInfo(cpu_type)) {
+ BPLOG(ERROR) << "MinidumpContext MIPS does not match system info";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ // context_mips->context_flags was already swapped.
+ for (int ireg_index = 0;
+ ireg_index < MD_CONTEXT_MIPS_GPR_COUNT;
+ ++ireg_index) {
+ Swap(&context_mips->iregs[ireg_index]);
+ }
+ Swap(&context_mips->mdhi);
+ Swap(&context_mips->mdlo);
+ for (int dsp_index = 0;
+ dsp_index < MD_CONTEXT_MIPS_DSP_COUNT;
+ ++dsp_index) {
+ Swap(&context_mips->hi[dsp_index]);
+ Swap(&context_mips->lo[dsp_index]);
+ }
+ Swap(&context_mips->dsp_control);
+ Swap(&context_mips->epc);
+ Swap(&context_mips->badvaddr);
+ Swap(&context_mips->status);
+ Swap(&context_mips->cause);
+ for (int fpr_index = 0;
+ fpr_index < MD_FLOATINGSAVEAREA_MIPS_FPR_COUNT;
+ ++fpr_index) {
+ Swap(&context_mips->float_save.regs[fpr_index]);
+ }
+ Swap(&context_mips->float_save.fpcsr);
+ Swap(&context_mips->float_save.fir);
+ }
+ SetContextMIPS(context_mips.release());
+
+ break;
+ }
+
+ default: {
+ // Unknown context type - Don't log as an error yet. Let the
+ // caller work that out.
+ BPLOG(INFO) << "MinidumpContext unknown context type " <<
+ HexString(cpu_type);
+ return false;
+ break;
+ }
+ }
+ SetContextFlags(context_flags);
+ }
+
+ valid_ = true;
+ return true;
+}
+
+bool MinidumpContext::CheckAgainstSystemInfo(uint32_t context_cpu_type) {
+ // It's OK if the minidump doesn't contain an MD_SYSTEM_INFO_STREAM,
+ // as this function just implements a sanity check.
+ MinidumpSystemInfo* system_info = minidump_->GetSystemInfo();
+ if (!system_info) {
+ BPLOG(INFO) << "MinidumpContext could not be compared against "
+ "MinidumpSystemInfo";
+ return true;
+ }
+
+ // If there is an MD_SYSTEM_INFO_STREAM, it should contain valid system info.
+ const MDRawSystemInfo* raw_system_info = system_info->system_info();
+ if (!raw_system_info) {
+ BPLOG(INFO) << "MinidumpContext could not be compared against "
+ "MDRawSystemInfo";
+ return false;
+ }
+
+ MDCPUArchitecture system_info_cpu_type = static_cast<MDCPUArchitecture>(
+ raw_system_info->processor_architecture);
+
+ // Compare the CPU type of the context record to the CPU type in the
+ // minidump's system info stream.
+ bool return_value = false;
+ switch (context_cpu_type) {
+ case MD_CONTEXT_X86:
+ if (system_info_cpu_type == MD_CPU_ARCHITECTURE_X86 ||
+ system_info_cpu_type == MD_CPU_ARCHITECTURE_X86_WIN64 ||
+ system_info_cpu_type == MD_CPU_ARCHITECTURE_AMD64) {
+ return_value = true;
+ }
+ break;
+
+ case MD_CONTEXT_PPC:
+ if (system_info_cpu_type == MD_CPU_ARCHITECTURE_PPC)
+ return_value = true;
+ break;
+
+ case MD_CONTEXT_PPC64:
+ if (system_info_cpu_type == MD_CPU_ARCHITECTURE_PPC64)
+ return_value = true;
+ break;
+
+ case MD_CONTEXT_AMD64:
+ if (system_info_cpu_type == MD_CPU_ARCHITECTURE_AMD64)
+ return_value = true;
+ break;
+
+ case MD_CONTEXT_SPARC:
+ if (system_info_cpu_type == MD_CPU_ARCHITECTURE_SPARC)
+ return_value = true;
+ break;
+
+ case MD_CONTEXT_ARM:
+ if (system_info_cpu_type == MD_CPU_ARCHITECTURE_ARM)
+ return_value = true;
+ break;
+
+ case MD_CONTEXT_ARM64:
+ if (system_info_cpu_type == MD_CPU_ARCHITECTURE_ARM64)
+ return_value = true;
+ break;
+
+ case MD_CONTEXT_MIPS:
+ if (system_info_cpu_type == MD_CPU_ARCHITECTURE_MIPS)
+ return_value = true;
+ break;
+
+ case MD_CONTEXT_MIPS64:
+ if (system_info_cpu_type == MD_CPU_ARCHITECTURE_MIPS64)
+ return_value = true;
+ break;
+ }
+
+ BPLOG_IF(ERROR, !return_value) << "MinidumpContext CPU " <<
+ HexString(context_cpu_type) <<
+ " wrong for MinidumpSystemInfo CPU " <<
+ HexString(system_info_cpu_type);
+
+ return return_value;
+}
+
+
+//
+// MinidumpMemoryRegion
+//
+
+
+uint32_t MinidumpMemoryRegion::max_bytes_ = 2 * 1024 * 1024; // 2MB
+
+
+MinidumpMemoryRegion::MinidumpMemoryRegion(Minidump* minidump)
+ : MinidumpObject(minidump),
+ descriptor_(NULL),
+ memory_(NULL) {
+}
+
+
+MinidumpMemoryRegion::~MinidumpMemoryRegion() {
+ delete memory_;
+}
+
+
+void MinidumpMemoryRegion::SetDescriptor(MDMemoryDescriptor* descriptor) {
+ descriptor_ = descriptor;
+ valid_ = descriptor &&
+ descriptor_->memory.data_size <=
+ numeric_limits<uint64_t>::max() -
+ descriptor_->start_of_memory_range;
+}
+
+
+const uint8_t* MinidumpMemoryRegion::GetMemory() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for GetMemory";
+ return NULL;
+ }
+
+ if (!memory_) {
+ if (descriptor_->memory.data_size == 0) {
+ BPLOG(ERROR) << "MinidumpMemoryRegion is empty";
+ return NULL;
+ }
+
+ if (!minidump_->SeekSet(descriptor_->memory.rva)) {
+ BPLOG(ERROR) << "MinidumpMemoryRegion could not seek to memory region";
+ return NULL;
+ }
+
+ if (descriptor_->memory.data_size > max_bytes_) {
+ BPLOG(ERROR) << "MinidumpMemoryRegion size " <<
+ descriptor_->memory.data_size << " exceeds maximum " <<
+ max_bytes_;
+ return NULL;
+ }
+
+ scoped_ptr< vector<uint8_t> > memory(
+ new vector<uint8_t>(descriptor_->memory.data_size));
+
+ if (!minidump_->ReadBytes(&(*memory)[0], descriptor_->memory.data_size)) {
+ BPLOG(ERROR) << "MinidumpMemoryRegion could not read memory region";
+ return NULL;
+ }
+
+ memory_ = memory.release();
+ }
+
+ return &(*memory_)[0];
+}
+
+
+uint64_t MinidumpMemoryRegion::GetBase() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for GetBase";
+ return static_cast<uint64_t>(-1);
+ }
+
+ return descriptor_->start_of_memory_range;
+}
+
+
+uint32_t MinidumpMemoryRegion::GetSize() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for GetSize";
+ return 0;
+ }
+
+ return descriptor_->memory.data_size;
+}
+
+
+void MinidumpMemoryRegion::FreeMemory() {
+ delete memory_;
+ memory_ = NULL;
+}
+
+
+template<typename T>
+bool MinidumpMemoryRegion::GetMemoryAtAddressInternal(uint64_t address,
+ T* value) const {
+ BPLOG_IF(ERROR, !value) << "MinidumpMemoryRegion::GetMemoryAtAddressInternal "
+ "requires |value|";
+ assert(value);
+ *value = 0;
+
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpMemoryRegion for "
+ "GetMemoryAtAddressInternal";
+ return false;
+ }
+
+ // Common failure case
+ if (address < descriptor_->start_of_memory_range ||
+ sizeof(T) > numeric_limits<uint64_t>::max() - address ||
+ address + sizeof(T) > descriptor_->start_of_memory_range +
+ descriptor_->memory.data_size) {
+ BPLOG(INFO) << "MinidumpMemoryRegion request out of range: " <<
+ HexString(address) << "+" << sizeof(T) << "/" <<
+ HexString(descriptor_->start_of_memory_range) << "+" <<
+ HexString(descriptor_->memory.data_size);
+ return false;
+ }
+
+ const uint8_t* memory = GetMemory();
+ if (!memory) {
+ // GetMemory already logged a perfectly good message.
+ return false;
+ }
+
+ // If the CPU requires memory accesses to be aligned, this can crash.
+ // x86 and ppc are able to cope, though.
+ *value = *reinterpret_cast<const T*>(
+ &memory[address - descriptor_->start_of_memory_range]);
+
+ if (minidump_->swap())
+ Swap(value);
+
+ return true;
+}
+
+
+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t address,
+ uint8_t* value) const {
+ return GetMemoryAtAddressInternal(address, value);
+}
+
+
+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t address,
+ uint16_t* value) const {
+ return GetMemoryAtAddressInternal(address, value);
+}
+
+
+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t address,
+ uint32_t* value) const {
+ return GetMemoryAtAddressInternal(address, value);
+}
+
+
+bool MinidumpMemoryRegion::GetMemoryAtAddress(uint64_t address,
+ uint64_t* value) const {
+ return GetMemoryAtAddressInternal(address, value);
+}
+
+
+void MinidumpMemoryRegion::Print() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpMemoryRegion cannot print invalid data";
+ return;
+ }
+
+ const uint8_t* memory = GetMemory();
+ if (memory) {
+ printf("0x");
+ for (unsigned int byte_index = 0;
+ byte_index < descriptor_->memory.data_size;
+ byte_index++) {
+ printf("%02x", memory[byte_index]);
+ }
+ printf("\n");
+ } else {
+ printf("No memory\n");
+ }
+}
+
+
+//
+// MinidumpThread
+//
+
+
+MinidumpThread::MinidumpThread(Minidump* minidump)
+ : MinidumpObject(minidump),
+ thread_(),
+ memory_(NULL),
+ context_(NULL) {
+}
+
+
+MinidumpThread::~MinidumpThread() {
+ delete memory_;
+ delete context_;
+}
+
+
+bool MinidumpThread::Read() {
+ // Invalidate cached data.
+ delete memory_;
+ memory_ = NULL;
+ delete context_;
+ context_ = NULL;
+
+ valid_ = false;
+
+ if (!minidump_->ReadBytes(&thread_, sizeof(thread_))) {
+ BPLOG(ERROR) << "MinidumpThread cannot read thread";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ Swap(&thread_.thread_id);
+ Swap(&thread_.suspend_count);
+ Swap(&thread_.priority_class);
+ Swap(&thread_.priority);
+ Swap(&thread_.teb);
+ Swap(&thread_.stack);
+ Swap(&thread_.thread_context);
+ }
+
+ // Check for base + size overflow or undersize.
+ if (thread_.stack.memory.rva == 0 ||
+ thread_.stack.memory.data_size == 0 ||
+ thread_.stack.memory.data_size > numeric_limits<uint64_t>::max() -
+ thread_.stack.start_of_memory_range) {
+ // This is ok, but log an error anyway.
+ BPLOG(ERROR) << "MinidumpThread has a memory region problem, " <<
+ HexString(thread_.stack.start_of_memory_range) << "+" <<
+ HexString(thread_.stack.memory.data_size) <<
+ ", RVA 0x" << HexString(thread_.stack.memory.rva);
+ } else {
+ memory_ = new MinidumpMemoryRegion(minidump_);
+ memory_->SetDescriptor(&thread_.stack);
+ }
+
+ valid_ = true;
+ return true;
+}
+
+uint64_t MinidumpThread::GetStartOfStackMemoryRange() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "GetStartOfStackMemoryRange: Invalid MinidumpThread";
+ return 0;
+ }
+
+ return thread_.stack.start_of_memory_range;
+}
+
+MinidumpMemoryRegion* MinidumpThread::GetMemory() {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpThread for GetMemory";
+ return NULL;
+ }
+
+ return memory_;
+}
+
+
+MinidumpContext* MinidumpThread::GetContext() {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpThread for GetContext";
+ return NULL;
+ }
+
+ if (!context_) {
+ if (!minidump_->SeekSet(thread_.thread_context.rva)) {
+ BPLOG(ERROR) << "MinidumpThread cannot seek to context";
+ return NULL;
+ }
+
+ scoped_ptr<MinidumpContext> context(new MinidumpContext(minidump_));
+
+ if (!context->Read(thread_.thread_context.data_size)) {
+ BPLOG(ERROR) << "MinidumpThread cannot read context";
+ return NULL;
+ }
+
+ context_ = context.release();
+ }
+
+ return context_;
+}
+
+
+bool MinidumpThread::GetThreadID(uint32_t *thread_id) const {
+ BPLOG_IF(ERROR, !thread_id) << "MinidumpThread::GetThreadID requires "
+ "|thread_id|";
+ assert(thread_id);
+ *thread_id = 0;
+
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpThread for GetThreadID";
+ return false;
+ }
+
+ *thread_id = thread_.thread_id;
+ return true;
+}
+
+
+void MinidumpThread::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpThread cannot print invalid data";
+ return;
+ }
+
+ printf("MDRawThread\n");
+ printf(" thread_id = 0x%x\n", thread_.thread_id);
+ printf(" suspend_count = %d\n", thread_.suspend_count);
+ printf(" priority_class = 0x%x\n", thread_.priority_class);
+ printf(" priority = 0x%x\n", thread_.priority);
+ printf(" teb = 0x%" PRIx64 "\n", thread_.teb);
+ printf(" stack.start_of_memory_range = 0x%" PRIx64 "\n",
+ thread_.stack.start_of_memory_range);
+ printf(" stack.memory.data_size = 0x%x\n",
+ thread_.stack.memory.data_size);
+ printf(" stack.memory.rva = 0x%x\n", thread_.stack.memory.rva);
+ printf(" thread_context.data_size = 0x%x\n",
+ thread_.thread_context.data_size);
+ printf(" thread_context.rva = 0x%x\n",
+ thread_.thread_context.rva);
+
+ MinidumpContext* context = GetContext();
+ if (context) {
+ printf("\n");
+ context->Print();
+ } else {
+ printf(" (no context)\n");
+ printf("\n");
+ }
+
+ MinidumpMemoryRegion* memory = GetMemory();
+ if (memory) {
+ printf("Stack\n");
+ memory->Print();
+ } else {
+ printf("No stack\n");
+ }
+ printf("\n");
+}
+
+
+//
+// MinidumpThreadList
+//
+
+
+uint32_t MinidumpThreadList::max_threads_ = 4096;
+
+
+MinidumpThreadList::MinidumpThreadList(Minidump* minidump)
+ : MinidumpStream(minidump),
+ id_to_thread_map_(),
+ threads_(NULL),
+ thread_count_(0) {
+}
+
+
+MinidumpThreadList::~MinidumpThreadList() {
+ delete threads_;
+}
+
+
+bool MinidumpThreadList::Read(uint32_t expected_size) {
+ // Invalidate cached data.
+ id_to_thread_map_.clear();
+ delete threads_;
+ threads_ = NULL;
+ thread_count_ = 0;
+
+ valid_ = false;
+
+ uint32_t thread_count;
+ if (expected_size < sizeof(thread_count)) {
+ BPLOG(ERROR) << "MinidumpThreadList count size mismatch, " <<
+ expected_size << " < " << sizeof(thread_count);
+ return false;
+ }
+ if (!minidump_->ReadBytes(&thread_count, sizeof(thread_count))) {
+ BPLOG(ERROR) << "MinidumpThreadList cannot read thread count";
+ return false;
+ }
+
+ if (minidump_->swap())
+ Swap(&thread_count);
+
+ if (thread_count > numeric_limits<uint32_t>::max() / sizeof(MDRawThread)) {
+ BPLOG(ERROR) << "MinidumpThreadList thread count " << thread_count <<
+ " would cause multiplication overflow";
+ return false;
+ }
+
+ if (expected_size != sizeof(thread_count) +
+ thread_count * sizeof(MDRawThread)) {
+ // may be padded with 4 bytes on 64bit ABIs for alignment
+ if (expected_size == sizeof(thread_count) + 4 +
+ thread_count * sizeof(MDRawThread)) {
+ uint32_t useless;
+ if (!minidump_->ReadBytes(&useless, 4)) {
+ BPLOG(ERROR) << "MinidumpThreadList cannot read threadlist padded "
+ "bytes";
+ return false;
+ }
+ } else {
+ BPLOG(ERROR) << "MinidumpThreadList size mismatch, " << expected_size <<
+ " != " << sizeof(thread_count) +
+ thread_count * sizeof(MDRawThread);
+ return false;
+ }
+ }
+
+
+ if (thread_count > max_threads_) {
+ BPLOG(ERROR) << "MinidumpThreadList count " << thread_count <<
+ " exceeds maximum " << max_threads_;
+ return false;
+ }
+
+ if (thread_count != 0) {
+ scoped_ptr<MinidumpThreads> threads(
+ new MinidumpThreads(thread_count, MinidumpThread(minidump_)));
+
+ for (unsigned int thread_index = 0;
+ thread_index < thread_count;
+ ++thread_index) {
+ MinidumpThread* thread = &(*threads)[thread_index];
+
+ // Assume that the file offset is correct after the last read.
+ if (!thread->Read()) {
+ BPLOG(ERROR) << "MinidumpThreadList cannot read thread " <<
+ thread_index << "/" << thread_count;
+ return false;
+ }
+
+ uint32_t thread_id;
+ if (!thread->GetThreadID(&thread_id)) {
+ BPLOG(ERROR) << "MinidumpThreadList cannot get thread ID for thread " <<
+ thread_index << "/" << thread_count;
+ return false;
+ }
+
+ if (GetThreadByID(thread_id)) {
+ // Another thread with this ID is already in the list. Data error.
+ BPLOG(ERROR) << "MinidumpThreadList found multiple threads with ID " <<
+ HexString(thread_id) << " at thread " <<
+ thread_index << "/" << thread_count;
+ return false;
+ }
+ id_to_thread_map_[thread_id] = thread;
+ }
+
+ threads_ = threads.release();
+ }
+
+ thread_count_ = thread_count;
+
+ valid_ = true;
+ return true;
+}
+
+
+MinidumpThread* MinidumpThreadList::GetThreadAtIndex(unsigned int index)
+ const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpThreadList for GetThreadAtIndex";
+ return NULL;
+ }
+
+ if (index >= thread_count_) {
+ BPLOG(ERROR) << "MinidumpThreadList index out of range: " <<
+ index << "/" << thread_count_;
+ return NULL;
+ }
+
+ return &(*threads_)[index];
+}
+
+
+MinidumpThread* MinidumpThreadList::GetThreadByID(uint32_t thread_id) {
+ // Don't check valid_. Read calls this method before everything is
+ // validated. It is safe to not check valid_ here.
+ return id_to_thread_map_[thread_id];
+}
+
+
+void MinidumpThreadList::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpThreadList cannot print invalid data";
+ return;
+ }
+
+ printf("MinidumpThreadList\n");
+ printf(" thread_count = %d\n", thread_count_);
+ printf("\n");
+
+ for (unsigned int thread_index = 0;
+ thread_index < thread_count_;
+ ++thread_index) {
+ printf("thread[%d]\n", thread_index);
+
+ (*threads_)[thread_index].Print();
+ }
+}
+
+
+//
+// MinidumpModule
+//
+
+
+uint32_t MinidumpModule::max_cv_bytes_ = 32768;
+uint32_t MinidumpModule::max_misc_bytes_ = 32768;
+
+
+MinidumpModule::MinidumpModule(Minidump* minidump)
+ : MinidumpObject(minidump),
+ module_valid_(false),
+ has_debug_info_(false),
+ module_(),
+ name_(NULL),
+ cv_record_(NULL),
+ cv_record_signature_(MD_CVINFOUNKNOWN_SIGNATURE),
+ misc_record_(NULL) {
+}
+
+
+MinidumpModule::~MinidumpModule() {
+ delete name_;
+ delete cv_record_;
+ delete misc_record_;
+}
+
+
+bool MinidumpModule::Read() {
+ // Invalidate cached data.
+ delete name_;
+ name_ = NULL;
+ delete cv_record_;
+ cv_record_ = NULL;
+ cv_record_signature_ = MD_CVINFOUNKNOWN_SIGNATURE;
+ delete misc_record_;
+ misc_record_ = NULL;
+
+ module_valid_ = false;
+ has_debug_info_ = false;
+ valid_ = false;
+
+ if (!minidump_->ReadBytes(&module_, MD_MODULE_SIZE)) {
+ BPLOG(ERROR) << "MinidumpModule cannot read module";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ Swap(&module_.base_of_image);
+ Swap(&module_.size_of_image);
+ Swap(&module_.checksum);
+ Swap(&module_.time_date_stamp);
+ Swap(&module_.module_name_rva);
+ Swap(&module_.version_info.signature);
+ Swap(&module_.version_info.struct_version);
+ Swap(&module_.version_info.file_version_hi);
+ Swap(&module_.version_info.file_version_lo);
+ Swap(&module_.version_info.product_version_hi);
+ Swap(&module_.version_info.product_version_lo);
+ Swap(&module_.version_info.file_flags_mask);
+ Swap(&module_.version_info.file_flags);
+ Swap(&module_.version_info.file_os);
+ Swap(&module_.version_info.file_type);
+ Swap(&module_.version_info.file_subtype);
+ Swap(&module_.version_info.file_date_hi);
+ Swap(&module_.version_info.file_date_lo);
+ Swap(&module_.cv_record);
+ Swap(&module_.misc_record);
+ // Don't swap reserved fields because their contents are unknown (as
+ // are their proper widths).
+ }
+
+ // Check for base + size overflow or undersize.
+ if (module_.size_of_image == 0 ||
+ module_.size_of_image >
+ numeric_limits<uint64_t>::max() - module_.base_of_image) {
+ BPLOG(ERROR) << "MinidumpModule has a module problem, " <<
+ HexString(module_.base_of_image) << "+" <<
+ HexString(module_.size_of_image);
+ return false;
+ }
+
+ module_valid_ = true;
+ return true;
+}
+
+
+bool MinidumpModule::ReadAuxiliaryData() {
+ if (!module_valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModule for ReadAuxiliaryData";
+ return false;
+ }
+
+ // Each module must have a name.
+ name_ = minidump_->ReadString(module_.module_name_rva);
+ if (!name_) {
+ BPLOG(ERROR) << "MinidumpModule could not read name";
+ return false;
+ }
+
+ // At this point, we have enough info for the module to be valid.
+ valid_ = true;
+
+ // CodeView and miscellaneous debug records are only required if the
+ // module indicates that they exist.
+ if (module_.cv_record.data_size && !GetCVRecord(NULL)) {
+ BPLOG(ERROR) << "MinidumpModule has no CodeView record, "
+ "but one was expected";
+ return false;
+ }
+
+ if (module_.misc_record.data_size && !GetMiscRecord(NULL)) {
+ BPLOG(ERROR) << "MinidumpModule has no miscellaneous debug record, "
+ "but one was expected";
+ return false;
+ }
+
+ has_debug_info_ = true;
+ return true;
+}
+
+
+string MinidumpModule::code_file() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModule for code_file";
+ return "";
+ }
+
+ return *name_;
+}
+
+
+string MinidumpModule::code_identifier() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModule for code_identifier";
+ return "";
+ }
+
+ if (!has_debug_info_)
+ return "";
+
+ MinidumpSystemInfo *minidump_system_info = minidump_->GetSystemInfo();
+ if (!minidump_system_info) {
+ BPLOG(ERROR) << "MinidumpModule code_identifier requires "
+ "MinidumpSystemInfo";
+ return "";
+ }
+
+ const MDRawSystemInfo *raw_system_info = minidump_system_info->system_info();
+ if (!raw_system_info) {
+ BPLOG(ERROR) << "MinidumpModule code_identifier requires MDRawSystemInfo";
+ return "";
+ }
+
+ string identifier;
+
+ switch (raw_system_info->platform_id) {
+ case MD_OS_WIN32_NT:
+ case MD_OS_WIN32_WINDOWS: {
+ // Use the same format that the MS symbol server uses in filesystem
+ // hierarchies.
+ char identifier_string[17];
+ snprintf(identifier_string, sizeof(identifier_string), "%08X%x",
+ module_.time_date_stamp, module_.size_of_image);
+ identifier = identifier_string;
+ break;
+ }
+
+ case MD_OS_ANDROID:
+ case MD_OS_LINUX: {
+ // If ELF CodeView data is present, return the debug id.
+ if (cv_record_ && cv_record_signature_ == MD_CVINFOELF_SIGNATURE) {
+ const MDCVInfoELF* cv_record_elf =
+ reinterpret_cast<const MDCVInfoELF*>(&(*cv_record_)[0]);
+ assert(cv_record_elf->cv_signature == MD_CVINFOELF_SIGNATURE);
+
+ for (unsigned int build_id_index = 0;
+ build_id_index < (cv_record_->size() - MDCVInfoELF_minsize);
+ ++build_id_index) {
+ char hexbyte[3];
+ snprintf(hexbyte, sizeof(hexbyte), "%02x",
+ cv_record_elf->build_id[build_id_index]);
+ identifier += hexbyte;
+ }
+ break;
+ }
+ // Otherwise fall through to the case below.
+ }
+
+ case MD_OS_MAC_OS_X:
+ case MD_OS_IOS:
+ case MD_OS_SOLARIS:
+ case MD_OS_NACL:
+ case MD_OS_PS3: {
+ // TODO(mmentovai): support uuid extension if present, otherwise fall
+ // back to version (from LC_ID_DYLIB?), otherwise fall back to something
+ // else.
+ identifier = "id";
+ break;
+ }
+
+ default: {
+ // Without knowing what OS generated the dump, we can't generate a good
+ // identifier. Return an empty string, signalling failure.
+ BPLOG(ERROR) << "MinidumpModule code_identifier requires known platform, "
+ "found " << HexString(raw_system_info->platform_id);
+ break;
+ }
+ }
+
+ return identifier;
+}
+
+
+string MinidumpModule::debug_file() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModule for debug_file";
+ return "";
+ }
+
+ if (!has_debug_info_)
+ return "";
+
+ string file;
+ // Prefer the CodeView record if present.
+ if (cv_record_) {
+ if (cv_record_signature_ == MD_CVINFOPDB70_SIGNATURE) {
+ // It's actually an MDCVInfoPDB70 structure.
+ const MDCVInfoPDB70* cv_record_70 =
+ reinterpret_cast<const MDCVInfoPDB70*>(&(*cv_record_)[0]);
+ assert(cv_record_70->cv_signature == MD_CVINFOPDB70_SIGNATURE);
+
+ // GetCVRecord guarantees pdb_file_name is null-terminated.
+ file = reinterpret_cast<const char*>(cv_record_70->pdb_file_name);
+ } else if (cv_record_signature_ == MD_CVINFOPDB20_SIGNATURE) {
+ // It's actually an MDCVInfoPDB20 structure.
+ const MDCVInfoPDB20* cv_record_20 =
+ reinterpret_cast<const MDCVInfoPDB20*>(&(*cv_record_)[0]);
+ assert(cv_record_20->cv_header.signature == MD_CVINFOPDB20_SIGNATURE);
+
+ // GetCVRecord guarantees pdb_file_name is null-terminated.
+ file = reinterpret_cast<const char*>(cv_record_20->pdb_file_name);
+ } else if (cv_record_signature_ == MD_CVINFOELF_SIGNATURE) {
+ // It's actually an MDCVInfoELF structure.
+ assert(reinterpret_cast<const MDCVInfoELF*>(&(*cv_record_)[0])->
+ cv_signature == MD_CVINFOELF_SIGNATURE);
+
+ // For MDCVInfoELF, the debug file is the code file.
+ file = *name_;
+ }
+
+ // If there's a CodeView record but it doesn't match a known signature,
+ // try the miscellaneous record.
+ }
+
+ if (file.empty()) {
+ // No usable CodeView record. Try the miscellaneous debug record.
+ if (misc_record_) {
+ const MDImageDebugMisc* misc_record =
+ reinterpret_cast<const MDImageDebugMisc *>(&(*misc_record_)[0]);
+ if (!misc_record->unicode) {
+ // If it's not Unicode, just stuff it into the string. It's unclear
+ // if misc_record->data is 0-terminated, so use an explicit size.
+ file = string(
+ reinterpret_cast<const char*>(misc_record->data),
+ module_.misc_record.data_size - MDImageDebugMisc_minsize);
+ } else {
+ // There's a misc_record but it encodes the debug filename in UTF-16.
+ // (Actually, because miscellaneous records are so old, it's probably
+ // UCS-2.) Convert it to UTF-8 for congruity with the other strings
+ // that this method (and all other methods in the Minidump family)
+ // return.
+
+ unsigned int bytes =
+ module_.misc_record.data_size - MDImageDebugMisc_minsize;
+ if (bytes % 2 == 0) {
+ unsigned int utf16_words = bytes / 2;
+
+ // UTF16ToUTF8 expects a vector<uint16_t>, so create a temporary one
+ // and copy the UTF-16 data into it.
+ vector<uint16_t> string_utf16(utf16_words);
+ if (utf16_words)
+ memcpy(&string_utf16[0], &misc_record->data, bytes);
+
+ // GetMiscRecord already byte-swapped the data[] field if it contains
+ // UTF-16, so pass false as the swap argument.
+ scoped_ptr<string> new_file(UTF16ToUTF8(string_utf16, false));
+ file = *new_file;
+ }
+ }
+ }
+ }
+
+ // Relatively common case
+ BPLOG_IF(INFO, file.empty()) << "MinidumpModule could not determine "
+ "debug_file for " << *name_;
+
+ return file;
+}
+
+static string guid_and_age_to_debug_id(const MDGUID& guid,
+ uint32_t age) {
+ char identifier_string[41];
+ snprintf(identifier_string, sizeof(identifier_string),
+ "%08X%04X%04X%02X%02X%02X%02X%02X%02X%02X%02X%x",
+ guid.data1,
+ guid.data2,
+ guid.data3,
+ guid.data4[0],
+ guid.data4[1],
+ guid.data4[2],
+ guid.data4[3],
+ guid.data4[4],
+ guid.data4[5],
+ guid.data4[6],
+ guid.data4[7],
+ age);
+ return identifier_string;
+}
+
+string MinidumpModule::debug_identifier() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModule for debug_identifier";
+ return "";
+ }
+
+ if (!has_debug_info_)
+ return "";
+
+ string identifier;
+
+ // Use the CodeView record if present.
+ if (cv_record_) {
+ if (cv_record_signature_ == MD_CVINFOPDB70_SIGNATURE) {
+ // It's actually an MDCVInfoPDB70 structure.
+ const MDCVInfoPDB70* cv_record_70 =
+ reinterpret_cast<const MDCVInfoPDB70*>(&(*cv_record_)[0]);
+ assert(cv_record_70->cv_signature == MD_CVINFOPDB70_SIGNATURE);
+
+ // Use the same format that the MS symbol server uses in filesystem
+ // hierarchies.
+ identifier = guid_and_age_to_debug_id(cv_record_70->signature,
+ cv_record_70->age);
+ } else if (cv_record_signature_ == MD_CVINFOPDB20_SIGNATURE) {
+ // It's actually an MDCVInfoPDB20 structure.
+ const MDCVInfoPDB20* cv_record_20 =
+ reinterpret_cast<const MDCVInfoPDB20*>(&(*cv_record_)[0]);
+ assert(cv_record_20->cv_header.signature == MD_CVINFOPDB20_SIGNATURE);
+
+ // Use the same format that the MS symbol server uses in filesystem
+ // hierarchies.
+ char identifier_string[17];
+ snprintf(identifier_string, sizeof(identifier_string),
+ "%08X%x", cv_record_20->signature, cv_record_20->age);
+ identifier = identifier_string;
+ } else if (cv_record_signature_ == MD_CVINFOELF_SIGNATURE) {
+ // It's actually an MDCVInfoELF structure.
+ const MDCVInfoELF* cv_record_elf =
+ reinterpret_cast<const MDCVInfoELF*>(&(*cv_record_)[0]);
+ assert(cv_record_elf->cv_signature == MD_CVINFOELF_SIGNATURE);
+
+ // For backwards-compatibility, stuff as many bytes as will fit into
+ // a MDGUID and use the MS symbol server format as MDCVInfoPDB70 does
+ // with age = 0. Historically Breakpad would do this during dump
+ // writing to fit the build id data into a MDCVInfoPDB70 struct.
+ // The full build id is available by calling code_identifier.
+ MDGUID guid = {0};
+ memcpy(&guid, &cv_record_elf->build_id,
+ std::min(cv_record_->size() - MDCVInfoELF_minsize,
+ sizeof(MDGUID)));
+ identifier = guid_and_age_to_debug_id(guid, 0);
+ }
+ }
+
+ // TODO(mmentovai): if there's no usable CodeView record, there might be a
+ // miscellaneous debug record. It only carries a filename, though, and no
+ // identifier. I'm not sure what the right thing to do for the identifier
+ // is in that case, but I don't expect to find many modules without a
+ // CodeView record (or some other Breakpad extension structure in place of
+ // a CodeView record). Treat it as an error (empty identifier) for now.
+
+ // TODO(mmentovai): on the Mac, provide fallbacks as in code_identifier().
+
+ // Relatively common case
+ BPLOG_IF(INFO, identifier.empty()) << "MinidumpModule could not determine "
+ "debug_identifier for " << *name_;
+
+ return identifier;
+}
+
+
+string MinidumpModule::version() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModule for version";
+ return "";
+ }
+
+ string version;
+
+ if (module_.version_info.signature == MD_VSFIXEDFILEINFO_SIGNATURE &&
+ module_.version_info.struct_version & MD_VSFIXEDFILEINFO_VERSION) {
+ char version_string[24];
+ snprintf(version_string, sizeof(version_string), "%u.%u.%u.%u",
+ module_.version_info.file_version_hi >> 16,
+ module_.version_info.file_version_hi & 0xffff,
+ module_.version_info.file_version_lo >> 16,
+ module_.version_info.file_version_lo & 0xffff);
+ version = version_string;
+ }
+
+ // TODO(mmentovai): possibly support other struct types in place of
+ // the one used with MD_VSFIXEDFILEINFO_SIGNATURE. We can possibly use
+ // a different structure that better represents versioning facilities on
+ // Mac OS X and Linux, instead of forcing them to adhere to the dotted
+ // quad of 16-bit ints that Windows uses.
+
+ BPLOG_IF(INFO, version.empty()) << "MinidumpModule could not determine "
+ "version for " << *name_;
+
+ return version;
+}
+
+
+CodeModule* MinidumpModule::Copy() const {
+ return new BasicCodeModule(this);
+}
+
+
+uint64_t MinidumpModule::shrink_down_delta() const {
+ return 0;
+}
+
+void MinidumpModule::SetShrinkDownDelta(uint64_t shrink_down_delta) {
+ // Not implemented
+ assert(false);
+}
+
+
+const uint8_t* MinidumpModule::GetCVRecord(uint32_t* size) {
+ if (!module_valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModule for GetCVRecord";
+ return NULL;
+ }
+
+ if (!cv_record_) {
+ // This just guards against 0-sized CodeView records; more specific checks
+ // are used when the signature is checked against various structure types.
+ if (module_.cv_record.data_size == 0) {
+ return NULL;
+ }
+
+ if (!minidump_->SeekSet(module_.cv_record.rva)) {
+ BPLOG(ERROR) << "MinidumpModule could not seek to CodeView record";
+ return NULL;
+ }
+
+ if (module_.cv_record.data_size > max_cv_bytes_) {
+ BPLOG(ERROR) << "MinidumpModule CodeView record size " <<
+ module_.cv_record.data_size << " exceeds maximum " <<
+ max_cv_bytes_;
+ return NULL;
+ }
+
+ // Allocating something that will be accessed as MDCVInfoPDB70 or
+ // MDCVInfoPDB20 but is allocated as uint8_t[] can cause alignment
+ // problems. x86 and ppc are able to cope, though. This allocation
+ // style is needed because the MDCVInfoPDB70 or MDCVInfoPDB20 are
+ // variable-sized due to their pdb_file_name fields; these structures
+ // are not MDCVInfoPDB70_minsize or MDCVInfoPDB20_minsize and treating
+ // them as such would result in incomplete structures or overruns.
+ scoped_ptr< vector<uint8_t> > cv_record(
+ new vector<uint8_t>(module_.cv_record.data_size));
+
+ if (!minidump_->ReadBytes(&(*cv_record)[0], module_.cv_record.data_size)) {
+ BPLOG(ERROR) << "MinidumpModule could not read CodeView record";
+ return NULL;
+ }
+
+ uint32_t signature = MD_CVINFOUNKNOWN_SIGNATURE;
+ if (module_.cv_record.data_size > sizeof(signature)) {
+ MDCVInfoPDB70* cv_record_signature =
+ reinterpret_cast<MDCVInfoPDB70*>(&(*cv_record)[0]);
+ signature = cv_record_signature->cv_signature;
+ if (minidump_->swap())
+ Swap(&signature);
+ }
+
+ if (signature == MD_CVINFOPDB70_SIGNATURE) {
+ // Now that the structure type is known, recheck the size.
+ if (MDCVInfoPDB70_minsize > module_.cv_record.data_size) {
+ BPLOG(ERROR) << "MinidumpModule CodeView7 record size mismatch, " <<
+ MDCVInfoPDB70_minsize << " > " <<
+ module_.cv_record.data_size;
+ return NULL;
+ }
+
+ if (minidump_->swap()) {
+ MDCVInfoPDB70* cv_record_70 =
+ reinterpret_cast<MDCVInfoPDB70*>(&(*cv_record)[0]);
+ Swap(&cv_record_70->cv_signature);
+ Swap(&cv_record_70->signature);
+ Swap(&cv_record_70->age);
+ // Don't swap cv_record_70.pdb_file_name because it's an array of 8-bit
+ // quantities. (It's a path, is it UTF-8?)
+ }
+
+ // The last field of either structure is null-terminated 8-bit character
+ // data. Ensure that it's null-terminated.
+ if ((*cv_record)[module_.cv_record.data_size - 1] != '\0') {
+ BPLOG(ERROR) << "MinidumpModule CodeView7 record string is not "
+ "0-terminated";
+ return NULL;
+ }
+ } else if (signature == MD_CVINFOPDB20_SIGNATURE) {
+ // Now that the structure type is known, recheck the size.
+ if (MDCVInfoPDB20_minsize > module_.cv_record.data_size) {
+ BPLOG(ERROR) << "MinidumpModule CodeView2 record size mismatch, " <<
+ MDCVInfoPDB20_minsize << " > " <<
+ module_.cv_record.data_size;
+ return NULL;
+ }
+ if (minidump_->swap()) {
+ MDCVInfoPDB20* cv_record_20 =
+ reinterpret_cast<MDCVInfoPDB20*>(&(*cv_record)[0]);
+ Swap(&cv_record_20->cv_header.signature);
+ Swap(&cv_record_20->cv_header.offset);
+ Swap(&cv_record_20->signature);
+ Swap(&cv_record_20->age);
+ // Don't swap cv_record_20.pdb_file_name because it's an array of 8-bit
+ // quantities. (It's a path, is it UTF-8?)
+ }
+
+ // The last field of either structure is null-terminated 8-bit character
+ // data. Ensure that it's null-terminated.
+ if ((*cv_record)[module_.cv_record.data_size - 1] != '\0') {
+ BPLOG(ERROR) << "MindumpModule CodeView2 record string is not "
+ "0-terminated";
+ return NULL;
+ }
+ } else if (signature == MD_CVINFOELF_SIGNATURE) {
+ // Now that the structure type is known, recheck the size.
+ if (MDCVInfoELF_minsize > module_.cv_record.data_size) {
+ BPLOG(ERROR) << "MinidumpModule CodeViewELF record size mismatch, " <<
+ MDCVInfoELF_minsize << " > " <<
+ module_.cv_record.data_size;
+ return NULL;
+ }
+ // There's nothing to swap in CVInfoELF, it's just raw bytes.
+ }
+
+ // If the signature doesn't match something above, it's not something
+ // that Breakpad can presently handle directly. Because some modules in
+ // the wild contain such CodeView records as MD_CVINFOCV50_SIGNATURE,
+ // don't bail out here - allow the data to be returned to the user,
+ // although byte-swapping can't be done.
+
+ // Store the vector type because that's how storage was allocated, but
+ // return it casted to uint8_t*.
+ cv_record_ = cv_record.release();
+ cv_record_signature_ = signature;
+ }
+
+ if (size)
+ *size = module_.cv_record.data_size;
+
+ return &(*cv_record_)[0];
+}
+
+
+const MDImageDebugMisc* MinidumpModule::GetMiscRecord(uint32_t* size) {
+ if (!module_valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModule for GetMiscRecord";
+ return NULL;
+ }
+
+ if (!misc_record_) {
+ if (module_.misc_record.data_size == 0) {
+ return NULL;
+ }
+
+ if (MDImageDebugMisc_minsize > module_.misc_record.data_size) {
+ BPLOG(ERROR) << "MinidumpModule miscellaneous debugging record "
+ "size mismatch, " << MDImageDebugMisc_minsize << " > " <<
+ module_.misc_record.data_size;
+ return NULL;
+ }
+
+ if (!minidump_->SeekSet(module_.misc_record.rva)) {
+ BPLOG(ERROR) << "MinidumpModule could not seek to miscellaneous "
+ "debugging record";
+ return NULL;
+ }
+
+ if (module_.misc_record.data_size > max_misc_bytes_) {
+ BPLOG(ERROR) << "MinidumpModule miscellaneous debugging record size " <<
+ module_.misc_record.data_size << " exceeds maximum " <<
+ max_misc_bytes_;
+ return NULL;
+ }
+
+ // Allocating something that will be accessed as MDImageDebugMisc but
+ // is allocated as uint8_t[] can cause alignment problems. x86 and
+ // ppc are able to cope, though. This allocation style is needed
+ // because the MDImageDebugMisc is variable-sized due to its data field;
+ // this structure is not MDImageDebugMisc_minsize and treating it as such
+ // would result in an incomplete structure or an overrun.
+ scoped_ptr< vector<uint8_t> > misc_record_mem(
+ new vector<uint8_t>(module_.misc_record.data_size));
+ MDImageDebugMisc* misc_record =
+ reinterpret_cast<MDImageDebugMisc*>(&(*misc_record_mem)[0]);
+
+ if (!minidump_->ReadBytes(misc_record, module_.misc_record.data_size)) {
+ BPLOG(ERROR) << "MinidumpModule could not read miscellaneous debugging "
+ "record";
+ return NULL;
+ }
+
+ if (minidump_->swap()) {
+ Swap(&misc_record->data_type);
+ Swap(&misc_record->length);
+ // Don't swap misc_record.unicode because it's an 8-bit quantity.
+ // Don't swap the reserved fields for the same reason, and because
+ // they don't contain any valid data.
+ if (misc_record->unicode) {
+ // There is a potential alignment problem, but shouldn't be a problem
+ // in practice due to the layout of MDImageDebugMisc.
+ uint16_t* data16 = reinterpret_cast<uint16_t*>(&(misc_record->data));
+ unsigned int dataBytes = module_.misc_record.data_size -
+ MDImageDebugMisc_minsize;
+ Swap(data16, dataBytes);
+ }
+ }
+
+ if (module_.misc_record.data_size != misc_record->length) {
+ BPLOG(ERROR) << "MinidumpModule miscellaneous debugging record data "
+ "size mismatch, " << module_.misc_record.data_size <<
+ " != " << misc_record->length;
+ return NULL;
+ }
+
+ // Store the vector type because that's how storage was allocated, but
+ // return it casted to MDImageDebugMisc*.
+ misc_record_ = misc_record_mem.release();
+ }
+
+ if (size)
+ *size = module_.misc_record.data_size;
+
+ return reinterpret_cast<MDImageDebugMisc*>(&(*misc_record_)[0]);
+}
+
+
+void MinidumpModule::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpModule cannot print invalid data";
+ return;
+ }
+
+ printf("MDRawModule\n");
+ printf(" base_of_image = 0x%" PRIx64 "\n",
+ module_.base_of_image);
+ printf(" size_of_image = 0x%x\n",
+ module_.size_of_image);
+ printf(" checksum = 0x%x\n",
+ module_.checksum);
+ printf(" time_date_stamp = 0x%x %s\n",
+ module_.time_date_stamp,
+ TimeTToUTCString(module_.time_date_stamp).c_str());
+ printf(" module_name_rva = 0x%x\n",
+ module_.module_name_rva);
+ printf(" version_info.signature = 0x%x\n",
+ module_.version_info.signature);
+ printf(" version_info.struct_version = 0x%x\n",
+ module_.version_info.struct_version);
+ printf(" version_info.file_version = 0x%x:0x%x\n",
+ module_.version_info.file_version_hi,
+ module_.version_info.file_version_lo);
+ printf(" version_info.product_version = 0x%x:0x%x\n",
+ module_.version_info.product_version_hi,
+ module_.version_info.product_version_lo);
+ printf(" version_info.file_flags_mask = 0x%x\n",
+ module_.version_info.file_flags_mask);
+ printf(" version_info.file_flags = 0x%x\n",
+ module_.version_info.file_flags);
+ printf(" version_info.file_os = 0x%x\n",
+ module_.version_info.file_os);
+ printf(" version_info.file_type = 0x%x\n",
+ module_.version_info.file_type);
+ printf(" version_info.file_subtype = 0x%x\n",
+ module_.version_info.file_subtype);
+ printf(" version_info.file_date = 0x%x:0x%x\n",
+ module_.version_info.file_date_hi,
+ module_.version_info.file_date_lo);
+ printf(" cv_record.data_size = %d\n",
+ module_.cv_record.data_size);
+ printf(" cv_record.rva = 0x%x\n",
+ module_.cv_record.rva);
+ printf(" misc_record.data_size = %d\n",
+ module_.misc_record.data_size);
+ printf(" misc_record.rva = 0x%x\n",
+ module_.misc_record.rva);
+
+ printf(" (code_file) = \"%s\"\n", code_file().c_str());
+ printf(" (code_identifier) = \"%s\"\n",
+ code_identifier().c_str());
+
+ uint32_t cv_record_size;
+ const uint8_t *cv_record = GetCVRecord(&cv_record_size);
+ if (cv_record) {
+ if (cv_record_signature_ == MD_CVINFOPDB70_SIGNATURE) {
+ const MDCVInfoPDB70* cv_record_70 =
+ reinterpret_cast<const MDCVInfoPDB70*>(cv_record);
+ assert(cv_record_70->cv_signature == MD_CVINFOPDB70_SIGNATURE);
+
+ printf(" (cv_record).cv_signature = 0x%x\n",
+ cv_record_70->cv_signature);
+ printf(" (cv_record).signature = %08x-%04x-%04x-%02x%02x-",
+ cv_record_70->signature.data1,
+ cv_record_70->signature.data2,
+ cv_record_70->signature.data3,
+ cv_record_70->signature.data4[0],
+ cv_record_70->signature.data4[1]);
+ for (unsigned int guidIndex = 2;
+ guidIndex < 8;
+ ++guidIndex) {
+ printf("%02x", cv_record_70->signature.data4[guidIndex]);
+ }
+ printf("\n");
+ printf(" (cv_record).age = %d\n",
+ cv_record_70->age);
+ printf(" (cv_record).pdb_file_name = \"%s\"\n",
+ cv_record_70->pdb_file_name);
+ } else if (cv_record_signature_ == MD_CVINFOPDB20_SIGNATURE) {
+ const MDCVInfoPDB20* cv_record_20 =
+ reinterpret_cast<const MDCVInfoPDB20*>(cv_record);
+ assert(cv_record_20->cv_header.signature == MD_CVINFOPDB20_SIGNATURE);
+
+ printf(" (cv_record).cv_header.signature = 0x%x\n",
+ cv_record_20->cv_header.signature);
+ printf(" (cv_record).cv_header.offset = 0x%x\n",
+ cv_record_20->cv_header.offset);
+ printf(" (cv_record).signature = 0x%x %s\n",
+ cv_record_20->signature,
+ TimeTToUTCString(cv_record_20->signature).c_str());
+ printf(" (cv_record).age = %d\n",
+ cv_record_20->age);
+ printf(" (cv_record).pdb_file_name = \"%s\"\n",
+ cv_record_20->pdb_file_name);
+ } else if (cv_record_signature_ == MD_CVINFOELF_SIGNATURE) {
+ const MDCVInfoELF* cv_record_elf =
+ reinterpret_cast<const MDCVInfoELF*>(cv_record);
+ assert(cv_record_elf->cv_signature == MD_CVINFOELF_SIGNATURE);
+
+ printf(" (cv_record).cv_signature = 0x%x\n",
+ cv_record_elf->cv_signature);
+ printf(" (cv_record).build_id = ");
+ for (unsigned int build_id_index = 0;
+ build_id_index < (cv_record_size - MDCVInfoELF_minsize);
+ ++build_id_index) {
+ printf("%02x", cv_record_elf->build_id[build_id_index]);
+ }
+ printf("\n");
+ } else {
+ printf(" (cv_record) = ");
+ for (unsigned int cv_byte_index = 0;
+ cv_byte_index < cv_record_size;
+ ++cv_byte_index) {
+ printf("%02x", cv_record[cv_byte_index]);
+ }
+ printf("\n");
+ }
+ } else {
+ printf(" (cv_record) = (null)\n");
+ }
+
+ const MDImageDebugMisc* misc_record = GetMiscRecord(NULL);
+ if (misc_record) {
+ printf(" (misc_record).data_type = 0x%x\n",
+ misc_record->data_type);
+ printf(" (misc_record).length = 0x%x\n",
+ misc_record->length);
+ printf(" (misc_record).unicode = %d\n",
+ misc_record->unicode);
+ if (misc_record->unicode) {
+ string misc_record_data_utf8;
+ ConvertUTF16BufferToUTF8String(
+ reinterpret_cast<const uint16_t*>(misc_record->data),
+ misc_record->length - offsetof(MDImageDebugMisc, data),
+ &misc_record_data_utf8,
+ false); // already swapped
+ printf(" (misc_record).data = \"%s\"\n",
+ misc_record_data_utf8.c_str());
+ } else {
+ printf(" (misc_record).data = \"%s\"\n",
+ misc_record->data);
+ }
+ } else {
+ printf(" (misc_record) = (null)\n");
+ }
+
+ printf(" (debug_file) = \"%s\"\n", debug_file().c_str());
+ printf(" (debug_identifier) = \"%s\"\n",
+ debug_identifier().c_str());
+ printf(" (version) = \"%s\"\n", version().c_str());
+ printf("\n");
+}
+
+
+//
+// MinidumpModuleList
+//
+
+
+uint32_t MinidumpModuleList::max_modules_ = 1024;
+
+
+MinidumpModuleList::MinidumpModuleList(Minidump* minidump)
+ : MinidumpStream(minidump),
+ range_map_(new RangeMap<uint64_t, unsigned int>()),
+ modules_(NULL),
+ module_count_(0) {
+ range_map_->SetEnableShrinkDown(minidump_->IsAndroid());
+}
+
+
+MinidumpModuleList::~MinidumpModuleList() {
+ delete range_map_;
+ delete modules_;
+}
+
+
+bool MinidumpModuleList::Read(uint32_t expected_size) {
+ // Invalidate cached data.
+ range_map_->Clear();
+ delete modules_;
+ modules_ = NULL;
+ module_count_ = 0;
+
+ valid_ = false;
+
+ uint32_t module_count;
+ if (expected_size < sizeof(module_count)) {
+ BPLOG(ERROR) << "MinidumpModuleList count size mismatch, " <<
+ expected_size << " < " << sizeof(module_count);
+ return false;
+ }
+ if (!minidump_->ReadBytes(&module_count, sizeof(module_count))) {
+ BPLOG(ERROR) << "MinidumpModuleList could not read module count";
+ return false;
+ }
+
+ if (minidump_->swap())
+ Swap(&module_count);
+
+ if (module_count > numeric_limits<uint32_t>::max() / MD_MODULE_SIZE) {
+ BPLOG(ERROR) << "MinidumpModuleList module count " << module_count <<
+ " would cause multiplication overflow";
+ return false;
+ }
+
+ if (expected_size != sizeof(module_count) +
+ module_count * MD_MODULE_SIZE) {
+ // may be padded with 4 bytes on 64bit ABIs for alignment
+ if (expected_size == sizeof(module_count) + 4 +
+ module_count * MD_MODULE_SIZE) {
+ uint32_t useless;
+ if (!minidump_->ReadBytes(&useless, 4)) {
+ BPLOG(ERROR) << "MinidumpModuleList cannot read modulelist padded "
+ "bytes";
+ return false;
+ }
+ } else {
+ BPLOG(ERROR) << "MinidumpModuleList size mismatch, " << expected_size <<
+ " != " << sizeof(module_count) +
+ module_count * MD_MODULE_SIZE;
+ return false;
+ }
+ }
+
+ if (module_count > max_modules_) {
+ BPLOG(ERROR) << "MinidumpModuleList count " << module_count_ <<
+ " exceeds maximum " << max_modules_;
+ return false;
+ }
+
+ if (module_count != 0) {
+ scoped_ptr<MinidumpModules> modules(
+ new MinidumpModules(module_count, MinidumpModule(minidump_)));
+
+ for (unsigned int module_index = 0;
+ module_index < module_count;
+ ++module_index) {
+ MinidumpModule* module = &(*modules)[module_index];
+
+ // Assume that the file offset is correct after the last read.
+ if (!module->Read()) {
+ BPLOG(ERROR) << "MinidumpModuleList could not read module " <<
+ module_index << "/" << module_count;
+ return false;
+ }
+ }
+
+ // Loop through the module list once more to read additional data and
+ // build the range map. This is done in a second pass because
+ // MinidumpModule::ReadAuxiliaryData seeks around, and if it were
+ // included in the loop above, additional seeks would be needed where
+ // none are now to read contiguous data.
+ uint64_t last_end_address = 0;
+ for (unsigned int module_index = 0;
+ module_index < module_count;
+ ++module_index) {
+ MinidumpModule* module = &(*modules)[module_index];
+
+ // ReadAuxiliaryData fails if any data that the module indicates should
+ // exist is missing, but we treat some such cases as valid anyway. See
+ // issue #222: if a debugging record is of a format that's too large to
+ // handle, it shouldn't render the entire dump invalid. Check module
+ // validity before giving up.
+ if (!module->ReadAuxiliaryData() && !module->valid()) {
+ BPLOG(ERROR) << "MinidumpModuleList could not read required module "
+ "auxiliary data for module " <<
+ module_index << "/" << module_count;
+ return false;
+ }
+
+ // It is safe to use module->code_file() after successfully calling
+ // module->ReadAuxiliaryData or noting that the module is valid.
+
+ uint64_t base_address = module->base_address();
+ uint64_t module_size = module->size();
+ if (base_address == static_cast<uint64_t>(-1)) {
+ BPLOG(ERROR) << "MinidumpModuleList found bad base address "
+ "for module " << module_index << "/" << module_count <<
+ ", " << module->code_file();
+ return false;
+ }
+
+ if (!range_map_->StoreRange(base_address, module_size, module_index)) {
+ // Android's shared memory implementation /dev/ashmem can contain
+ // duplicate entries for JITted code, so ignore these.
+ // TODO(wfh): Remove this code when Android is fixed.
+ // See https://crbug.com/439531
+ const string kDevAshmem("/dev/ashmem/");
+ if (module->code_file().compare(
+ 0, kDevAshmem.length(), kDevAshmem) != 0) {
+ if (base_address < last_end_address) {
+ // If failed due to apparent range overlap the cause may be
+ // the client correction applied for Android packed relocations.
+ // If this is the case, back out the client correction and retry.
+ module_size -= last_end_address - base_address;
+ base_address = last_end_address;
+ if (!range_map_->StoreRange(base_address,
+ module_size, module_index)) {
+ BPLOG(ERROR) << "MinidumpModuleList could not store module " <<
+ module_index << "/" << module_count << ", " <<
+ module->code_file() << ", " <<
+ HexString(base_address) << "+" <<
+ HexString(module_size) << ", after adjusting";
+ return false;
+ }
+ } else {
+ BPLOG(ERROR) << "MinidumpModuleList could not store module " <<
+ module_index << "/" << module_count << ", " <<
+ module->code_file() << ", " <<
+ HexString(base_address) << "+" <<
+ HexString(module_size);
+ return false;
+ }
+ } else {
+ BPLOG(INFO) << "MinidumpModuleList ignoring overlapping module " <<
+ module_index << "/" << module_count << ", " <<
+ module->code_file() << ", " <<
+ HexString(base_address) << "+" <<
+ HexString(module_size);
+ }
+ }
+ last_end_address = base_address + module_size;
+ }
+
+ modules_ = modules.release();
+ }
+
+ module_count_ = module_count;
+
+ valid_ = true;
+ return true;
+}
+
+
+const MinidumpModule* MinidumpModuleList::GetModuleForAddress(
+ uint64_t address) const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModuleList for GetModuleForAddress";
+ return NULL;
+ }
+
+ unsigned int module_index;
+ if (!range_map_->RetrieveRange(address, &module_index, NULL /* base */,
+ NULL /* delta */, NULL /* size */)) {
+ BPLOG(INFO) << "MinidumpModuleList has no module at " <<
+ HexString(address);
+ return NULL;
+ }
+
+ return GetModuleAtIndex(module_index);
+}
+
+
+const MinidumpModule* MinidumpModuleList::GetMainModule() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModuleList for GetMainModule";
+ return NULL;
+ }
+
+ // The main code module is the first one present in a minidump file's
+ // MDRawModuleList.
+ return GetModuleAtIndex(0);
+}
+
+
+const MinidumpModule* MinidumpModuleList::GetModuleAtSequence(
+ unsigned int sequence) const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModuleList for GetModuleAtSequence";
+ return NULL;
+ }
+
+ if (sequence >= module_count_) {
+ BPLOG(ERROR) << "MinidumpModuleList sequence out of range: " <<
+ sequence << "/" << module_count_;
+ return NULL;
+ }
+
+ unsigned int module_index;
+ if (!range_map_->RetrieveRangeAtIndex(sequence, &module_index,
+ NULL /* base */, NULL /* delta */,
+ NULL /* size */)) {
+ BPLOG(ERROR) << "MinidumpModuleList has no module at sequence " << sequence;
+ return NULL;
+ }
+
+ return GetModuleAtIndex(module_index);
+}
+
+
+const MinidumpModule* MinidumpModuleList::GetModuleAtIndex(
+ unsigned int index) const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpModuleList for GetModuleAtIndex";
+ return NULL;
+ }
+
+ if (index >= module_count_) {
+ BPLOG(ERROR) << "MinidumpModuleList index out of range: " <<
+ index << "/" << module_count_;
+ return NULL;
+ }
+
+ return &(*modules_)[index];
+}
+
+
+const CodeModules* MinidumpModuleList::Copy() const {
+ return new BasicCodeModules(this);
+}
+
+vector<linked_ptr<const CodeModule> >
+MinidumpModuleList::GetShrunkRangeModules() const {
+ return vector<linked_ptr<const CodeModule> >();
+}
+
+bool MinidumpModuleList::IsModuleShrinkEnabled() const {
+ return range_map_->IsShrinkDownEnabled();
+}
+
+void MinidumpModuleList::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpModuleList cannot print invalid data";
+ return;
+ }
+
+ printf("MinidumpModuleList\n");
+ printf(" module_count = %d\n", module_count_);
+ printf("\n");
+
+ for (unsigned int module_index = 0;
+ module_index < module_count_;
+ ++module_index) {
+ printf("module[%d]\n", module_index);
+
+ (*modules_)[module_index].Print();
+ }
+}
+
+
+//
+// MinidumpMemoryList
+//
+
+
+uint32_t MinidumpMemoryList::max_regions_ = 4096;
+
+
+MinidumpMemoryList::MinidumpMemoryList(Minidump* minidump)
+ : MinidumpStream(minidump),
+ range_map_(new RangeMap<uint64_t, unsigned int>()),
+ descriptors_(NULL),
+ regions_(NULL),
+ region_count_(0) {
+}
+
+
+MinidumpMemoryList::~MinidumpMemoryList() {
+ delete range_map_;
+ delete descriptors_;
+ delete regions_;
+}
+
+
+bool MinidumpMemoryList::Read(uint32_t expected_size) {
+ // Invalidate cached data.
+ delete descriptors_;
+ descriptors_ = NULL;
+ delete regions_;
+ regions_ = NULL;
+ range_map_->Clear();
+ region_count_ = 0;
+
+ valid_ = false;
+
+ uint32_t region_count;
+ if (expected_size < sizeof(region_count)) {
+ BPLOG(ERROR) << "MinidumpMemoryList count size mismatch, " <<
+ expected_size << " < " << sizeof(region_count);
+ return false;
+ }
+ if (!minidump_->ReadBytes(&region_count, sizeof(region_count))) {
+ BPLOG(ERROR) << "MinidumpMemoryList could not read memory region count";
+ return false;
+ }
+
+ if (minidump_->swap())
+ Swap(&region_count);
+
+ if (region_count >
+ numeric_limits<uint32_t>::max() / sizeof(MDMemoryDescriptor)) {
+ BPLOG(ERROR) << "MinidumpMemoryList region count " << region_count <<
+ " would cause multiplication overflow";
+ return false;
+ }
+
+ if (expected_size != sizeof(region_count) +
+ region_count * sizeof(MDMemoryDescriptor)) {
+ // may be padded with 4 bytes on 64bit ABIs for alignment
+ if (expected_size == sizeof(region_count) + 4 +
+ region_count * sizeof(MDMemoryDescriptor)) {
+ uint32_t useless;
+ if (!minidump_->ReadBytes(&useless, 4)) {
+ BPLOG(ERROR) << "MinidumpMemoryList cannot read memorylist padded "
+ "bytes";
+ return false;
+ }
+ } else {
+ BPLOG(ERROR) << "MinidumpMemoryList size mismatch, " << expected_size <<
+ " != " << sizeof(region_count) +
+ region_count * sizeof(MDMemoryDescriptor);
+ return false;
+ }
+ }
+
+ if (region_count > max_regions_) {
+ BPLOG(ERROR) << "MinidumpMemoryList count " << region_count <<
+ " exceeds maximum " << max_regions_;
+ return false;
+ }
+
+ if (region_count != 0) {
+ scoped_ptr<MemoryDescriptors> descriptors(
+ new MemoryDescriptors(region_count));
+
+ // Read the entire array in one fell swoop, instead of reading one entry
+ // at a time in the loop.
+ if (!minidump_->ReadBytes(&(*descriptors)[0],
+ sizeof(MDMemoryDescriptor) * region_count)) {
+ BPLOG(ERROR) << "MinidumpMemoryList could not read memory region list";
+ return false;
+ }
+
+ scoped_ptr<MemoryRegions> regions(
+ new MemoryRegions(region_count, MinidumpMemoryRegion(minidump_)));
+
+ for (unsigned int region_index = 0;
+ region_index < region_count;
+ ++region_index) {
+ MDMemoryDescriptor* descriptor = &(*descriptors)[region_index];
+
+ if (minidump_->swap())
+ Swap(descriptor);
+
+ uint64_t base_address = descriptor->start_of_memory_range;
+ uint32_t region_size = descriptor->memory.data_size;
+
+ // Check for base + size overflow or undersize.
+ if (region_size == 0 ||
+ region_size > numeric_limits<uint64_t>::max() - base_address) {
+ BPLOG(ERROR) << "MinidumpMemoryList has a memory region problem, " <<
+ " region " << region_index << "/" << region_count <<
+ ", " << HexString(base_address) << "+" <<
+ HexString(region_size);
+ return false;
+ }
+
+ if (!range_map_->StoreRange(base_address, region_size, region_index)) {
+ BPLOG(ERROR) << "MinidumpMemoryList could not store memory region " <<
+ region_index << "/" << region_count << ", " <<
+ HexString(base_address) << "+" <<
+ HexString(region_size);
+ return false;
+ }
+
+ (*regions)[region_index].SetDescriptor(descriptor);
+ }
+
+ descriptors_ = descriptors.release();
+ regions_ = regions.release();
+ }
+
+ region_count_ = region_count;
+
+ valid_ = true;
+ return true;
+}
+
+
+MinidumpMemoryRegion* MinidumpMemoryList::GetMemoryRegionAtIndex(
+ unsigned int index) {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpMemoryList for GetMemoryRegionAtIndex";
+ return NULL;
+ }
+
+ if (index >= region_count_) {
+ BPLOG(ERROR) << "MinidumpMemoryList index out of range: " <<
+ index << "/" << region_count_;
+ return NULL;
+ }
+
+ return &(*regions_)[index];
+}
+
+
+MinidumpMemoryRegion* MinidumpMemoryList::GetMemoryRegionForAddress(
+ uint64_t address) {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpMemoryList for GetMemoryRegionForAddress";
+ return NULL;
+ }
+
+ unsigned int region_index;
+ if (!range_map_->RetrieveRange(address, &region_index, NULL /* base */,
+ NULL /* delta */, NULL /* size */)) {
+ BPLOG(INFO) << "MinidumpMemoryList has no memory region at " <<
+ HexString(address);
+ return NULL;
+ }
+
+ return GetMemoryRegionAtIndex(region_index);
+}
+
+
+void MinidumpMemoryList::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpMemoryList cannot print invalid data";
+ return;
+ }
+
+ printf("MinidumpMemoryList\n");
+ printf(" region_count = %d\n", region_count_);
+ printf("\n");
+
+ for (unsigned int region_index = 0;
+ region_index < region_count_;
+ ++region_index) {
+ MDMemoryDescriptor* descriptor = &(*descriptors_)[region_index];
+ printf("region[%d]\n", region_index);
+ printf("MDMemoryDescriptor\n");
+ printf(" start_of_memory_range = 0x%" PRIx64 "\n",
+ descriptor->start_of_memory_range);
+ printf(" memory.data_size = 0x%x\n", descriptor->memory.data_size);
+ printf(" memory.rva = 0x%x\n", descriptor->memory.rva);
+ MinidumpMemoryRegion* region = GetMemoryRegionAtIndex(region_index);
+ if (region) {
+ printf("Memory\n");
+ region->Print();
+ } else {
+ printf("No memory\n");
+ }
+ printf("\n");
+ }
+}
+
+
+//
+// MinidumpException
+//
+
+
+MinidumpException::MinidumpException(Minidump* minidump)
+ : MinidumpStream(minidump),
+ exception_(),
+ context_(NULL) {
+}
+
+
+MinidumpException::~MinidumpException() {
+ delete context_;
+}
+
+
+bool MinidumpException::Read(uint32_t expected_size) {
+ // Invalidate cached data.
+ delete context_;
+ context_ = NULL;
+
+ valid_ = false;
+
+ if (expected_size != sizeof(exception_)) {
+ BPLOG(ERROR) << "MinidumpException size mismatch, " << expected_size <<
+ " != " << sizeof(exception_);
+ return false;
+ }
+
+ if (!minidump_->ReadBytes(&exception_, sizeof(exception_))) {
+ BPLOG(ERROR) << "MinidumpException cannot read exception";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ Swap(&exception_.thread_id);
+ // exception_.__align is for alignment only and does not need to be
+ // swapped.
+ Swap(&exception_.exception_record.exception_code);
+ Swap(&exception_.exception_record.exception_flags);
+ Swap(&exception_.exception_record.exception_record);
+ Swap(&exception_.exception_record.exception_address);
+ Swap(&exception_.exception_record.number_parameters);
+ // exception_.exception_record.__align is for alignment only and does not
+ // need to be swapped.
+ for (unsigned int parameter_index = 0;
+ parameter_index < MD_EXCEPTION_MAXIMUM_PARAMETERS;
+ ++parameter_index) {
+ Swap(&exception_.exception_record.exception_information[parameter_index]);
+ }
+ Swap(&exception_.thread_context);
+ }
+
+ valid_ = true;
+ return true;
+}
+
+
+bool MinidumpException::GetThreadID(uint32_t *thread_id) const {
+ BPLOG_IF(ERROR, !thread_id) << "MinidumpException::GetThreadID requires "
+ "|thread_id|";
+ assert(thread_id);
+ *thread_id = 0;
+
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpException for GetThreadID";
+ return false;
+ }
+
+ *thread_id = exception_.thread_id;
+ return true;
+}
+
+
+MinidumpContext* MinidumpException::GetContext() {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpException for GetContext";
+ return NULL;
+ }
+
+ if (!context_) {
+ if (!minidump_->SeekSet(exception_.thread_context.rva)) {
+ BPLOG(ERROR) << "MinidumpException cannot seek to context";
+ return NULL;
+ }
+
+ scoped_ptr<MinidumpContext> context(new MinidumpContext(minidump_));
+
+ // Don't log as an error if we can still fall back on the thread's context
+ // (which must be possible if we got this far.)
+ if (!context->Read(exception_.thread_context.data_size)) {
+ BPLOG(INFO) << "MinidumpException cannot read context";
+ return NULL;
+ }
+
+ context_ = context.release();
+ }
+
+ return context_;
+}
+
+
+void MinidumpException::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpException cannot print invalid data";
+ return;
+ }
+
+ printf("MDException\n");
+ printf(" thread_id = 0x%x\n",
+ exception_.thread_id);
+ printf(" exception_record.exception_code = 0x%x\n",
+ exception_.exception_record.exception_code);
+ printf(" exception_record.exception_flags = 0x%x\n",
+ exception_.exception_record.exception_flags);
+ printf(" exception_record.exception_record = 0x%" PRIx64 "\n",
+ exception_.exception_record.exception_record);
+ printf(" exception_record.exception_address = 0x%" PRIx64 "\n",
+ exception_.exception_record.exception_address);
+ printf(" exception_record.number_parameters = %d\n",
+ exception_.exception_record.number_parameters);
+ for (unsigned int parameterIndex = 0;
+ parameterIndex < exception_.exception_record.number_parameters;
+ ++parameterIndex) {
+ printf(" exception_record.exception_information[%2d] = 0x%" PRIx64 "\n",
+ parameterIndex,
+ exception_.exception_record.exception_information[parameterIndex]);
+ }
+ printf(" thread_context.data_size = %d\n",
+ exception_.thread_context.data_size);
+ printf(" thread_context.rva = 0x%x\n",
+ exception_.thread_context.rva);
+ MinidumpContext* context = GetContext();
+ if (context) {
+ printf("\n");
+ context->Print();
+ } else {
+ printf(" (no context)\n");
+ printf("\n");
+ }
+}
+
+//
+// MinidumpAssertion
+//
+
+
+MinidumpAssertion::MinidumpAssertion(Minidump* minidump)
+ : MinidumpStream(minidump),
+ assertion_(),
+ expression_(),
+ function_(),
+ file_() {
+}
+
+
+MinidumpAssertion::~MinidumpAssertion() {
+}
+
+
+bool MinidumpAssertion::Read(uint32_t expected_size) {
+ // Invalidate cached data.
+ valid_ = false;
+
+ if (expected_size != sizeof(assertion_)) {
+ BPLOG(ERROR) << "MinidumpAssertion size mismatch, " << expected_size <<
+ " != " << sizeof(assertion_);
+ return false;
+ }
+
+ if (!minidump_->ReadBytes(&assertion_, sizeof(assertion_))) {
+ BPLOG(ERROR) << "MinidumpAssertion cannot read assertion";
+ return false;
+ }
+
+ // Each of {expression, function, file} is a UTF-16 string,
+ // we'll convert them to UTF-8 for ease of use.
+ ConvertUTF16BufferToUTF8String(assertion_.expression,
+ sizeof(assertion_.expression), &expression_,
+ minidump_->swap());
+ ConvertUTF16BufferToUTF8String(assertion_.function,
+ sizeof(assertion_.function), &function_,
+ minidump_->swap());
+ ConvertUTF16BufferToUTF8String(assertion_.file, sizeof(assertion_.file),
+ &file_, minidump_->swap());
+
+ if (minidump_->swap()) {
+ Swap(&assertion_.line);
+ Swap(&assertion_.type);
+ }
+
+ valid_ = true;
+ return true;
+}
+
+void MinidumpAssertion::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpAssertion cannot print invalid data";
+ return;
+ }
+
+ printf("MDAssertion\n");
+ printf(" expression = %s\n",
+ expression_.c_str());
+ printf(" function = %s\n",
+ function_.c_str());
+ printf(" file = %s\n",
+ file_.c_str());
+ printf(" line = %u\n",
+ assertion_.line);
+ printf(" type = %u\n",
+ assertion_.type);
+ printf("\n");
+}
+
+//
+// MinidumpSystemInfo
+//
+
+
+MinidumpSystemInfo::MinidumpSystemInfo(Minidump* minidump)
+ : MinidumpStream(minidump),
+ system_info_(),
+ csd_version_(NULL),
+ cpu_vendor_(NULL) {
+}
+
+
+MinidumpSystemInfo::~MinidumpSystemInfo() {
+ delete csd_version_;
+ delete cpu_vendor_;
+}
+
+
+bool MinidumpSystemInfo::Read(uint32_t expected_size) {
+ // Invalidate cached data.
+ delete csd_version_;
+ csd_version_ = NULL;
+ delete cpu_vendor_;
+ cpu_vendor_ = NULL;
+
+ valid_ = false;
+
+ if (expected_size != sizeof(system_info_)) {
+ BPLOG(ERROR) << "MinidumpSystemInfo size mismatch, " << expected_size <<
+ " != " << sizeof(system_info_);
+ return false;
+ }
+
+ if (!minidump_->ReadBytes(&system_info_, sizeof(system_info_))) {
+ BPLOG(ERROR) << "MinidumpSystemInfo cannot read system info";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ Swap(&system_info_.processor_architecture);
+ Swap(&system_info_.processor_level);
+ Swap(&system_info_.processor_revision);
+ // number_of_processors and product_type are 8-bit quantities and need no
+ // swapping.
+ Swap(&system_info_.major_version);
+ Swap(&system_info_.minor_version);
+ Swap(&system_info_.build_number);
+ Swap(&system_info_.platform_id);
+ Swap(&system_info_.csd_version_rva);
+ Swap(&system_info_.suite_mask);
+ // Don't swap the reserved2 field because its contents are unknown.
+
+ if (system_info_.processor_architecture == MD_CPU_ARCHITECTURE_X86 ||
+ system_info_.processor_architecture == MD_CPU_ARCHITECTURE_X86_WIN64) {
+ for (unsigned int i = 0; i < 3; ++i)
+ Swap(&system_info_.cpu.x86_cpu_info.vendor_id[i]);
+ Swap(&system_info_.cpu.x86_cpu_info.version_information);
+ Swap(&system_info_.cpu.x86_cpu_info.feature_information);
+ Swap(&system_info_.cpu.x86_cpu_info.amd_extended_cpu_features);
+ } else {
+ for (unsigned int i = 0; i < 2; ++i)
+ Swap(&system_info_.cpu.other_cpu_info.processor_features[i]);
+ }
+ }
+
+ valid_ = true;
+ return true;
+}
+
+
+string MinidumpSystemInfo::GetOS() {
+ string os;
+
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpSystemInfo for GetOS";
+ return os;
+ }
+
+ switch (system_info_.platform_id) {
+ case MD_OS_WIN32_NT:
+ case MD_OS_WIN32_WINDOWS:
+ os = "windows";
+ break;
+
+ case MD_OS_MAC_OS_X:
+ os = "mac";
+ break;
+
+ case MD_OS_IOS:
+ os = "ios";
+ break;
+
+ case MD_OS_LINUX:
+ os = "linux";
+ break;
+
+ case MD_OS_SOLARIS:
+ os = "solaris";
+ break;
+
+ case MD_OS_ANDROID:
+ os = "android";
+ break;
+
+ case MD_OS_PS3:
+ os = "ps3";
+ break;
+
+ case MD_OS_NACL:
+ os = "nacl";
+ break;
+
+ default:
+ BPLOG(ERROR) << "MinidumpSystemInfo unknown OS for platform " <<
+ HexString(system_info_.platform_id);
+ break;
+ }
+
+ return os;
+}
+
+
+string MinidumpSystemInfo::GetCPU() {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpSystemInfo for GetCPU";
+ return "";
+ }
+
+ string cpu;
+
+ switch (system_info_.processor_architecture) {
+ case MD_CPU_ARCHITECTURE_X86:
+ case MD_CPU_ARCHITECTURE_X86_WIN64:
+ cpu = "x86";
+ break;
+
+ case MD_CPU_ARCHITECTURE_AMD64:
+ cpu = "x86-64";
+ break;
+
+ case MD_CPU_ARCHITECTURE_PPC:
+ cpu = "ppc";
+ break;
+
+ case MD_CPU_ARCHITECTURE_PPC64:
+ cpu = "ppc64";
+ break;
+
+ case MD_CPU_ARCHITECTURE_SPARC:
+ cpu = "sparc";
+ break;
+
+ case MD_CPU_ARCHITECTURE_ARM:
+ cpu = "arm";
+ break;
+
+ case MD_CPU_ARCHITECTURE_ARM64:
+ cpu = "arm64";
+ break;
+
+ default:
+ BPLOG(ERROR) << "MinidumpSystemInfo unknown CPU for architecture " <<
+ HexString(system_info_.processor_architecture);
+ break;
+ }
+
+ return cpu;
+}
+
+
+const string* MinidumpSystemInfo::GetCSDVersion() {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpSystemInfo for GetCSDVersion";
+ return NULL;
+ }
+
+ if (!csd_version_)
+ csd_version_ = minidump_->ReadString(system_info_.csd_version_rva);
+
+ BPLOG_IF(ERROR, !csd_version_) << "MinidumpSystemInfo could not read "
+ "CSD version";
+
+ return csd_version_;
+}
+
+
+const string* MinidumpSystemInfo::GetCPUVendor() {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpSystemInfo for GetCPUVendor";
+ return NULL;
+ }
+
+ // CPU vendor information can only be determined from x86 minidumps.
+ if (!cpu_vendor_ &&
+ (system_info_.processor_architecture == MD_CPU_ARCHITECTURE_X86 ||
+ system_info_.processor_architecture == MD_CPU_ARCHITECTURE_X86_WIN64)) {
+ char cpu_vendor_string[13];
+ snprintf(cpu_vendor_string, sizeof(cpu_vendor_string),
+ "%c%c%c%c%c%c%c%c%c%c%c%c",
+ system_info_.cpu.x86_cpu_info.vendor_id[0] & 0xff,
+ (system_info_.cpu.x86_cpu_info.vendor_id[0] >> 8) & 0xff,
+ (system_info_.cpu.x86_cpu_info.vendor_id[0] >> 16) & 0xff,
+ (system_info_.cpu.x86_cpu_info.vendor_id[0] >> 24) & 0xff,
+ system_info_.cpu.x86_cpu_info.vendor_id[1] & 0xff,
+ (system_info_.cpu.x86_cpu_info.vendor_id[1] >> 8) & 0xff,
+ (system_info_.cpu.x86_cpu_info.vendor_id[1] >> 16) & 0xff,
+ (system_info_.cpu.x86_cpu_info.vendor_id[1] >> 24) & 0xff,
+ system_info_.cpu.x86_cpu_info.vendor_id[2] & 0xff,
+ (system_info_.cpu.x86_cpu_info.vendor_id[2] >> 8) & 0xff,
+ (system_info_.cpu.x86_cpu_info.vendor_id[2] >> 16) & 0xff,
+ (system_info_.cpu.x86_cpu_info.vendor_id[2] >> 24) & 0xff);
+ cpu_vendor_ = new string(cpu_vendor_string);
+ }
+
+ return cpu_vendor_;
+}
+
+
+void MinidumpSystemInfo::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpSystemInfo cannot print invalid data";
+ return;
+ }
+
+ printf("MDRawSystemInfo\n");
+ printf(" processor_architecture = 0x%x\n",
+ system_info_.processor_architecture);
+ printf(" processor_level = %d\n",
+ system_info_.processor_level);
+ printf(" processor_revision = 0x%x\n",
+ system_info_.processor_revision);
+ printf(" number_of_processors = %d\n",
+ system_info_.number_of_processors);
+ printf(" product_type = %d\n",
+ system_info_.product_type);
+ printf(" major_version = %d\n",
+ system_info_.major_version);
+ printf(" minor_version = %d\n",
+ system_info_.minor_version);
+ printf(" build_number = %d\n",
+ system_info_.build_number);
+ printf(" platform_id = 0x%x\n",
+ system_info_.platform_id);
+ printf(" csd_version_rva = 0x%x\n",
+ system_info_.csd_version_rva);
+ printf(" suite_mask = 0x%x\n",
+ system_info_.suite_mask);
+ if (system_info_.processor_architecture == MD_CPU_ARCHITECTURE_X86 ||
+ system_info_.processor_architecture == MD_CPU_ARCHITECTURE_X86_WIN64) {
+ printf(" cpu.x86_cpu_info (valid):\n");
+ } else {
+ printf(" cpu.x86_cpu_info (invalid):\n");
+ }
+ for (unsigned int i = 0; i < 3; ++i) {
+ printf(" cpu.x86_cpu_info.vendor_id[%d] = 0x%x\n",
+ i, system_info_.cpu.x86_cpu_info.vendor_id[i]);
+ }
+ printf(" cpu.x86_cpu_info.version_information = 0x%x\n",
+ system_info_.cpu.x86_cpu_info.version_information);
+ printf(" cpu.x86_cpu_info.feature_information = 0x%x\n",
+ system_info_.cpu.x86_cpu_info.feature_information);
+ printf(" cpu.x86_cpu_info.amd_extended_cpu_features = 0x%x\n",
+ system_info_.cpu.x86_cpu_info.amd_extended_cpu_features);
+ if (system_info_.processor_architecture != MD_CPU_ARCHITECTURE_X86 &&
+ system_info_.processor_architecture != MD_CPU_ARCHITECTURE_X86_WIN64) {
+ printf(" cpu.other_cpu_info (valid):\n");
+ for (unsigned int i = 0; i < 2; ++i) {
+ printf(" cpu.other_cpu_info.processor_features[%d] = 0x%" PRIx64 "\n",
+ i, system_info_.cpu.other_cpu_info.processor_features[i]);
+ }
+ }
+ const string* csd_version = GetCSDVersion();
+ if (csd_version) {
+ printf(" (csd_version) = \"%s\"\n",
+ csd_version->c_str());
+ } else {
+ printf(" (csd_version) = (null)\n");
+ }
+ const string* cpu_vendor = GetCPUVendor();
+ if (cpu_vendor) {
+ printf(" (cpu_vendor) = \"%s\"\n",
+ cpu_vendor->c_str());
+ } else {
+ printf(" (cpu_vendor) = (null)\n");
+ }
+ printf("\n");
+}
+
+
+//
+// MinidumpMiscInfo
+//
+
+
+MinidumpMiscInfo::MinidumpMiscInfo(Minidump* minidump)
+ : MinidumpStream(minidump),
+ misc_info_() {
+}
+
+
+bool MinidumpMiscInfo::Read(uint32_t expected_size) {
+ valid_ = false;
+
+ size_t padding = 0;
+ if (expected_size != MD_MISCINFO_SIZE &&
+ expected_size != MD_MISCINFO2_SIZE &&
+ expected_size != MD_MISCINFO3_SIZE &&
+ expected_size != MD_MISCINFO4_SIZE &&
+ expected_size != MD_MISCINFO5_SIZE) {
+ if (expected_size > MD_MISCINFO5_SIZE) {
+ // Only read the part of the misc info structure we know how to handle
+ BPLOG(INFO) << "MinidumpMiscInfo size larger than expected "
+ << expected_size << ", skipping over the unknown part";
+ padding = expected_size - MD_MISCINFO5_SIZE;
+ expected_size = MD_MISCINFO5_SIZE;
+ } else {
+ BPLOG(ERROR) << "MinidumpMiscInfo size mismatch, " << expected_size
+ << " != " << MD_MISCINFO_SIZE << ", " << MD_MISCINFO2_SIZE
+ << ", " << MD_MISCINFO3_SIZE << ", " << MD_MISCINFO4_SIZE
+ << ", " << MD_MISCINFO5_SIZE << ")";
+ return false;
+ }
+ }
+
+ if (!minidump_->ReadBytes(&misc_info_, expected_size)) {
+ BPLOG(ERROR) << "MinidumpMiscInfo cannot read miscellaneous info";
+ return false;
+ }
+
+ if (padding != 0) {
+ off_t saved_position = minidump_->Tell();
+ if (saved_position == -1) {
+ BPLOG(ERROR) << "MinidumpMiscInfo could not tell the current position";
+ return false;
+ }
+
+ if (!minidump_->SeekSet(saved_position + padding)) {
+ BPLOG(ERROR) << "MinidumpMiscInfo could not seek past the miscellaneous "
+ << "info structure";
+ return false;
+ }
+ }
+
+ if (minidump_->swap()) {
+ // Swap version 1 fields
+ Swap(&misc_info_.size_of_info);
+ Swap(&misc_info_.flags1);
+ Swap(&misc_info_.process_id);
+ Swap(&misc_info_.process_create_time);
+ Swap(&misc_info_.process_user_time);
+ Swap(&misc_info_.process_kernel_time);
+ if (misc_info_.size_of_info > MD_MISCINFO_SIZE) {
+ // Swap version 2 fields
+ Swap(&misc_info_.processor_max_mhz);
+ Swap(&misc_info_.processor_current_mhz);
+ Swap(&misc_info_.processor_mhz_limit);
+ Swap(&misc_info_.processor_max_idle_state);
+ Swap(&misc_info_.processor_current_idle_state);
+ }
+ if (misc_info_.size_of_info > MD_MISCINFO2_SIZE) {
+ // Swap version 3 fields
+ Swap(&misc_info_.process_integrity_level);
+ Swap(&misc_info_.process_execute_flags);
+ Swap(&misc_info_.protected_process);
+ Swap(&misc_info_.time_zone_id);
+ Swap(&misc_info_.time_zone);
+ }
+ if (misc_info_.size_of_info > MD_MISCINFO3_SIZE) {
+ // Swap version 4 fields.
+ // Do not swap UTF-16 strings. The swap is done as part of the
+ // conversion to UTF-8 (code follows below).
+ }
+ if (misc_info_.size_of_info > MD_MISCINFO4_SIZE) {
+ // Swap version 5 fields
+ Swap(&misc_info_.xstate_data);
+ Swap(&misc_info_.process_cookie);
+ }
+ }
+
+ if (expected_size + padding != misc_info_.size_of_info) {
+ BPLOG(ERROR) << "MinidumpMiscInfo size mismatch, " <<
+ expected_size << " != " << misc_info_.size_of_info;
+ return false;
+ }
+
+ // Convert UTF-16 strings
+ if (misc_info_.size_of_info > MD_MISCINFO2_SIZE) {
+ // Convert UTF-16 strings in version 3 fields
+ ConvertUTF16BufferToUTF8String(misc_info_.time_zone.standard_name,
+ sizeof(misc_info_.time_zone.standard_name),
+ &standard_name_, minidump_->swap());
+ ConvertUTF16BufferToUTF8String(misc_info_.time_zone.daylight_name,
+ sizeof(misc_info_.time_zone.daylight_name),
+ &daylight_name_, minidump_->swap());
+ }
+ if (misc_info_.size_of_info > MD_MISCINFO3_SIZE) {
+ // Convert UTF-16 strings in version 4 fields
+ ConvertUTF16BufferToUTF8String(misc_info_.build_string,
+ sizeof(misc_info_.build_string),
+ &build_string_, minidump_->swap());
+ ConvertUTF16BufferToUTF8String(misc_info_.dbg_bld_str,
+ sizeof(misc_info_.dbg_bld_str),
+ &dbg_bld_str_, minidump_->swap());
+ }
+
+ valid_ = true;
+ return true;
+}
+
+
+void MinidumpMiscInfo::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpMiscInfo cannot print invalid data";
+ return;
+ }
+
+ printf("MDRawMiscInfo\n");
+ // Print version 1 fields
+ printf(" size_of_info = %d\n", misc_info_.size_of_info);
+ printf(" flags1 = 0x%x\n", misc_info_.flags1);
+ printf(" process_id = ");
+ PrintValueOrInvalid(misc_info_.flags1 & MD_MISCINFO_FLAGS1_PROCESS_ID,
+ kNumberFormatDecimal, misc_info_.process_id);
+ if (misc_info_.flags1 & MD_MISCINFO_FLAGS1_PROCESS_TIMES) {
+ printf(" process_create_time = 0x%x %s\n",
+ misc_info_.process_create_time,
+ TimeTToUTCString(misc_info_.process_create_time).c_str());
+ } else {
+ printf(" process_create_time = (invalid)\n");
+ }
+ printf(" process_user_time = ");
+ PrintValueOrInvalid(misc_info_.flags1 & MD_MISCINFO_FLAGS1_PROCESS_TIMES,
+ kNumberFormatDecimal, misc_info_.process_user_time);
+ printf(" process_kernel_time = ");
+ PrintValueOrInvalid(misc_info_.flags1 & MD_MISCINFO_FLAGS1_PROCESS_TIMES,
+ kNumberFormatDecimal, misc_info_.process_kernel_time);
+ if (misc_info_.size_of_info > MD_MISCINFO_SIZE) {
+ // Print version 2 fields
+ printf(" processor_max_mhz = ");
+ PrintValueOrInvalid(misc_info_.flags1 &
+ MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO,
+ kNumberFormatDecimal, misc_info_.processor_max_mhz);
+ printf(" processor_current_mhz = ");
+ PrintValueOrInvalid(misc_info_.flags1 &
+ MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO,
+ kNumberFormatDecimal, misc_info_.processor_current_mhz);
+ printf(" processor_mhz_limit = ");
+ PrintValueOrInvalid(misc_info_.flags1 &
+ MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO,
+ kNumberFormatDecimal, misc_info_.processor_mhz_limit);
+ printf(" processor_max_idle_state = ");
+ PrintValueOrInvalid(misc_info_.flags1 &
+ MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO,
+ kNumberFormatDecimal,
+ misc_info_.processor_max_idle_state);
+ printf(" processor_current_idle_state = ");
+ PrintValueOrInvalid(misc_info_.flags1 &
+ MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO,
+ kNumberFormatDecimal,
+ misc_info_.processor_current_idle_state);
+ }
+ if (misc_info_.size_of_info > MD_MISCINFO2_SIZE) {
+ // Print version 3 fields
+ printf(" process_integrity_level = ");
+ PrintValueOrInvalid(misc_info_.flags1 &
+ MD_MISCINFO_FLAGS1_PROCESS_INTEGRITY,
+ kNumberFormatHexadecimal,
+ misc_info_.process_integrity_level);
+ printf(" process_execute_flags = ");
+ PrintValueOrInvalid(misc_info_.flags1 &
+ MD_MISCINFO_FLAGS1_PROCESS_EXECUTE_FLAGS,
+ kNumberFormatHexadecimal,
+ misc_info_.process_execute_flags);
+ printf(" protected_process = ");
+ PrintValueOrInvalid(misc_info_.flags1 &
+ MD_MISCINFO_FLAGS1_PROTECTED_PROCESS,
+ kNumberFormatDecimal, misc_info_.protected_process);
+ printf(" time_zone_id = ");
+ PrintValueOrInvalid(misc_info_.flags1 & MD_MISCINFO_FLAGS1_TIMEZONE,
+ kNumberFormatDecimal, misc_info_.time_zone_id);
+ if (misc_info_.flags1 & MD_MISCINFO_FLAGS1_TIMEZONE) {
+ printf(" time_zone.bias = %d\n",
+ misc_info_.time_zone.bias);
+ printf(" time_zone.standard_name = %s\n", standard_name_.c_str());
+ printf(" time_zone.standard_date = "
+ "%04d-%02d-%02d (%d) %02d:%02d:%02d.%03d\n",
+ misc_info_.time_zone.standard_date.year,
+ misc_info_.time_zone.standard_date.month,
+ misc_info_.time_zone.standard_date.day,
+ misc_info_.time_zone.standard_date.day_of_week,
+ misc_info_.time_zone.standard_date.hour,
+ misc_info_.time_zone.standard_date.minute,
+ misc_info_.time_zone.standard_date.second,
+ misc_info_.time_zone.standard_date.milliseconds);
+ printf(" time_zone.standard_bias = %d\n",
+ misc_info_.time_zone.standard_bias);
+ printf(" time_zone.daylight_name = %s\n", daylight_name_.c_str());
+ printf(" time_zone.daylight_date = "
+ "%04d-%02d-%02d (%d) %02d:%02d:%02d.%03d\n",
+ misc_info_.time_zone.daylight_date.year,
+ misc_info_.time_zone.daylight_date.month,
+ misc_info_.time_zone.daylight_date.day,
+ misc_info_.time_zone.daylight_date.day_of_week,
+ misc_info_.time_zone.daylight_date.hour,
+ misc_info_.time_zone.daylight_date.minute,
+ misc_info_.time_zone.daylight_date.second,
+ misc_info_.time_zone.daylight_date.milliseconds);
+ printf(" time_zone.daylight_bias = %d\n",
+ misc_info_.time_zone.daylight_bias);
+ } else {
+ printf(" time_zone.bias = (invalid)\n");
+ printf(" time_zone.standard_name = (invalid)\n");
+ printf(" time_zone.standard_date = (invalid)\n");
+ printf(" time_zone.standard_bias = (invalid)\n");
+ printf(" time_zone.daylight_name = (invalid)\n");
+ printf(" time_zone.daylight_date = (invalid)\n");
+ printf(" time_zone.daylight_bias = (invalid)\n");
+ }
+ }
+ if (misc_info_.size_of_info > MD_MISCINFO3_SIZE) {
+ // Print version 4 fields
+ if (misc_info_.flags1 & MD_MISCINFO_FLAGS1_BUILDSTRING) {
+ printf(" build_string = %s\n", build_string_.c_str());
+ printf(" dbg_bld_str = %s\n", dbg_bld_str_.c_str());
+ } else {
+ printf(" build_string = (invalid)\n");
+ printf(" dbg_bld_str = (invalid)\n");
+ }
+ }
+ if (misc_info_.size_of_info > MD_MISCINFO4_SIZE) {
+ // Print version 5 fields
+ if (misc_info_.flags1 & MD_MISCINFO_FLAGS1_PROCESS_COOKIE) {
+ printf(" xstate_data.size_of_info = %d\n",
+ misc_info_.xstate_data.size_of_info);
+ printf(" xstate_data.context_size = %d\n",
+ misc_info_.xstate_data.context_size);
+ printf(" xstate_data.enabled_features = 0x%" PRIx64 "\n",
+ misc_info_.xstate_data.enabled_features);
+ for (size_t i = 0; i < MD_MAXIMUM_XSTATE_FEATURES; i++) {
+ if (misc_info_.xstate_data.enabled_features & (1 << i)) {
+ printf(" xstate_data.features[%02zu] = { %d, %d }\n", i,
+ misc_info_.xstate_data.features[i].offset,
+ misc_info_.xstate_data.features[i].size);
+ }
+ }
+ if (misc_info_.xstate_data.enabled_features == 0) {
+ printf(" xstate_data.features[] = (empty)\n");
+ }
+ printf(" process_cookie = %d\n",
+ misc_info_.process_cookie);
+ } else {
+ printf(" xstate_data.size_of_info = (invalid)\n");
+ printf(" xstate_data.context_size = (invalid)\n");
+ printf(" xstate_data.enabled_features = (invalid)\n");
+ printf(" xstate_data.features[] = (invalid)\n");
+ printf(" process_cookie = (invalid)\n");
+ }
+ }
+ printf("\n");
+}
+
+
+//
+// MinidumpBreakpadInfo
+//
+
+
+MinidumpBreakpadInfo::MinidumpBreakpadInfo(Minidump* minidump)
+ : MinidumpStream(minidump),
+ breakpad_info_() {
+}
+
+
+bool MinidumpBreakpadInfo::Read(uint32_t expected_size) {
+ valid_ = false;
+
+ if (expected_size != sizeof(breakpad_info_)) {
+ BPLOG(ERROR) << "MinidumpBreakpadInfo size mismatch, " << expected_size <<
+ " != " << sizeof(breakpad_info_);
+ return false;
+ }
+
+ if (!minidump_->ReadBytes(&breakpad_info_, sizeof(breakpad_info_))) {
+ BPLOG(ERROR) << "MinidumpBreakpadInfo cannot read Breakpad info";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ Swap(&breakpad_info_.validity);
+ Swap(&breakpad_info_.dump_thread_id);
+ Swap(&breakpad_info_.requesting_thread_id);
+ }
+
+ valid_ = true;
+ return true;
+}
+
+
+bool MinidumpBreakpadInfo::GetDumpThreadID(uint32_t *thread_id) const {
+ BPLOG_IF(ERROR, !thread_id) << "MinidumpBreakpadInfo::GetDumpThreadID "
+ "requires |thread_id|";
+ assert(thread_id);
+ *thread_id = 0;
+
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpBreakpadInfo for GetDumpThreadID";
+ return false;
+ }
+
+ if (!(breakpad_info_.validity & MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID)) {
+ BPLOG(INFO) << "MinidumpBreakpadInfo has no dump thread";
+ return false;
+ }
+
+ *thread_id = breakpad_info_.dump_thread_id;
+ return true;
+}
+
+
+bool MinidumpBreakpadInfo::GetRequestingThreadID(uint32_t *thread_id)
+ const {
+ BPLOG_IF(ERROR, !thread_id) << "MinidumpBreakpadInfo::GetRequestingThreadID "
+ "requires |thread_id|";
+ assert(thread_id);
+ *thread_id = 0;
+
+ if (!thread_id || !valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpBreakpadInfo for GetRequestingThreadID";
+ return false;
+ }
+
+ if (!(breakpad_info_.validity &
+ MD_BREAKPAD_INFO_VALID_REQUESTING_THREAD_ID)) {
+ BPLOG(INFO) << "MinidumpBreakpadInfo has no requesting thread";
+ return false;
+ }
+
+ *thread_id = breakpad_info_.requesting_thread_id;
+ return true;
+}
+
+
+void MinidumpBreakpadInfo::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpBreakpadInfo cannot print invalid data";
+ return;
+ }
+
+ printf("MDRawBreakpadInfo\n");
+ printf(" validity = 0x%x\n", breakpad_info_.validity);
+ printf(" dump_thread_id = ");
+ PrintValueOrInvalid(breakpad_info_.validity &
+ MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID,
+ kNumberFormatHexadecimal, breakpad_info_.dump_thread_id);
+ printf(" requesting_thread_id = ");
+ PrintValueOrInvalid(breakpad_info_.validity &
+ MD_BREAKPAD_INFO_VALID_REQUESTING_THREAD_ID,
+ kNumberFormatHexadecimal,
+ breakpad_info_.requesting_thread_id);
+
+ printf("\n");
+}
+
+
+//
+// MinidumpMemoryInfo
+//
+
+
+MinidumpMemoryInfo::MinidumpMemoryInfo(Minidump* minidump)
+ : MinidumpObject(minidump),
+ memory_info_() {
+}
+
+
+bool MinidumpMemoryInfo::IsExecutable() const {
+ uint32_t protection =
+ memory_info_.protection & MD_MEMORY_PROTECTION_ACCESS_MASK;
+ return protection == MD_MEMORY_PROTECT_EXECUTE ||
+ protection == MD_MEMORY_PROTECT_EXECUTE_READ ||
+ protection == MD_MEMORY_PROTECT_EXECUTE_READWRITE;
+}
+
+
+bool MinidumpMemoryInfo::IsWritable() const {
+ uint32_t protection =
+ memory_info_.protection & MD_MEMORY_PROTECTION_ACCESS_MASK;
+ return protection == MD_MEMORY_PROTECT_READWRITE ||
+ protection == MD_MEMORY_PROTECT_WRITECOPY ||
+ protection == MD_MEMORY_PROTECT_EXECUTE_READWRITE ||
+ protection == MD_MEMORY_PROTECT_EXECUTE_WRITECOPY;
+}
+
+
+bool MinidumpMemoryInfo::Read() {
+ valid_ = false;
+
+ if (!minidump_->ReadBytes(&memory_info_, sizeof(memory_info_))) {
+ BPLOG(ERROR) << "MinidumpMemoryInfo cannot read memory info";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ Swap(&memory_info_.base_address);
+ Swap(&memory_info_.allocation_base);
+ Swap(&memory_info_.allocation_protection);
+ Swap(&memory_info_.region_size);
+ Swap(&memory_info_.state);
+ Swap(&memory_info_.protection);
+ Swap(&memory_info_.type);
+ }
+
+ // Check for base + size overflow or undersize.
+ if (memory_info_.region_size == 0 ||
+ memory_info_.region_size > numeric_limits<uint64_t>::max() -
+ memory_info_.base_address) {
+ BPLOG(ERROR) << "MinidumpMemoryInfo has a memory region problem, " <<
+ HexString(memory_info_.base_address) << "+" <<
+ HexString(memory_info_.region_size);
+ return false;
+ }
+
+ valid_ = true;
+ return true;
+}
+
+
+void MinidumpMemoryInfo::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpMemoryInfo cannot print invalid data";
+ return;
+ }
+
+ printf("MDRawMemoryInfo\n");
+ printf(" base_address = 0x%" PRIx64 "\n",
+ memory_info_.base_address);
+ printf(" allocation_base = 0x%" PRIx64 "\n",
+ memory_info_.allocation_base);
+ printf(" allocation_protection = 0x%x\n",
+ memory_info_.allocation_protection);
+ printf(" region_size = 0x%" PRIx64 "\n", memory_info_.region_size);
+ printf(" state = 0x%x\n", memory_info_.state);
+ printf(" protection = 0x%x\n", memory_info_.protection);
+ printf(" type = 0x%x\n", memory_info_.type);
+}
+
+
+//
+// MinidumpMemoryInfoList
+//
+
+
+MinidumpMemoryInfoList::MinidumpMemoryInfoList(Minidump* minidump)
+ : MinidumpStream(minidump),
+ range_map_(new RangeMap<uint64_t, unsigned int>()),
+ infos_(NULL),
+ info_count_(0) {
+}
+
+
+MinidumpMemoryInfoList::~MinidumpMemoryInfoList() {
+ delete range_map_;
+ delete infos_;
+}
+
+
+bool MinidumpMemoryInfoList::Read(uint32_t expected_size) {
+ // Invalidate cached data.
+ delete infos_;
+ infos_ = NULL;
+ range_map_->Clear();
+ info_count_ = 0;
+
+ valid_ = false;
+
+ MDRawMemoryInfoList header;
+ if (expected_size < sizeof(MDRawMemoryInfoList)) {
+ BPLOG(ERROR) << "MinidumpMemoryInfoList header size mismatch, " <<
+ expected_size << " < " << sizeof(MDRawMemoryInfoList);
+ return false;
+ }
+ if (!minidump_->ReadBytes(&header, sizeof(header))) {
+ BPLOG(ERROR) << "MinidumpMemoryInfoList could not read header";
+ return false;
+ }
+
+ if (minidump_->swap()) {
+ Swap(&header.size_of_header);
+ Swap(&header.size_of_entry);
+ Swap(&header.number_of_entries);
+ }
+
+ // Sanity check that the header is the expected size.
+ // TODO(ted): could possibly handle this more gracefully, assuming
+ // that future versions of the structs would be backwards-compatible.
+ if (header.size_of_header != sizeof(MDRawMemoryInfoList)) {
+ BPLOG(ERROR) << "MinidumpMemoryInfoList header size mismatch, " <<
+ header.size_of_header << " != " <<
+ sizeof(MDRawMemoryInfoList);
+ return false;
+ }
+
+ // Sanity check that the entries are the expected size.
+ if (header.size_of_entry != sizeof(MDRawMemoryInfo)) {
+ BPLOG(ERROR) << "MinidumpMemoryInfoList entry size mismatch, " <<
+ header.size_of_entry << " != " <<
+ sizeof(MDRawMemoryInfo);
+ return false;
+ }
+
+ if (header.number_of_entries >
+ numeric_limits<uint32_t>::max() / sizeof(MDRawMemoryInfo)) {
+ BPLOG(ERROR) << "MinidumpMemoryInfoList info count " <<
+ header.number_of_entries <<
+ " would cause multiplication overflow";
+ return false;
+ }
+
+ if (expected_size != sizeof(MDRawMemoryInfoList) +
+ header.number_of_entries * sizeof(MDRawMemoryInfo)) {
+ BPLOG(ERROR) << "MinidumpMemoryInfoList size mismatch, " << expected_size <<
+ " != " << sizeof(MDRawMemoryInfoList) +
+ header.number_of_entries * sizeof(MDRawMemoryInfo);
+ return false;
+ }
+
+ // Check for data loss when converting header.number_of_entries from
+ // uint64_t into MinidumpMemoryInfos::size_type (uint32_t)
+ MinidumpMemoryInfos::size_type header_number_of_entries =
+ static_cast<unsigned int>(header.number_of_entries);
+ if (static_cast<uint64_t>(header_number_of_entries) !=
+ header.number_of_entries) {
+ BPLOG(ERROR) << "Data loss detected when converting "
+ "the header's number_of_entries";
+ return false;
+ }
+
+ if (header.number_of_entries != 0) {
+ scoped_ptr<MinidumpMemoryInfos> infos(
+ new MinidumpMemoryInfos(header_number_of_entries,
+ MinidumpMemoryInfo(minidump_)));
+
+ for (unsigned int index = 0;
+ index < header.number_of_entries;
+ ++index) {
+ MinidumpMemoryInfo* info = &(*infos)[index];
+
+ // Assume that the file offset is correct after the last read.
+ if (!info->Read()) {
+ BPLOG(ERROR) << "MinidumpMemoryInfoList cannot read info " <<
+ index << "/" << header.number_of_entries;
+ return false;
+ }
+
+ uint64_t base_address = info->GetBase();
+ uint64_t region_size = info->GetSize();
+
+ if (!range_map_->StoreRange(base_address, region_size, index)) {
+ BPLOG(ERROR) << "MinidumpMemoryInfoList could not store"
+ " memory region " <<
+ index << "/" << header.number_of_entries << ", " <<
+ HexString(base_address) << "+" <<
+ HexString(region_size);
+ return false;
+ }
+ }
+
+ infos_ = infos.release();
+ }
+
+ info_count_ = header_number_of_entries;
+
+ valid_ = true;
+ return true;
+}
+
+
+const MinidumpMemoryInfo* MinidumpMemoryInfoList::GetMemoryInfoAtIndex(
+ unsigned int index) const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpMemoryInfoList for GetMemoryInfoAtIndex";
+ return NULL;
+ }
+
+ if (index >= info_count_) {
+ BPLOG(ERROR) << "MinidumpMemoryInfoList index out of range: " <<
+ index << "/" << info_count_;
+ return NULL;
+ }
+
+ return &(*infos_)[index];
+}
+
+
+const MinidumpMemoryInfo* MinidumpMemoryInfoList::GetMemoryInfoForAddress(
+ uint64_t address) const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid MinidumpMemoryInfoList for"
+ " GetMemoryInfoForAddress";
+ return NULL;
+ }
+
+ unsigned int info_index;
+ if (!range_map_->RetrieveRange(address, &info_index, NULL /* base */,
+ NULL /* delta */, NULL /* size */)) {
+ BPLOG(INFO) << "MinidumpMemoryInfoList has no memory info at " <<
+ HexString(address);
+ return NULL;
+ }
+
+ return GetMemoryInfoAtIndex(info_index);
+}
+
+
+void MinidumpMemoryInfoList::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpMemoryInfoList cannot print invalid data";
+ return;
+ }
+
+ printf("MinidumpMemoryInfoList\n");
+ printf(" info_count = %d\n", info_count_);
+ printf("\n");
+
+ for (unsigned int info_index = 0;
+ info_index < info_count_;
+ ++info_index) {
+ printf("info[%d]\n", info_index);
+ (*infos_)[info_index].Print();
+ printf("\n");
+ }
+}
+
+//
+// MinidumpLinuxMaps
+//
+
+MinidumpLinuxMaps::MinidumpLinuxMaps(Minidump *minidump)
+ : MinidumpObject(minidump) {
+}
+
+void MinidumpLinuxMaps::Print() const {
+ if (!valid_) {
+ BPLOG(ERROR) << "MinidumpLinuxMaps cannot print invalid data";
+ return;
+ }
+ std::cout << region_.line << std::endl;
+}
+
+//
+// MinidumpLinuxMapsList
+//
+
+MinidumpLinuxMapsList::MinidumpLinuxMapsList(Minidump *minidump)
+ : MinidumpStream(minidump),
+ maps_(NULL),
+ maps_count_(0) {
+}
+
+MinidumpLinuxMapsList::~MinidumpLinuxMapsList() {
+ if (maps_) {
+ for (unsigned int i = 0; i < maps_->size(); i++) {
+ delete (*maps_)[i];
+ }
+ delete maps_;
+ }
+}
+
+const MinidumpLinuxMaps *MinidumpLinuxMapsList::GetLinuxMapsForAddress(
+ uint64_t address) const {
+ if (!valid_ || (maps_ == NULL)) {
+ BPLOG(ERROR) << "Invalid MinidumpLinuxMapsList for GetLinuxMapsForAddress";
+ return NULL;
+ }
+
+ // Search every memory mapping.
+ for (unsigned int index = 0; index < maps_count_; index++) {
+ // Check if address is within bounds of the current memory region.
+ if ((*maps_)[index]->GetBase() <= address &&
+ (*maps_)[index]->GetBase() + (*maps_)[index]->GetSize() > address) {
+ return (*maps_)[index];
+ }
+ }
+
+ // No mapping encloses the memory address.
+ BPLOG(ERROR) << "MinidumpLinuxMapsList has no mapping at "
+ << HexString(address);
+ return NULL;
+}
+
+const MinidumpLinuxMaps *MinidumpLinuxMapsList::GetLinuxMapsAtIndex(
+ unsigned int index) const {
+ if (!valid_ || (maps_ == NULL)) {
+ BPLOG(ERROR) << "Invalid MinidumpLinuxMapsList for GetLinuxMapsAtIndex";
+ return NULL;
+ }
+
+ // Index out of bounds.
+ if (index >= maps_count_ || (maps_ == NULL)) {
+ BPLOG(ERROR) << "MinidumpLinuxMapsList index of out range: "
+ << index
+ << "/"
+ << maps_count_;
+ return NULL;
+ }
+ return (*maps_)[index];
+}
+
+bool MinidumpLinuxMapsList::Read(uint32_t expected_size) {
+ // Invalidate cached data.
+ if (maps_) {
+ for (unsigned int i = 0; i < maps_->size(); i++) {
+ delete (*maps_)[i];
+ }
+ delete maps_;
+ }
+ maps_ = NULL;
+ maps_count_ = 0;
+
+ valid_ = false;
+
+ // Load and check expected stream length.
+ uint32_t length = 0;
+ if (!minidump_->SeekToStreamType(MD_LINUX_MAPS, &length)) {
+ BPLOG(ERROR) << "MinidumpLinuxMapsList stream type not found";
+ return false;
+ }
+ if (expected_size != length) {
+ BPLOG(ERROR) << "MinidumpLinuxMapsList size mismatch: "
+ << expected_size
+ << " != "
+ << length;
+ return false;
+ }
+
+ // Create a vector to read stream data. The vector needs to have
+ // at least enough capacity to read all the data.
+ vector<char> mapping_bytes(length);
+ if (!minidump_->ReadBytes(&mapping_bytes[0], length)) {
+ BPLOG(ERROR) << "MinidumpLinuxMapsList failed to read bytes";
+ return false;
+ }
+ string map_string(mapping_bytes.begin(), mapping_bytes.end());
+ vector<MappedMemoryRegion> all_regions;
+
+ // Parse string into mapping data.
+ if (!ParseProcMaps(map_string, &all_regions)) {
+ return false;
+ }
+
+ scoped_ptr<MinidumpLinuxMappings> maps(new MinidumpLinuxMappings());
+
+ // Push mapping data into wrapper classes.
+ for (size_t i = 0; i < all_regions.size(); i++) {
+ scoped_ptr<MinidumpLinuxMaps> ele(new MinidumpLinuxMaps(minidump_));
+ ele->region_ = all_regions[i];
+ ele->valid_ = true;
+ maps->push_back(ele.release());
+ }
+
+ // Set instance variables.
+ maps_ = maps.release();
+ maps_count_ = maps_->size();
+ valid_ = true;
+ return true;
+}
+
+void MinidumpLinuxMapsList::Print() const {
+ if (!valid_ || (maps_ == NULL)) {
+ BPLOG(ERROR) << "MinidumpLinuxMapsList cannot print valid data";
+ return;
+ }
+ for (size_t i = 0; i < maps_->size(); i++) {
+ (*maps_)[i]->Print();
+ }
+}
+
+//
+// Minidump
+//
+
+
+uint32_t Minidump::max_streams_ = 128;
+unsigned int Minidump::max_string_length_ = 1024;
+
+
+Minidump::Minidump(const string& path)
+ : header_(),
+ directory_(NULL),
+ stream_map_(new MinidumpStreamMap()),
+ path_(path),
+ stream_(NULL),
+ swap_(false),
+ valid_(false) {
+}
+
+Minidump::Minidump(istream& stream)
+ : header_(),
+ directory_(NULL),
+ stream_map_(new MinidumpStreamMap()),
+ path_(),
+ stream_(&stream),
+ swap_(false),
+ valid_(false) {
+}
+
+Minidump::~Minidump() {
+ if (stream_) {
+ BPLOG(INFO) << "Minidump closing minidump";
+ }
+ if (!path_.empty()) {
+ delete stream_;
+ }
+ delete directory_;
+ delete stream_map_;
+}
+
+
+bool Minidump::Open() {
+ if (stream_ != NULL) {
+ BPLOG(INFO) << "Minidump reopening minidump " << path_;
+
+ // The file is already open. Seek to the beginning, which is the position
+ // the file would be at if it were opened anew.
+ return SeekSet(0);
+ }
+
+ stream_ = new ifstream(path_.c_str(), std::ios::in | std::ios::binary);
+ if (!stream_ || !stream_->good()) {
+ string error_string;
+ int error_code = ErrnoString(&error_string);
+ BPLOG(ERROR) << "Minidump could not open minidump " << path_ <<
+ ", error " << error_code << ": " << error_string;
+ return false;
+ }
+
+ BPLOG(INFO) << "Minidump opened minidump " << path_;
+ return true;
+}
+
+bool Minidump::GetContextCPUFlagsFromSystemInfo(uint32_t *context_cpu_flags) {
+ // Initialize output parameters
+ *context_cpu_flags = 0;
+
+ // Save the current stream position
+ off_t saved_position = Tell();
+ if (saved_position == -1) {
+ // Failed to save the current stream position.
+ // Returns true because the current position of the stream is preserved.
+ return true;
+ }
+
+ const MDRawSystemInfo* system_info =
+ GetSystemInfo() ? GetSystemInfo()->system_info() : NULL;
+
+ if (system_info != NULL) {
+ switch (system_info->processor_architecture) {
+ case MD_CPU_ARCHITECTURE_X86:
+ *context_cpu_flags = MD_CONTEXT_X86;
+ break;
+ case MD_CPU_ARCHITECTURE_MIPS:
+ *context_cpu_flags = MD_CONTEXT_MIPS;
+ break;
+ case MD_CPU_ARCHITECTURE_MIPS64:
+ *context_cpu_flags = MD_CONTEXT_MIPS64;
+ break;
+ case MD_CPU_ARCHITECTURE_ALPHA:
+ *context_cpu_flags = MD_CONTEXT_ALPHA;
+ break;
+ case MD_CPU_ARCHITECTURE_PPC:
+ *context_cpu_flags = MD_CONTEXT_PPC;
+ break;
+ case MD_CPU_ARCHITECTURE_PPC64:
+ *context_cpu_flags = MD_CONTEXT_PPC64;
+ break;
+ case MD_CPU_ARCHITECTURE_SHX:
+ *context_cpu_flags = MD_CONTEXT_SHX;
+ break;
+ case MD_CPU_ARCHITECTURE_ARM:
+ *context_cpu_flags = MD_CONTEXT_ARM;
+ break;
+ case MD_CPU_ARCHITECTURE_ARM64:
+ *context_cpu_flags = MD_CONTEXT_ARM64;
+ break;
+ case MD_CPU_ARCHITECTURE_IA64:
+ *context_cpu_flags = MD_CONTEXT_IA64;
+ break;
+ case MD_CPU_ARCHITECTURE_ALPHA64:
+ *context_cpu_flags = 0;
+ break;
+ case MD_CPU_ARCHITECTURE_MSIL:
+ *context_cpu_flags = 0;
+ break;
+ case MD_CPU_ARCHITECTURE_AMD64:
+ *context_cpu_flags = MD_CONTEXT_AMD64;
+ break;
+ case MD_CPU_ARCHITECTURE_X86_WIN64:
+ *context_cpu_flags = 0;
+ break;
+ case MD_CPU_ARCHITECTURE_SPARC:
+ *context_cpu_flags = MD_CONTEXT_SPARC;
+ break;
+ case MD_CPU_ARCHITECTURE_UNKNOWN:
+ *context_cpu_flags = 0;
+ break;
+ default:
+ *context_cpu_flags = 0;
+ break;
+ }
+ }
+
+ // Restore position and return
+ return SeekSet(saved_position);
+}
+
+
+bool Minidump::Read() {
+ // Invalidate cached data.
+ delete directory_;
+ directory_ = NULL;
+ stream_map_->clear();
+
+ valid_ = false;
+
+ if (!Open()) {
+ BPLOG(ERROR) << "Minidump cannot open minidump";
+ return false;
+ }
+
+ if (!ReadBytes(&header_, sizeof(MDRawHeader))) {
+ BPLOG(ERROR) << "Minidump cannot read header";
+ return false;
+ }
+
+ if (header_.signature != MD_HEADER_SIGNATURE) {
+ // The file may be byte-swapped. Under the present architecture, these
+ // classes don't know or need to know what CPU (or endianness) the
+ // minidump was produced on in order to parse it. Use the signature as
+ // a byte order marker.
+ uint32_t signature_swapped = header_.signature;
+ Swap(&signature_swapped);
+ if (signature_swapped != MD_HEADER_SIGNATURE) {
+ // This isn't a minidump or a byte-swapped minidump.
+ BPLOG(ERROR) << "Minidump header signature mismatch: (" <<
+ HexString(header_.signature) << ", " <<
+ HexString(signature_swapped) << ") != " <<
+ HexString(MD_HEADER_SIGNATURE);
+ return false;
+ }
+ swap_ = true;
+ } else {
+ // The file is not byte-swapped. Set swap_ false (it may have been true
+ // if the object is being reused?)
+ swap_ = false;
+ }
+
+ BPLOG(INFO) << "Minidump " << (swap_ ? "" : "not ") <<
+ "byte-swapping minidump";
+
+ if (swap_) {
+ Swap(&header_.signature);
+ Swap(&header_.version);
+ Swap(&header_.stream_count);
+ Swap(&header_.stream_directory_rva);
+ Swap(&header_.checksum);
+ Swap(&header_.time_date_stamp);
+ Swap(&header_.flags);
+ }
+
+ // Version check. The high 16 bits of header_.version contain something
+ // else "implementation specific."
+ if ((header_.version & 0x0000ffff) != MD_HEADER_VERSION) {
+ BPLOG(ERROR) << "Minidump version mismatch: " <<
+ HexString(header_.version & 0x0000ffff) << " != " <<
+ HexString(MD_HEADER_VERSION);
+ return false;
+ }
+
+ if (!SeekSet(header_.stream_directory_rva)) {
+ BPLOG(ERROR) << "Minidump cannot seek to stream directory";
+ return false;
+ }
+
+ if (header_.stream_count > max_streams_) {
+ BPLOG(ERROR) << "Minidump stream count " << header_.stream_count <<
+ " exceeds maximum " << max_streams_;
+ return false;
+ }
+
+ if (header_.stream_count != 0) {
+ scoped_ptr<MinidumpDirectoryEntries> directory(
+ new MinidumpDirectoryEntries(header_.stream_count));
+
+ // Read the entire array in one fell swoop, instead of reading one entry
+ // at a time in the loop.
+ if (!ReadBytes(&(*directory)[0],
+ sizeof(MDRawDirectory) * header_.stream_count)) {
+ BPLOG(ERROR) << "Minidump cannot read stream directory";
+ return false;
+ }
+
+ for (unsigned int stream_index = 0;
+ stream_index < header_.stream_count;
+ ++stream_index) {
+ MDRawDirectory* directory_entry = &(*directory)[stream_index];
+
+ if (swap_) {
+ Swap(&directory_entry->stream_type);
+ Swap(&directory_entry->location);
+ }
+
+ // Initialize the stream_map_ map, which speeds locating a stream by
+ // type.
+ unsigned int stream_type = directory_entry->stream_type;
+ switch (stream_type) {
+ case MD_THREAD_LIST_STREAM:
+ case MD_MODULE_LIST_STREAM:
+ case MD_MEMORY_LIST_STREAM:
+ case MD_EXCEPTION_STREAM:
+ case MD_SYSTEM_INFO_STREAM:
+ case MD_MISC_INFO_STREAM:
+ case MD_BREAKPAD_INFO_STREAM: {
+ if (stream_map_->find(stream_type) != stream_map_->end()) {
+ // Another stream with this type was already found. A minidump
+ // file should contain at most one of each of these stream types.
+ BPLOG(ERROR) << "Minidump found multiple streams of type " <<
+ stream_type << ", but can only deal with one";
+ return false;
+ }
+ // Fall through to default
+ }
+
+ default: {
+ // Overwrites for stream types other than those above, but it's
+ // expected to be the user's burden in that case.
+ (*stream_map_)[stream_type].stream_index = stream_index;
+ }
+ }
+ }
+
+ directory_ = directory.release();
+ }
+
+ valid_ = true;
+ return true;
+}
+
+
+MinidumpThreadList* Minidump::GetThreadList() {
+ MinidumpThreadList* thread_list;
+ return GetStream(&thread_list);
+}
+
+
+MinidumpModuleList* Minidump::GetModuleList() {
+ MinidumpModuleList* module_list;
+ return GetStream(&module_list);
+}
+
+
+MinidumpMemoryList* Minidump::GetMemoryList() {
+ MinidumpMemoryList* memory_list;
+ return GetStream(&memory_list);
+}
+
+
+MinidumpException* Minidump::GetException() {
+ MinidumpException* exception;
+ return GetStream(&exception);
+}
+
+MinidumpAssertion* Minidump::GetAssertion() {
+ MinidumpAssertion* assertion;
+ return GetStream(&assertion);
+}
+
+
+MinidumpSystemInfo* Minidump::GetSystemInfo() {
+ MinidumpSystemInfo* system_info;
+ return GetStream(&system_info);
+}
+
+
+MinidumpMiscInfo* Minidump::GetMiscInfo() {
+ MinidumpMiscInfo* misc_info;
+ return GetStream(&misc_info);
+}
+
+
+MinidumpBreakpadInfo* Minidump::GetBreakpadInfo() {
+ MinidumpBreakpadInfo* breakpad_info;
+ return GetStream(&breakpad_info);
+}
+
+MinidumpMemoryInfoList* Minidump::GetMemoryInfoList() {
+ MinidumpMemoryInfoList* memory_info_list;
+ return GetStream(&memory_info_list);
+}
+
+MinidumpLinuxMapsList *Minidump::GetLinuxMapsList() {
+ MinidumpLinuxMapsList *linux_maps_list;
+ return GetStream(&linux_maps_list);
+}
+
+bool Minidump::IsAndroid() {
+ // Save the current stream position
+ off_t saved_position = Tell();
+ if (saved_position == -1) {
+ return false;
+ }
+ const MDRawSystemInfo* system_info =
+ GetSystemInfo() ? GetSystemInfo()->system_info() : NULL;
+
+ // Restore position and return
+ if (!SeekSet(saved_position)) {
+ BPLOG(ERROR) << "Couldn't seek back to saved position";
+ return false;
+ }
+
+ return system_info && system_info->platform_id == MD_OS_ANDROID;
+}
+
+static const char* get_stream_name(uint32_t stream_type) {
+ switch (stream_type) {
+ case MD_UNUSED_STREAM:
+ return "MD_UNUSED_STREAM";
+ case MD_RESERVED_STREAM_0:
+ return "MD_RESERVED_STREAM_0";
+ case MD_RESERVED_STREAM_1:
+ return "MD_RESERVED_STREAM_1";
+ case MD_THREAD_LIST_STREAM:
+ return "MD_THREAD_LIST_STREAM";
+ case MD_MODULE_LIST_STREAM:
+ return "MD_MODULE_LIST_STREAM";
+ case MD_MEMORY_LIST_STREAM:
+ return "MD_MEMORY_LIST_STREAM";
+ case MD_EXCEPTION_STREAM:
+ return "MD_EXCEPTION_STREAM";
+ case MD_SYSTEM_INFO_STREAM:
+ return "MD_SYSTEM_INFO_STREAM";
+ case MD_THREAD_EX_LIST_STREAM:
+ return "MD_THREAD_EX_LIST_STREAM";
+ case MD_MEMORY_64_LIST_STREAM:
+ return "MD_MEMORY_64_LIST_STREAM";
+ case MD_COMMENT_STREAM_A:
+ return "MD_COMMENT_STREAM_A";
+ case MD_COMMENT_STREAM_W:
+ return "MD_COMMENT_STREAM_W";
+ case MD_HANDLE_DATA_STREAM:
+ return "MD_HANDLE_DATA_STREAM";
+ case MD_FUNCTION_TABLE_STREAM:
+ return "MD_FUNCTION_TABLE_STREAM";
+ case MD_UNLOADED_MODULE_LIST_STREAM:
+ return "MD_UNLOADED_MODULE_LIST_STREAM";
+ case MD_MISC_INFO_STREAM:
+ return "MD_MISC_INFO_STREAM";
+ case MD_MEMORY_INFO_LIST_STREAM:
+ return "MD_MEMORY_INFO_LIST_STREAM";
+ case MD_THREAD_INFO_LIST_STREAM:
+ return "MD_THREAD_INFO_LIST_STREAM";
+ case MD_HANDLE_OPERATION_LIST_STREAM:
+ return "MD_HANDLE_OPERATION_LIST_STREAM";
+ case MD_TOKEN_STREAM:
+ return "MD_TOKEN_STREAM";
+ case MD_JAVASCRIPT_DATA_STREAM:
+ return "MD_JAVASCRIPT_DATA_STREAM";
+ case MD_SYSTEM_MEMORY_INFO_STREAM:
+ return "MD_SYSTEM_MEMORY_INFO_STREAM";
+ case MD_PROCESS_VM_COUNTERS_STREAM:
+ return "MD_PROCESS_VM_COUNTERS_STREAM";
+ case MD_LAST_RESERVED_STREAM:
+ return "MD_LAST_RESERVED_STREAM";
+ case MD_BREAKPAD_INFO_STREAM:
+ return "MD_BREAKPAD_INFO_STREAM";
+ case MD_ASSERTION_INFO_STREAM:
+ return "MD_ASSERTION_INFO_STREAM";
+ case MD_LINUX_CPU_INFO:
+ return "MD_LINUX_CPU_INFO";
+ case MD_LINUX_PROC_STATUS:
+ return "MD_LINUX_PROC_STATUS";
+ case MD_LINUX_LSB_RELEASE:
+ return "MD_LINUX_LSB_RELEASE";
+ case MD_LINUX_CMD_LINE:
+ return "MD_LINUX_CMD_LINE";
+ case MD_LINUX_ENVIRON:
+ return "MD_LINUX_ENVIRON";
+ case MD_LINUX_AUXV:
+ return "MD_LINUX_AUXV";
+ case MD_LINUX_MAPS:
+ return "MD_LINUX_MAPS";
+ case MD_LINUX_DSO_DEBUG:
+ return "MD_LINUX_DSO_DEBUG";
+ default:
+ return "unknown";
+ }
+}
+
+void Minidump::Print() {
+ if (!valid_) {
+ BPLOG(ERROR) << "Minidump cannot print invalid data";
+ return;
+ }
+
+ printf("MDRawHeader\n");
+ printf(" signature = 0x%x\n", header_.signature);
+ printf(" version = 0x%x\n", header_.version);
+ printf(" stream_count = %d\n", header_.stream_count);
+ printf(" stream_directory_rva = 0x%x\n", header_.stream_directory_rva);
+ printf(" checksum = 0x%x\n", header_.checksum);
+ printf(" time_date_stamp = 0x%x %s\n",
+ header_.time_date_stamp,
+ TimeTToUTCString(header_.time_date_stamp).c_str());
+ printf(" flags = 0x%" PRIx64 "\n", header_.flags);
+ printf("\n");
+
+ for (unsigned int stream_index = 0;
+ stream_index < header_.stream_count;
+ ++stream_index) {
+ MDRawDirectory* directory_entry = &(*directory_)[stream_index];
+
+ printf("mDirectory[%d]\n", stream_index);
+ printf("MDRawDirectory\n");
+ printf(" stream_type = 0x%x (%s)\n", directory_entry->stream_type,
+ get_stream_name(directory_entry->stream_type));
+ printf(" location.data_size = %d\n",
+ directory_entry->location.data_size);
+ printf(" location.rva = 0x%x\n", directory_entry->location.rva);
+ printf("\n");
+ }
+
+ printf("Streams:\n");
+ for (MinidumpStreamMap::const_iterator iterator = stream_map_->begin();
+ iterator != stream_map_->end();
+ ++iterator) {
+ uint32_t stream_type = iterator->first;
+ const MinidumpStreamInfo& info = iterator->second;
+ printf(" stream type 0x%x (%s) at index %d\n", stream_type,
+ get_stream_name(stream_type),
+ info.stream_index);
+ }
+ printf("\n");
+}
+
+
+const MDRawDirectory* Minidump::GetDirectoryEntryAtIndex(unsigned int index)
+ const {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid Minidump for GetDirectoryEntryAtIndex";
+ return NULL;
+ }
+
+ if (index >= header_.stream_count) {
+ BPLOG(ERROR) << "Minidump stream directory index out of range: " <<
+ index << "/" << header_.stream_count;
+ return NULL;
+ }
+
+ return &(*directory_)[index];
+}
+
+
+bool Minidump::ReadBytes(void* bytes, size_t count) {
+ // Can't check valid_ because Read needs to call this method before
+ // validity can be determined.
+ if (!stream_) {
+ return false;
+ }
+ stream_->read(static_cast<char*>(bytes), count);
+ std::streamsize bytes_read = stream_->gcount();
+ if (bytes_read == -1) {
+ string error_string;
+ int error_code = ErrnoString(&error_string);
+ BPLOG(ERROR) << "ReadBytes: error " << error_code << ": " << error_string;
+ return false;
+ }
+
+ // Convert to size_t and check for data loss
+ size_t bytes_read_converted = static_cast<size_t>(bytes_read);
+ if (static_cast<std::streamsize>(bytes_read_converted) != bytes_read) {
+ BPLOG(ERROR) << "ReadBytes: conversion data loss detected when converting "
+ << bytes_read << " to " << bytes_read_converted;
+ return false;
+ }
+
+ if (bytes_read_converted != count) {
+ BPLOG(ERROR) << "ReadBytes: read " << bytes_read_converted << "/" << count;
+ return false;
+ }
+
+ return true;
+}
+
+
+bool Minidump::SeekSet(off_t offset) {
+ // Can't check valid_ because Read needs to call this method before
+ // validity can be determined.
+ if (!stream_) {
+ return false;
+ }
+ stream_->seekg(offset, std::ios_base::beg);
+ if (!stream_->good()) {
+ string error_string;
+ int error_code = ErrnoString(&error_string);
+ BPLOG(ERROR) << "SeekSet: error " << error_code << ": " << error_string;
+ return false;
+ }
+ return true;
+}
+
+off_t Minidump::Tell() {
+ if (!valid_ || !stream_) {
+ return (off_t)-1;
+ }
+
+ // Check for conversion data loss
+ std::streamoff std_streamoff = stream_->tellg();
+ off_t rv = static_cast<off_t>(std_streamoff);
+ if (static_cast<std::streamoff>(rv) == std_streamoff) {
+ return rv;
+ } else {
+ BPLOG(ERROR) << "Data loss detected";
+ return (off_t)-1;
+ }
+}
+
+
+string* Minidump::ReadString(off_t offset) {
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid Minidump for ReadString";
+ return NULL;
+ }
+ if (!SeekSet(offset)) {
+ BPLOG(ERROR) << "ReadString could not seek to string at offset " << offset;
+ return NULL;
+ }
+
+ uint32_t bytes;
+ if (!ReadBytes(&bytes, sizeof(bytes))) {
+ BPLOG(ERROR) << "ReadString could not read string size at offset " <<
+ offset;
+ return NULL;
+ }
+ if (swap_)
+ Swap(&bytes);
+
+ if (bytes % 2 != 0) {
+ BPLOG(ERROR) << "ReadString found odd-sized " << bytes <<
+ "-byte string at offset " << offset;
+ return NULL;
+ }
+ unsigned int utf16_words = bytes / 2;
+
+ if (utf16_words > max_string_length_) {
+ BPLOG(ERROR) << "ReadString string length " << utf16_words <<
+ " exceeds maximum " << max_string_length_ <<
+ " at offset " << offset;
+ return NULL;
+ }
+
+ vector<uint16_t> string_utf16(utf16_words);
+
+ if (utf16_words) {
+ if (!ReadBytes(&string_utf16[0], bytes)) {
+ BPLOG(ERROR) << "ReadString could not read " << bytes <<
+ "-byte string at offset " << offset;
+ return NULL;
+ }
+ }
+
+ return UTF16ToUTF8(string_utf16, swap_);
+}
+
+
+bool Minidump::SeekToStreamType(uint32_t stream_type,
+ uint32_t* stream_length) {
+ BPLOG_IF(ERROR, !stream_length) << "Minidump::SeekToStreamType requires "
+ "|stream_length|";
+ assert(stream_length);
+ *stream_length = 0;
+
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid Mindump for SeekToStreamType";
+ return false;
+ }
+
+ MinidumpStreamMap::const_iterator iterator = stream_map_->find(stream_type);
+ if (iterator == stream_map_->end()) {
+ // This stream type didn't exist in the directory.
+ BPLOG(INFO) << "SeekToStreamType: type " << stream_type << " not present";
+ return false;
+ }
+
+ const MinidumpStreamInfo& info = iterator->second;
+ if (info.stream_index >= header_.stream_count) {
+ BPLOG(ERROR) << "SeekToStreamType: type " << stream_type <<
+ " out of range: " <<
+ info.stream_index << "/" << header_.stream_count;
+ return false;
+ }
+
+ MDRawDirectory* directory_entry = &(*directory_)[info.stream_index];
+ if (!SeekSet(directory_entry->location.rva)) {
+ BPLOG(ERROR) << "SeekToStreamType could not seek to stream type " <<
+ stream_type;
+ return false;
+ }
+
+ *stream_length = directory_entry->location.data_size;
+
+ return true;
+}
+
+
+template<typename T>
+T* Minidump::GetStream(T** stream) {
+ // stream is a garbage parameter that's present only to account for C++'s
+ // inability to overload a method based solely on its return type.
+
+ const uint32_t stream_type = T::kStreamType;
+
+ BPLOG_IF(ERROR, !stream) << "Minidump::GetStream type " << stream_type <<
+ " requires |stream|";
+ assert(stream);
+ *stream = NULL;
+
+ if (!valid_) {
+ BPLOG(ERROR) << "Invalid Minidump for GetStream type " << stream_type;
+ return NULL;
+ }
+
+ MinidumpStreamMap::iterator iterator = stream_map_->find(stream_type);
+ if (iterator == stream_map_->end()) {
+ // This stream type didn't exist in the directory.
+ BPLOG(INFO) << "GetStream: type " << stream_type << " not present";
+ return NULL;
+ }
+
+ // Get a pointer so that the stored stream field can be altered.
+ MinidumpStreamInfo* info = &iterator->second;
+
+ if (info->stream) {
+ // This cast is safe because info.stream is only populated by this
+ // method, and there is a direct correlation between T and stream_type.
+ *stream = static_cast<T*>(info->stream);
+ return *stream;
+ }
+
+ uint32_t stream_length;
+ if (!SeekToStreamType(stream_type, &stream_length)) {
+ BPLOG(ERROR) << "GetStream could not seek to stream type " << stream_type;
+ return NULL;
+ }
+
+ scoped_ptr<T> new_stream(new T(this));
+
+ if (!new_stream->Read(stream_length)) {
+ BPLOG(ERROR) << "GetStream could not read stream type " << stream_type;
+ return NULL;
+ }
+
+ *stream = new_stream.release();
+ info->stream = *stream;
+ return *stream;
+}
+
+
+} // namespace google_breakpad
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-15 07:39:56 +0000