Roll breakpad r1454:r1456 and add product info in microdumps

components/crash/app/breakpad_linux.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // For linux_syscall_support.h. This makes it safe to call embedded system
 // calls when in seccomp mode.
 
 #include "components/crash/app/breakpad_linux.h"
 
 #include <fcntl.h>
@@ skipping 31 matching lines @@
 #include "components/crash/app/breakpad_linux_impl.h"
 #include "components/crash/app/crash_reporter_client.h"
 #include "content/public/common/content_descriptors.h"
 
 #if defined(OS_ANDROID)
 #include <android/log.h>
 #include <sys/stat.h>
 
 #include "base/android/build_info.h"
 #include "base/android/path_utils.h"
+#include "base/lazy_instance.h"
 #endif
 #include "third_party/lss/linux_syscall_support.h"
 
 #if defined(ADDRESS_SANITIZER)
 #include <ucontext.h>  // for getcontext().
 #endif
 
 #if defined(OS_ANDROID)
 #define STAT_STRUCT struct stat
 #define FSTAT_FUNC fstat
@@ skipping 16 matching lines @@
 
 namespace {
 
 #if !defined(OS_CHROMEOS)
 const char kUploadURL[] = "https://clients2.google.com/cr/report";
 #endif
 
 bool g_is_crash_reporter_enabled = false;
 uint64_t g_process_start_time = 0;
 pid_t g_pid = 0;
-char* g_crash_log_path = NULL;
-ExceptionHandler* g_breakpad = NULL;
-ExceptionHandler* g_microdump = NULL;
+char* g_crash_log_path = nullptr;
+ExceptionHandler* g_breakpad = nullptr;
+
+#if defined(OS_ANDROID)
+ExceptionHandler* g_microdump = nullptr;
+
+base::LazyInstance<std::string>::Leaky g_microdump_build_fingerprint =
+    LAZY_INSTANCE_INITIALIZER;
+const char* g_c_microdump_build_fingerprint = nullptr;
+
+base::LazyInstance<std::string>::Leaky g_microdump_product_info =
+    LAZY_INSTANCE_INITIALIZER;
+const char* g_c_microdump_product_info = nullptr;
+#endif
 
 #if defined(ADDRESS_SANITIZER)
-const char* g_asan_report_str = NULL;
+const char* g_asan_report_str = nullptr;
 #endif
 #if defined(OS_ANDROID)
-char* g_process_type = NULL;
+char* g_process_type = nullptr;
 #endif
 
-CrashKeyStorage* g_crash_keys = NULL;
+CrashKeyStorage* g_crash_keys = nullptr;
 
 // Writes the value |v| as 16 hex characters to the memory pointed at by
 // |output|.
 void write_uint64_hex(char* output, uint64_t v) {
   static const char hextable[] = "0123456789abcdef";
 
   for (int i = 15; i >= 0; --i) {
     output[i] = hextable[v & 15];
     v >>= 4;
   }
@@ skipping 16 matching lines @@
   ret += tv->tv_usec / 1000;
   return ret;
 }
 
 // String buffer size to use to convert a uint64_t to string.
 const size_t kUint64StringSize = 21;
 
 void SetProcessStartTime() {
   // Set the base process start time value.
   struct timeval tv;
-  if (!gettimeofday(&tv, NULL))
+  if (!gettimeofday(&tv, nullptr))
     g_process_start_time = timeval_to_ms(&tv);
   else
     g_process_start_time = 0;
 }
 
 // uint64_t version of my_int_len() from
 // breakpad/src/common/linux/linux_libc_support.h. Return the length of the
 // given, non-negative integer when expressed in base 10.
 unsigned my_uint64_len(uint64_t i) {
   if (!i)
@@ skipping 358 matching lines @@
   AddString(g_sep);
   AddItem(file_data, file_size);
   Flush();
 }
 #endif  // defined(OS_CHROMEOS)
 
 void DumpProcess() {
   if (g_breakpad)
     g_breakpad->WriteMinidump();
 
+#if defined(OS_ANDROID)
   // If microdumps are enabled write also a microdump on the system log.
   if (g_microdump)
     g_microdump->WriteMinidump();
+#endif
 }
 
 #if defined(OS_ANDROID)
 const char kGoogleBreakpad[] = "google-breakpad";
 #endif
 
 size_t WriteLog(const char* buf, size_t nbytes) {
 #if defined(OS_ANDROID)
   return __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad, buf);
 #else
@@ skipping 143 matching lines @@
     minidump_descriptor.set_size_limit(-1);  // unlimited.
   } else {
     minidump_descriptor.set_size_limit(kMaxMinidumpFileSize);
   }
 #if defined(OS_ANDROID)
   unattended = true;  // Android never uploads directly.
 #endif
   if (unattended) {
     g_breakpad = new ExceptionHandler(
         minidump_descriptor,
-        NULL,
+        nullptr,
         CrashDoneNoUpload,
-        NULL,
+        nullptr,
         true,  // Install handlers.
         -1);   // Server file descriptor. -1 for in-process.
     return;
   }
 
 #if !defined(OS_ANDROID)
   // Attended mode
   g_breakpad = new ExceptionHandler(
       minidump_descriptor,
-      NULL,
+      nullptr,
       CrashDoneUpload,
-      NULL,
+      nullptr,
       true,  // Install handlers.
       -1);   // Server file descriptor. -1 for in-process.
 #endif
 }
 
 #if defined(OS_ANDROID)
 bool MicrodumpCrashDone(const MinidumpDescriptor& minidump,
                         void* context,
                         bool succeeded) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
   if (!succeeded) {
     static const char msg[] = "Microdump crash handler failed.\n";
     WriteLog(msg, sizeof(msg) - 1);
     return false;
   }
 
