Fix minidump-generation for debug builds.

components/crash/content/app/breakpad_linux.cc

 // Copyright 2013 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 "components/crash/content/app/breakpad_linux.h"
 
 #include <fcntl.h>
@@ skipping 92 matching lines @@
 
 #if defined(OS_ANDROID)
 #define G_DUMPS_SUPPRESSED_MAGIC 0x5AFECEDE
 uint32_t g_dumps_suppressed = 0;
 char* g_process_type = nullptr;
 ExceptionHandler* g_microdump = nullptr;
 int g_signal_code_pipe_fd = -1;
 
 class MicrodumpInfo {
  public:
-  MicrodumpInfo()
-      : microdump_build_fingerprint_(nullptr),
-        microdump_product_info_(nullptr),
-        microdump_gpu_fingerprint_(nullptr),
-        microdump_process_type_(nullptr),
-        skip_dump_if_principal_mapping_not_referenced_(false),
-        address_within_principal_mapping_(0ul),
-        should_sanitize_dumps_(false) {}
+  MicrodumpInfo() : microdump_gpu_fingerprint_(nullptr) {}
 
   // The order in which SetGpuFingerprint and Initialize are called
   // may be dependent on the timing of the availability of GPU
   // information. For this reason, they can be called in either order,
   // resulting in the same effect.
   //
   // The following restrictions apply, however:
   // * Both methods must be called from the same thread.
   // * Both methods must be called at most once.
   //
   // Microdumps will only be generated if Initialize is called. If
   // SetGpuFingerprint has not been called called at the point at
   // which a microdump is generated, then the GPU fingerprint will be
   // UNKNOWN.
-  void SetGpuFingerprint(const std::string& gpu_fingerprint);
-  void SetSkipDumpIfPrincipalMappingNotReferenced(
-      uintptr_t address_within_principal_mapping);
-  void SetShouldSanitizeDumps(bool should_sanitize_dumps);
-  void UpdateMinidumpDescriptor(MinidumpDescriptor* minidump_descriptor);
-  void UpdateExceptionHandlers();
+  void SetGpuFingerprintForMicrodump(const std::string& gpu_fingerprint);
   void Initialize(const std::string& process_type,
                   const char* product_name,
                   const char* product_version,
-                  const char* android_build_fp);
+                  const char* android_build_fp,
+                  const SanitizationInfo& sanitization_info);
 
  private:
   base::ThreadChecker thread_checker_;
-  const char* microdump_build_fingerprint_;
-  const char* microdump_product_info_;
   const char* microdump_gpu_fingerprint_;
-  const char* microdump_process_type_;
-  bool skip_dump_if_principal_mapping_not_referenced_;
-  uintptr_t address_within_principal_mapping_;
-  bool should_sanitize_dumps_;
 };
 
