Upstream native crash handling changes for Android.

chrome/app/breakpad_linuxish.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"
+#include "chrome/app/breakpad_linuxish.h"
 
 #include <fcntl.h>
 #include <poll.h>
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/uio.h>
 #include <time.h>
@@ skipping 15 matching lines @@
 #include "breakpad/src/common/linux/linux_libc_support.h"
 #include "breakpad/src/common/memory.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/env_vars.h"
 #include "chrome/common/logging_chrome.h"
 #include "content/common/chrome_descriptors.h"
+
+#if defined(OS_ANDROID)
+#include <android/log.h>
+#include <sys/stat.h>
+#include "base/android/path_utils.h"
+#include "base/android/build_info.h"
+#include "third_party/lss/linux_syscall_support.h"
+#else
 #include "seccompsandbox/linux_syscall_support.h"
+#endif
 
 #ifndef PR_SET_PTRACER
 #define PR_SET_PTRACER 0x59616d61
 #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)
@@ skipping 55 matching lines @@
 }
 
 // uint64_t version of my_itos() from
 // breakpad/src/common/linux/linux_libc_support.h. Convert a non-negative
 // integer to a string (not null-terminated).
 static void my_uint64tos(char* output, uint64_t i, unsigned i_len) {
   for (unsigned index = i_len; index; --index, i /= 10)
     output[index - 1] = '0' + (i % 10);
 }
 
+#if defind(OS_ANDROID)
+static char* my_strncpy(char* dst, const char* src, size_t len) {
+  int i = len;
+  char* p = dst;
+  if (!dst || !src)
+    return dst;
+  while (i != 0 && *src != '\0') {
+    *p++ = *src++;
+    i--;
+  }
+  while (i != 0) {
+    *p++ = '\0';
+    i--;
+  }
+  return dst;
+}
+
+static char* my_strncat(char *dest, const char *src, size_t len) {
+  char *ret = dest;
+  while (*dest)
+      dest++;
+  while (len--)
+    if (!(*dest++ = *src++))
+      return ret;
+  *dest = 0;
+  return ret;
+}
+#endif
+
 namespace {
 
 // MIME substrings.
 static const char g_rn[] = "\r\n";
 static const char g_form_data_msg[] = "Content-Disposition: form-data; name=\"";
 static const char g_quote_msg[] = "\"";
 static const char g_dashdash_msg[] = "--";
 static const char g_dump_msg[] = "upload_file_minidump\"; filename=\"dump\"";
 static const char g_content_type_msg[] =
     "Content-Type: application/octet-stream";
@@ skipping 167 matching lines @@
     size--;
   }
   AddItem(base, size);
 }
 
 void DumpProcess() {
   if (g_breakpad)
     g_breakpad->WriteMinidump();
 }
 
+size_t log(const char* buf, size_t nbytes) {
+#if defined(OS_ANDROID)
+  return __android_log_write(ANDROID_LOG_WARN, "google-breakpad", buf);
+#else
+  return sys_write(2, buf, nbytes)
+#endif
+}
+
 }  // namespace
 
 void HandleCrashDump(const BreakpadInfo& info) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
 
   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";
-    sys_write(2, msg, sizeof(msg));
+    log(msg, sizeof(msg));
     return;
   }
+#if defined(OS_ANDROID)
+  struct stat st;
+  if (fstat(dumpfd, &st) != 0) {
+#else
   struct kernel_stat st;
   if (sys_fstat(dumpfd, &st) != 0) {
+#endif
     static const char msg[] = "Cannot upload crash dump: stat failed\n";
-    sys_write(2, msg, sizeof(msg));
+    log(msg, sizeof(msg));
     IGNORE_RET(sys_close(dumpfd));
     return;
   }
 
   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";
-    sys_write(2, msg, sizeof(msg));
+    log(msg, sizeof(msg));
     IGNORE_RET(sys_close(dumpfd));
     return;
   }
 
   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";
