contrib/compiler-rt/lib/lsan/lsan_allocator.cc

   1 //=-- lsan_allocator.cc ---------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is a part of LeakSanitizer.
  11 // See lsan_allocator.h for details.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "lsan_allocator.h"
  16
  17 #include "sanitizer_common/sanitizer_allocator.h"
  18 #include "sanitizer_common/sanitizer_allocator_interface.h"
  19 #include "sanitizer_common/sanitizer_internal_defs.h"
  20 #include "sanitizer_common/sanitizer_stackdepot.h"
  21 #include "sanitizer_common/sanitizer_stacktrace.h"
  22 #include "lsan_common.h"
  23
  24 extern "C" void *memset(void *ptr, int value, uptr num);
  25
  26 namespace __lsan {
  27
  28 struct ChunkMetadata {
  29   u8 allocated : 8;  // Must be first.
  30   ChunkTag tag : 2;
  31   uptr requested_size : 54;
  32   u32 stack_trace_id;
  33 };
  34
  35 #if defined(__mips64) || defined(__aarch64__)
  36 static const uptr kMaxAllowedMallocSize = 4UL << 30;
  37 static const uptr kRegionSizeLog = 20;
  38 static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
  39 typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
  40 typedef CompactSizeClassMap SizeClassMap;
  41 typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE,
  42     sizeof(ChunkMetadata), SizeClassMap, kRegionSizeLog, ByteMap>
  43     PrimaryAllocator;
  44 #else
  45 static const uptr kMaxAllowedMallocSize = 8UL << 30;
  46 static const uptr kAllocatorSpace = 0x600000000000ULL;
  47 static const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
  48 typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize,
  49         sizeof(ChunkMetadata), DefaultSizeClassMap> PrimaryAllocator;
  50 #endif
  51 typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
  52 typedef LargeMmapAllocator<> SecondaryAllocator;
  53 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
  54           SecondaryAllocator> Allocator;
  55
  56 static Allocator allocator;
  57 static THREADLOCAL AllocatorCache cache;
  58
  59 void InitializeAllocator() {
  60   allocator.InitLinkerInitialized(common_flags()->allocator_may_return_null);
  61 }
  62
  63 void AllocatorThreadFinish() {
  64   allocator.SwallowCache(&cache);
  65 }
  66
  67 static ChunkMetadata *Metadata(const void *p) {
  68   return reinterpret_cast<ChunkMetadata *>(allocator.GetMetaData(p));
  69 }
  70
  71 static void RegisterAllocation(const StackTrace &stack, void *p, uptr size) {
  72   if (!p) return;
  73   ChunkMetadata *m = Metadata(p);
  74   CHECK(m);
  75   m->tag = DisabledInThisThread() ? kIgnored : kDirectlyLeaked;
  76   m->stack_trace_id = StackDepotPut(stack);
  77   m->requested_size = size;
  78   atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 1, memory_order_relaxed);
  79 }
  80
  81 static void RegisterDeallocation(void *p) {
  82   if (!p) return;
  83   ChunkMetadata *m = Metadata(p);
  84   CHECK(m);
  85   atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 0, memory_order_relaxed);
  86 }
  87
  88 void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
  89                bool cleared) {
  90   if (size == 0)
  91     size = 1;
  92   if (size > kMaxAllowedMallocSize) {
  93     Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", size);
  94     return nullptr;
  95   }
  96   void *p = allocator.Allocate(&cache, size, alignment, false);
  97   // Do not rely on the allocator to clear the memory (it's slow).
  98   if (cleared && allocator.FromPrimary(p))
  99     memset(p, 0, size);
 100   RegisterAllocation(stack, p, size);
 101   if (&__sanitizer_malloc_hook) __sanitizer_malloc_hook(p, size);
 102   return p;
 103 }
 104
 105 void Deallocate(void *p) {
 106   if (&__sanitizer_free_hook) __sanitizer_free_hook(p);
 107   RegisterDeallocation(p);
 108   allocator.Deallocate(&cache, p);
 109 }
 110
 111 void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
 112                  uptr alignment) {
 113   RegisterDeallocation(p);
 114   if (new_size > kMaxAllowedMallocSize) {
 115     Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", new_size);
 116     allocator.Deallocate(&cache, p);
 117     return nullptr;
 118   }
 119   p = allocator.Reallocate(&cache, p, new_size, alignment);
 120   RegisterAllocation(stack, p, new_size);
 121   return p;
 122 }
 123
 124 void GetAllocatorCacheRange(uptr *begin, uptr *end) {
 125   *begin = (uptr)&cache;
 126   *end = *begin + sizeof(cache);
 127 }
 128
 129 uptr GetMallocUsableSize(const void *p) {
 130   ChunkMetadata *m = Metadata(p);
 131   if (!m) return 0;
 132   return m->requested_size;
 133 }
 134
 135 ///// Interface to the common LSan module. /////
 136
 137 void LockAllocator() {
 138   allocator.ForceLock();
 139 }
 140
 141 void UnlockAllocator() {
 142   allocator.ForceUnlock();
 143 }
 144
 145 void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
 146   *begin = (uptr)&allocator;
 147   *end = *begin + sizeof(allocator);
 148 }
 149
 150 uptr PointsIntoChunk(void* p) {
 151   uptr addr = reinterpret_cast<uptr>(p);
 152   uptr chunk = reinterpret_cast<uptr>(allocator.GetBlockBeginFastLocked(p));
 153   if (!chunk) return 0;
 154   // LargeMmapAllocator considers pointers to the meta-region of a chunk to be
 155   // valid, but we don't want that.
 156   if (addr < chunk) return 0;
 157   ChunkMetadata *m = Metadata(reinterpret_cast<void *>(chunk));
 158   CHECK(m);
 159   if (!m->allocated)
 160     return 0;
 161   if (addr < chunk + m->requested_size)
 162     return chunk;
 163   if (IsSpecialCaseOfOperatorNew0(chunk, m->requested_size, addr))
 164     return chunk;
 165   return 0;
 166 }
 167
 168 uptr GetUserBegin(uptr chunk) {
 169   return chunk;
 170 }
 171
 172 LsanMetadata::LsanMetadata(uptr chunk) {
 173   metadata_ = Metadata(reinterpret_cast<void *>(chunk));
 174   CHECK(metadata_);
 175 }
 176
 177 bool LsanMetadata::allocated() const {
 178   return reinterpret_cast<ChunkMetadata *>(metadata_)->allocated;
 179 }
 180
 181 ChunkTag LsanMetadata::tag() const {
 182   return reinterpret_cast<ChunkMetadata *>(metadata_)->tag;
 183 }
 184
 185 void LsanMetadata::set_tag(ChunkTag value) {
 186   reinterpret_cast<ChunkMetadata *>(metadata_)->tag = value;
 187 }
 188
 189 uptr LsanMetadata::requested_size() const {
 190   return reinterpret_cast<ChunkMetadata *>(metadata_)->requested_size;
 191 }
 192
 193 u32 LsanMetadata::stack_trace_id() const {
 194   return reinterpret_cast<ChunkMetadata *>(metadata_)->stack_trace_id;
 195 }
 196
 197 void ForEachChunk(ForEachChunkCallback callback, void *arg) {
 198   allocator.ForEachChunk(callback, arg);
 199 }
 200
 201 IgnoreObjectResult IgnoreObjectLocked(const void *p) {
 202   void *chunk = allocator.GetBlockBegin(p);
 203   if (!chunk || p < chunk) return kIgnoreObjectInvalid;
 204   ChunkMetadata *m = Metadata(chunk);
 205   CHECK(m);
 206   if (m->allocated && (uptr)p < (uptr)chunk + m->requested_size) {
 207     if (m->tag == kIgnored)
 208       return kIgnoreObjectAlreadyIgnored;
 209     m->tag = kIgnored;
 210     return kIgnoreObjectSuccess;
 211   } else {
 212     return kIgnoreObjectInvalid;
 213   }
 214 }
 215 } // namespace __lsan
 216
 217 using namespace __lsan;
 218
 219 extern "C" {
 220 SANITIZER_INTERFACE_ATTRIBUTE
 221 uptr __sanitizer_get_current_allocated_bytes() {
 222   uptr stats[AllocatorStatCount];
 223   allocator.GetStats(stats);
 224   return stats[AllocatorStatAllocated];
 225 }
 226
 227 SANITIZER_INTERFACE_ATTRIBUTE
 228 uptr __sanitizer_get_heap_size() {
 229   uptr stats[AllocatorStatCount];
 230   allocator.GetStats(stats);
 231   return stats[AllocatorStatMapped];
 232 }
 233
 234 SANITIZER_INTERFACE_ATTRIBUTE
 235 uptr __sanitizer_get_free_bytes() { return 0; }
 236
 237 SANITIZER_INTERFACE_ATTRIBUTE
 238 uptr __sanitizer_get_unmapped_bytes() { return 0; }
 239
 240 SANITIZER_INTERFACE_ATTRIBUTE
 241 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 242
 243 SANITIZER_INTERFACE_ATTRIBUTE
 244 int __sanitizer_get_ownership(const void *p) { return Metadata(p) != nullptr; }
 245
 246 SANITIZER_INTERFACE_ATTRIBUTE
 247 uptr __sanitizer_get_allocated_size(const void *p) {
 248   return GetMallocUsableSize(p);
 249 }
 250 } // extern "C"