+void SetMinidumpSanitizationFields(MinidumpDescriptor* minidump_descriptor,
+                                   const SanitizationInfo& sanitization_info);
+
 base::LazyInstance<MicrodumpInfo> g_microdump_info =
     LAZY_INSTANCE_INITIALIZER;
 
 #endif
 
 CrashKeyStorage* g_crash_keys = nullptr;
 
 // Writes the value |v| as 16 hex characters to the memory pointed at by
 // |output|.
 void write_uint64_hex(char* output, uint64_t v) {
@@ skipping 606 matching lines @@
 void __asan_set_error_report_callback(void (*cb)(const char*));
 
 extern "C"
 void AsanLinuxBreakpadCallback(const char* report) {
   g_asan_report_str = report;
   // Send minidump here.
   g_breakpad->SimulateSignalDelivery(SIGKILL);
 }
 #endif
 
+#if defined(OS_ANDROID)
+void EnableCrashDumping(bool unattended,
+                        const SanitizationInfo& sanitization_info) {
+#else
 void EnableCrashDumping(bool unattended) {
+#endif  // defined(OS_ANDROID)
   g_is_crash_reporter_enabled = true;
 
   base::FilePath tmp_path("/tmp");
   PathService::Get(base::DIR_TEMP, &tmp_path);
 
   base::FilePath dumps_path(tmp_path);
   if (GetCrashReporterClient()->GetCrashDumpLocation(&dumps_path)) {
     base::FilePath logfile =
         dumps_path.Append(GetCrashReporterClient()->GetReporterLogFilename());
     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);
   MinidumpDescriptor minidump_descriptor(dumps_path.value());
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kFullMemoryCrashReport)) {
     minidump_descriptor.set_size_limit(-1);  // unlimited.
   } else {
     minidump_descriptor.set_size_limit(kMaxMinidumpFileSize);
   }
 #if defined(OS_ANDROID)
   unattended = true;  // Android never uploads directly.
-  g_microdump_info.Get().UpdateMinidumpDescriptor(&minidump_descriptor);
+  SetMinidumpSanitizationFields(&minidump_descriptor, sanitization_info);
 #endif
   if (unattended) {
     g_breakpad = new ExceptionHandler(
         minidump_descriptor,
 #if defined(OS_ANDROID)
         ShouldGenerateDump,
 #else
         nullptr,
 #endif
         CrashDoneNoUpload,
@@ skipping 57 matching lines @@
   info.distro_length = 0;
   info.upload = false;
   info.process_start_time = g_process_start_time;
   info.pid = g_pid;
   info.crash_keys = g_crash_keys;
   HandleCrashDump(info);
   return FinalizeCrashDoneAndroid(false /* is_browser_process */);
 }
 
 void EnableNonBrowserCrashDumping(const std::string& process_type,
-                                  int minidump_fd) {
+                                  int minidump_fd,
+                                  const SanitizationInfo& sanitization_info) {
   // This will guarantee that the BuildInfo has been initialized and subsequent
   // calls will not require memory allocation.
   base::android::BuildInfo::GetInstance();
   SetClientIdFromCommandLine(*base::CommandLine::ForCurrentProcess());
 
   // On Android, the current sandboxing uses process isolation, in which the
   // child process runs with a different UID. That breaks the normal crash
   // reporting where the browser process generates the minidump by inspecting
   // the child process. This is because the browser process now does not have
   // the permission to access the states of the child process (as it has a
   // different UID).
   // TODO(jcivelli): http://b/issue?id=6776356 we should use a watchdog
   // process forked from the renderer process that generates the minidump.
   if (minidump_fd == -1) {
     LOG(ERROR) << "Minidump file descriptor not found, crash reporting will "
         " not work.";
     return;
   }
   SetProcessStartTime();
   g_pid = getpid();
 
   g_is_crash_reporter_enabled = true;
   // Save the process type (it is leaked).
   const size_t process_type_len = process_type.size() + 1;
   g_process_type = new char[process_type_len];
   strncpy(g_process_type, process_type.c_str(), process_type_len);
 
   MinidumpDescriptor descriptor(minidump_fd);
-  g_microdump_info.Get().UpdateMinidumpDescriptor(&descriptor);
+  SetMinidumpSanitizationFields(&descriptor, sanitization_info);
   g_breakpad =
       new ExceptionHandler(descriptor, ShouldGenerateDump,
                            CrashDoneInProcessNoUpload, nullptr, true, -1);
 }
 
-void MicrodumpInfo::SetGpuFingerprint(const std::string& gpu_fingerprint) {
+void MicrodumpInfo::SetGpuFingerprintForMicrodump(
+    const std::string& gpu_fingerprint) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!microdump_gpu_fingerprint_);
   microdump_gpu_fingerprint_ = strdup(gpu_fingerprint.c_str());
   ANNOTATE_LEAKING_OBJECT_PTR(microdump_gpu_fingerprint_);
 
-  UpdateExceptionHandlers();
+  if (g_microdump) {
+    MinidumpDescriptor descriptor(g_microdump->minidump_descriptor());
+    descriptor.microdump_extra_info()->gpu_fingerprint =
+        microdump_gpu_fingerprint_;
+    g_microdump->set_minidump_descriptor(descriptor);
+  }
 }
 
-void MicrodumpInfo::SetSkipDumpIfPrincipalMappingNotReferenced(
-    uintptr_t address_within_principal_mapping) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  skip_dump_if_principal_mapping_not_referenced_ = true;
-  address_within_principal_mapping_ = address_within_principal_mapping;
-
-  UpdateExceptionHandlers();
-}
-
-void MicrodumpInfo::SetShouldSanitizeDumps(bool should_sanitize_dumps) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  should_sanitize_dumps_ = should_sanitize_dumps;
-
-  UpdateExceptionHandlers();
-}
-
-void MicrodumpInfo::UpdateMinidumpDescriptor(
-    MinidumpDescriptor* minidump_descriptor) {
-  google_breakpad::MicrodumpExtraInfo* microdump_extra_info =
-      minidump_descriptor->microdump_extra_info();
-
+void SetMinidumpSanitizationFields(MinidumpDescriptor* minidump_descriptor,
+                                   const SanitizationInfo& sanitization_info) {
   minidump_descriptor->set_skip_dump_if_principal_mapping_not_referenced(
-      skip_dump_if_principal_mapping_not_referenced_);
+      sanitization_info.skip_dump_if_principal_mapping_not_referenced);
   minidump_descriptor->set_address_within_principal_mapping(
-      address_within_principal_mapping_);
-  minidump_descriptor->set_sanitize_stacks(should_sanitize_dumps_);
-
-  microdump_extra_info->gpu_fingerprint = microdump_gpu_fingerprint_;
-  microdump_extra_info->product_info = microdump_product_info_;
-  microdump_extra_info->process_type = microdump_process_type_;
-  microdump_extra_info->build_fingerprint = microdump_build_fingerprint_;
-}
-
-void MicrodumpInfo::UpdateExceptionHandlers() {
-  if (g_breakpad) {
-    MinidumpDescriptor descriptor(g_breakpad->minidump_descriptor());
-    UpdateMinidumpDescriptor(&descriptor);
-    g_breakpad->set_minidump_descriptor(descriptor);
-  }
-  if (g_microdump) {
-    MinidumpDescriptor descriptor(g_microdump->minidump_descriptor());
-    UpdateMinidumpDescriptor(&descriptor);
-    g_microdump->set_minidump_descriptor(descriptor);
-  }
+      sanitization_info.address_within_principal_mapping);
+  minidump_descriptor->set_sanitize_stacks(
+      sanitization_info.should_sanitize_dumps);
 }
 
 void MicrodumpInfo::Initialize(const std::string& process_type,
                                const char* product_name,
                                const char* product_version,
-                               const char* android_build_fp) {
+                               const char* android_build_fp,
+                               const SanitizationInfo& sanitization_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!g_microdump);
   // |process_type| for webview's browser process is kBrowserProcessType or
   // kWebViewSingleProcessType. |process_type| for chrome's browser process is
   // an empty string.
   bool is_browser_process = process_type.empty() ||
                             process_type == kWebViewSingleProcessType ||
                             process_type == kBrowserProcessType;
 
   MinidumpDescriptor descriptor(MinidumpDescriptor::kMicrodumpOnConsole);