-    sys_write(2, msg, sizeof(msg) - 1);
+    log(msg, sizeof(msg) - 1);
     return;
   }
 
   static const char temp_file_template[] =
       "/tmp/chromium-upload-XXXXXXXXXXXXXXXX";
   char temp_file[sizeof(temp_file_template)];
   int temp_file_fd = -1;
   if (info.upload) {
     memcpy(temp_file, temp_file_template, sizeof(temp_file_template));
 
     for (unsigned i = 0; i < 10; ++i) {
       uint64_t t;
       sys_read(ufd, &t, sizeof(t));
       write_uint64_hex(temp_file + sizeof(temp_file) - (16 + 1), t);
 
       temp_file_fd = sys_open(temp_file, O_WRONLY | O_CREAT | O_EXCL, 0600);
       if (temp_file_fd >= 0)
         break;
     }
 
     if (temp_file_fd < 0) {
       static const char msg[] = "Failed to create temporary file in /tmp: "
           "cannot upload crash dump\n";
-      sys_write(2, msg, sizeof(msg) - 1);
+      log(msg, sizeof(msg) - 1);
       IGNORE_RET(sys_close(ufd));
       return;
     }
   } else {
     temp_file_fd = sys_open(info.filename, O_WRONLY, 0600);
     if (temp_file_fd < 0) {
       static const char msg[] = "Failed to save crash dump: failed to open\n";
-      sys_write(2, msg, sizeof(msg) - 1);
+      log(msg, sizeof(msg) - 1);
       IGNORE_RET(sys_close(ufd));
       return;
     }
   }
 
   // The MIME boundary is 28 hyphens, followed by a 64-bit nonce and a NUL.
   char mime_boundary[28 + 16 + 1];
   my_memset(mime_boundary, '-', 28);
   uint64_t boundary_rand;
   sys_read(ufd, &boundary_rand, sizeof(boundary_rand));
@@ skipping 78 matching lines @@
   //   1234567890 \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_CHROMEOS)
+#if defined(OS_ANDROID)
+    static const char chrome_product_msg[] = "Chrome_Android";
+#elif defined(OS_CHROMEOS)
     static const char chrome_product_msg[] = "Chrome_ChromeOS";
 #else  // OS_LINUX
     static const char chrome_product_msg[] = "Chrome_Linux";
 #endif
+
+#if defined (OS_ANDROID)
+    base::android::BuildInfo* android_build_info =
+        base::android::BuildInfo::GetInstance();
+    static const char* version_msg =
+        android_build_info->package_version_code();
+    static const char android_build_id[] = "android_build_id";
+    static const char android_build_fp[] = "android_build_fp";
+    static const char device[] = "device";
+    static const char model[] = "model";
+    static const char brand[] = "brand";
+#else
     static const char version_msg[] = PRODUCT_VERSION;
+#endif
 
     writer.AddBoundary();
     writer.AddPairString("prod", chrome_product_msg);
     writer.AddBoundary();
     writer.AddPairString("ver", version_msg);
     writer.AddBoundary();
     writer.AddPairString("guid", info.guid);
     writer.AddBoundary();
+    if (info.pid > 0) {
+      uint64_t pid_str_len = my_uint64_len(info.pid);
+      char* pid_buf = reinterpret_cast<char*>(allocator.Alloc(pid_str_len));
+      my_uint64tos(pid_buf, info.pid, pid_str_len);
+      writer.AddPairString("pid", pid_buf);
+      writer.AddBoundary();
+    }
+#if defined(OS_ANDROID)
+    // Addtional MIME blocks are added for logging on Android devices.
+    writer.AddPairString(
+        android_build_id, android_build_info->android_build_id());
+    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();
+#endif
     writer.Flush();
   }
 
   if (info.process_start_time > 0) {
     struct kernel_timeval tv;
     if (!sys_gettimeofday(&tv, NULL)) {
       uint64_t time = kernel_timeval_to_ms(&tv);
       if (time > info.process_start_time) {
         time -= info.process_start_time;
         char time_str[kUint64StringSize];
@@ skipping 127 matching lines @@
                        oom_size_str, oom_size_len);
     writer.AddBoundary();
     writer.Flush();
   }
 
   writer.AddFileDump(dump_data, st.st_size);
   writer.AddEnd();
   writer.Flush();
 
   IGNORE_RET(sys_close(temp_file_fd));
+#if defined(OS_ANDROID)
+  uint64_t pid_str_len = my_uint64_len(info.pid);
+  char* pid_buf = reinterpret_cast<char*>(allocator.Alloc(pid_str_len));
+  my_uint64tos(pid_buf, info.pid, pid_str_len);
+
+  static const char* output_msg = "Output crash dump file:";
+  log(output_msg, my_strlen(output_msg));
+  int initial_filename_len = my_strln(info.filename);
+  log(info.filename, info.filename);
+  // -1 because we won't need the null terminator on the original filename.
+  size_t done_filename_len = initial_filename_len -1 + pid_str_len;
+  char* done_filename = reinterpret_cast<char*>(
+      allocator.Alloc(done_filename_len));
+  // Rename the file such that the pid is the suffix in order signal to other
+  // processes that the minidump is complete. The advantage of using the pid as
+  // the suffix is that it is trivial to associate the minidump with the
+  // crashed process.
+  // Finally, note strncpy prevents null terminators from
+  // being copied. Pad the rest with 0's.
+  my_strncpy(done_filename, info.filename, done_filename_len);
+  // Append the suffix a null terminator should be added.
+  my_strncat(done_filename, pid_buf, pid_str_len);
+  // Rename the minidump file to signal that it is complete.
+  if (rename(info.filename, done_filename)) {
+    __android_log_write(ANDROID_LOG_WARN, "chromium", "Failed to rename:");
+    __android_log_write(ANDROID_LOG_WARN, "chromium", info.filename);
+    __android_log_write(ANDROID_LOG_WARN, "chromium", "to");
+    __android_log_write(ANDROID_LOG_WARN, "chromium", done_filename);
+  }
+#endif
 
   if (!info.upload)
     return;
 
   // 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 61 matching lines @@
           "--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,
         };
 
         execve(kWgetBinary, const_cast<char**>(args), environ);
         static const char msg[] = "Cannot upload crash dump: cannot exec "
                                   "/usr/bin/wget\n";
