[ASan] Introduce AllocatorOptions to configure allocator behavior.

[samsonov]

Summary

Reduce the dependency of allocator code on runtime flags. Instead,
pass a bunch of options that configure allocator behavior at
initialization or re-initialization. That would allow us to
cleaner modify allocator behavior during a program execution
when ASan is activated or de-activated.

[kcc]

Some of these options may be accessed on fast path, so I'd like to have the struct as small as possible

lib/asan/asan_allocator.cc

230

maybe u16?

lib/asan/asan_allocator.h

36

group the fields so that the struct is as small as possible.
also make quarantine_size quarantine_size_mb (for now, only the internal one, but I'd love to make the external flag to be _mb too).
and make it u32

39

maybe u16?

[samsonov]

• Introduced AllocatorOptions::SetFrom() to initialize from flags.
• Reorder the fields.

lib/asan/asan_allocator.cc

230

Done

lib/asan/asan_allocator.h

36

Done

39

Done

[kcc]

LGTM

lib/asan/asan_activation.cc

 #include "asan_internal.h"
 #include "asan_poisoning.h"
 #include "asan_stack.h"
 #include "sanitizer_common/sanitizer_flags.h"
 
 namespace __asan {
 
 static struct AsanDeactivatedFlags {
-  int quarantine_size;
-  int max_redzone;
+  AllocatorOptions allocator_options;
   int malloc_context_size;
   bool poison_heap;
-  bool alloc_dealloc_mismatch;
-  bool allocator_may_return_null;
 } asan_deactivated_flags;
 
 static bool asan_is_deactivated;
 
 void AsanStartDeactivated() {
   VReport(1, "Deactivating ASan\n");
   // Save flag values.
-  asan_deactivated_flags.quarantine_size = flags()->quarantine_size;
-  asan_deactivated_flags.max_redzone = flags()->max_redzone;
-  asan_deactivated_flags.poison_heap = flags()->poison_heap;
+  asan_deactivated_flags.allocator_options.SetFrom(flags(), common_flags());
   asan_deactivated_flags.malloc_context_size =
       common_flags()->malloc_context_size;
-  asan_deactivated_flags.alloc_dealloc_mismatch =
-      flags()->alloc_dealloc_mismatch;
-  asan_deactivated_flags.allocator_may_return_null =
-      common_flags()->allocator_may_return_null;
+  asan_deactivated_flags.poison_heap = flags()->poison_heap;
 
   flags()->quarantine_size = 0;
   flags()->max_redzone = 16;
   flags()->poison_heap = false;
   common_flags()->malloc_context_size = 0;
   flags()->alloc_dealloc_mismatch = false;
   common_flags()->allocator_may_return_null = true;
 
   asan_is_deactivated = true;
 }
 
 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()->alloc_dealloc_mismatch =
-      asan_deactivated_flags.alloc_dealloc_mismatch;
-
   // FIXME: Avoid modifying global common_flags() and flags() and restrict the
   // set of supported flags that can be provided in activation.
   char buf[100];
   GetExtraActivationFlags(buf, sizeof(buf));
   ParseCommonFlagsFromString(common_flags(), buf);
   ParseFlagsFromString(flags(), buf);
   if (buf[0] != '\0')
     VReport(1, "Extra activation flags: %s\n", buf);
 
   SetCanPoisonMemory(asan_deactivated_flags.poison_heap);
   SetMallocContextSize(asan_deactivated_flags.malloc_context_size);
-  ReInitializeAllocator(asan_deactivated_flags.allocator_may_return_null,
-                        asan_deactivated_flags.quarantine_size);
+  ReInitializeAllocator(asan_deactivated_flags.allocator_options);
 
   asan_is_deactivated = false;
-  VReport(1, "quarantine_size %d, max_redzone %d, poison_heap %d, "
+  VReport(1, "quarantine_size_mb %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,
+          asan_deactivated_flags.allocator_options.quarantine_size_mb,
+          asan_deactivated_flags.allocator_options.max_redzone,
           asan_deactivated_flags.poison_heap,
           asan_deactivated_flags.malloc_context_size,
-          flags()->alloc_dealloc_mismatch,
-          asan_deactivated_flags.allocator_may_return_null);
+          asan_deactivated_flags.allocator_options.alloc_dealloc_mismatch,
+          asan_deactivated_flags.allocator_options.may_return_null);
 }
 
 }  // namespace __asan

lib/asan/asan_allocator.h

 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // ASan-private header for asan_allocator.cc.
 //===----------------------------------------------------------------------===//
 
 #ifndef ASAN_ALLOCATOR_H
 #define ASAN_ALLOCATOR_H
 
