compiler-rt/lib/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 "lsan/lsan_common.h"
  21 #include "sanitizer_common/sanitizer_allocator.h"
  22 #include "sanitizer_common/sanitizer_allocator_checks.h"
  23 #include "sanitizer_common/sanitizer_allocator_interface.h"
  24 #include "sanitizer_common/sanitizer_allocator_report.h"
  25 #include "sanitizer_common/sanitizer_common.h"
  26 #include "sanitizer_common/sanitizer_ring_buffer.h"
  27
  28 #if !defined(__aarch64__) && !defined(__x86_64__) && !(SANITIZER_RISCV64)
  29 #  error Unsupported platform
  30 #endif
  31
  32 namespace __hwasan {
  33
  34 struct Metadata {
  35  private:
  36   atomic_uint64_t alloc_context_id;
  37   u32 requested_size_low;
  38   u16 requested_size_high;
  39   atomic_uint8_t chunk_state;
  40   u8 lsan_tag;
  41
  42  public:
  43   inline void SetAllocated(u32 stack, u64 size);
  44   inline void SetUnallocated();
  45
  46   inline bool IsAllocated() const;
  47   inline u64 GetRequestedSize() const;
  48   inline u32 GetAllocStackId() const;
  49   inline u32 GetAllocThreadId() const;
  50   inline void SetLsanTag(__lsan::ChunkTag tag);
  51   inline __lsan::ChunkTag GetLsanTag() const;
  52 };
  53 static_assert(sizeof(Metadata) == 16);
  54
  55 struct HwasanMapUnmapCallback {
  56   void OnMap(uptr p, uptr size) const { UpdateMemoryUsage(); }
  57   void OnMapSecondary(uptr p, uptr size, uptr user_begin,
  58                       uptr user_size) const {
  59     UpdateMemoryUsage();
  60   }
  61   void OnUnmap(uptr p, uptr size) const {
  62     // We are about to unmap a chunk of user memory.
  63     // It can return as user-requested mmap() or another thread stack.
  64     // Make it accessible with zero-tagged pointer.
  65     TagMemory(p, size, 0);
  66   }
  67 };
  68
  69 static const uptr kMaxAllowedMallocSize = 1UL << 40;  // 1T
  70
  71 struct AP64 {
  72   static const uptr kSpaceBeg = ~0ULL;
  73
  74 #if defined(HWASAN_ALIASING_MODE)
  75   static const uptr kSpaceSize = 1ULL << kAddressTagShift;
  76   typedef __sanitizer::DefaultSizeClassMap SizeClassMap;
  77 #elif SANITIZER_LINUX && !SANITIZER_ANDROID
  78   static const uptr kSpaceSize = 0x40000000000ULL;  // 4T.
  79   typedef __sanitizer::DefaultSizeClassMap SizeClassMap;
  80 #else
  81   static const uptr kSpaceSize = 0x2000000000ULL;  // 128G.
  82   typedef __sanitizer::VeryDenseSizeClassMap SizeClassMap;
  83 #endif
  84
  85   static const uptr kMetadataSize = sizeof(Metadata);
  86   using AddressSpaceView = LocalAddressSpaceView;
  87   typedef HwasanMapUnmapCallback MapUnmapCallback;
  88   static const uptr kFlags = 0;
  89 };
  90
  91 typedef SizeClassAllocator64<AP64> PrimaryAllocator;
  92 typedef CombinedAllocator<PrimaryAllocator> Allocator;
  93 typedef Allocator::AllocatorCache AllocatorCache;
  94
  95 void AllocatorThreadStart(AllocatorCache *cache);
  96 void AllocatorThreadFinish(AllocatorCache *cache);
  97
  98 class HwasanChunkView {
  99  public:
 100   HwasanChunkView() : block_(0), metadata_(nullptr) {}
 101   HwasanChunkView(uptr block, Metadata *metadata)
 102       : block_(block), metadata_(metadata) {}
 103   bool IsAllocated() const;    // Checks if the memory is currently allocated
 104   uptr Beg() const;            // First byte of user memory
 105   uptr End() const;            // Last byte of user memory
 106   uptr UsedSize() const;       // Size requested by the user
 107   uptr ActualSize() const;     // Size allocated by the allocator.
 108   u32 GetAllocStackId() const;
 109   u32 GetAllocThreadId() const;
 110   bool FromSmallHeap() const;
 111   bool AddrIsInside(uptr addr) const;
 112
 113  private:
 114   friend class __lsan::LsanMetadata;
 115   uptr block_;
 116   Metadata *const metadata_;
 117 };
 118
 119 HwasanChunkView FindHeapChunkByAddress(uptr address);
 120
 121 // Information about one (de)allocation that happened in the past.
 122 // These are recorded in a thread-local ring buffer.
 123 struct HeapAllocationRecord {
 124   uptr tagged_addr;
 125   u32 alloc_thread_id;
 126   u32 alloc_context_id;
 127   u32 free_context_id;
 128   u32 requested_size;
 129 };
 130
 131 typedef RingBuffer<HeapAllocationRecord> HeapAllocationsRingBuffer;
 132
 133 void GetAllocatorStats(AllocatorStatCounters s);
 134
 135 } // namespace __hwasan
 136
 137 #endif // HWASAN_ALLOCATOR_H