+  google_breakpad::MicrodumpExtraInfo* microdump_extra_info =
+      descriptor.microdump_extra_info();
 
   if (product_name && product_version) {
-    microdump_product_info_ =
+    microdump_extra_info->product_info =

[Tobias Sargeant, 2017/02/24 11:36:24]

It looks like you would need ANNOTATE_LEAKING_OBJECT_PTR still for all of these.

[gsennton, 2017/02/24 13:44:27]

Done.

         strdup((product_name + std::string(":") + product_version).c_str());
-    ANNOTATE_LEAKING_OBJECT_PTR(microdump_product_info_);
   }
 
-  microdump_process_type_ =
+  microdump_extra_info->process_type =
       strdup(process_type.empty() ? kBrowserProcessType : process_type.c_str());
-  ANNOTATE_LEAKING_OBJECT_PTR(microdump_process_type_);
 
   if (android_build_fp) {
-    microdump_build_fingerprint_ = strdup(android_build_fp);
-    ANNOTATE_LEAKING_OBJECT_PTR(microdump_build_fingerprint_);
+    microdump_extra_info->build_fingerprint = strdup(android_build_fp);
   }
 
-  UpdateMinidumpDescriptor(&descriptor);
+  SetMinidumpSanitizationFields(&descriptor, sanitization_info);
+  microdump_extra_info->gpu_fingerprint = microdump_gpu_fingerprint_;
 
   g_microdump =
       new ExceptionHandler(descriptor, ShouldGenerateDump, MicrodumpCrashDone,
                            reinterpret_cast<void*>(is_browser_process),
                            true,  // Install handlers.
                            -1);   // Server file descriptor. -1 for in-process.
 
   if (process_type != kWebViewSingleProcessType &&
       process_type != kBrowserProcessType &&
       !process_type.empty()) {
@@ skipping 906 matching lines @@
     IGNORE_RET(sys_unlink(temp_file));
     sys__exit(0);
   }
 
   // Main browser process.
   if (child <= 0)
     return;
   (void) HANDLE_EINTR(sys_waitpid(child, nullptr, 0));
 }
 
