Revert r150326 - "Breakpad support for AddressSanitizer."

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.
 #define SYS_SYSCALL_ENTRYPOINT "playground$syscallEntryPoint"
 
 #include "chrome/app/breakpad_linux.h"
 
@@ skipping 36 matching lines @@
 #include <android/log.h>
 #include <sys/stat.h>
 
 #include "base/android/build_info.h"
 #include "base/android/path_utils.h"
 #include "third_party/lss/linux_syscall_support.h"
 #else
 #include "sandbox/linux/seccomp-legacy/linux_syscall_support.h"
 #endif
 
-#if defined(ADDRESS_SANITIZER)
-#include <ucontext.h> // for getcontext().
-#endif
-
 #if defined(OS_ANDROID)
 #define STAT_STRUCT struct stat
 #define FSTAT_FUNC fstat
 #else
 #define STAT_STRUCT struct kernel_stat
 #define FSTAT_FUNC sys_fstat
 #endif
 
 // Some versions of gcc are prone to warn about unused return values. In cases
 // where we either a) know the call cannot fail, or b) there is nothing we
 // can do when a call fails, we mark the return code as ignored. This avoids
 // spurious compiler warnings.
 #define IGNORE_RET(x) do { if (x); } while (0)
 
-#if !defined(ADDRESS_SANITIZER)
 static const char kUploadURL[] =
     "https://clients2.google.com/cr/report";
-#else
-// AddressSanitizer should currently upload the crash reports to the staging
-// crash server.
-static const char kUploadURL[] =
-    "https://clients2.google.com/cr/staging_report";
-#endif
 
 static bool g_is_crash_reporter_enabled = false;
 static uint64_t g_process_start_time = 0;
 static char* g_crash_log_path = NULL;
 static google_breakpad::ExceptionHandler* g_breakpad = NULL;
-#if defined(ADDRESS_SANITIZER)
-static char* g_asan_report_str = NULL;
-#endif
 
 // Writes the value |v| as 16 hex characters to the memory pointed at by
 // |output|.
 static 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 74 matching lines @@
 #endif
 
 namespace {
 
 // MIME substrings.
 const char g_rn[] = "\r\n";
 const char g_form_data_msg[] = "Content-Disposition: form-data; name=\"";
 const char g_quote_msg[] = "\"";
 const char g_dashdash_msg[] = "--";
 const char g_dump_msg[] = "upload_file_minidump\"; filename=\"dump\"";
-#if defined(ADDRESS_SANITIZER)
-const char g_log_msg[] = "upload_file_log\"; filename=\"log\"";
-#endif
 const char g_content_type_msg[] = "Content-Type: application/octet-stream";
 
 // MimeWriter manages an iovec for writing MIMEs to a file.
 class MimeWriter {
  public:
   static const int kIovCapacity = 30;
   static const size_t kMaxCrashChunkSize = 64;
 
   MimeWriter(int fd, const char* const mime_boundary);
   ~MimeWriter();
@@ skipping 19 matching lines @@
   // Append key/value pair, splitting value into chunks no larger than
   // |chunk_size|. |chunk_size| cannot be greater than |kMaxCrashChunkSize|.
   // The msg_type string will have a counter suffix to distinguish each chunk.
   void AddPairDataInChunks(const char* msg_type,
                            size_t msg_type_size,
                            const char* msg_data,
                            size_t msg_data_size,
                            size_t chunk_size,
                            bool strip_trailing_spaces);
 
-  // Add binary file contents to be uploaded with the specified filename.
-  void AddFileContents(const char* filename_msg,
-                       uint8_t* file_data,
-                       size_t file_size);
+  // Add binary file dump. Currently this is only done once, so the name is
+  // fixed.
+  void AddFileDump(uint8_t* file_data,
+                   size_t file_size);
 
   // Flush any pending iovecs to the output file.
   void Flush() {
     IGNORE_RET(sys_writev(fd_, iov_, iov_index_));
     iov_index_ = 0;
   }
 
  private:
   void AddItem(const void* base, size_t size);
   // Minor performance trade-off for easier-to-maintain code.
@@ skipping 78 matching lines @@
     }
     AddString(g_rn);
     AddBoundary();
     Flush();
 
     done += chunk_len;
     msg_length -= chunk_len;
   }
 }
 
