Breakpad support for ASan: take 2.

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>
@@ skipping 110 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];
 
   // 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
 
   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);
-
   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);
+#if defined(ADDRESS_SANITIZER)
+  iov[8].iov_base = asan_report_str_;
+  iov[8].iov_len = kMaxAsanReportSize + 1;
+#endif
   msg.msg_iov = iov;
   msg.msg_iovlen = kIovSize;
   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
@@ skipping 141 matching lines @@
   info->guid = guid;
 
   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
+
+#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,
                  base::Unretained(this),
                  info,
                  crashing_pid,
                  crash_context,
                  signal_fd));
 }
 
 void CrashHandlerHostLinux::WriteDumpFile(BreakpadInfo* info,
                                           pid_t crashing_pid,
                                           char* crash_context,
                                           int signal_fd) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   FilePath dumps_path("/tmp");
   PathService::Get(base::DIR_TEMP, &dumps_path);
   if (!info->upload)
     PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path);
   const uint64 rand = base::RandUint64();
   const std::string minidump_filename =
       base::StringPrintf("%s/chromium-%s-minidump-%016" PRIx64 ".dmp",
                          dumps_path.value().c_str(),
                          process_type_.c_str(),
                          rand);
+
   if (!google_breakpad::WriteMinidump(minidump_filename.c_str(),
                                       crashing_pid, crash_context,
                                       kCrashContextSize)) {
     LOG(ERROR) << "Failed to write crash dump for pid " << crashing_pid;
   }
+#if defined(ADDRESS_SANITIZER)
+  // Create a temporary file holding the AddressSanitizer report.
+  const std::string log_filename =
+      base::StringPrintf("%s/chromium-%s-minidump-%016" PRIx64 ".log",
+                         dumps_path.value().c_str(),
+                         process_type_.c_str(),
+                         rand);
+  FILE *logfile = fopen(log_filename.c_str(), "w");
+  fprintf(logfile, "%s", asan_report_str_);
+  fclose(logfile);
+#endif
+
   delete[] crash_context;
 
   // Freed in CrashDumpTask();
   char* minidump_filename_str = new char[minidump_filename.length() + 1];
   minidump_filename.copy(minidump_filename_str, minidump_filename.length());
   minidump_filename_str[minidump_filename.length()] = '\0';
   info->filename = minidump_filename_str;
+#if defined(ADDRESS_SANITIZER)
+  char* minidump_log_filename_str = new char[minidump_filename.length() + 1];
+  minidump_filename.copy(minidump_log_filename_str, minidump_filename.length());
+  strcpy(minidump_log_filename_str + minidump_filename.length() - 3, "log");
+  minidump_log_filename_str[minidump_filename.length()] = '\0';
+  info->log_filename = minidump_log_filename_str;
+#endif
   info->pid = crashing_pid;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CrashHandlerHostLinux::QueueCrashDumpTask,
                  base::Unretained(this),
                  info,
                  signal_fd));
 }
 
@@ skipping 102 matching lines @@
 }
 
 void RendererCrashHandlerHostLinux::SetProcessType() {
   process_type_ = "renderer";
 }
 
 // static
 RendererCrashHandlerHostLinux* RendererCrashHandlerHostLinux::GetInstance() {
   return Singleton<RendererCrashHandlerHostLinux>::get();
 }