+#if defined(OS_ANDROID)
+// In Android WebView, microdumps are generated conditionally (depending on the
+// cause of the crash) and can be sanitized to prevent exposing unnecessary data
+// from the embedding application.
 void InitCrashReporter(const std::string& process_type) {
+  SanitizationInfo sanitization_info;
+  InitCrashReporter(process_type, sanitization_info);
+}
+
+void InitCrashReporter(const std::string& process_type,
+                       const SanitizationInfo& sanitization_info) {
+#else
+void InitCrashReporter(const std::string& process_type) {
+#endif  // defined(OS_ANDROID)
   // The maximum lengths specified by breakpad include the trailing NULL, so the
   // actual length of the chunk is one less.
   static_assert(crash_keys::kChunkMaxLength == 63, "kChunkMaxLength mismatch");
   static_assert(crash_keys::kSmallSize <= crash_keys::kChunkMaxLength,
                 "crash key chunk size too small");
 #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();
 
   // Handler registration is LIFO. Install the microdump handler first, such
   // that if conventional minidump crash reporting is enabled below, it takes
   // precedence (i.e. its handler is run first) over the microdump handler.
-  InitMicrodumpCrashHandlerIfNecessary(process_type);
+  InitMicrodumpCrashHandlerIfNecessary(process_type, sanitization_info);
 #endif
   // Determine the process type and take appropriate action.
   const base::CommandLine& parsed_command_line =
       *base::CommandLine::ForCurrentProcess();
   if (parsed_command_line.HasSwitch(switches::kDisableBreakpad))
     return;
 
   if (process_type.empty()) {
     bool enable_breakpad = GetCrashReporterClient()->GetCollectStatsConsent() ||
                            GetCrashReporterClient()->IsRunningUnattended();
     enable_breakpad &=
         !parsed_command_line.HasSwitch(switches::kDisableBreakpad);
     if (!enable_breakpad) {
       enable_breakpad = parsed_command_line.HasSwitch(
           switches::kEnableCrashReporterForTesting);
     }
     if (!enable_breakpad) {
       VLOG(1) << "Breakpad disabled";
       return;
     }
 
     InitCrashKeys();
+#if defined(OS_ANDROID)
+    EnableCrashDumping(GetCrashReporterClient()->IsRunningUnattended(),
+                       sanitization_info);
+#else
     EnableCrashDumping(GetCrashReporterClient()->IsRunningUnattended());
+#endif  // defined(OS_ANDROID)
   } else if (GetCrashReporterClient()->EnableBreakpadForProcess(process_type)) {
 #if defined(OS_ANDROID)
     NOTREACHED() << "Breakpad initialized with InitCrashReporter() instead of "
       "InitNonBrowserCrashReporter in " << process_type << " process.";
     return;
 #else
     // 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;
 
     InitCrashKeys();
     SetChannelFromCommandLine(parsed_command_line);
     SetClientIdFromCommandLine(parsed_command_line);
     EnableNonBrowserCrashDumping();
     VLOG(1) << "Non Browser crash dumping enabled for: " << process_type;
 #endif  // #if defined(OS_ANDROID)
   }
 
   PostEnableBreakpadInitialization();
 }
 
 #if defined(OS_ANDROID)
 void InitNonBrowserCrashReporterForAndroid(const std::string& process_type) {
+  SanitizationInfo sanitization_info;
+  sanitization_info.should_sanitize_dumps = false;
+  sanitization_info.skip_dump_if_principal_mapping_not_referenced = false;
+  InitNonBrowserCrashReporterForAndroid(process_type, sanitization_info);
+}
+
+void InitNonBrowserCrashReporterForAndroid(
+    const std::string& process_type,
+    const SanitizationInfo& sanitization_info) {
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
 
   // Handler registration is LIFO. Install the microdump handler first, such
   // that if conventional minidump crash reporting is enabled below, it takes
   // precedence (i.e. its handler is run first) over the microdump handler.
-  InitMicrodumpCrashHandlerIfNecessary(process_type);
+  InitMicrodumpCrashHandlerIfNecessary(process_type, sanitization_info);
 
   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(
         GetCrashReporterClient()->GetAndroidMinidumpDescriptor());
     if (minidump_fd < 0) {
       NOTREACHED() << "Could not find minidump FD, crash reporting disabled.";
     } else {
       InitCrashKeys();
-      EnableNonBrowserCrashDumping(process_type, minidump_fd);
+      EnableNonBrowserCrashDumping(process_type, minidump_fd,
+                                   sanitization_info);
       // Note: not installing DumpWithoutCrash handler here because browser
       // is not set up to receive multiple reports from child process.
     }
   }
 }
 
 // The microdump handler does NOT upload anything. It just dumps out on the
 // system console (logcat) a restricted and serialized variant of a minidump.
 // See crbug.com/410294 for more details.
