path: root/toolkit/crashreporter/breakpad-patches/21-thread-names.patch

diff --git a/src/google_breakpad/common/minidump_format.h b/src/google_breakpad/common/minidump_format.h
--- a/src/google_breakpad/common/minidump_format.h
+++ b/src/google_breakpad/common/minidump_format.h
@@ -227,17 +227,18 @@ typedef struct {
 
 /*
  * DbgHelp.h
  */
 
 
 /* An MDRVA is an offset into the minidump file.  The beginning of the
  * MDRawHeader is at offset 0. */
-typedef uint32_t MDRVA;  /* RVA */
+typedef uint32_t MDRVA;   /* RVA   */
+typedef uint64_t MDRVA64; /* RVA64 */
 
 typedef struct {
   uint32_t  data_size;
   MDRVA     rva;
 } MDLocationDescriptor;  /* MINIDUMP_LOCATION_DESCRIPTOR */
 
 
 typedef struct {
@@ -327,16 +328,18 @@ typedef enum {
   MD_MISC_INFO_STREAM            = 15,  /* MDRawMiscInfo */
   MD_MEMORY_INFO_LIST_STREAM     = 16,  /* MDRawMemoryInfoList */
   MD_THREAD_INFO_LIST_STREAM     = 17,
   MD_HANDLE_OPERATION_LIST_STREAM = 18,
   MD_TOKEN_STREAM                = 19,
   MD_JAVASCRIPT_DATA_STREAM      = 20,
   MD_SYSTEM_MEMORY_INFO_STREAM   = 21,
   MD_PROCESS_VM_COUNTERS_STREAM  = 22,
+  MD_IPT_TRACE_STREAM            = 23,
+  MD_THREAD_NAMES_STREAM         = 24,
   MD_LAST_RESERVED_STREAM        = 0x0000ffff,
 
   /* Breakpad extension types.  0x4767 = "Gg" */
   MD_BREAKPAD_INFO_STREAM        = 0x47670001,  /* MDRawBreakpadInfo  */
   MD_ASSERTION_INFO_STREAM       = 0x47670002,  /* MDRawAssertionInfo */
   /* These are additional minidump stream values which are specific to
    * the linux breakpad implementation. */
   MD_LINUX_CPU_INFO              = 0x47670003,  /* /proc/cpuinfo      */
@@ -1117,16 +1120,26 @@ typedef struct {
    *   module_path;
    *   message;
    *   signature_string;
    *   backtrace;
    *   message2; */
   uint8_t data[0];
 } MDRawMacCrashInfoRecord;
 
+typedef struct __attribute__((packed,aligned(4))) {
+  uint32_t thread_id;
+  MDRVA64 rva_of_thread_name;
+} MDRawThreadName;
+
+typedef struct {
+  uint32_t number_of_thread_names;
+  MDRawThreadName thread_names[0];
+} MDRawThreadNamesList;
+
 /* This is the maximum supported size for each string in
  * (MDRawMacCrashInfoRecord).data. If we encounter a string in the
  * __crash_info section which seems larger than this, that's a sign of data
  * corruption. */
 #define MACCRASHINFO_STRING_MAXSIZE 8192
 
 /* In principle there should only be one or two non-empty __DATA,__crash_info
  * sections per process. But the __crash_info section is almost entirely
diff --git a/src/google_breakpad/processor/call_stack.h b/src/google_breakpad/processor/call_stack.h
--- a/src/google_breakpad/processor/call_stack.h
+++ b/src/google_breakpad/processor/call_stack.h
@@ -41,21 +41,23 @@
 // beginning with the innermost callee frame.
 //
 // Author: Mark Mentovai
 
 #ifndef GOOGLE_BREAKPAD_PROCESSOR_CALL_STACK_H__
 #define GOOGLE_BREAKPAD_PROCESSOR_CALL_STACK_H__
 
 #include <cstdint>
+#include <string>
 #include <vector>
 
 namespace google_breakpad {
 
 using std::vector;
+using std::string;
 
 struct StackFrame;
 template<typename T> class linked_ptr;
 
 class CallStack {
  public:
   CallStack() { Clear(); }
   ~CallStack();
@@ -63,29 +65,33 @@ class CallStack {
   // Resets the CallStack to its initial empty state
   void Clear();
 
   const vector<StackFrame*>* frames() const { return &frames_; }
 
   // Set the TID associated with this call stack.
   void set_tid(uint32_t tid) { tid_ = tid; }
   void set_last_error(uint32_t last_error) { last_error_ = last_error; }
+  void set_name(const string& name) { name_ = name; }
 
   uint32_t tid() const { return tid_; }
   uint32_t last_error() const { return last_error_; }
+  const string name() const { return name_; }
 
  private:
   // Stackwalker is responsible for building the frames_ vector.
   friend class Stackwalker;
 
   // Storage for pushed frames.
   vector<StackFrame*> frames_;
 
   // The TID associated with this call stack. Default to 0 if it's not
   // available.
   uint32_t tid_;
   // The last error the OS set for this thread (win32's GetLastError())
   uint32_t last_error_;
+  // The name of this thread, empty if it's not available
+  string name_;
 };
 
 }  // namespace google_breakpad
 
 #endif  // GOOGLE_BREAKPAD_PROCSSOR_CALL_STACK_H__
diff --git a/src/google_breakpad/processor/minidump.h b/src/google_breakpad/processor/minidump.h
--- a/src/google_breakpad/processor/minidump.h
+++ b/src/google_breakpad/processor/minidump.h
@@ -1197,16 +1197,96 @@ class MinidumpMacCrashInfo : public Mini
   bool ReadCrashInfoRecord(MDLocationDescriptor location,
                            uint32_t record_start_size);
   bool Read(uint32_t expected_size);
 
   string description_;
   vector<crash_info_record_t> records_;
 };
 
+// MinidumpThreadName wraps MDRawThreadName
+class MinidumpThreadName : public MinidumpObject {
+ public:
+  ~MinidumpThreadName() override;
+
+  const MDRawThreadName* thread_name() const {
+    if (valid_) {
+      return &thread_name_;
+    }
+
+    return NULL;
+  }
+
+  uint32_t thread_id() const {
+    if (valid_) {
+      return thread_name_.thread_id;
+    }
+
+    return 0;
+  }
+
+  string name() const;
+
+  // Print a human-readable representation of the object to stdout.
+  void Print();
+
+ protected:
+  explicit MinidumpThreadName(Minidump* minidump);
+
+ private:
+  // These objects are managed by MinidumpThreadNameList
+  friend class MinidumpThreadNamesList;
+
+  // This works like MinidumpStream::Read, but is driven by
+  // MinidumpThreadNameList.
+  bool Read(uint32_t expected_size);
+
+  // Reads the thread name. This is done separately from Read to
+  // allow contiguous reading of thread names by MinidumpThreadNameList.
+  bool ReadAuxiliaryData();
+
+  bool valid_;
+  MDRawThreadName thread_name_;
+  const string* name_;
+};
+
+
+// MinidumpThreadNamesList contains all the names for threads in a process
+// in the form of MinidumpThreadNames.
+class MinidumpThreadNamesList : public MinidumpStream {
+ public:
+  ~MinidumpThreadNamesList() override;
+
+  unsigned int name_count() const {
+    return valid_ ? name_count_ : 0;
+  }
+
+  const string GetNameForThreadId(uint32_t thread_id) const;
+
+  // Print a human-readable representation of the object to stdout.
+  void Print();
+
+ protected:
+  explicit MinidumpThreadNamesList(Minidump* minidump_);
+
+ private:
+  friend class Minidump;
+
+  typedef vector<MinidumpThreadName> MinidumpThreadNames;
+
+  static const uint32_t kStreamType = MD_THREAD_NAMES_STREAM;
+
+  bool Read(uint32_t expected_size_) override;
+
+  MinidumpThreadNames* thread_names_;
+  uint32_t name_count_;
+  bool valid_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpThreadNamesList);
+};
 
 // 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 {
  public:
   // path is the pathname of a file containing the minidump.
   explicit Minidump(const string& path,
                     bool hexdump=false,
@@ -1261,16 +1343,17 @@ class Minidump {
   virtual MinidumpAssertion* GetAssertion();
   virtual MinidumpSystemInfo* GetSystemInfo();
   virtual MinidumpUnloadedModuleList* GetUnloadedModuleList();
   virtual MinidumpMiscInfo* GetMiscInfo();
   virtual MinidumpBreakpadInfo* GetBreakpadInfo();
   virtual MinidumpMemoryInfoList* GetMemoryInfoList();
   MinidumpCrashpadInfo* GetCrashpadInfo();
   MinidumpMacCrashInfo* GetMacCrashInfo();
+  MinidumpThreadNamesList* GetThreadNamesList();
 
   // The next method also calls GetStream, but is exclusive for Linux dumps.
   virtual MinidumpLinuxMapsList *GetLinuxMapsList();
 
   // The next set of methods are provided for users who wish to access
   // data in minidump files directly, while leveraging the rest of
   // this class and related classes to handle the basic minidump
   // structure and known stream types.
diff --git a/src/processor/call_stack.cc b/src/processor/call_stack.cc
--- a/src/processor/call_stack.cc
+++ b/src/processor/call_stack.cc
@@ -45,11 +45,12 @@ CallStack::~CallStack() {
 void CallStack::Clear() {
   for (vector<StackFrame *>::const_iterator iterator = frames_.begin();
        iterator != frames_.end();
        ++iterator) {
     delete *iterator;
   }
   tid_ = 0;
   last_error_ = 0;
+  name_ = "";
 }
 
 }  // namespace google_breakpad
diff --git a/src/processor/minidump.cc b/src/processor/minidump.cc
--- a/src/processor/minidump.cc
+++ b/src/processor/minidump.cc
@@ -5724,16 +5724,226 @@ MinidumpCrashpadInfo* Minidump::GetCrash
   return GetStream(&crashpad_info);
 }
 
 MinidumpMacCrashInfo* Minidump::GetMacCrashInfo() {
   MinidumpMacCrashInfo* mac_crash_info;
   return GetStream(&mac_crash_info);
 }
 
+MinidumpThreadNamesList* Minidump::GetThreadNamesList() {
+  MinidumpThreadNamesList* thread_names_list;
+  return GetStream(&thread_names_list);
+}
+
+//
+// MinidumpThreadName
+//
+
+
+MinidumpThreadName::MinidumpThreadName(Minidump* minidump)
+    : MinidumpObject(minidump),
+      valid_(false),
+      thread_name_(),
+      name_(NULL) {
+
+}
+
+MinidumpThreadName::~MinidumpThreadName() {
+  ;
+}
+
+void MinidumpThreadName::Print() {
+  if (!valid_) {
+    BPLOG(ERROR) << "MinidumpThreadName cannot print invalid data";
+    return;
+  }
+
+  printf("MDRawThreadName\n");
+  printf("  thread_id          = 0x%x\n",
+         thread_name_.thread_id);
+  printf("  rva_of_thread_name = 0x%" PRIx64 "\n",
+         thread_name_.rva_of_thread_name);
+
+  printf("  (name)             = \"%s\"\n", name().c_str());
+  printf("\n");
+}
+
+string MinidumpThreadName::name() const {
+  if (!valid_) {
+    BPLOG(ERROR) << "Invalid MinidumpThreadName for name";
+    return "";
+  }
+
+  return *name_;
+}
+
+bool MinidumpThreadName::Read(uint32_t expected_size) {
+
+  delete name_;
+
+  if (expected_size < sizeof(thread_name_)) {
+    BPLOG(ERROR) << "MinidumpThreadName expected size is less than size "
+                 << "of struct " << expected_size << " < "
+                 << sizeof(thread_name_);
+    return false;
+  }
+
+  if (!minidump_->ReadBytes(&thread_name_, sizeof(thread_name_))) {
+    BPLOG(ERROR) << "MinidumpThreadName cannot read name";
+    return false;
+  }
+
+  if (expected_size > sizeof(thread_name_)) {
+    uint32_t thread_name_bytes_remaining = expected_size - sizeof(thread_name_);
+    off_t pos = minidump_->Tell();
+    if (!minidump_->SeekSet(pos + thread_name_bytes_remaining)) {
+      BPLOG(ERROR) << "MinidumpThreadName unable to seek to end of name";
+      return false;
+    }
+  }
+
+  if (minidump_->swap()) {
+    Swap(&thread_name_.thread_id);
+    uint64_t rva_of_thread_name;
+    memcpy(&rva_of_thread_name, &thread_name_.rva_of_thread_name, sizeof(uint64_t));
+    Swap(&rva_of_thread_name);
+    memcpy(&thread_name_.rva_of_thread_name, &rva_of_thread_name, sizeof(uint64_t));
+  }
+
+  return true;
+}
+
+bool MinidumpThreadName::ReadAuxiliaryData() {
+  // Each thread must have a name string.
+  name_ = minidump_->ReadString(thread_name_.rva_of_thread_name);
+  if (!name_) {
+    BPLOG(ERROR) << "MinidumpThreadName could not read name";
+    valid_ = false;
+    return false;
+  }
+
+  // At this point, we have enough info for the name to be valid.
+  valid_ = true;
+  return true;
+}
+
+//
+// MinidumpThreadNamesList
+//
+
+
+MinidumpThreadNamesList::MinidumpThreadNamesList(Minidump* minidump)
+  : MinidumpStream(minidump),
+    thread_names_(NULL),
+    name_count_(0),
+    valid_(false) {
+  ;
+}
+
+MinidumpThreadNamesList::~MinidumpThreadNamesList() {
+  delete thread_names_;
+}
+
+const string MinidumpThreadNamesList::GetNameForThreadId(uint32_t thread_id) const {
+  if (valid_) {
+    for (unsigned int name_index = 0;
+         name_index < name_count_;
+         ++name_index) {
+      const MinidumpThreadName& thread_name = (*thread_names_)[name_index];
+      if (thread_name.thread_id() == thread_id) {
+        return thread_name.name();
+      }
+    }
+  }
+
+  return "";
+}
+
+void MinidumpThreadNamesList::Print() {
+  if (!valid_) {
+    BPLOG(ERROR) << "MinidumpThreadNamesList cannot print invalid data";
+    return;
+  }
+
+  printf("MinidumpThreadNamesList\n");
+  printf("  name_count = %d\n", name_count_);
+  printf("\n");
+
+  for (unsigned int name_index = 0;
+       name_index < name_count_;
+       ++name_index) {
+    printf("thread_name[%d]\n", name_index);
+
+    (*thread_names_)[name_index].Print();
+  }
+}
+
+bool MinidumpThreadNamesList::Read(uint32_t expected_size) {
+  delete thread_names_;
+  thread_names_ = NULL;
+  name_count_ = 0;
+
+  valid_ = false;
+
+  uint32_t number_of_thread_names;
+  if (!minidump_->ReadBytes(&number_of_thread_names, sizeof(number_of_thread_names))) {
+    BPLOG(ERROR) << "MinidumpThreadNamesList could not read the number of thread names";
+    return false;
+  }
+
+  if (minidump_->swap()) {
+    Swap(&number_of_thread_names);
+  }
+
+  if (expected_size !=
+      sizeof(number_of_thread_names) + (sizeof(MDRawThreadName) * number_of_thread_names)) {
+    BPLOG(ERROR) << "MinidumpThreadNamesList expected_size mismatch " <<
+                 expected_size << " != " << sizeof(number_of_thread_names) << " + (" <<
+                 sizeof(MDRawThreadName) << " * " << number_of_thread_names << ")";
+    return false;
+  }
+
+  if (number_of_thread_names != 0) {
+    scoped_ptr<MinidumpThreadNames> thread_names(
+        new MinidumpThreadNames(number_of_thread_names,
+                                MinidumpThreadName(minidump_)));
+
+    for (unsigned int name_index = 0;
+         name_index < number_of_thread_names;
+         ++name_index) {
+      MinidumpThreadName* thread_name = &(*thread_names)[name_index];
+
+      if (!thread_name->Read(sizeof(MDRawThreadName))) {
+        BPLOG(ERROR) << "MinidumpThreadNamesList could not read name " <<
+                     name_index << "/" << number_of_thread_names;
+        return false;
+      }
+    }
+
+    for (unsigned int name_index = 0;
+         name_index < number_of_thread_names;
+         ++name_index) {
+      MinidumpThreadName* thread_name = &(*thread_names)[name_index];
+
+      if (!thread_name->ReadAuxiliaryData()) {
+        BPLOG(ERROR) << "MinidumpThreadNamesList could not read required "
+                     "auxiliary data for thread name " <<
+                     name_index << "/" << number_of_thread_names;
+        return false;
+      }
+    }
+    thread_names_ = thread_names.release();
+  }
+
+  name_count_ = number_of_thread_names;
+  valid_ = true;
+  return true;
+}
+
 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";
@@ -5772,16 +5982,20 @@ static const char* get_stream_name(uint3
   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_IPT_TRACE_STREAM:
+    return "MD_IPT_TRACE_STREAM";
+  case MD_THREAD_NAMES_STREAM:
+    return "MD_THREAD_NAMES_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";
diff --git a/src/processor/minidump_dump.cc b/src/processor/minidump_dump.cc
--- a/src/processor/minidump_dump.cc
+++ b/src/processor/minidump_dump.cc
@@ -49,16 +49,17 @@ using google_breakpad::MinidumpUnloadedM
 using google_breakpad::MinidumpMemoryInfoList;
 using google_breakpad::MinidumpMemoryList;
 using google_breakpad::MinidumpException;
 using google_breakpad::MinidumpAssertion;
 using google_breakpad::MinidumpSystemInfo;
 using google_breakpad::MinidumpMiscInfo;
 using google_breakpad::MinidumpBreakpadInfo;
 using google_breakpad::MinidumpCrashpadInfo;
+using google_breakpad::MinidumpThreadNamesList;
 
 struct Options {
   Options()
       : minidumpPath(), hexdump(false), hexdump_width(16) {}
 
   string minidumpPath;
   bool hexdump;
   unsigned int hexdump_width;
@@ -197,16 +198,21 @@ static bool PrintMinidumpDump(const Opti
   }
 
   MinidumpCrashpadInfo *crashpad_info = minidump.GetCrashpadInfo();
   if (crashpad_info) {
     // Crashpad info is optional, so don't treat absence as an error.
     crashpad_info->Print();
   }
 
+  MinidumpThreadNamesList *thread_names_list = minidump.GetThreadNamesList();
+  if (thread_names_list) {
+    thread_names_list->Print();
+  }
+
   DumpRawStream(&minidump,
                 MD_LINUX_CMD_LINE,
                 "MD_LINUX_CMD_LINE",
                 &errors);
   DumpRawStream(&minidump,
                 MD_LINUX_ENVIRON,
                 "MD_LINUX_ENVIRON",
                 &errors);
diff --git a/src/processor/minidump_processor.cc b/src/processor/minidump_processor.cc
--- a/src/processor/minidump_processor.cc
+++ b/src/processor/minidump_processor.cc
@@ -173,16 +173,22 @@ ProcessResult MinidumpProcessor::Process
   }
 
   MinidumpMemoryList *memory_list = dump->GetMemoryList();
   if (memory_list) {
     BPLOG(INFO) << "Found " << memory_list->region_count()
                 << " memory regions.";
   }
 
+  MinidumpThreadNamesList* thread_names_list = dump->GetThreadNamesList();
+  if (thread_names_list) {
+    BPLOG(INFO) << "Found " << thread_names_list->name_count()
+                << " thread names.";
+  }
+
   MinidumpThreadList *threads = dump->GetThreadList();
   if (!threads) {
     BPLOG(ERROR) << "Minidump " << dump->path() << " has no thread list";
     return PROCESS_ERROR_NO_THREAD_LIST;
   }
 
   BPLOG(INFO) << "Minidump " << dump->path() << " has " <<
       (has_cpu_info            ? "" : "no ") << "CPU info, " <<
@@ -308,16 +314,19 @@ ProcessResult MinidumpProcessor::Process
     } else {
       // Threads with missing CPU contexts will hit this, but
       // don't abort processing the rest of the dump just for
       // one bad thread.
       BPLOG(ERROR) << "No stackwalker for " << thread_string;
     }
     stack->set_tid(thread_id);
     stack->set_last_error(thread->GetLastError());
+    if (thread_names_list) {
+      stack->set_name(thread_names_list->GetNameForThreadId(thread_id));
+    }
     process_state->threads_.push_back(stack.release());
     process_state->thread_memory_regions_.push_back(thread_memory);
   }
 
   if (interrupted) {
     BPLOG(INFO) << "Processing interrupted for " << dump->path();
     return PROCESS_SYMBOL_SUPPLIER_INTERRUPTED;
   }
diff --git a/src/processor/stackwalk_common.cc b/src/processor/stackwalk_common.cc
--- a/src/processor/stackwalk_common.cc
+++ b/src/processor/stackwalk_common.cc
@@ -876,35 +876,45 @@ void PrintProcessState(const ProcessStat
     printf("\n");
     printf("Application-specific information:\n");
     printf("%s", process_state.mac_crash_info().c_str());
   }
 
   // If the thread that requested the dump is known, print it first.
   int requesting_thread = process_state.requesting_thread();
   if (requesting_thread != -1) {
-    printf("\n");
-    printf("Thread %d (%s)\n",
-          requesting_thread,
-          process_state.crashed() ? "crashed" :
-                                    "requested dump, did not crash");
-    PrintStack(process_state.threads()->at(requesting_thread), cpu,
+    const CallStack* requesting_thread_callstack =
+      process_state.threads()->at(requesting_thread);
+    printf("\n"
+           "Thread %d (%s)",
+           requesting_thread,
+           process_state.crashed() ? "crashed" :
+                                     "requested dump, did not crash");
+    if (!requesting_thread_callstack->name().empty()) {
+      printf(" - %s", requesting_thread_callstack->name().c_str());
+    }
+    PrintStack(requesting_thread_callstack, cpu,
                output_stack_contents,
                process_state.thread_memory_regions()->at(requesting_thread),
                process_state.modules(), resolver);
   }
 
   // Print all of the threads in the dump.
   int thread_count = process_state.threads()->size();
   for (int thread_index = 0; thread_index < thread_count; ++thread_index) {
     if (thread_index != requesting_thread) {
       // Don't print the crash thread again, it was already printed.
+      const CallStack* callstack = process_state.threads()->at(thread_index);
+      printf("\n"
+             "Thread %d", thread_index);
+      if (!callstack->name().empty()) {
+        printf(" - %s", callstack->name().c_str());
+      }
       printf("\n");
-      printf("Thread %d\n", thread_index);
-      PrintStack(process_state.threads()->at(thread_index), cpu,
+      PrintStack(callstack, cpu,
                  output_stack_contents,
                  process_state.thread_memory_regions()->at(thread_index),
                  process_state.modules(), resolver);
     }
   }
 
   PrintModules(process_state.modules(),
                process_state.modules_without_symbols(),