[Sanitizer] Make CommonFlags immutable after initialization.

[samsonov]

Summary

Protect CommonFlags singleton by adding const qualifier to
common_flags() accessor. The only ways to modify the flags are
SetCommonFlagsDefaults(), ParseCommonFlagsFromString() functions
and OVERRIDE_COMMON_FLAG macro, which are only supposed to be
called during initialization.

[kcc]

lib/sanitizer_common/sanitizer_flags.h

91

Macro in a header file? You got to be kidding.

[samsonov]

• Replace macro with a function.

lib/sanitizer_common/sanitizer_flags.h

91

Replaced it with "OverrideCommonFlags()" function. Unfortunately, we can't atomically switch common_flags_dont_use singleton during tool initialization, and have to gradually update it by calls to SetCommonFlagsDefaults(), OverrideCommonFlags() and ParseCommonFlagsFromString().

[kcc]

LGTM

lib/asan/asan_flags.cc

ParseFlag(str, &f->detect_odr_violation, "detect_odr_violation",
             "If ==1, detect ODR-violation only if the two variables "
             "have different sizes");
 
   ParseFlag(str, &f->dump_instruction_bytes, "dump_instruction_bytes",
       "If true, dump 16 bytes starting at the instruction that caused SEGV");
 }
 
 void InitializeFlags(Flags *f) {
-  CommonFlags *cf = common_flags();
   SetCommonFlagsDefaults();
-  cf->detect_leaks = CAN_SANITIZE_LEAKS;
-  cf->external_symbolizer_path = GetEnv("ASAN_SYMBOLIZER_PATH");
-  cf->malloc_context_size = kDefaultMallocContextSize;
-  cf->intercept_tls_get_addr = true;
-  cf->coverage = false;
+  OVERRIDE_COMMON_FLAG(detect_leaks, CAN_SANITIZE_LEAKS);
+  OVERRIDE_COMMON_FLAG(external_symbolizer_path,
+                       GetEnv("ASAN_SYMBOLIZER_PATH"));
+  OVERRIDE_COMMON_FLAG(malloc_context_size, kDefaultMallocContextSize);
+  OVERRIDE_COMMON_FLAG(intercept_tls_get_addr, true);
 
   internal_memset(f, 0, sizeof(*f));
   f->quarantine_size = (ASAN_LOW_MEMORY) ? 1UL << 26 : 1UL << 28;
   f->redzone = 16;
   f->max_redzone = 2048;
   f->debug = false;
   f->report_globals = 1;
   f->check_initialization_order = false;
if (buf[0] != '\0')
       VReport(1, "Parsed activation flags: %s\n", buf);
   }
 
   if (common_flags()->help) {
     PrintFlagDescriptions();
   }
 
   // Flag validation:
-  if (!CAN_SANITIZE_LEAKS && cf->detect_leaks) {
+  if (!CAN_SANITIZE_LEAKS && common_flags()->detect_leaks) {
     Report("%s: detect_leaks is not supported on this platform.\n",
            SanitizerToolName);
-    cf->detect_leaks = false;
+    OVERRIDE_COMMON_FLAG(detect_leaks, false);
   }
   // Make "strict_init_order" imply "check_initialization_order".
   // TODO(samsonov): Use a single runtime flag for an init-order checker.
   if (f->strict_init_order) {
     f->check_initialization_order = true;
   }
-  CHECK_LE((uptr)cf->malloc_context_size, kStackTraceMax);
+  CHECK_LE((uptr)common_flags()->malloc_context_size, kStackTraceMax);
   CHECK_LE(f->min_uar_stack_size_log, f->max_uar_stack_size_log);
   CHECK_GE(f->redzone, 16);
   CHECK_GE(f->max_redzone, f->redzone);
   CHECK_LE(f->max_redzone, 2048);
   CHECK(IsPowerOfTwo(f->redzone));
   CHECK(IsPowerOfTwo(f->max_redzone));
 }
 
 }  // namespace __asan
 
 #if !SANITIZER_SUPPORTS_WEAK_HOOKS
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 const char* __asan_default_options() { return ""; }
 }  // extern "C"
 #endif

