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, tag: 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

source code of compiler-rt/lib/hwasan/hwasan_allocator.h