-void InitMicrodumpCrashHandlerIfNecessary(const std::string& process_type) {
+void InitMicrodumpCrashHandlerIfNecessary(
+    const std::string& process_type,
+    const SanitizationInfo& sanitization_info) {
   if (!GetCrashReporterClient()->ShouldEnableBreakpadMicrodumps())
     return;
 
   VLOG(1) << "Enabling microdumps crash handler (process_type:"
           << process_type << ")";
 
   // The exception handler runs in a compromised context and cannot use c_str()
   // as that would require the heap. Therefore, we have to guarantee that the
   // build fingerprint and product info pointers are always valid.
   const char* product_name = nullptr;
   const char* product_version = nullptr;
   GetCrashReporterClient()->GetProductNameAndVersion(&product_name,
                                                      &product_version);
 
   const char* android_build_fp =
       base::android::BuildInfo::GetInstance()->android_build_fp();
 
   g_microdump_info.Get().Initialize(process_type, product_name, product_version,
-                                    android_build_fp);
+                                    android_build_fp, sanitization_info);
 }
 
 void AddGpuFingerprintToMicrodumpCrashHandler(
     const std::string& gpu_fingerprint) {
-  g_microdump_info.Get().SetGpuFingerprint(gpu_fingerprint);
+  g_microdump_info.Get().SetGpuFingerprintForMicrodump(gpu_fingerprint);
 }
 
 void GenerateMinidumpOnDemandForAndroid(int dump_fd) {
   if (dump_fd >= 0) {
     MinidumpDescriptor minidump_descriptor(dump_fd);
     minidump_descriptor.set_size_limit(-1);
     ExceptionHandler(minidump_descriptor, nullptr, MinidumpGenerated, nullptr,
                      false, -1)
         .WriteMinidump();
   }
 }
 
 void SuppressDumpGeneration() {
   g_dumps_suppressed = G_DUMPS_SUPPRESSED_MAGIC;
 }
-
-void SetSkipDumpIfPrincipalMappingNotReferenced(
-    uintptr_t address_within_principal_mapping) {
-  g_microdump_info.Get().SetSkipDumpIfPrincipalMappingNotReferenced(
-      address_within_principal_mapping);
-}
-
-void SetShouldSanitizeDumps(bool should_sanitize_dumps) {
-  g_microdump_info.Get().SetShouldSanitizeDumps(should_sanitize_dumps);
-}
 #endif  // OS_ANDROID
 
 bool IsCrashReporterEnabled() {
   return g_is_crash_reporter_enabled;
 }
 
 }  // namespace breakpad