lib/lsan/lsan_common.cc

if (options) {
     CHECK_GE(&f->max_leaks, 0);
     ParseFlag(options, &f->log_pointers, "log_pointers", "");
     ParseFlag(options, &f->log_threads, "log_threads", "");
     ParseFlag(options, &f->exitcode, "exitcode", "");
   }
 
   // Set defaults for common flags (only in standalone mode) and parse
   // them from LSAN_OPTIONS.
-  CommonFlags *cf = common_flags();
   if (standalone) {
     SetCommonFlagsDefaults();
-    cf->external_symbolizer_path = GetEnv("LSAN_SYMBOLIZER_PATH");
-    cf->malloc_context_size = 30;
-    cf->detect_leaks = true;
+    OVERRIDE_COMMON_FLAG(external_symbolizer_path,
+                         GetEnv("LSAN_SYMBOLIZER_PATH"));
+    OVERRIDE_COMMON_FLAG(malloc_context_size, 30);
+    OVERRIDE_COMMON_FLAG(detect_leaks, true);
   }
   ParseCommonFlagsFromString(options);
 }
 
 #define LOG_POINTERS(...)                           \
   do {                                              \
     if (flags()->log_pointers) Report(__VA_ARGS__); \
   } while (0);

lib/msan/msan.cc

static void ParseFlagsFromString(Flags *f, const char *str) {
   // and it has inverse meaning.
   f->halt_on_error = !f->halt_on_error;
   ParseFlag(str, &f->halt_on_error, "keep_going", "");
   f->halt_on_error = !f->halt_on_error;
   ParseFlag(str, &f->halt_on_error, "halt_on_error", "");
 }
 
 static void InitializeFlags(Flags *f, const char *options) {
-  CommonFlags *cf = common_flags();
   SetCommonFlagsDefaults();
-  cf->external_symbolizer_path = GetEnv("MSAN_SYMBOLIZER_PATH");
-  cf->malloc_context_size = 20;
-  cf->handle_ioctl = true;
+  OVERRIDE_COMMON_FLAG(external_symbolizer_path,
+                       GetEnv("MSAN_SYMBOLIZER_PATH"));
+  OVERRIDE_COMMON_FLAG(malloc_context_size, 20);
+  OVERRIDE_COMMON_FLAG(handle_ioctl, true);
   // FIXME: test and enable.
-  cf->check_printf = false;
-  cf->intercept_tls_get_addr = true;
+  OVERRIDE_COMMON_FLAG(check_printf, false);
+  OVERRIDE_COMMON_FLAG(intercept_tls_get_addr, true);
 
   internal_memset(f, 0, sizeof(*f));
   f->poison_heap_with_zeroes = false;
   f->poison_stack_with_zeroes = false;
   f->poison_in_malloc = true;
   f->poison_in_free = true;
   f->exit_code = 77;
   f->origin_history_size = Origin::kMaxDepth;

lib/sanitizer_common/sanitizer_flags.h

struct CommonFlags {
   const char *stack_trace_format;
 
   void SetDefaults();
   void ParseFromString(const char *str);
 };
 
 // Functions to get/set global CommonFlags shared by all sanitizer runtimes:
 extern CommonFlags common_flags_dont_use;
-inline CommonFlags *common_flags() {
+inline const CommonFlags *common_flags() {
   return &common_flags_dont_use;
 }
 
 inline void SetCommonFlagsDefaults() {
   common_flags_dont_use.SetDefaults();
 }
 
 inline void ParseCommonFlagsFromString(const char *str) {
   common_flags_dont_use.ParseFromString(str);
 }
+
+// This macro should be used to setup tool-specific overrides for CommonFlags
+// defaults. Generally, it should only be used right after
+// SetCommonFlagsDefaults(), but before ParseCommonFlagsFromString(), and
+// only during the flags initialization (i.e. before they are used for the first
+// time).
+#define OVERRIDE_COMMON_FLAG(flag, value) \
+    common_flags_dont_use.flag = value
+
 void PrintFlagDescriptions();
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FLAGS_H

lib/tsan/dd/dd_rtl.cc

 }
 
 void InitializeFlags(Flags *f, const char *env) {
   internal_memset(f, 0, sizeof(*f));
 
   // Default values.
   f->second_deadlock_stack = false;
 
-  CommonFlags *cf = common_flags();
   SetCommonFlagsDefaults();
   // Override some common flags defaults.
-  cf->allow_addr2line = true;
+  OVERRIDE_COMMON_FLAG(allow_addr2line, true);
 
   // Override from command line.
   ParseFlag(env, &f->second_deadlock_stack, "second_deadlock_stack", "");
   ParseCommonFlagsFromString(env);
 }
 
 void Initialize() {
   static u64 ctx_mem[sizeof(Context) / sizeof(u64) + 1];

lib/tsan/rtl/tsan_flags.cc

void InitializeFlags(Flags *f, const char *env) {
   f->running_on_valgrind = false;
   f->history_size = kGoMode ? 1 : 2;  // There are a lot of goroutines in Go.
   f->io_sync = 1;
   f->die_after_fork = true;
 
   // DDFlags
   f->second_deadlock_stack = false;
 
-  CommonFlags *cf = common_flags();
   SetCommonFlagsDefaults();
   // Override some common flags defaults.
-  cf->allow_addr2line = true;
-  cf->detect_deadlocks = true;
-  cf->print_suppressions = false;
-  cf->stack_trace_format = "    #%n %f %S %M";
+  OVERRIDE_COMMON_FLAG(allow_addr2line, true);
+  OVERRIDE_COMMON_FLAG(detect_deadlocks, true);
+  OVERRIDE_COMMON_FLAG(print_suppressions, false);
+  OVERRIDE_COMMON_FLAG(stack_trace_format, "    #%n %f %S %M");
 
   // Let a frontend override.
   ParseFlags(f, __tsan_default_options());
   ParseCommonFlagsFromString(__tsan_default_options());
   // Override from command line.
   ParseFlags(f, env);
   ParseCommonFlagsFromString(env);
 
   // Sanity check.
   if (!f->report_bugs) {
     f->report_thread_leaks = false;
     f->report_destroy_locked = false;
     f->report_signal_unsafe = false;
   }
 
-  if (cf->help) PrintFlagDescriptions();
+  if (common_flags()->help)
+    PrintFlagDescriptions();
 
   if (f->history_size < 0 || f->history_size > 7) {
     Printf("ThreadSanitizer: incorrect value for history_size"
            " (must be [0..7])\n");
     Die();
   }
 
   if (f->io_sync < 0 || f->io_sync > 2) {
     Printf("ThreadSanitizer: incorrect value for io_sync"
            " (must be [0..2])\n");
     Die();
   }
 }
 
 }  // namespace __tsan

lib/ubsan/ubsan_flags.cc

 
 namespace __ubsan {
 
 static const char *MaybeCallUbsanDefaultOptions() {
   return (&__ubsan_default_options) ? __ubsan_default_options() : "";
 }
 
 void InitializeCommonFlags() {
-  CommonFlags *cf = common_flags();
   SetCommonFlagsDefaults();
-  cf->print_summary = false;
+  OVERRIDE_COMMON_FLAG(print_summary, false);
   // Override from user-specified string.
   ParseCommonFlagsFromString(MaybeCallUbsanDefaultOptions());
   // Override from environment variable.
   ParseCommonFlagsFromString(GetEnv("UBSAN_OPTIONS"));
 }
 
 Flags ubsan_flags;