libsanitizer/lsan/lsan_allocator.cc

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