Add the ability to defer the initialization of the SyzyAsan crash reporter.

syzygy/agent/asan/runtime.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 442 matching lines @@
 base::Lock AsanRuntime::lock_;
 AsanRuntime* AsanRuntime::runtime_ = NULL;
 LPTOP_LEVEL_EXCEPTION_FILTER AsanRuntime::previous_uef_ = NULL;
 bool AsanRuntime::uef_installed_ = false;
 
 AsanRuntime::AsanRuntime()
     : logger_(),
       stack_cache_(),
       asan_error_callback_(),
       heap_manager_(),
-      random_key_(::__rdtsc()) {
+      random_key_(::__rdtsc()),
+      crash_reporter_initialized_(false) {
   ::common::SetDefaultAsanParameters(&params_);
   starting_ticks_ = ::GetTickCount();
 }
 
 AsanRuntime::~AsanRuntime() {
 }
 
 bool AsanRuntime::SetUp(const std::wstring& flags_command_line) {
   base::AutoLock auto_lock(lock_);
   DCHECK(!runtime_);
@@ skipping 20 matching lines @@
   if (!SetUpMemoryNotifier())
     return false;
   if (!SetUpLogger())
     return false;
   if (!SetUpStackCache())
     return false;
   if (!SetUpHeapManager())
     return false;
   WindowsHeapAdapter::SetUp(heap_manager_.get());
 
-  // Determine the preferred crash reporter type, as specified in the
-  // environment. If this isn't present it defaults to
-  // kDefaultCrashReporterType, in which case experiments or command-line flags
-  // may specify the crash reporter to use.
-  CrashReporterType crash_reporter_type =
-      GetCrashReporterTypeFromEnvironment(logger());
-
   if (params_.feature_randomization) {
     AsanFeatureSet feature_set = GenerateRandomFeatureSet();
     PropagateFeatureSet(feature_set);
   }
 
   // Propagates the flags values to the different modules.
   PropagateParams();
 
-  // The name 'disable_breakpad_reporting' is legacy; this actually means to
-  // disable all external crash reporting integration.
-  if (!params_.disable_breakpad_reporting) {
-    // This will create the crash reporter with a preference for creating a
-    // reporter of the hinted type. If such a reporter isn't available, it will
-    // fall back to trying to create the most 'modern' reporter available.
-    crash_reporter_.reset(CreateCrashReporterWithTypeHint(
-        logger(), crash_reporter_type).release());
-  }
-
-  // Set up the appropriate error handler depending on whether or not
-  // we successfully initialized a crash reporter.
-  if (crash_reporter_.get() != nullptr) {
-    logger_->Write(base::StringPrintf(
-        "SyzyASAN: Using %s for error reporting.",
-        crash_reporter_->GetName()));
-    SetErrorCallBack(base::Bind(&CrashReporterErrorHandler));
-  } else {
-    logger_->Write("SyzyASAN: Using default error reporting handler.");
-    SetErrorCallBack(base::Bind(&DefaultErrorHandler));
-  }
+  if (!params_.defer_crash_reporter_initialization)
+    InitializeCrashReporter();
 
   // Install the unhandled exception handler. This is only installed once
   // across all runtime instances in a process so we check that it hasn't
   // already been installed.
   // TODO(chrisha): Conditionally install this based on the crash reporter in
   // use. Eventually, Crashpad will provide us a callback instead of having us
   // register the handler ourselves.
   if (!uef_installed_) {
     uef_installed_ = true;
     previous_uef_ = ::SetUnhandledExceptionFilter(&UnhandledExceptionFilter);
@@ skipping 266 matching lines @@
 void AsanRuntime::PropagateParams() {
   // This function has to be kept in sync with the AsanParameters struct. These
   // checks will ensure that this is the case.
 #ifdef _WIN64
   static_assert(sizeof(::common::AsanParameters) == 64,
                 "Must propagate parameters.");
 #else
   static_assert(sizeof(::common::AsanParameters) == 60,
                 "Must propagate parameters.");
 #endif
-  static_assert(::common::kAsanParametersVersion == 14,
+  static_assert(::common::kAsanParametersVersion == 15,
                 "Must update parameters version.");
 
   // Push the configured parameter values to the appropriate endpoints.
   heap_manager_->set_parameters(params_);
   StackCaptureCache::set_compression_reporting_period(params_.reporting_period);
   common::StackCapture::set_bottom_frames_to_skip(
       params_.bottom_frames_to_skip);
   stack_cache_->set_max_num_frames(params_.max_num_frames);
   // ignored_stack_ids is used locally by AsanRuntime.
   logger_->set_log_as_text(params_.log_as_text);
@@ skipping 383 matching lines @@
 AsanFeatureSet AsanRuntime::GetEnabledFeatureSet() {
   AsanFeatureSet enabled_features = static_cast<AsanFeatureSet>(0U);
   if (heap_manager_->enable_page_protections_)
     enabled_features |= ASAN_FEATURE_ENABLE_PAGE_PROTECTIONS;
   if (params_.enable_large_block_heap)
     enabled_features |= ASAN_FEATURE_ENABLE_LARGE_BLOCK_HEAP;
 
   return enabled_features;
 }
 
+void AsanRuntime::InitializeCrashReporter() {
+  DCHECK_EQ(nullptr, crash_reporter_.get());
+  // Make sure that the crash reporter hasn't already been initialized.
+  CHECK(!crash_reporter_initialized_) << "The crash reporter can only "
+      "be initialized once.";
+
+  crash_reporter_initialized_ = true;
+
+  // Determine the preferred crash reporter type, as specified in the
+  // environment. If this isn't present it defaults to
+  // kDefaultCrashReporterType, in which case experiments or command-line flags
+  // may specify the crash reporter to use.
+  CrashReporterType crash_reporter_type =
+      GetCrashReporterTypeFromEnvironment(logger());
+
+  // The name 'disable_breakpad_reporting' is legacy; this actually means to
+  // disable all external crash reporting integration.
+  if (!params_.disable_breakpad_reporting) {
+    // This will create the crash reporter with a preference for creating a
+    // reporter of the hinted type. If such a reporter isn't available, it will
+    // fall back to trying to create the most 'modern' reporter available.
+    crash_reporter_.reset(CreateCrashReporterWithTypeHint(
+                              logger(), crash_reporter_type).release());
+  }
+
+  // Set up the appropriate error handler depending on whether or not
+  // we successfully initialized a crash reporter.
+  if (crash_reporter_.get() != nullptr) {
+    logger_->Write(base::StringPrintf("SyzyASAN: Using %s for error reporting.",
+                                      crash_reporter_->GetName()));
+    SetErrorCallBack(base::Bind(&CrashReporterErrorHandler));
+  } else {
+    logger_->Write("SyzyASAN: Using default error reporting handler.");
+    SetErrorCallBack(base::Bind(&DefaultErrorHandler));
+  }
+}
+
 }  // namespace asan
 }  // namespace agent