Minidumper: Get the nexe's build ID from PT_NOTE when available

src/untrusted/minidump_generator/minidump_generator.cc

 /*
  * Copyright (c) 2013 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <assert.h>
 #include <pthread.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
 #include <unistd.h>
 
 #include <algorithm>
 
 #include "breakpad/src/google_breakpad/common/minidump_format.h"
 #include "native_client/src/include/elf_constants.h"
 #include "native_client/src/include/nacl/nacl_exception.h"
 #include "native_client/src/include/nacl/nacl_minidump.h"
 #include "native_client/src/untrusted/irt/irt.h"
+#include "native_client/src/untrusted/minidump_generator/build_id.c"
 
 
 extern char __executable_start[];  // Start of code segment
 extern char __etext[];  // End of code segment
 
 // @IGNORE_LINES_FOR_CODE_HYGIENE[1]
 #if defined(__GLIBC__)
 // Variable defined by ld.so, used as a workaround for
 // https://code.google.com/p/nativeclient/issues/detail?id=3431.
 extern void *__libc_stack_end;
 #endif
 
 class MinidumpFileWriter;
 
 // Restrict how much of the stack we dump to reduce upload size and to
 // avoid dynamic allocation.
 static const size_t kLimitStackDumpSize = 512 * 1024;
 
 static const size_t kLimitNonStackSize = 64 * 1024;
 
 // The crash reporter is expected to be used in a situation where the
 // current process is damaged or out of memory, so it avoids dynamic
 // memory allocation and allocates a fixed-size buffer of the
 // following size at startup.
 static const size_t kMinidumpBufferSize =
     kLimitStackDumpSize + kLimitNonStackSize;
 
 static const char *g_module_name = "main.nexe";
 static MDGUID g_module_build_id;
+static int g_module_build_id_set;
 static nacl_minidump_callback_t g_callback_func;
 static MinidumpFileWriter *g_minidump_writer;
 static int g_handling_exception = 0;
 
 
 class MinidumpFileWriter {
   char *buf_;
   uint32_t buf_size_;
   uint32_t offset_;
 
@@ skipping 361 matching lines @@
                            &irt_exception_handling,
                            sizeof(irt_exception_handling))
       != sizeof(irt_exception_handling)) {
     fprintf(stderr, "minidump: Exception handling IRT interface not present\n");
     return;
   }
   if (irt_exception_handling.exception_handler(CrashHandler, NULL) != 0) {
     fprintf(stderr, "minidump: Failed to register an exception handler\n");
     return;
   }
+
+  if (!g_module_build_id_set) {
+    // Try to use the nexe's built-in build ID.
+    const char *data_ptr;
+    size_t size;
+    if (nacl_get_build_id(&data_ptr, &size)) {
+      // Truncate the ID if necessary.  The minidump format uses a 16
+      // byte ID, whereas ELF build IDs are typically 20-byte SHA1
+      // hashes.
+      memcpy(&g_module_build_id, data_ptr,
+             std::min(size, sizeof(g_module_build_id)));
+      g_module_build_id_set = 1;
+    }
+  }
+
   g_minidump_writer = new MinidumpFileWriter();
 }
 
 void nacl_minidump_set_callback(nacl_minidump_callback_t callback) {
   g_callback_func = callback;
 }
 
 void nacl_minidump_set_module_name(const char *module_name) {
   g_module_name = module_name;
 }
 
 void nacl_minidump_set_module_build_id(
     const uint8_t data[NACL_MINIDUMP_BUILD_ID_SIZE]) {
   assert(sizeof(g_module_build_id) == NACL_MINIDUMP_BUILD_ID_SIZE);
   memcpy(&g_module_build_id, data, NACL_MINIDUMP_BUILD_ID_SIZE);
+  g_module_build_id_set = 1;
 }