[sanitizer] Allow for the allocator "names" to be set by the tools

[cryptoad]

Summary

In the same spirit of SanitizerToolName, allow the Primary & Secondary
allocators to have names that can be set by the tools via PrimaryAllocatorName
and SecondaryAllocatorName.

Additionally, set a non-default name for Scudo.

lib/sanitizer_common/sanitizer_allocator.h

 #include "sanitizer_libc.h"
 #include "sanitizer_list.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_lfstack.h"
 #include "sanitizer_procmaps.h"
 
 namespace __sanitizer {
 
+// Allows the tools to name their allocations appropriately.
+extern const char *PrimaryAllocatorName;
+extern const char *SecondaryAllocatorName;
+
 // Since flags are immutable and allocator behavior can be changed at runtime
 // (unit tests or ASan on Android are some examples), allocator_may_return_null
 // flag value is cached here and can be altered later.
 bool AllocatorMayReturnNull();
 void SetAllocatorMayReturnNull(bool may_return_null);
 
 // Allocator failure handling policies:
 // Implements AllocatorMayReturnNull policy, returns null when the flag is set,

lib/sanitizer_common/sanitizer_allocator.cc

 
 #include "sanitizer_allocator_checks.h"
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_atomic.h"
 #include "sanitizer_common.h"
 
 namespace __sanitizer {
 
+// Default allocator names.
+const char *PrimaryAllocatorName = "SizeClassAllocator";
+const char *SecondaryAllocatorName = "LargeMmapAllocator";
+
 // ThreadSanitizer for Go uses libc malloc/free.
 #if SANITIZER_GO || defined(SANITIZER_USE_MALLOC)
 # if SANITIZER_LINUX && !SANITIZER_ANDROID
 extern "C" void *__libc_malloc(uptr size);
 #  if !SANITIZER_GO
 extern "C" void *__libc_memalign(uptr alignment, uptr size);
 #  endif
 extern "C" void *__libc_realloc(void *ptr, uptr size);

lib/sanitizer_common/sanitizer_allocator_primary32.h

void SetReleaseToOSIntervalMs(s32 release_to_os_interval_ms) {
     // This is empty here. Currently only implemented in 64-bit allocator.
   }
 
   void ForceReleaseToOS() {
     // Currently implemented in 64-bit allocator only.
   }
 
   void *MapWithCallback(uptr size) {
-    void *res = MmapOrDie(size, "SizeClassAllocator32");
+    void *res = MmapOrDie(size, PrimaryAllocatorName);
     MapUnmapCallback().OnMap((uptr)res, size);
     return res;
   }
 
   void UnmapWithCallback(uptr beg, uptr size) {
     MapUnmapCallback().OnUnmap(beg, size);
     UnmapOrDie(reinterpret_cast<void *>(beg), size);
   }
private:
 
   uptr ComputeRegionBeg(uptr mem) {
     return mem & ~(kRegionSize - 1);
   }
 
   uptr AllocateRegion(AllocatorStats *stat, uptr class_id) {
     CHECK_LT(class_id, kNumClasses);
     uptr res = reinterpret_cast<uptr>(MmapAlignedOrDieOnFatalError(
-        kRegionSize, kRegionSize, "SizeClassAllocator32"));
+        kRegionSize, kRegionSize, PrimaryAllocatorName));
     if (UNLIKELY(!res))
       return 0;
     MapUnmapCallback().OnMap(res, kRegionSize);
     stat->Add(AllocatorStatMapped, kRegionSize);
     CHECK(IsAligned(res, kRegionSize));
     possible_regions.set(ComputeRegionId(res), static_cast<u8>(class_id));
     return res;
   }

lib/sanitizer_common/sanitizer_allocator_primary64.h

public:
   }
   uptr CompactPtrToPointer(uptr base, CompactPtrT ptr32) const {
     return base + (static_cast<uptr>(ptr32) << kCompactPtrScale);
   }
 
   void Init(s32 release_to_os_interval_ms) {
     uptr TotalSpaceSize = kSpaceSize + AdditionalSize();
     if (kUsingConstantSpaceBeg) {
-      CHECK_EQ(kSpaceBeg, address_range.Init(TotalSpaceSize, AllocatorName(),
-                                             kSpaceBeg));
+      CHECK_EQ(kSpaceBeg, address_range.Init(TotalSpaceSize,
+                                             PrimaryAllocatorName, kSpaceBeg));
     } else {
-      NonConstSpaceBeg = address_range.Init(TotalSpaceSize, AllocatorName());
+      NonConstSpaceBeg = address_range.Init(TotalSpaceSize,
+                                            PrimaryAllocatorName);
       CHECK_NE(NonConstSpaceBeg, ~(uptr)0);
     }
     SetReleaseToOSIntervalMs(release_to_os_interval_ms);
     MapWithCallbackOrDie(SpaceEnd(), AdditionalSize());
     // Check that the RegionInfo array is aligned on the CacheLine size.
     DCHECK_EQ(SpaceEnd() % kCacheLineSize, 0);
   }
 