-        sys_write(2, msg, sizeof(msg) - 1);
+        log(msg, sizeof(msg) - 1);
         sys__exit(1);
       }
 
       // Helper process.
       if (wget_child > 0) {
         IGNORE_RET(sys_close(fds[1]));
         char id_buf[17];  // Crash report IDs are expected to be 16 chars.
         ssize_t len = -1;
         // Wget should finish in about 10 seconds. Add a few more 500 ms
         // internals to account for process startup time.
         for (size_t wait_count = 0; wait_count < 24; ++wait_count) {
           struct kernel_pollfd poll_fd;
           poll_fd.fd = fds[0];
           poll_fd.events = POLLIN | POLLPRI | POLLERR;
           int ret = sys_poll(&poll_fd, 1, 500);
           if (ret < 0) {
             // Error
             break;
           } else if (ret > 0) {
             // There is data to read.
             len = HANDLE_EINTR(sys_read(fds[0], id_buf, sizeof(id_buf) - 1));
             break;
           }
           // ret == 0 -> timed out, continue waiting.
         }
         if (len > 0) {
           // Write crash dump id to stderr.
           id_buf[len] = 0;
           static const char msg[] = "\nCrash dump id: ";
-          sys_write(2, msg, sizeof(msg) - 1);
-          sys_write(2, id_buf, my_strlen(id_buf));
-          sys_write(2, "\n", 1);
+          log(msg, sizeof(msg) - 1);
+          log(id_buf, my_strlen(id_buf));
+          log("\n", 1);
 
           // 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)) {
             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);
 
             int log_fd = sys_open(g_crash_log_path,
@@ skipping 54 matching lines @@
   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;
   info.oom_size = base::g_oom_size;
+  info.pid = 0;
   HandleCrashDump(info);
   return true;
 }
 
 // Wrapper function, do not add more code here.
 static bool CrashDoneNoUpload(const char* dump_path,
                       const char* minidump_id,
                       void* context,
                       bool succeeded) {
   return CrashDone(dump_path, minidump_id, false, succeeded);
 }
 
+#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
 
 void EnableCrashDumping(const 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);
     std::string logfile_str = logfile.value();
     const size_t crash_log_path_len = logfile_str.size() + 1;
     g_crash_log_path = new char[crash_log_path_len];
     strncpy(g_crash_log_path, logfile_str.c_str(), crash_log_path_len);
   }
-
   DCHECK(!g_breakpad);
+#if defined(OS_ANDROID)
+  // In Android we never upload from native code.
+  g_breakpad = new google_breakpad::ExceptionHandler(
+      dumps_path.value().c_str(),
+      NULL,
+      CrashDoneNoUpload,
+      NULL,
+      true /* install handlers */);
+#else
   if (unattended) {
     g_breakpad = new google_breakpad::ExceptionHandler(
         dumps_path.value().c_str(),
         NULL,
         CrashDoneNoUpload,
         NULL,
         true /* install handlers */);
   } else {
     g_breakpad = new google_breakpad::ExceptionHandler(
         tmp_path.value().c_str(),
         NULL,
         CrashDoneUpload,
         NULL,
         true /* install handlers */);
   }
