[Linux] Implement the crash key logging mechanism.

chrome/browser/crash_handler_host_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.
 
 #include "chrome/browser/crash_handler_host_linux.h"
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/format_macros.h"
 #include "base/linux_util.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "breakpad/src/client/linux/handler/exception_handler.h"
 #include "breakpad/src/client/linux/minidump_writer/linux_dumper.h"
 #include "breakpad/src/client/linux/minidump_writer/minidump_writer.h"
-#include "chrome/app/breakpad_linux.h"
+#include "chrome/app/breakpad_linux_impl.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/env_vars.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_ANDROID)
 #include <sys/linux-syscalls.h>
 
 #define SYS_read __NR_read
 #endif
 
@@ skipping 12 matching lines @@
 void CrashDumpTask(CrashHandlerHostLinux* handler, BreakpadInfo* info) {
   if (handler->IsShuttingDown())
     return;
 
   HandleCrashDump(*info);
   delete[] info->filename;
   delete[] info->process_type;
   delete[] info->crash_url;
   delete[] info->guid;
   delete[] info->distro;
+  delete info->crash_keys;
   delete info;
 }
 
 }  // namespace
 
 // Since classes derived from CrashHandlerHostLinux are singletons, it's only
 // destroyed at the end of the processes lifetime, which is greater in span than
 // the lifetime of the IO message loop. Thus, all calls to base::Bind() use
 // non-refcounted pointers.
 
@@ skipping 48 matching lines @@
 void CrashHandlerHostLinux::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK_EQ(fd, browser_socket_);
 
   // A process has crashed and has signaled us by writing a datagram
   // to the death signal socket. The datagram contains the crash context needed
   // for writing the minidump as well as a file descriptor and a credentials
   // block so that they can't lie about their pid.
   //
   // The message sender is in chrome/app/breakpad_linux.cc.
 
-#if !defined(ADDRESS_SANITIZER)
-  const size_t kIovSize = 8;
-#else
-  const size_t kIovSize = 9;
-#endif
-
   struct msghdr msg = {0};
-  struct iovec iov[kIovSize];
+  struct iovec iov[kCrashIovSize];
 
   // Freed in WriteDumpFile();
   char* crash_context = new char[kCrashContextSize];
   // Freed in CrashDumpTask();
   char* guid = new char[kGuidSize + 1];
   char* crash_url = new char[kMaxActiveURLSize + 1];
   char* distro = new char[kDistroSize + 1];
 #if defined(ADDRESS_SANITIZER)
   asan_report_str_ = new char[kMaxAsanReportSize + 1];
 #endif
 
+  // Deleted in CrashDumpTask.

[Lei Zhang, 2013/05/28 22:02:24]

nit: Would you mind writing CrashDumpTask() to be consistent with the other
comments in the file?

[Robert Sesek, 2013/05/29 18:39:45]

Done.

+  CrashKeyStorage* crash_keys = new CrashKeyStorage;
+  google_breakpad::SerializedNonAllocatingMap* serialzed_crash_keys;

[Lei Zhang, 2013/05/28 22:02:24]

nit: typo in var name

[Robert Sesek, 2013/05/29 18:39:45]

Done.

+  size_t crash_keys_size = crash_keys->Serialize(
+      const_cast<const google_breakpad::SerializedNonAllocatingMap**>(
+          &serialzed_crash_keys));
+
   char* tid_buf_addr = NULL;
   int tid_fd = -1;
   uint64_t uptime;
   size_t oom_size;
   char control[kControlMsgSize];
   const ssize_t expected_msg_size =
       kCrashContextSize +
       kGuidSize + 1 +
       kMaxActiveURLSize + 1 +
       kDistroSize + 1 +
       sizeof(tid_buf_addr) + sizeof(tid_fd) +
       sizeof(uptime) +
 #if defined(ADDRESS_SANITIZER)
       kMaxAsanReportSize + 1 +
 #endif
-      sizeof(oom_size);
+      sizeof(oom_size) +
+      crash_keys_size;
   iov[0].iov_base = crash_context;
   iov[0].iov_len = kCrashContextSize;
   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 = &tid_buf_addr;
   iov[4].iov_len = sizeof(tid_buf_addr);
   iov[5].iov_base = &tid_fd;
   iov[5].iov_len = sizeof(tid_fd);
   iov[6].iov_base = &uptime;
   iov[6].iov_len = sizeof(uptime);
   iov[7].iov_base = &oom_size;
   iov[7].iov_len = sizeof(oom_size);
+  iov[8].iov_base = serialzed_crash_keys;
+  iov[8].iov_len = crash_keys_size;
 #if defined(ADDRESS_SANITIZER)
-  iov[8].iov_base = asan_report_str_;
-  iov[8].iov_len = kMaxAsanReportSize + 1;
+  iov[9].iov_base = asan_report_str_;
+  iov[9].iov_len = kMaxAsanReportSize + 1;
 #endif
   msg.msg_iov = iov;
-  msg.msg_iovlen = kIovSize;
+  msg.msg_iovlen = kCrashIovSize;
   msg.msg_control = control;
   msg.msg_controllen = kControlMsgSize;
 
   const ssize_t msg_size = HANDLE_EINTR(recvmsg(browser_socket_, &msg, 0));
   if (msg_size != expected_msg_size) {
     LOG(ERROR) << "Error reading from death signal socket. Crash dumping"
                << " is disabled."
                << " msg_size:" << msg_size
                << " errno:" << errno;
     file_descriptor_watcher_.StopWatchingFileDescriptor();
@@ skipping 141 matching lines @@
 
   info->distro_length = strlen(distro);
   info->distro = distro;
 #if defined(OS_ANDROID)
   // Nothing gets uploaded in android.
   info->upload = false;
 #else
   info->upload = (getenv(env_vars::kHeadless) == NULL);
 #endif
 
+  info->crash_keys = crash_keys;
+
 #if defined(ADDRESS_SANITIZER)
   info->asan_report_str = asan_report_str_;
   info->asan_report_length = strlen(asan_report_str_);
 #endif
   info->process_start_time = uptime;
   info->oom_size = oom_size;
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&CrashHandlerHostLinux::WriteDumpFile,
@@ skipping 171 matching lines @@
 }
 
 void RendererCrashHandlerHostLinux::SetProcessType() {
   process_type_ = "renderer";
 }
 
 // static
 RendererCrashHandlerHostLinux* RendererCrashHandlerHostLinux::GetInstance() {
   return Singleton<RendererCrashHandlerHostLinux>::get();
 }