static void ReleaseFreeMemoryToOS(CompactPtrT *free_array,
     }
     range_tracker.Done();
   }
 
  private:
   friend class MemoryMapper;
 
   ReservedAddressRange address_range;
-  static const char *AllocatorName() { return "sanitizer_allocator"; }
 
   static const uptr kRegionSize = kSpaceSize / kNumClassesRounded;
   // FreeArray is the array of free-d chunks (stored as 4-byte offsets).
   // In the worst case it may reguire kRegionSize/SizeClassMap::kMinSize
   // elements, but in reality this will not happen. For simplicity we
   // dedicate 1/8 of the region's virtual space to FreeArray.
   static const uptr kFreeArraySize = kRegionSize / 8;
 

lib/sanitizer_common/sanitizer_allocator_secondary.h

 // Much less restricted LargeMmapAllocator chunks list (comparing to
 // PtrArrayStatic). Backed by mmaped memory region and can hold up to 1M chunks.
 // ReservedAddressRange was used instead of just MAP_NORESERVE to achieve the
 // same functionality in Fuchsia case, which does not support MAP_NORESERVE.
 class LargeMmapAllocatorPtrArrayDynamic {
  public:
   INLINE void *Init() {
     uptr p = address_range_.Init(kMaxNumChunks * sizeof(uptr),
-                                 "sanitizer_large_allocator");
+                                 SecondaryAllocatorName);
     CHECK(p);
     return reinterpret_cast<void*>(p);
   }
 
   INLINE void EnsureSpace(uptr n) {
     CHECK_LT(n, kMaxNumChunks);
     DCHECK(n <= n_reserved_);
     if (UNLIKELY(n == n_reserved_)) {
void *Allocate(AllocatorStats *stat, uptr size, uptr alignment) {
     // Overflow.
     if (map_size < size) {
       Report("WARNING: %s: LargeMmapAllocator allocation overflow: "
              "0x%zx bytes with 0x%zx alignment requested\n",
              SanitizerToolName, map_size, alignment);
       return nullptr;
     }
     uptr map_beg = reinterpret_cast<uptr>(
-        MmapOrDieOnFatalError(map_size, "LargeMmapAllocator"));
+        MmapOrDieOnFatalError(map_size, SecondaryAllocatorName));
     if (!map_beg)
       return nullptr;
     CHECK(IsAligned(map_beg, page_size_));
     MapUnmapCallback().OnMap(map_beg, map_size);
     uptr map_end = map_beg + map_size;
     uptr res = map_beg + page_size_;
     if (res & (alignment - 1))  // Align.
       res += alignment - (res & (alignment - 1));

lib/scudo/scudo_allocator.cpp

NOINLINE void performSanityChecks() {
     const uptr LargestClassId = SizeClassMap::kLargestClassID;
     Header.ClassId = LargestClassId;
     if (Header.ClassId != LargestClassId)
       dieWithMessage("largest class ID doesn't fit in header\n");
   }
 
   void init() {
     SanitizerToolName = "Scudo";
+    PrimaryAllocatorName = "ScudoPrimary";
+    SecondaryAllocatorName = "ScudoSecondary";
+
     initFlags();
 
     performSanityChecks();
 
     // Check if hardware CRC32 is supported in the binary and by the platform,
     // if so, opt for the CRC32 hardware version of the checksum.
     if (&computeHardwareCRC32 && hasHardwareCRC32())
       atomic_store_relaxed(&HashAlgorithm, CRC32Hardware);

lib/scudo/scudo_allocator_secondary.h

void *Allocate(AllocatorStats *Stats, uptr Size, uptr Alignment) {
     if (UNLIKELY(Alignment > MinAlignment))
       ReservedSize += Alignment;
     const uptr PageSize = GetPageSizeCached();
     ReservedSize = RoundUpTo(ReservedSize, PageSize);
     // Account for 2 guard pages, one before and one after the chunk.
     ReservedSize += 2 * PageSize;
 
     ReservedAddressRange AddressRange;
-    uptr ReservedBeg = AddressRange.Init(ReservedSize);
+    uptr ReservedBeg = AddressRange.Init(ReservedSize, SecondaryAllocatorName);
     if (UNLIKELY(ReservedBeg == ~static_cast<uptr>(0)))
       return ReturnNullOrDieOnFailure::OnOOM();
     // A page-aligned pointer is assumed after that, so check it now.
     DCHECK(IsAligned(ReservedBeg, PageSize));
     uptr ReservedEnd = ReservedBeg + ReservedSize;
     // The beginning of the user area for that allocation comes after the
     // initial guard page, and both headers. This is the pointer that has to
     // abide by alignment requirements.