-void MimeWriter::AddFileContents(const char* filename_msg, uint8_t* file_data,
-                                 size_t file_size) {
+void MimeWriter::AddFileDump(uint8_t* file_data,
+                             size_t file_size) {
   AddString(g_form_data_msg);
-  AddString(filename_msg);
+  AddString(g_dump_msg);
   AddString(g_rn);
   AddString(g_content_type_msg);
   AddString(g_rn);
   AddString(g_rn);
   AddItem(file_data, file_size);
   AddString(g_rn);
 }
 
 void MimeWriter::AddItem(const void* base, size_t size) {
   // Check if the iovec is full and needs to be flushed to output file.
@@ skipping 25 matching lines @@
 size_t WriteLog(const char* buf, size_t nbytes) {
 #if defined(OS_ANDROID)
   return __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad, buf);
 #else
   return sys_write(2, buf, nbytes);
 #endif
 }
 
 }  // namespace
 
-void LoadDataFromFile(google_breakpad::PageAllocator& allocator,
-                      const BreakpadInfo& info, int* fd,
-                      uint8_t** file_data, size_t* size,
-                      const char* filename) {
+void HandleCrashDump(const BreakpadInfo& info) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
-  *fd = sys_open(filename, O_RDONLY, 0);
-  *size = 0;
 
-  if (*fd < 0) {
+  const int dumpfd = sys_open(info.filename, O_RDONLY, 0);
+  if (dumpfd < 0) {
     static const char msg[] = "Cannot upload crash dump: failed to open\n";
     WriteLog(msg, sizeof(msg));
     return;
   }
   STAT_STRUCT st;
-  if (FSTAT_FUNC(*fd, &st) != 0) {
+  if (FSTAT_FUNC(dumpfd, &st) != 0) {
     static const char msg[] = "Cannot upload crash dump: stat failed\n";
     WriteLog(msg, sizeof(msg));
-    IGNORE_RET(sys_close(*fd));
+    IGNORE_RET(sys_close(dumpfd));
     return;
   }
 
-  *file_data = reinterpret_cast<uint8_t*>(allocator.Alloc(st.st_size));
-  if (!(*file_data)) {
+  google_breakpad::PageAllocator allocator;
+
+  uint8_t* dump_data = reinterpret_cast<uint8_t*>(allocator.Alloc(st.st_size));
+  if (!dump_data) {
     static const char msg[] = "Cannot upload crash dump: cannot alloc\n";
     WriteLog(msg, sizeof(msg));
-    IGNORE_RET(sys_close(*fd));
+    IGNORE_RET(sys_close(dumpfd));
     return;
   }
-  my_memset(*file_data, 0xf, st.st_size);
 
-  *size = st.st_size;
-  sys_read(*fd, *file_data, *size);
-  IGNORE_RET(sys_close(*fd));
-}
-
-void HandleCrashDump(const BreakpadInfo& info) {
-  int dumpfd;
-  size_t dump_size;
-  uint8_t *dump_data;
-  google_breakpad::PageAllocator allocator;
-  LoadDataFromFile(allocator, info, &dumpfd, &dump_data, &dump_size,
-                   info.filename);
-#if defined(ADDRESS_SANITIZER)
-  int logfd;
-  size_t log_size;
-  uint8_t *log_data;
-  // Load the AddressSanitizer log into log_data.
-  LoadDataFromFile(allocator, info, &logfd, &log_data, &log_size,
-                   info.log_filename);
-#endif
+  sys_read(dumpfd, dump_data, st.st_size);
+  IGNORE_RET(sys_close(dumpfd));
 
   // We need to build a MIME block for uploading to the server. Since we are
   // going to fork and run wget, it needs to be written to a temp file.
+
   const int ufd = sys_open("/dev/urandom", O_RDONLY, 0);
   if (ufd < 0) {
     static const char msg[] = "Cannot upload crash dump because /dev/urandom"
                               " is missing\n";
     WriteLog(msg, sizeof(msg) - 1);
     return;
   }
 
   static const char temp_file_template[] =
       "/tmp/chromium-upload-XXXXXXXXXXXXXXXX";
@@ skipping 311 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();
   }
 
-  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.AddFileDump(dump_data, st.st_size);
   writer.AddEnd();
   writer.Flush();
 
   IGNORE_RET(sys_close(temp_file_fd));
 
 #if defined(OS_ANDROID)
   __android_log_write(ANDROID_LOG_WARN,
                       kGoogleBreakpad,
                       "Output crash dump file:");
   __android_log_write(ANDROID_LOG_WARN, kGoogleBreakpad, info.filename);
@@ skipping 160 matching lines @@
         }
         if (sys_waitpid(wget_child, NULL, WNOHANG) == 0) {
           // Wget process is still around, kill it.
           sys_kill(wget_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));
 }
 
@@ skipping 10 matching lines @@
   const unsigned dump_path_len = my_strlen(dump_path);
   const unsigned minidump_id_len = my_strlen(minidump_id);
   char* const path = reinterpret_cast<char*>(allocator.Alloc(
       dump_path_len + 1 /* '/' */ + minidump_id_len +
       4 /* ".dmp" */ + 1 /* NUL */));
   memcpy(path, dump_path, dump_path_len);
   path[dump_path_len] = '/';
   memcpy(path + dump_path_len + 1, minidump_id, minidump_id_len);
   memcpy(path + dump_path_len + 1 + minidump_id_len, ".dmp", 4);
   path[dump_path_len + 1 + minidump_id_len + 4] = 0;
-  char* const log_path = reinterpret_cast<char*>(allocator.Alloc(
-      dump_path_len + 1 /* '/' */ + minidump_id_len +
-      4 /* ".log" */ + 1 /* NUL */));
-  memcpy(log_path, path, dump_path_len + 1 + minidump_id_len + 4);
-  memcpy(log_path + dump_path_len + 1 + minidump_id_len, ".log", 4);
 
   BreakpadInfo info;
   info.filename = path;
-  info.log_filename = log_path;
   info.process_type = "browser";
   info.process_type_length = 7;
   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;
@@ skipping 14 matching lines @@
 #if !defined(OS_ANDROID)
 // Wrapper function, do not add more code here.
 static bool CrashDoneUpload(const char* dump_path,
                             const char* minidump_id,
                             void* context,
                             bool succeeded) {
   return CrashDone(dump_path, minidump_id, true, succeeded);
 }
 #endif
 
-extern "C"
-void __asan_set_error_report_callback(void (*cb)(const char*));
-
-extern "C"
-void AsanLinuxBreakpadCallback(const char* report) {
-  g_asan_report_str = const_cast<char*>(report);
-  // Send minidump here.
-  siginfo_t siginfo;
-  my_memset(&siginfo, 0, sizeof(siginfo_t));
-  struct ucontext context;
-  getcontext(&context);
-  g_breakpad->HandleSignal(9, &siginfo, &context);
-}
-
 static void EnableCrashDumping(bool unattended) {
   g_is_crash_reporter_enabled = true;
 
   FilePath tmp_path("/tmp");
   PathService::Get(base::DIR_TEMP, &tmp_path);
 
   FilePath dumps_path(tmp_path);
   if (PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path)) {
     FilePath logfile =
         dumps_path.AppendASCII(CrashUploadList::kReporterLogFilename);
@@ skipping 57 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];
   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);
-#if defined(ADDRESS_SANITIZER)
-  iov[8].iov_base = g_asan_report_str;
-  iov[8].iov_len = kMaxAsanReportSize + 1;
-#endif
 
   msg.msg_iov = iov;
   msg.msg_iovlen = kIovSize;
   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;
@@ skipping 72 matching lines @@
   }
 
   // Set the base process start time value.
   struct timeval tv;
   if (!gettimeofday(&tv, NULL))
     g_process_start_time = timeval_to_ms(&tv);
   else
     g_process_start_time = 0;
 
   logging::SetDumpWithoutCrashingFunction(&DumpProcess);
-#if defined(ADDRESS_SANITIZER)
-  // Register the callback for AddressSanitizer error reporting.
-  __asan_set_error_report_callback(AsanLinuxBreakpadCallback);
-#endif
 }
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }