[Linux] Implement the crash key logging mechanism.

chrome/app/breakpad_linux.cc

 // Copyright (c) 2012 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 "chrome/app/breakpad_linux.h"
 
 #include <fcntl.h>
 #include <poll.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
+#include "base/debug/crash_logging.h"
 #include "base/files/file_path.h"
 #include "base/linux_util.h"
 #include "base/path_service.h"
 #include "base/platform_file.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/global_descriptors.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "breakpad/src/client/linux/handler/exception_handler.h"
 #include "breakpad/src/client/linux/minidump_writer/directory_reader.h"
 #include "breakpad/src/common/linux/linux_libc_support.h"
 #include "breakpad/src/common/memory.h"
+#include "chrome/app/breakpad_linux_impl.h"
 #include "chrome/browser/crash_upload_list.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info_posix.h"
+#include "chrome/common/crash_keys.h"
 #include "chrome/common/dump_without_crashing.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/common/logging_chrome.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"
@@ skipping 24 matching lines @@
 using google_breakpad::MinidumpDescriptor;
 
 namespace {
 
 const char kUploadURL[] = "https://clients2.google.com/cr/report";
 
 bool g_is_crash_reporter_enabled = false;
 uint64_t g_process_start_time = 0;
 char* g_crash_log_path = NULL;
 ExceptionHandler* g_breakpad = NULL;
+
 #if defined(ADDRESS_SANITIZER)
 const char* g_asan_report_str = NULL;
 #endif
 #if defined(OS_ANDROID)
 char* g_process_type = NULL;
 #endif
 
+CrashKeyStorage* g_crash_keys = NULL;
+
 // 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 372 matching lines @@
   info.crash_url = NULL;
   info.crash_url_length = 0;
   info.guid = child_process_logging::g_client_id;
   info.guid_length = my_strlen(child_process_logging::g_client_id);
   info.distro = base::g_linux_distro;
   info.distro_length = my_strlen(base::g_linux_distro);
   info.upload = upload;
   info.process_start_time = g_process_start_time;
   info.oom_size = base::g_oom_size;
   info.pid = 0;
+  info.crash_keys = g_crash_keys;
   HandleCrashDump(info);
 #if defined(OS_ANDROID)
   return FinalizeCrashDoneAndroid();
 #else
   return true;
 #endif
 }
 
 // Wrapper function, do not add more code here.
 bool CrashDoneNoUpload(const MinidumpDescriptor& minidump,
@@ skipping 160 matching lines @@
   char b;  // Dummy variable for sys_read below.
   const char* b_addr = &b;  // Get the address of |b| so we can create the
                             // expected /proc/[pid]/syscall content in the
                             // browser to convert namespace tids.
 
   // The length of the control message:
   static const unsigned kControlMsgSize = sizeof(fds);
   static const unsigned kControlMsgSpaceSize = CMSG_SPACE(kControlMsgSize);
   static const unsigned kControlMsgLenSize = CMSG_LEN(kControlMsgSize);
 
-#if !defined(ADDRESS_SANITIZER)
-  const size_t kIovSize = 8;
-#else
-  // Additional field to pass the AddressSanitizer log to the crash handler.
-  const size_t kIovSize = 9;
-#endif
   struct kernel_msghdr msg;
   my_memset(&msg, 0, sizeof(struct kernel_msghdr));
-  struct kernel_iovec iov[kIovSize];
+  struct kernel_iovec iov[kCrashIovSize];
   iov[0].iov_base = const_cast<void*>(crash_context);
   iov[0].iov_len = crash_context_size;
   iov[1].iov_base = guid;
   iov[1].iov_len = kGuidSize + 1;
   iov[2].iov_base = crash_url;
   iov[2].iov_len = kMaxActiveURLSize + 1;
   iov[3].iov_base = distro;
   iov[3].iov_len = kDistroSize + 1;
   iov[4].iov_base = &b_addr;
   iov[4].iov_len = sizeof(b_addr);
   iov[5].iov_base = &fds[0];
   iov[5].iov_len = sizeof(fds[0]);
   iov[6].iov_base = &g_process_start_time;
   iov[6].iov_len = sizeof(g_process_start_time);
   iov[7].iov_base = &base::g_oom_size;
   iov[7].iov_len = sizeof(base::g_oom_size);
+  google_breakpad::SerializedNonAllocatingMap* serialized_map;
+  iov[8].iov_len = g_crash_keys->Serialize(
+      const_cast<const google_breakpad::SerializedNonAllocatingMap**>(
+          &serialized_map));
+  iov[8].iov_base = serialized_map;
 #if defined(ADDRESS_SANITIZER)
-  iov[8].iov_base = const_cast<char*>(g_asan_report_str);
-  iov[8].iov_len = kMaxAsanReportSize + 1;
+  iov[9].iov_base = const_cast<char*>(g_asan_report_str);
+  iov[9].iov_len = kMaxAsanReportSize + 1;
 #endif
 
   msg.msg_iov = iov;
-  msg.msg_iovlen = kIovSize;
+  msg.msg_iovlen = kCrashIovSize;
   char cmsg[kControlMsgSpaceSize];
   my_memset(cmsg, 0, kControlMsgSpaceSize);
   msg.msg_control = cmsg;
   msg.msg_controllen = sizeof(cmsg);
 
   struct cmsghdr *hdr = CMSG_FIRSTHDR(&msg);
   hdr->cmsg_level = SOL_SOCKET;
   hdr->cmsg_type = SCM_RIGHTS;
   hdr->cmsg_len = kControlMsgLenSize;
   ((int*) CMSG_DATA(hdr))[0] = fds[0];
@@ skipping 25 matching lines @@
       MinidumpDescriptor("/tmp"),  // Unused but needed or Breakpad will assert.
       NULL,
       NULL,
       reinterpret_cast<void*>(fd),  // Param passed to the crash handler.
       true,
       -1);
   g_breakpad->set_crash_handler(NonBrowserCrashHandler);
 }
 #endif  // defined(OS_ANDROID)
 
