From 76f052f8fbf8864dee5992b857229d06560a766a Mon Sep 17 00:00:00 2001 From: mmentovai Date: Mon, 6 Nov 2006 23:00:19 +0000 Subject: Suppress handler thread from appearing in MinidumpProcessor's ProcessState (#65). r=bryner - Interface change: (ProcessState).crash_thread is now requesting_thread and will be populated for non-crash dumps. If the requesting thread cannot be determined, requesting_thread is set to -1. http://groups.google.com/group/airbag-dev/browse_thread/thread/c422ec481a2db440 git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@62 4c0a9323-5329-0410-9bdc-e9ce6186880e --- src/google_airbag/processor/minidump.h | 65 +++++++++++++++++++++++------ src/google_airbag/processor/process_state.h | 16 ++++--- 2 files changed, 64 insertions(+), 17 deletions(-) (limited to 'src/google_airbag') diff --git a/src/google_airbag/processor/minidump.h b/src/google_airbag/processor/minidump.h index edcda9f8..2a666fe7 100644 --- a/src/google_airbag/processor/minidump.h +++ b/src/google_airbag/processor/minidump.h @@ -280,8 +280,9 @@ class MinidumpThread : public MinidumpObject { // The thread ID is used to determine if a thread is the exception thread, // so a special getter is provided to retrieve this data from the - // MDRawThread structure. - u_int32_t GetThreadID(); + // MDRawThread structure. Returns false if the thread ID cannot be + // determined. + bool GetThreadID(u_int32_t *thread_id) const; // Print a human-readable representation of the object to stdout. void Print(); @@ -349,9 +350,10 @@ class MinidumpModule : public MinidumpObject { public: ~MinidumpModule(); - const MDRawModule* module() const { return valid_ ? &module_ : 0; } + const MDRawModule* module() const { return valid_ ? &module_ : NULL; } u_int64_t base_address() const { - return valid_ ? module_.base_of_image : static_cast(-1); } + return valid_ ? module_.base_of_image : static_cast(-1); + } u_int32_t size() const { return valid_ ? module_.size_of_image : 0; } // The name of the file containing this module's code (exe, dll, so, @@ -513,12 +515,14 @@ class MinidumpException : public MinidumpStream { ~MinidumpException(); const MDRawExceptionStream* exception() const { - return valid_ ? &exception_ : 0; } + return valid_ ? &exception_ : NULL; + } // The thread ID is used to determine if a thread is the exception thread, // so a special getter is provided to retrieve this data from the - // MDRawExceptionStream structure. - u_int32_t GetThreadID(); + // MDRawExceptionStream structure. Returns false if the thread ID cannot + // be determined. + bool GetThreadID(u_int32_t *thread_id) const; MinidumpContext* GetContext(); @@ -546,7 +550,8 @@ class MinidumpSystemInfo : public MinidumpStream { ~MinidumpSystemInfo(); const MDRawSystemInfo* system_info() const { - return valid_ ? &system_info_ : 0; } + return valid_ ? &system_info_ : NULL; + } // I don't know what CSD stands for, but this field is documented as // returning a textual representation of the OS service pack. On other @@ -587,7 +592,9 @@ class MinidumpSystemInfo : public MinidumpStream { // information. See also MinidumpSystemInfo. class MinidumpMiscInfo : public MinidumpStream { public: - const MDRawMiscInfo* misc_info() const { return valid_ ? &misc_info_ : 0; } + const MDRawMiscInfo* misc_info() const { + return valid_ ? &misc_info_ : NULL; + } // Print a human-readable representation of the object to stdout. void Print(); @@ -605,6 +612,38 @@ class MinidumpMiscInfo : public MinidumpStream { }; +// MinidumpAirbagInfo wraps MDRawAirbagInfo, which is an optional stream in +// a minidump that provides additional information about the process state +// at the time the minidump was generated. +class MinidumpAirbagInfo : public MinidumpStream { + public: + const MDRawAirbagInfo* airbag_info() const { + return valid_ ? &airbag_info_ : NULL; + } + + // These thread IDs are used to determine if threads deserve special + // treatment, so special getters are provided to retrieve this data from + // the MDRawAirbagInfo structure. The getters return false if the thread + // IDs cannot be determined. + bool GetDumpThreadID(u_int32_t *thread_id) const; + bool GetRequestingThreadID(u_int32_t *thread_id) const; + + // Print a human-readable representation of the object to stdout. + void Print(); + + private: + friend class Minidump; + + static const u_int32_t kStreamType = MD_AIRBAG_INFO_STREAM; + + explicit MinidumpAirbagInfo(Minidump* minidump_); + + bool Read(u_int32_t expected_size_); + + MDRawAirbagInfo airbag_info_; +}; + + // Minidump is the user's interface to a minidump file. It wraps MDRawHeader // and provides access to the minidump's top-level stream directory. class Minidump { @@ -614,7 +653,7 @@ class Minidump { ~Minidump(); - const MDRawHeader* header() const { return valid_ ? &header_ : 0; } + const MDRawHeader* header() const { return valid_ ? &header_ : NULL; } // Reads the minidump file's header and top-level stream directory. // The minidump is expected to be positioned at the beginning of the @@ -622,7 +661,7 @@ class Minidump { // Minidump object. bool Read(); - // The next 6 methods are stubs that call GetStream. They exist to + // The next set of methods are stubs that call GetStream. They exist to // force code generation of the templatized API within the module, and // to avoid exposing an ugly API (GetStream needs to accept a garbage // parameter). @@ -632,6 +671,7 @@ class Minidump { MinidumpException* GetException(); MinidumpSystemInfo* GetSystemInfo(); MinidumpMiscInfo* GetMiscInfo(); + MinidumpAirbagInfo* GetAirbagInfo(); // The next set of methods are provided for users who wish to access // data in minidump files directly, while leveraging the rest of @@ -639,7 +679,8 @@ class Minidump { // structure and known stream types. unsigned int GetDirectoryEntryCount() const { - return valid_ ? header_.stream_count : 0; } + return valid_ ? header_.stream_count : 0; + } const MDRawDirectory* GetDirectoryEntryAtIndex(unsigned int index) const; // The next 2 methods are lower-level I/O routines. They use fd_. diff --git a/src/google_airbag/processor/process_state.h b/src/google_airbag/processor/process_state.h index e67ae9ae..eb75703a 100644 --- a/src/google_airbag/processor/process_state.h +++ b/src/google_airbag/processor/process_state.h @@ -52,7 +52,7 @@ class ProcessState { bool crashed() const { return crashed_; } string crash_reason() const { return crash_reason_; } u_int64_t crash_address() const { return crash_address_; } - unsigned int crash_thread() const { return crash_thread_; } + int requesting_thread() const { return requesting_thread_; } const vector* threads() const { return &threads_; } string os() const { return os_; } string os_version() const { return os_version_; } @@ -65,7 +65,7 @@ class ProcessState { // Disallow instantiation other than by friends. ProcessState() : crashed_(false), crash_reason_(), crash_address_(0), - crash_thread_(0), threads_(), os_(), os_version_(), + requesting_thread_(-1), threads_(), os_(), os_version_(), cpu_(), cpu_info_() {} // True if the process crashed, false if the dump was produced outside @@ -84,9 +84,15 @@ class ProcessState { // this will be the address of the instruction that caused the fault. u_int64_t crash_address_; - // If the process crashed, the index of the crashed thread's stack - // in the threads vector. - unsigned int crash_thread_; + // The index of the thread that requested a dump be written in the + // threads vector. If a dump was produced as a result of a crash, this + // will point to the thread that crashed. If the dump was produced as + // by user code without crashing, and the dump contains extended Airbag + // information, this will point to the thread that requested the dump. + // If the dump was not produced as a result of an exception and no + // extended Airbag information is present, this field will be set to -1, + // indicating that the dump thread is not available. + int requesting_thread_; // Stacks for each thread (except possibly the exception handler // thread) at the time of the crash. -- cgit v1.2.1