-  const bool is_browser_process = (context != NULL);
+  const bool is_browser_process = (context != nullptr);
   return FinalizeCrashDoneAndroid(is_browser_process);
  }
 
 // The microdump handler does NOT upload anything. It just dumps out on the
 // system console (logcat) a restricted and serialized variant of a minidump.
 // See crbug.com/410294 for more details.
 void InitMicrodumpCrashHandlerIfNecessary(const std::string& process_type) {
 #if (!defined(ARCH_CPU_ARMEL) && !defined(ARCH_CPU_ARM64))
   // TODO(primiano): For the moment microdumps are enabled only on arm (32/64).
   // Extend support to other architectures (requires some breakpad changes).
   return;
 #endif
 
   if (!GetCrashReporterClient()->ShouldEnableBreakpadMicrodumps())
     return;
 
   VLOG(1) << "Enabling microdumps crash handler (process_type:"
           << process_type << ")";
+
+  const char* product_name = nullptr;
+  const char* product_version = nullptr;
+  GetCrashReporterClient()->GetProductNameAndVersion(&product_name,
+                                                     &product_version);
+  g_microdump_product_info.Get() = product_name + string(":") + product_version;
+  g_microdump_build_fingerprint.Get() =

[Lei Zhang, 2015/05/15 10:37:18]

or maybe get rid of the LazyInstance, and just do:
g_c_microdump_build_fingerprint = strdup(foo_c_string) ?

[Primiano Tucci (use gerrit), 2015/05/15 11:41:44]

Yeah, I guess it's easier to read if I leak strings with annotations, rather
than using LazyInstance (we don't actually need their thread safety here)
How about now?

+      base::android::BuildInfo::GetInstance()->android_build_fp();
+
+  // The exception handler runs in a compromised context and cannot use c_str()
+  // as that would require the heap. Therefore, we have to guarantee that the
+  // build fingerprint and product info pointers are always valid.
+  g_c_microdump_product_info = g_microdump_product_info.Get().c_str();
+  g_c_microdump_build_fingerprint = g_microdump_build_fingerprint.Get().c_str();
+
+  MinidumpDescriptor descriptor(MinidumpDescriptor::kMicrodumpOnConsole);
+  descriptor.SetMicrodumpProductInfo(g_c_microdump_product_info);
+  descriptor.SetMicrodumpBuildFingerprint(g_c_microdump_build_fingerprint);
+
   DCHECK(!g_microdump);
   bool is_browser_process = process_type.empty() || process_type == "webview";
   g_microdump = new ExceptionHandler(
-        MinidumpDescriptor(MinidumpDescriptor::kMicrodumpOnConsole),
-        NULL,
+        descriptor,
+        nullptr,
         MicrodumpCrashDone,
         reinterpret_cast<void*>(is_browser_process),
         true,  // Install handlers.
         -1);   // Server file descriptor. -1 for in-process.
     return;
 }
 
 bool CrashDoneInProcessNoUpload(
     const google_breakpad::MinidumpDescriptor& descriptor,
     void* context,
     const bool succeeded) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
   if (!succeeded) {
     static const char msg[] = "Crash dump generation failed.\n";
     WriteLog(msg, sizeof(msg) - 1);
     return false;
   }
 
   // Start constructing the message to send to the browser.
   BreakpadInfo info = {0};
-  info.filename = NULL;
+  info.filename = nullptr;
   info.fd = descriptor.fd();
   info.process_type = g_process_type;
   info.process_type_length = my_strlen(g_process_type);
-  info.distro = NULL;
+  info.distro = nullptr;
   info.distro_length = 0;
   info.upload = false;
   info.process_start_time = g_process_start_time;
   info.pid = g_pid;
   info.crash_keys = g_crash_keys;
   HandleCrashDump(info);
   return FinalizeCrashDoneAndroid(false /* is_browser_process */);
 }
 
 void EnableNonBrowserCrashDumping(const std::string& process_type,
@@ skipping 18 matching lines @@
   }
   SetProcessStartTime();
   g_pid = getpid();
 
   g_is_crash_reporter_enabled = true;
   // Save the process type (it is leaked).
   const size_t process_type_len = process_type.size() + 1;
   g_process_type = new char[process_type_len];
   strncpy(g_process_type, process_type.c_str(), process_type_len);
   new google_breakpad::ExceptionHandler(MinidumpDescriptor(minidump_fd),
-      NULL, CrashDoneInProcessNoUpload, NULL, true, -1);
+      nullptr, CrashDoneInProcessNoUpload, nullptr, true, -1);
 }
 #else
 // Non-Browser = Extension, Gpu, Plugins, Ppapi and Renderer
 class NonBrowserCrashHandler : public google_breakpad::CrashGenerationClient {
  public:
   NonBrowserCrashHandler()
       : server_fd_(base::GlobalDescriptors::GetInstance()->Get(
             kCrashDumpSignal)) {
   }
 
@@ skipping 83 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(NonBrowserCrashHandler);
 };
 
 void EnableNonBrowserCrashDumping() {
   g_is_crash_reporter_enabled = true;
   // We deliberately leak this object.
   DCHECK(!g_breakpad);
 
   g_breakpad = new ExceptionHandler(
       MinidumpDescriptor("/tmp"),  // Unused but needed or Breakpad will assert.
-      NULL,
-      NULL,
-      NULL,
+      nullptr,
+      nullptr,
+      nullptr,
       true,
       -1);
   g_breakpad->set_crash_generation_client(new NonBrowserCrashHandler());
 }
 #endif  // defined(OS_ANDROID)
 
 void SetCrashKeyValue(const base::StringPiece& key,
                       const base::StringPiece& value) {
   g_crash_keys->SetKeyValue(key.data(), value.data());
 }
@@ skipping 132 matching lines @@
   exe_flag[0] = '\0';
   my_strlcat(exe_flag, kExeBuf, buf_len);
   my_strlcat(exe_flag, exe_buf, buf_len);
 
   const char* args[] = {
     kCrashReporterBinary,
     chrome_flag,
     pid_flag,
     uid_flag,
     exe_flag,
-    NULL,
+    nullptr,
   };
   static const char msg[] = "Cannot upload crash dump: cannot exec "
                             "/sbin/crash_reporter\n";
 #else
   // The --header argument to wget looks like:
   //   --header=Content-Type: multipart/form-data; boundary=XYZ
   // where the boundary has two fewer leading '-' chars
   static const char header_msg[] =
       "--header=Content-Type: multipart/form-data; boundary=";
   char* const header = reinterpret_cast<char*>(allocator->Alloc(
@@ skipping 14 matching lines @@
   static const char kWgetBinary[] = "/usr/bin/wget";
   const char* args[] = {
     kWgetBinary,
     header,
     post_file,
     kUploadURL,
     "--timeout=10",  // Set a timeout so we don't hang forever.
     "--tries=1",     // Don't retry if the upload fails.
     "-O",  // output reply to fd 3
     "/dev/fd/3",
-    NULL,
+    nullptr,
   };
   static const char msg[] = "Cannot upload crash dump: cannot exec "
                             "/usr/bin/wget\n";
 #endif
   execve(args[0], const_cast<char**>(args), environ);
   WriteLog(msg, sizeof(msg) - 1);
   sys__exit(1);
 }
 
 // Runs in the helper process to wait for the upload process running
@@ skipping 24 matching lines @@
       if (bytes_read == bytes_to_read)
         break;
     }
     // |ret| == 0 -> timed out, continue waiting.
     // or |bytes_read| < |bytes_to_read| still, keep reading.
   }
   buf[bytes_to_read] = 0;  // Always NUL terminate the buffer.
   return bytes_read;
 }
 
-// |buf| should be |expected_len| + 1 characters in size and NULL terminated.
+// |buf| should be |expected_len| + 1 characters in size and nullptr terminated.
 bool IsValidCrashReportId(const char* buf, size_t bytes_read,
                           size_t expected_len) {
   if (bytes_read != expected_len)
     return false;
 #if defined(OS_CHROMEOS)
   return my_strcmp(buf, "_sys_cr_finished") == 0;
 #else
   for (size_t i = 0; i < bytes_read; ++i) {
     if (!my_isxdigit(buf[i]))
       return false;
   }
   return true;
 #endif
 }
 
-// |buf| should be |expected_len| + 1 characters in size and NULL terminated.
+// |buf| should be |expected_len| + 1 characters in size and nullptr terminated.
 void HandleCrashReportId(const char* buf, size_t bytes_read,
                          size_t expected_len) {
   WriteNewline();
   if (!IsValidCrashReportId(buf, bytes_read, expected_len)) {
 #if defined(OS_CHROMEOS)
     static const char msg[] =
         "System crash-reporter failed to process crash report.";
 #else
     static const char msg[] = "Failed to get crash dump id.";
 #endif
@@ skipping 12 matching lines @@
   WriteLog(msg, sizeof(msg) - 1);
 #else
   // Write crash dump id to stderr.
   static const char msg[] = "Crash dump id: ";
   WriteLog(msg, sizeof(msg) - 1);
   WriteLog(buf, my_strlen(buf));
   WriteNewline();
 
   // Write crash dump id to crash log as: seconds_since_epoch,crash_id
   struct kernel_timeval tv;
-  if (g_crash_log_path && !sys_gettimeofday(&tv, NULL)) {
+  if (g_crash_log_path && !sys_gettimeofday(&tv, nullptr)) {
     uint64_t time = kernel_timeval_to_ms(&tv) / 1000;
     char time_str[kUint64StringSize];
     const unsigned time_len = my_uint64_len(time);
     my_uint64tos(time_str, time, time_len);
 
     const int kLogOpenFlags = O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC;
     int log_fd = sys_open(g_crash_log_path, kLogOpenFlags, 0600);
     if (log_fd > 0) {
       sys_write(log_fd, time_str, time_len);
       sys_write(log_fd, ",", 1);
@@ skipping 34 matching lines @@
   return "chrome-crash-unknown-process";
 }
 #endif
 
 void HandleCrashDump(const BreakpadInfo& info) {
   int dumpfd;
   bool keep_fd = false;
   size_t dump_size;
   uint8_t* dump_data;
   google_breakpad::PageAllocator allocator;
-  const char* exe_buf = NULL;
+  const char* exe_buf = nullptr;
 
   if (GetCrashReporterClient()->HandleCrashDump(info.filename)) {
     return;
   }
 
 #if defined(OS_CHROMEOS)
   // Grab the crashing process' name now, when it should still be available.
   // If we try to do this later in our grandchild the crashing process has
   // already terminated.
   exe_buf = GetCrashingProcessName(info, &allocator);
@@ skipping 174 matching lines @@
     writer.AddBoundary();
     writer.AddPairString(
         android_build_fp, android_build_info->android_build_fp());
     writer.AddBoundary();
     writer.AddPairString(device, android_build_info->device());
     writer.AddBoundary();
     writer.AddPairString(model, android_build_info->model());
     writer.AddBoundary();
     writer.AddPairString(brand, android_build_info->brand());
     writer.AddBoundary();
-    if (android_build_info->java_exception_info() != NULL) {
+    if (android_build_info->java_exception_info() != nullptr) {
       writer.AddPairString(exception_info,
                            android_build_info->java_exception_info());
       writer.AddBoundary();
     }
 #endif
     writer.Flush();
   }
 
   if (info.process_start_time > 0) {
     struct kernel_timeval tv;
-    if (!sys_gettimeofday(&tv, NULL)) {
+    if (!sys_gettimeofday(&tv, nullptr)) {
       uint64_t time = kernel_timeval_to_ms(&tv);
       if (time > info.process_start_time) {
         time -= info.process_start_time;
         char time_str[kUint64StringSize];
         const unsigned time_len = my_uint64_len(time);
         my_uint64tos(time_str, time, time_len);
 
         static const char process_time_msg[] = "ptime";
         writer.AddPairData(process_time_msg, sizeof(process_time_msg) - 1,
                            time_str, time_len);
@@ skipping 138 matching lines @@
       // Helper process.
       if (upload_child > 0) {
         IGNORE_RET(sys_close(fds[1]));
 
         const size_t kCrashIdLength = 16;
         char id_buf[kCrashIdLength + 1];
         size_t bytes_read =
             WaitForCrashReportUploadProcess(fds[0], kCrashIdLength, id_buf);
         HandleCrashReportId(id_buf, bytes_read, kCrashIdLength);
 
-        if (sys_waitpid(upload_child, NULL, WNOHANG) == 0) {
+        if (sys_waitpid(upload_child, nullptr, WNOHANG) == 0) {
           // Upload process is still around, kill it.
           sys_kill(upload_child, SIGKILL);
         }
       }
     }
 
     // Helper process.
     IGNORE_RET(sys_unlink(info.filename));
 #if defined(ADDRESS_SANITIZER)
     IGNORE_RET(sys_unlink(info.log_filename));
 #endif
     IGNORE_RET(sys_unlink(temp_file));
     sys__exit(0);
   }
 
   // Main browser process.
   if (child <= 0)
     return;
-  (void) HANDLE_EINTR(sys_waitpid(child, NULL, 0));
+  (void) HANDLE_EINTR(sys_waitpid(child, nullptr, 0));
 }
 
 void InitCrashReporter(const std::string& process_type) {
 #if defined(OS_ANDROID)
   // This will guarantee that the BuildInfo has been initialized and subsequent
   // calls will not require memory allocation.
   base::android::BuildInfo::GetInstance();
 
   // Handler registration is LIFO. Install the microdump handler first, such
   // that if conventional minidump crash reporting is enabled below, it takes
@@ skipping 69 matching lines @@
     }
   }
 }
 #endif  // OS_ANDROID
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }
 
 }  // namespace breakpad