+void SetCrashKeyValue(const base::StringPiece& key,
+                      const base::StringPiece& value) {
+  g_crash_keys->SetKeyValue(key.data(), value.data());
+}
+
+void ClearCrashKey(const base::StringPiece& key) {
+  g_crash_keys->RemoveKey(key.data());
+}
+
 }  // namespace
 
 void LoadDataFromFD(google_breakpad::PageAllocator& allocator,
                     int fd, bool close_fd, uint8_t** file_data, size_t* size) {
   STAT_STRUCT st;
   if (FSTAT_FUNC(fd, &st) != 0) {
     static const char msg[] = "Cannot upload crash dump: stat failed\n";
     WriteLog(msg, sizeof(msg) - 1);
     if (close_fd)
       IGNORE_RET(sys_close(fd));
@@ skipping 213 matching lines @@
   //   zero to 15:
   //   Content-Disposition: form-data; name="switch-1" \r\n \r\n
   //   --foo \r\n
   //   BOUNDARY \r\n
   //
   //   zero or one:
   //   Content-Disposition: form-data; name="oom-size" \r\n \r\n
   //   1234567890 \r\n
   //   BOUNDARY \r\n
   //
+  //   zero or more (up to CrashKeyStorage::num_entries = 64):
+  //   Content-Disposition: form-data; name=crash-key-name \r\n
+  //   crash-key-value \r\n
+  //   BOUNDARY \r\n
+  //
   //   Content-Disposition: form-data; name="dump"; filename="dump" \r\n
   //   Content-Type: application/octet-stream \r\n \r\n
   //   <dump contents>
   //   \r\n BOUNDARY -- \r\n
 
   MimeWriter writer(temp_file_fd, mime_boundary);
   {
 #if defined(OS_ANDROID)
     static const char chrome_product_msg[] = "Chrome_Android";
 #elif defined(OS_CHROMEOS)
@@ skipping 218 matching lines @@
     char oom_size_str[kUint64StringSize];
     const unsigned oom_size_len = my_uint64_len(info.oom_size);
     my_uint64tos(oom_size_str, info.oom_size, oom_size_len);
     static const char oom_size_msg[] = "oom-size";
     writer.AddPairData(oom_size_msg, sizeof(oom_size_msg) - 1,
                        oom_size_str, oom_size_len);
     writer.AddBoundary();
     writer.Flush();
   }
 
+  if (info.crash_keys) {
+    CrashKeyStorage::Iterator crash_key_iterator(*info.crash_keys);
+    const CrashKeyStorage::Entry* entry;
+    while ((entry = crash_key_iterator.Next())) {
+      writer.AddPairString(entry->key, entry->value);
+      writer.AddBoundary();
+      writer.Flush();
+    }
+  }
+
   writer.AddFileContents(g_dump_msg, dump_data, dump_size);
 #if defined(ADDRESS_SANITIZER)
   // Append a multipart boundary and the contents of the AddressSanitizer log.
   writer.AddBoundary();
   writer.AddFileContents(g_log_msg, log_data, log_size);
 #endif
   writer.AddEnd();
   writer.Flush();
 
   IGNORE_RET(sys_close(temp_file_fd));
@@ skipping 242 matching lines @@
 #endif  // #if defined(OS_ANDROID)
   }
 
   SetProcessStartTime();
 
   logging::SetDumpWithoutCrashingFunction(&DumpProcess);
 #if defined(ADDRESS_SANITIZER)
   // Register the callback for AddressSanitizer error reporting.
   __asan_set_error_report_callback(AsanLinuxBreakpadCallback);
 #endif
+
+  g_crash_keys = new CrashKeyStorage;
+  crash_keys::RegisterChromeCrashKeys();
+  base::debug::SetCrashKeyReportingFunctions(
+      &SetCrashKeyValue, &ClearCrashKey);
 }
 
 #if defined(OS_ANDROID)
 void InitNonBrowserCrashReporterForAndroid() {
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kEnableCrashReporter)) {
     // On Android we need to provide a FD to the file where the minidump is
     // generated as the renderer and browser run with different UIDs
     // (preventing the browser from inspecting the renderer process).
     int minidump_fd = base::GlobalDescriptors::GetInstance()->
         MaybeGet(kAndroidMinidumpDescriptor);
     if (minidump_fd == base::kInvalidPlatformFileValue) {
       NOTREACHED() << "Could not find minidump FD, crash reporting disabled.";
     } else {
       EnableNonBrowserCrashDumping(minidump_fd);
     }
   }
 }
 #endif  // OS_ANDROID
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }