[ASan] Allow to atomically modify malloc_context_size at runtime.

[samsonov]

Summary

Introduce __asan::malloc_context_size atomic that is used to determine
required malloc/free stack trace size. It is initialized with
common_flags()->malloc_context_size flag, but can later be overwritten
at runtime (e.g. when ASan is activated / deactivated).

[kcc]

lib/asan/asan_stack.h

26

I'd prefer to have it a static var with a getter

[samsonov]

• Replace extern atomic with Get/Set pair.

lib/asan/asan_stack.h

26

Done

[kcc]

LGTM

lib/asan/asan_activation.cc

 //
 // ASan activation/deactivation logic.
 //===----------------------------------------------------------------------===//
 
 #include "asan_activation.h"
 #include "asan_allocator.h"
 #include "asan_flags.h"
 #include "asan_internal.h"
+#include "asan_stack.h"
 #include "sanitizer_common/sanitizer_flags.h"
 
 namespace __asan {
 
 static struct AsanDeactivatedFlags {
   int quarantine_size;
   int max_redzone;
   int malloc_context_size;

 void AsanActivate() {
   if (!asan_is_deactivated) return;
   VReport(1, "Activating ASan\n");
 
   // Restore flag values.
   // FIXME: this is not atomic, and there may be other threads alive.
   flags()->max_redzone = asan_deactivated_flags.max_redzone;
   flags()->poison_heap = asan_deactivated_flags.poison_heap;
-  common_flags()->malloc_context_size =
-      asan_deactivated_flags.malloc_context_size;
   flags()->alloc_dealloc_mismatch =
       asan_deactivated_flags.alloc_dealloc_mismatch;
 
   ParseExtraActivationFlags();
 
+  SetMallocContextSize(asan_deactivated_flags.malloc_context_size);
   ReInitializeAllocator(asan_deactivated_flags.allocator_may_return_null,
                         asan_deactivated_flags.quarantine_size);
 
   asan_is_deactivated = false;
   VReport(1, "quarantine_size %d, max_redzone %d, poison_heap %d, "
              "malloc_context_size %d, alloc_dealloc_mismatch %d, "
              "allocator_may_return_null %d\n",
           asan_deactivated_flags.quarantine_size, flags()->max_redzone,
-          flags()->poison_heap, common_flags()->malloc_context_size,
+          flags()->poison_heap, asan_deactivated_flags.malloc_context_size,
           flags()->alloc_dealloc_mismatch,
           asan_deactivated_flags.allocator_may_return_null);
 }
 
 }  // namespace __asan

lib/asan/asan_rtl.cc

static void AsanCheckFailed(const char *file, int line, const char *cond,
   Report("AddressSanitizer CHECK failed: %s:%d \"%s\" (0x%zx, 0x%zx)\n", file,
          line, cond, (uptr)v1, (uptr)v2);
   // FIXME: check for infinite recursion without a thread-local counter here.
   PRINT_CURRENT_STACK_CHECK();
   Die();
 }
 
 // -------------------------- Flags ------------------------- {{{1
-static const int kDefaultMallocContextSize = 30;
-
 Flags asan_flags_dont_use_directly;  // use via flags().
 
 static const char *MaybeCallAsanDefaultOptions() {
   return (&__asan_default_options) ? __asan_default_options() : "";
 }
 
 static const char *MaybeUseAsanDefaultOptionsCompileDefinition() {
 #ifdef ASAN_DEFAULT_OPTIONS
 // Stringize the macro value.
 # define ASAN_STRINGIZE(x) #x
 # define ASAN_STRINGIZE_OPTIONS(options) ASAN_STRINGIZE(options)
   return ASAN_STRINGIZE_OPTIONS(ASAN_DEFAULT_OPTIONS);
 #else
   return "";
 #endif
 }
 
 static void ParseFlagsFromString(Flags *f, const char *str) {
   CommonFlags *cf = common_flags();
   ParseCommonFlagsFromString(cf, str);
-  CHECK((uptr)cf->malloc_context_size <= kStackTraceMax);
   // Please write meaningful flag descriptions when adding new flags.
   ParseFlag(str, &f->quarantine_size, "quarantine_size",
             "Size (in bytes) of quarantine used to detect use-after-free "
             "errors. Lower value may reduce memory usage but increase the "
             "chance of false negatives.");
   ParseFlag(str, &f->redzone, "redzone",
             "Minimal size (in bytes) of redzones around heap objects. "
             "Requirement: redzone >= 16, is a power of two.");
Report("%s: detect_leaks is not supported on this platform.\n",
            SanitizerToolName);
     cf->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(flags()->min_uar_stack_size_log, flags()->max_uar_stack_size_log);
+  CHECK_LE((uptr)cf->malloc_context_size, kStackTraceMax);
+  CHECK_LE(f->min_uar_stack_size_log, f->max_uar_stack_size_log);
 }
 
 // Parse flags that may change between startup and activation.
 // On Android they come from a system property.
 // On other platforms this is no-op.
 void ParseExtraActivationFlags() {
   char buf[100];
   GetExtraActivationFlags(buf, sizeof(buf));
static void AsanInitInternal() {
   CHECK(!asan_init_is_running && "ASan init calls itself!");
   asan_init_is_running = true;
 
   // Initialize flags. This must be done early, because most of the
   // initialization steps look at flags().
   const char *options = GetEnv("ASAN_OPTIONS");
   InitializeFlags(flags(), options);
 
+  SetMallocContextSize(common_flags()->malloc_context_size);
+
   InitializeHighMemEnd();
 
   // Make sure we are not statically linked.
   AsanDoesNotSupportStaticLinkage();
 
   // Install tool-specific callbacks in sanitizer_common.
   SetDieCallback(AsanDie);
   SetCheckFailedCallback(AsanCheckFailed);

lib/asan/asan_stack.h

 //
 // ASan-private header for asan_stack.cc.
 //===----------------------------------------------------------------------===//
 #ifndef ASAN_STACK_H
 #define ASAN_STACK_H
 
 #include "asan_flags.h"
 #include "asan_thread.h"
+#include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 
 namespace __asan {
 
+static const u32 kDefaultMallocContextSize = 30;
+
+void SetMallocContextSize(u32 size);
+u32 GetMallocContextSize();
+
 // Get the stack trace with the given pc and bp.
 // The pc will be in the position 0 of the resulting stack trace.
 // The bp may refer to the current frame or to the caller's frame.
 ALWAYS_INLINE
 void GetStackTraceWithPcBpAndContext(BufferedStackTrace *stack, uptr max_depth,
                                      uptr pc, uptr bp, void *context,
                                      bool fast) {
 #if SANITIZER_WINDOWS
#define GET_STACK_TRACE_FATAL_HERE                                \
   GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_fatal)
 
 #define GET_STACK_TRACE_CHECK_HERE                                \
   GET_STACK_TRACE(kStackTraceMax, common_flags()->fast_unwind_on_check)
 
 #define GET_STACK_TRACE_THREAD                                    \
   GET_STACK_TRACE(kStackTraceMax, true)
 
-#define GET_STACK_TRACE_MALLOC                                    \
-  GET_STACK_TRACE(common_flags()->malloc_context_size,            \
-                  common_flags()->fast_unwind_on_malloc)
+#define GET_STACK_TRACE_MALLOC                                                 \
+  GET_STACK_TRACE(GetMallocContextSize(), common_flags()->fast_unwind_on_malloc)
 
 #define GET_STACK_TRACE_FREE GET_STACK_TRACE_MALLOC
 
 #define PRINT_CURRENT_STACK()   \
   {                             \
     GET_STACK_TRACE_FATAL_HERE; \
     stack.Print();              \
   }
 
 #define PRINT_CURRENT_STACK_CHECK() \
   {                                 \
     GET_STACK_TRACE_CHECK_HERE;     \
     stack.Print();                  \
   }
 
 #endif  // ASAN_STACK_H

lib/asan/asan_stack.cc

 //===-- asan_stack.cc -----------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Code for ASan stack trace.
 //===----------------------------------------------------------------------===//
 #include "asan_internal.h"
 #include "asan_stack.h"
 
+namespace __asan {
+
+static atomic_uint32_t malloc_context_size;
+
+void SetMallocContextSize(u32 size) {
+  atomic_store(&malloc_context_size, size, memory_order_release);
+}
+
+u32 GetMallocContextSize() {
+  return atomic_load(&malloc_context_size, memory_order_acquire);
+}
+
+}  // namespace __asan
+
 // ------------------ Interface -------------- {{{1
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_print_stack_trace() {
   using namespace __asan;
   PRINT_CURRENT_STACK();
 }
 }  // extern "C"

lib/sanitizer_common/sanitizer_stacktrace.cc

void BufferedStackTrace::PopStackFrames(uptr count) {
   for (uptr i = 0; i < size; ++i) {
     trace_buffer[i] = trace_buffer[i + count];
   }
 }
 
 uptr BufferedStackTrace::LocatePcInTrace(uptr pc) {
   // Use threshold to find PC in stack trace, as PC we want to unwind from may
   // slightly differ from return address in the actual unwinded stack trace.
-  const int kPcThreshold = 288;
+  const int kPcThreshold = 304;
   for (uptr i = 0; i < size; ++i) {
     if (MatchPc(pc, trace[i], kPcThreshold))
       return i;
   }
   return 0;
 }
 
 }  // namespace __sanitizer