compiler-rt/lib/sanitizer_common/sanitizer_allocator_combined.h

   1 //===-- sanitizer_allocator_combined.h --------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Part of the Sanitizer Allocator.
  10 //
  11 //===----------------------------------------------------------------------===//
  12 #ifndef SANITIZER_ALLOCATOR_H
  13 #error This file must be included inside sanitizer_allocator.h
  14 #endif
  15
  16 // This class implements a complete memory allocator by using two
  17 // internal allocators:
  18 // PrimaryAllocator is efficient, but may not allocate some sizes (alignments).
  19 //  When allocating 2^x bytes it should return 2^x aligned chunk.
  20 // PrimaryAllocator is used via a local AllocatorCache.
  21 // SecondaryAllocator can allocate anything, but is not efficient.
  22 template <class PrimaryAllocator,
  23           class LargeMmapAllocatorPtrArray = DefaultLargeMmapAllocatorPtrArray>
  24 class CombinedAllocator {
  25  public:
  26   using AllocatorCache = typename PrimaryAllocator::AllocatorCache;
  27   using SecondaryAllocator =
  28       LargeMmapAllocator<typename PrimaryAllocator::MapUnmapCallback,
  29                          LargeMmapAllocatorPtrArray,
  30                          typename PrimaryAllocator::AddressSpaceView>;
  31
  32   void InitLinkerInitialized(s32 release_to_os_interval_ms,
  33                              uptr heap_start = 0) {
  34     primary_.Init(release_to_os_interval_ms, heap_start);
  35     secondary_.InitLinkerInitialized();
  36   }
  37
  38   void Init(s32 release_to_os_interval_ms, uptr heap_start = 0) {
  39     stats_.Init();
  40     primary_.Init(release_to_os_interval_ms, heap_start);
  41     secondary_.Init();
  42   }
  43
  44   void *Allocate(AllocatorCache *cache, uptr size, uptr alignment) {
  45     // Returning 0 on malloc(0) may break a lot of code.
  46     if (size == 0)
  47       size = 1;
  48     if (size + alignment < size) {
  49       Report("WARNING: %s: CombinedAllocator allocation overflow: "
  50              "0x%zx bytes with 0x%zx alignment requested\n",
  51              SanitizerToolName, size, alignment);
  52       return nullptr;
  53     }
  54     uptr original_size = size;
  55     // If alignment requirements are to be fulfilled by the frontend allocator
  56     // rather than by the primary or secondary, passing an alignment lower than
  57     // or equal to 8 will prevent any further rounding up, as well as the later
  58     // alignment check.
  59     if (alignment > 8)
  60       size = RoundUpTo(size, alignment);
  61     // The primary allocator should return a 2^x aligned allocation when
  62     // requested 2^x bytes, hence using the rounded up 'size' when being
  63     // serviced by the primary (this is no longer true when the primary is
  64     // using a non-fixed base address). The secondary takes care of the
  65     // alignment without such requirement, and allocating 'size' would use
  66     // extraneous memory, so we employ 'original_size'.
  67     void *res;
  68     if (primary_.CanAllocate(size, alignment))
  69       res = cache->Allocate(&primary_, primary_.ClassID(size));
  70     else
  71       res = secondary_.Allocate(&stats_, original_size, alignment);
  72     if (alignment > 8)
  73       CHECK_EQ(reinterpret_cast<uptr>(res) & (alignment - 1), 0);
  74     return res;
  75   }
  76
  77   s32 ReleaseToOSIntervalMs() const {
  78     return primary_.ReleaseToOSIntervalMs();
  79   }
  80
  81   void SetReleaseToOSIntervalMs(s32 release_to_os_interval_ms) {
  82     primary_.SetReleaseToOSIntervalMs(release_to_os_interval_ms);
  83   }
  84
  85   void ForceReleaseToOS() {
  86     primary_.ForceReleaseToOS();
  87   }
  88
  89   void Deallocate(AllocatorCache *cache, void *p) {
  90     if (!p) return;
  91     if (primary_.PointerIsMine(p))
  92       cache->Deallocate(&primary_, primary_.GetSizeClass(p), p);
  93     else
  94       secondary_.Deallocate(&stats_, p);
  95   }
  96
  97   void *Reallocate(AllocatorCache *cache, void *p, uptr new_size,
  98                    uptr alignment) {
  99     if (!p)
 100       return Allocate(cache, new_size, alignment);
 101     if (!new_size) {
 102       Deallocate(cache, p);
 103       return nullptr;
 104     }
 105     CHECK(PointerIsMine(p));
 106     uptr old_size = GetActuallyAllocatedSize(p);
 107     uptr memcpy_size = Min(new_size, old_size);
 108     void *new_p = Allocate(cache, new_size, alignment);
 109     if (new_p)
 110       internal_memcpy(new_p, p, memcpy_size);
 111     Deallocate(cache, p);
 112     return new_p;
 113   }
 114
 115   bool PointerIsMine(const void *p) const {
 116     if (primary_.PointerIsMine(p))
 117       return true;
 118     return secondary_.PointerIsMine(p);
 119   }
 120
 121   bool FromPrimary(const void *p) const { return primary_.PointerIsMine(p); }
 122
 123   void *GetMetaData(const void *p) {
 124     if (primary_.PointerIsMine(p))
 125       return primary_.GetMetaData(p);
 126     return secondary_.GetMetaData(p);
 127   }
 128
 129   void *GetBlockBegin(const void *p) {
 130     if (primary_.PointerIsMine(p))
 131       return primary_.GetBlockBegin(p);
 132     return secondary_.GetBlockBegin(p);
 133   }
 134
 135   // This function does the same as GetBlockBegin, but is much faster.
 136   // Must be called with the allocator locked.
 137   void *GetBlockBeginFastLocked(const void *p) {
 138     if (primary_.PointerIsMine(p))
 139       return primary_.GetBlockBegin(p);
 140     return secondary_.GetBlockBeginFastLocked(p);
 141   }
 142
 143   uptr GetActuallyAllocatedSize(void *p) {
 144     if (primary_.PointerIsMine(p))
 145       return primary_.GetActuallyAllocatedSize(p);
 146     return secondary_.GetActuallyAllocatedSize(p);
 147   }
 148
 149   uptr TotalMemoryUsed() {
 150     return primary_.TotalMemoryUsed() + secondary_.TotalMemoryUsed();
 151   }
 152
 153   void TestOnlyUnmap() { primary_.TestOnlyUnmap(); }
 154
 155   void InitCache(AllocatorCache *cache) {
 156     cache->Init(&stats_);
 157   }
 158
 159   void DestroyCache(AllocatorCache *cache) {
 160     cache->Destroy(&primary_, &stats_);
 161   }
 162
 163   void SwallowCache(AllocatorCache *cache) {
 164     cache->Drain(&primary_);
 165   }
 166
 167   void GetStats(AllocatorStatCounters s) const {
 168     stats_.Get(s);
 169   }
 170
 171   void PrintStats() {
 172     primary_.PrintStats();
 173     secondary_.PrintStats();
 174   }
 175
 176   // ForceLock() and ForceUnlock() are needed to implement Darwin malloc zone
 177   // introspection API.
 178   void ForceLock() SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
 179     primary_.ForceLock();
 180     secondary_.ForceLock();
 181   }
 182
 183   void ForceUnlock() SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
 184     secondary_.ForceUnlock();
 185     primary_.ForceUnlock();
 186   }
 187
 188   // Iterate over all existing chunks.
 189   // The allocator must be locked when calling this function.
 190   void ForEachChunk(ForEachChunkCallback callback, void *arg) {
 191     primary_.ForEachChunk(callback, arg);
 192     secondary_.ForEachChunk(callback, arg);
 193   }
 194
 195  private:
 196   PrimaryAllocator primary_;
 197   SecondaryAllocator secondary_;
 198   AllocatorGlobalStats stats_;
 199 };