+#include "asan_flags.h"
 #include "asan_internal.h"
 #include "asan_interceptors.h"
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_list.h"
 
 namespace __asan {
 
 enum AllocType {
   FROM_MALLOC = 1,  // Memory block came from malloc, calloc, realloc, etc.
   FROM_NEW = 2,     // Memory block came from operator new.
   FROM_NEW_BR = 3   // Memory block came from operator new [ ]
 };
 
 static const uptr kNumberOfSizeClasses = 255;
 struct AsanChunk;
 
-void InitializeAllocator(bool may_return_null, uptr quarantine_size);
-void ReInitializeAllocator(bool may_return_null, uptr quarantine_size);
+struct AllocatorOptions {
+  u32 quarantine_size_mb;
+  u16 min_redzone;
+  u16 max_redzone;
+  u8 may_return_null;
+  u8 alloc_dealloc_mismatch;
+
+  void SetFrom(const Flags *f, const CommonFlags *cf);
+};
+
+void InitializeAllocator(const AllocatorOptions &options);
+void ReInitializeAllocator(const AllocatorOptions &options);
 
 class AsanChunkView {
  public:
   explicit AsanChunkView(AsanChunk *chunk) : chunk_(chunk) {}
   bool IsValid();   // Checks if AsanChunkView points to a valid allocated
                     // or quarantined chunk.
   uptr Beg();       // First byte of user memory.
   uptr End();       // Last byte of user memory.

lib/asan/asan_allocator.cc

 }
 
 QuarantineCache *GetQuarantineCache(AsanThreadLocalMallocStorage *ms) {
   CHECK(ms);
   CHECK_LE(sizeof(QuarantineCache), sizeof(ms->quarantine_cache));
   return reinterpret_cast<QuarantineCache *>(ms->quarantine_cache);
 }
 
+void AllocatorOptions::SetFrom(const Flags *f, const CommonFlags *cf) {
+  quarantine_size_mb = f->quarantine_size >> 20;
+  min_redzone = f->redzone;
+  max_redzone = f->max_redzone;
+  may_return_null = cf->allocator_may_return_null;
+  alloc_dealloc_mismatch = f->alloc_dealloc_mismatch;
+}
+
 struct Allocator {
   static const uptr kMaxAllowedMallocSize =
       FIRST_32_SECOND_64(3UL << 30, 64UL << 30);
   static const uptr kMaxThreadLocalQuarantine =
       FIRST_32_SECOND_64(1 << 18, 1 << 20);
 
   AsanAllocator allocator;
   AsanQuarantine quarantine;
   StaticSpinMutex fallback_mutex;
   AllocatorCache fallback_allocator_cache;
   QuarantineCache fallback_quarantine_cache;
 
+  // ------------------- Options --------------------------
+  atomic_uint16_t min_redzone;
+  atomic_uint16_t max_redzone;
+  atomic_uint8_t alloc_dealloc_mismatch;
+
+  // ------------------- Initialization ------------------------
   explicit Allocator(LinkerInitialized)
       : quarantine(LINKER_INITIALIZED),
         fallback_quarantine_cache(LINKER_INITIALIZED) {}
 
-  // ------------------- Initialization ------------------------
-  void Initialize(bool may_return_null, uptr quarantine_size) {
-    allocator.Init(may_return_null);
-    quarantine.Init(quarantine_size, kMaxThreadLocalQuarantine);
-  }
-
-  void ReInitialize(bool may_return_null, uptr quarantine_size) {
-    allocator.SetMayReturnNull(may_return_null);
-    quarantine.Init(quarantine_size, kMaxThreadLocalQuarantine);
+  void CheckOptions(const AllocatorOptions &options) const {
+    CHECK_GE(options.min_redzone, 16);
+    CHECK_GE(options.max_redzone, options.min_redzone);
+    CHECK_LE(options.max_redzone, 2048);
+    CHECK(IsPowerOfTwo(options.min_redzone));
+    CHECK(IsPowerOfTwo(options.max_redzone));
+  }
+
+  void SharedInitCode(const AllocatorOptions &options) {
+    CheckOptions(options);
+    quarantine.Init((uptr)options.quarantine_size_mb << 20,
+                    kMaxThreadLocalQuarantine);
+    atomic_store(&alloc_dealloc_mismatch, options.alloc_dealloc_mismatch,
+                 memory_order_release);
+    atomic_store(&min_redzone, options.min_redzone, memory_order_release);
+    atomic_store(&max_redzone, options.max_redzone, memory_order_release);
+  }
+
+  void Initialize(const AllocatorOptions &options) {
+    allocator.Init(options.may_return_null);
+    SharedInitCode(options);
+  }
+
+  void ReInitialize(const AllocatorOptions &options) {
+    allocator.SetMayReturnNull(options.may_return_null);
+    SharedInitCode(options);
   }
 
   // -------------------- Helper methods. -------------------------
   uptr ComputeRZLog(uptr user_requested_size) {
     u32 rz_log =
       user_requested_size <= 64        - 16   ? 0 :
       user_requested_size <= 128       - 32   ? 1 :
       user_requested_size <= 512       - 64   ? 2 :
       user_requested_size <= 4096      - 128  ? 3 :
       user_requested_size <= (1 << 14) - 256  ? 4 :
       user_requested_size <= (1 << 15) - 512  ? 5 :
       user_requested_size <= (1 << 16) - 1024 ? 6 : 7;
-    return Min(Max(rz_log, RZSize2Log(flags()->redzone)),
-               RZSize2Log(flags()->max_redzone));
+    u32 min_rz = atomic_load(&min_redzone, memory_order_acquire);
+    u32 max_rz = atomic_load(&max_redzone, memory_order_acquire);
+    return Min(Max(rz_log, RZSize2Log(min_rz)), RZSize2Log(max_rz));
   }
 
   // We have an address between two chunks, and we want to report just one.
   AsanChunk *ChooseChunk(uptr addr, AsanChunk *left_chunk,
                          AsanChunk *right_chunk) {
     // Prefer an allocated chunk over freed chunk and freed chunk
     // over available chunk.
     if (left_chunk->chunk_state != right_chunk->chunk_state) {
#endif
   }
 
   // Expects the chunk to already be marked as quarantined by using
   // AtomicallySetQuarantineFlag.
   void QuarantineChunk(AsanChunk *m, void *ptr, BufferedStackTrace *stack,
                        AllocType alloc_type) {
     CHECK_EQ(m->chunk_state, CHUNK_QUARANTINE);
 
-    if (m->alloc_type != alloc_type && flags()->alloc_dealloc_mismatch)
-      ReportAllocTypeMismatch((uptr)ptr, stack,
-                              (AllocType)m->alloc_type, (AllocType)alloc_type);
+    if (m->alloc_type != alloc_type) {
+      if (atomic_load(&alloc_dealloc_mismatch, memory_order_acquire)) {
+        ReportAllocTypeMismatch((uptr)ptr, stack, (AllocType)m->alloc_type,
+                                (AllocType)alloc_type);
+      }
+    }
 
     CHECK_GE(m->alloc_tid, 0);
     if (SANITIZER_WORDSIZE == 64)  // On 32-bits this resides in user area.
       CHECK_EQ(m->free_tid, kInvalidTid);
     AsanThread *t = GetCurrentThread();
     m->free_tid = t ? t->tid() : 0;
     m->free_context_id = StackDepotPut(*stack);
     // Poison the region.

 StackTrace AsanChunkView::GetAllocStack() {
   return GetStackTraceFromId(chunk_->alloc_context_id);
 }
 
 StackTrace AsanChunkView::GetFreeStack() {
   return GetStackTraceFromId(chunk_->free_context_id);
 }
 
-void InitializeAllocator(bool may_return_null, uptr quarantine_size) {
-  instance.Initialize(may_return_null, quarantine_size);
+void InitializeAllocator(const AllocatorOptions &options) {
+  instance.Initialize(options);
 }
 
-void ReInitializeAllocator(bool may_return_null, uptr quarantine_size) {
-  instance.ReInitialize(may_return_null, quarantine_size);
+void ReInitializeAllocator(const AllocatorOptions &options) {
+  instance.ReInitialize(options);
 }
 
 AsanChunkView FindHeapChunkByAddress(uptr addr) {
   return instance.FindHeapChunkByAddress(addr);
 }
 
 void AsanThreadLocalMallocStorage::CommitBack() {
   instance.CommitBack(this);

lib/asan/asan_flags.cc

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.");
   ParseFlag(str, &f->max_redzone, "max_redzone",
             "Maximal size (in bytes) of redzones around heap objects.");
-  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));
 
   ParseFlag(str, &f->debug, "debug",
       "If set, prints some debugging information and does additional checks.");
   ParseFlag(str, &f->report_globals, "report_globals",
       "Controls the way to handle globals (0 - don't detect buffer overflow on "
       "globals, 1 - detect buffer overflow, 2 - print data about registered "
       "globals).");
 

lib/asan/asan_rtl.cc

Report("Shadow memory range interleaves with an existing memory mapping. "
            "ASan cannot proceed correctly. ABORTING.\n");
     DumpProcessMap();
     Die();
   }
 
   AsanTSDInit(PlatformTSDDtor);
   InstallDeadlySignalHandlers(AsanOnSIGSEGV);
 
-  InitializeAllocator(common_flags()->allocator_may_return_null,
-                      flags()->quarantine_size);
+  AllocatorOptions allocator_options;
+  allocator_options.SetFrom(flags(), common_flags());
+  InitializeAllocator(allocator_options);
 
   MaybeStartBackgroudThread();
 
   // On Linux AsanThread::ThreadStart() calls malloc() that's why asan_inited
   // should be set to 1 prior to initializing the threads.
   asan_inited = 1;
   asan_init_is_running = false;