+#endif
 }
 
 // Non-Browser = Extension, Gpu, Plugins, Ppapi and Renderer
 static bool NonBrowserCrashHandler(const void* crash_context,
                                    size_t crash_context_size,
                                    void* context) {
   const int fd = reinterpret_cast<intptr_t>(context);
   int fds[2] = { -1, -1 };
   if (sys_socketpair(AF_UNIX, SOCK_STREAM, 0, fds) < 0) {
     static const char msg[] = "Failed to create socket for crash dumping.\n";
-    sys_write(2, msg, sizeof(msg)-1);
+    log(msg, sizeof(msg)-1);
     return false;
   }
 
   // On kernels with ptrace protection, e.g. Ubuntu 10.10+, the browser cannot
   // ptrace this crashing process and crash dumping will fail. When using the
   // SUID sandbox, this crashing process is likely to be in its own PID
   // namespace, and thus there is no way to permit only the browser process to
   // ptrace it.
   // The workaround is to allow all processes to ptrace this process if we
   // reach this point, by passing -1 as the allowed PID. However, support for
@@ skipping 56 matching lines @@
 
   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];
   ((int*) CMSG_DATA(hdr))[1] = fds[1];
 
   if (HANDLE_EINTR(sys_sendmsg(fd, &msg, 0)) < 0) {
     static const char errmsg[] = "Failed to tell parent about crash.\n";
-    sys_write(2, errmsg, sizeof(errmsg)-1);
+    log(errmsg, sizeof(errmsg)-1);
     IGNORE_RET(sys_close(fds[1]));
     return false;
   }
   IGNORE_RET(sys_close(fds[1]));
 
   if (HANDLE_EINTR(sys_read(fds[0], &b, 1)) != 1) {
     static const char errmsg[] = "Parent failed to complete crash dump.\n";
-    sys_write(2, errmsg, sizeof(errmsg)-1);
+    log(errmsg, sizeof(errmsg)-1);
   }
 
   return true;
 }
 
 void EnableNonBrowserCrashDumping() {
   const int fd = base::GlobalDescriptors::GetInstance()->Get(kCrashDumpSignal);
   g_is_crash_reporter_enabled = true;
   // We deliberately leak this object.
   DCHECK(!g_breakpad);
   g_breakpad = new google_breakpad::ExceptionHandler(
       "" /* unused */, NULL, NULL, reinterpret_cast<void*>(fd), true);
   g_breakpad->set_crash_handler(NonBrowserCrashHandler);
 }
 
 void InitCrashReporter() {
+#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();
+#endif
   // Determine the process type and take appropriate action.
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   if (parsed_command_line.HasSwitch(switches::kDisableBreakpad))
     return;
 
   const std::string process_type =
       parsed_command_line.GetSwitchValueASCII(switches::kProcessType);
   if (process_type.empty()) {
     EnableCrashDumping(getenv(env_vars::kHeadless) != NULL);
   } else if (process_type == switches::kRendererProcess ||
              process_type == switches::kPluginProcess ||
              process_type == switches::kPpapiPluginProcess ||
              process_type == switches::kZygoteProcess ||
              process_type == switches::kGpuProcess) {
+#if defined(OS_ANDROID)
+    child_process_logging::SetClientId("Android");
+#endif
     // We might be chrooted in a zygote or renderer process so we cannot call
     // GetCollectStatsConsent because that needs access the the user's home
     // dir. Instead, we set a command line flag for these processes.
     // Even though plugins are not chrooted, we share the same code path for
     // simplicity.
     if (!parsed_command_line.HasSwitch(switches::kEnableCrashReporter))
       return;
     // Get the guid and linux distro from the command line switch.
     std::string switch_value =
         parsed_command_line.GetSwitchValueASCII(switches::kEnableCrashReporter);
@@ skipping 13 matching lines @@
     g_process_start_time = timeval_to_ms(&tv);
   else
     g_process_start_time = 0;
 
   logging::SetDumpWithoutCrashingFunction(&DumpProcess);
 }
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }