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
32namespace __hwasan {
33
34struct 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};
53static_assert(sizeof(Metadata) == 16);
54
55struct 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
69static const uptr kMaxAllowedMallocSize = 1UL << 40;  // 1T
70
71struct 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
91typedef SizeClassAllocator64<AP64> PrimaryAllocator;
92typedef CombinedAllocator<PrimaryAllocator> Allocator;
93typedef Allocator::AllocatorCache AllocatorCache;
94
95void AllocatorThreadStart(AllocatorCache *cache);
96void AllocatorThreadFinish(AllocatorCache *cache);
97
98class 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
119HwasanChunkView 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.
123struct 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
131typedef RingBuffer<HeapAllocationRecord> HeapAllocationsRingBuffer;
132
133void GetAllocatorStats(AllocatorStatCounters s);
134
135} // namespace __hwasan
136
137#endif // HWASAN_ALLOCATOR_H
138