libsanitizer/hwasan/hwasan_allocator.h

   1 //===-- hwasan_allocator.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 // This file is a part of HWAddressSanitizer.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef HWASAN_ALLOCATOR_H
  14 #define HWASAN_ALLOCATOR_H
  15
  16 #include "hwasan.h"
  17 #include "hwasan_interface_internal.h"
  18 #include "hwasan_mapping.h"
  19 #include "hwasan_poisoning.h"
  20 #include "sanitizer_common/sanitizer_allocator.h"
  21 #include "sanitizer_common/sanitizer_allocator_checks.h"
  22 #include "sanitizer_common/sanitizer_allocator_interface.h"
  23 #include "sanitizer_common/sanitizer_allocator_report.h"
  24 #include "sanitizer_common/sanitizer_common.h"
  25 #include "sanitizer_common/sanitizer_ring_buffer.h"
  26
  27 #if !defined(__aarch64__) && !defined(__x86_64__) && !(SANITIZER_RISCV64)
  28 #  error Unsupported platform
  29 #endif
  30
  31 namespace __hwasan {
  32
  33 struct Metadata {
  34   u32 requested_size_low;
  35   u32 requested_size_high : 31;
  36   u32 right_aligned : 1;
  37   u32 alloc_context_id;
  38   u64 get_requested_size() {
  39     return (static_cast<u64>(requested_size_high) << 32) + requested_size_low;
  40   }
  41   void set_requested_size(u64 size) {
  42     requested_size_low = size & ((1ul << 32) - 1);
  43     requested_size_high = size >> 32;
  44   }
  45 };
  46
  47 struct HwasanMapUnmapCallback {
  48   void OnMap(uptr p, uptr size) const { UpdateMemoryUsage(); }
  49   void OnUnmap(uptr p, uptr size) const {
  50     // We are about to unmap a chunk of user memory.
  51     // It can return as user-requested mmap() or another thread stack.
  52     // Make it accessible with zero-tagged pointer.
  53     TagMemory(p, size, 0);
  54   }
  55 };
  56
  57 static const uptr kMaxAllowedMallocSize = 1UL << 40;  // 1T
  58
  59 struct AP64 {
  60   static const uptr kSpaceBeg = ~0ULL;
  61
  62 #if defined(HWASAN_ALIASING_MODE)
  63   static const uptr kSpaceSize = 1ULL << kAddressTagShift;
  64 #else
  65   static const uptr kSpaceSize = 0x2000000000ULL;
  66 #endif
  67   static const uptr kMetadataSize = sizeof(Metadata);
  68   typedef __sanitizer::VeryDenseSizeClassMap SizeClassMap;
  69   using AddressSpaceView = LocalAddressSpaceView;
  70   typedef HwasanMapUnmapCallback MapUnmapCallback;
  71   static const uptr kFlags = 0;
  72 };
  73 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
  74 typedef CombinedAllocator<PrimaryAllocator> Allocator;
  75 typedef Allocator::AllocatorCache AllocatorCache;
  76
  77 void AllocatorSwallowThreadLocalCache(AllocatorCache *cache);
  78
  79 class HwasanChunkView {
  80  public:
  81   HwasanChunkView() : block_(0), metadata_(nullptr) {}
  82   HwasanChunkView(uptr block, Metadata *metadata)
  83       : block_(block), metadata_(metadata) {}
  84   bool IsAllocated() const;    // Checks if the memory is currently allocated
  85   uptr Beg() const;            // First byte of user memory
  86   uptr End() const;            // Last byte of user memory
  87   uptr UsedSize() const;       // Size requested by the user
  88   uptr ActualSize() const;     // Size allocated by the allocator.
  89   u32 GetAllocStackId() const;
  90   bool FromSmallHeap() const;
  91  private:
  92   uptr block_;
  93   Metadata *const metadata_;
  94 };
  95
  96 HwasanChunkView FindHeapChunkByAddress(uptr address);
  97
  98 // Information about one (de)allocation that happened in the past.
  99 // These are recorded in a thread-local ring buffer.
 100 // TODO: this is currently 24 bytes (20 bytes + alignment).
 101 // Compress it to 16 bytes or extend it to be more useful.
 102 struct HeapAllocationRecord {
 103   uptr tagged_addr;
 104   u32  alloc_context_id;
 105   u32  free_context_id;
 106   u32  requested_size;
 107 };
 108
 109 typedef RingBuffer<HeapAllocationRecord> HeapAllocationsRingBuffer;
 110
 111 void GetAllocatorStats(AllocatorStatCounters s);
 112
 113 inline bool InTaggableRegion(uptr addr) {
 114 #if defined(HWASAN_ALIASING_MODE)
 115   // Aliases are mapped next to shadow so that the upper bits match the shadow
 116   // base.
 117   return (addr >> kTaggableRegionCheckShift) ==
 118          (GetShadowOffset() >> kTaggableRegionCheckShift);
 119 #endif
 120   return true;
 121 }
 122
 123 } // namespace __hwasan
 124
 125 #endif // HWASAN_ALLOCATOR_H