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

syzygy/common/asan_parameters.h

 // Copyright 2014 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 18 matching lines @@
 #include "syzygy/common/assertions.h"
 
 namespace common {
 
 #pragma pack(push, 1)
 
 // The type used by stack IDs. This must be compatible with that used by
 // the StackCaptureCache.
 typedef uint32_t AsanStackId;
 
-static const size_t kAsanParametersReserved1Bits = 20;
+static const size_t kAsanParametersReserved1Bits = 19;
 
 // This data structure is injected into an instrumented image in a read-only
 // section. It is initialized by the instrumenter, and will be looked up at
 // runtime by the SyzyAsan RTL. Values in this structure (if present) will
 // override hard-coded default values. Values in this structure may be
 // superceded by environment variable parameter settings.
 struct AsanParameters {
   // The first two members of this structure are fixed, and must always be
   // present. This allows for the detection of version shear between RTLs and
   // instrumented code.
@@ skipping 59 matching lines @@
       // BlockHeapManager: Indicates if the allocation filtering is enabled. If
       // so, only blocks from filtered sites can make it into the zebra heap.
       unsigned enable_allocation_filter : 1;
       // Runtime: Indicates if the feature randomization is enabled.
       unsigned feature_randomization : 1;
       // BlockHeapManager: Indicates if we shouldn't report a crash for the same
       // corrupt block twice.
       unsigned prevent_duplicate_corruption_crashes : 1;
       // Runtime: Indicates if the invalid accesses should be reported.
       unsigned report_invalid_accesses : 1;
+      // Runtime: Defer the crash reporter initialization, the client has to
+      // manually call the crash reporter initialization function.
+      unsigned defer_crash_reporter_initialization : 1;
 
       // Add new flags here!
 
       unsigned reserved1 : kAsanParametersReserved1Bits;
     };
   };
 
   // HeapProxy: The rate at which allocations are instrumented with header and
   // footer guards. This happens for each allocation via a runtime cointoss.
   // A value in the range 0.0 to 1.0, inclusive.
@@ skipping 23 matching lines @@
 };
 #ifndef _WIN64
 COMPILE_ASSERT_IS_POD_OF_SIZE(AsanParameters, 60);
 #else
 COMPILE_ASSERT_IS_POD_OF_SIZE(AsanParameters, 64);
 #endif
 
 // The current version of the Asan parameters structure. This must be updated
 // if any changes are made to the above structure! This is defined in the header
 // file to allow compile time assertions against this version number.
-const uint32_t kAsanParametersVersion = 14;
+const uint32_t kAsanParametersVersion = 15;
 
 // If the number of free bits in the parameters struct changes, then the
 // version has to change as well. This is simply here to make sure that
 // everything changes in lockstep.
-static_assert(kAsanParametersReserved1Bits == 20 &&
-                  kAsanParametersVersion == 14,
+static_assert(kAsanParametersReserved1Bits == 19 &&
+                  kAsanParametersVersion == 15,
               "Version must change if reserved bits changes.");
 
 // The name of the section that will be injected into an instrumented image,
 // and contain the AsanParameters structure. Asan can't use your typical entry
 // hook because the entry hook is called after the RTL has initialized itself.
 // Instead the RTL scans through libraries in its memory and looks for a
 // telltale section containing parameters. The first set of parameters it
 // encounters are used. After that it may override some of them with environment
 // variable configuration.
 extern const char kAsanParametersSectionName[];
@@ skipping 51 matching lines @@
 extern const uint32_t kDefaultReportingPeriod;
 extern const uint32_t kDefaultMaxNumFrames;
 // Default values of StackCapture parameters.
 extern const uint32_t kDefaultBottomFramesToSkip;
 // Default values of AsanRuntime parameters.
 extern const bool kDefaultExitOnFailure;
 extern const bool kDefaultCheckHeapOnFailure;
 extern const bool kDefaultDisableBreakpadReporting;
 extern const bool kDefaultFeatureRandomization;
 extern const bool kDefaultReportInvalidAccesses;
+extern const bool kDefaultDeferCrashReporterInitialization;
 // Default values of AsanLogger parameters.
 extern const bool kDefaultMiniDumpOnFailure;
 extern const bool kDefaultLogAsText;
 // Default values of ZebraBlockHeap parameters.
 extern const uint32_t kDefaultZebraBlockHeapSize;
 extern const float kDefaultZebraBlockHeapQuarantineRatio;
 // Default values of the BlockHeapManager parameters.
 extern const bool kDefaultEnableZebraBlockHeap;
 extern const bool kDefaultEnableAllocationFilter;
 extern const float kDefaultQuarantineFloodFillRate;
@@ skipping 15 matching lines @@
 extern const char kParamReportingPeriod[];
 extern const char kParamBottomFramesToSkip[];
 // String names of StackCapture parameters.
 extern const char kParamMaxNumFrames[];
 // String names of AsanRuntime parameters.
 extern const char kParamIgnoredStackIds[];
 extern const char kParamExitOnFailure[];
 extern const char kParamDisableBreakpadReporting[];
 extern const char kParamFeatureRandomization[];
 extern const char kParamReportInvalidAccesses[];
+extern const char kParamDeferCrashReporterInitialization[];
 // String names of AsanLogger parameters.
 extern const char kParamMiniDumpOnFailure[];
 extern const char kParamLogAsText[];
 // String names of ZebraBlockHeap parameters.
 extern const char kParamZebraBlockHeapSize[];
 extern const char kParamZebraBlockHeapQuarantineRatio[];
 // String names of BlockHeapManager parameters.
 extern const char kParamDisableSizeTargetedHeaps[];
 extern const char kParamEnableZebraBlockHeap[];
 extern const char kParamEnableAllocationFilter[];
@@ skipping 16 matching lines @@
 // Parses parameters from a string, and updates the provided structure.
 // @param param_string the string of parameters to be parsed.
 // @param asan_parameters The AsanParameters struct to be updated.
 // @returns true on success, false otherwise. Logs verbosely on failure.
 bool ParseAsanParameters(const base::StringPiece16& param_string,
                          InflatedAsanParameters* asan_parameters);
 
 }  // namespace common
 
 #endif  // SYZYGY_COMMON_ASAN_PARAMETERS_H_