1 //=-- lsan_allocator.h ----------------------------------------------------===//
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 LeakSanitizer.
10 // Allocator for standalone LSan.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LSAN_ALLOCATOR_H
15 #define LSAN_ALLOCATOR_H
16 
17 #include "sanitizer_common/sanitizer_allocator.h"
18 #include "sanitizer_common/sanitizer_common.h"
19 #include "sanitizer_common/sanitizer_internal_defs.h"
20 #include "lsan_common.h"
21 
22 namespace __lsan {
23 
24 void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
25                bool cleared);
26 void Deallocate(void *p);
27 void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
28                  uptr alignment);
29 uptr GetMallocUsableSize(const void *p);
30 
31 template<typename Callable>
32 void ForEachChunk(const Callable &callback);
33 
34 void GetAllocatorCacheRange(uptr *begin, uptr *end);
35 void AllocatorThreadStart();
36 void AllocatorThreadFinish();
37 void InitializeAllocator();
38 
39 const bool kAlwaysClearMemory = true;
40 
41 struct ChunkMetadata {
42   u8 allocated : 8;  // Must be first.
43   ChunkTag tag : 2;
44 #if SANITIZER_WORDSIZE == 64
45   uptr requested_size : 54;
46 #else
47   uptr requested_size : 32;
48   uptr padding : 22;
49 #endif
50   u32 stack_trace_id;
51 };
52 
53 #if !SANITIZER_CAN_USE_ALLOCATOR64
54 template <typename AddressSpaceViewTy>
55 struct AP32 {
56   static const uptr kSpaceBeg = 0;
57   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
58   static const uptr kMetadataSize = sizeof(ChunkMetadata);
59   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
60   static const uptr kRegionSizeLog = 20;
61   using AddressSpaceView = AddressSpaceViewTy;
62   typedef NoOpMapUnmapCallback MapUnmapCallback;
63   static const uptr kFlags = 0;
64 };
65 template <typename AddressSpaceView>
66 using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView>>;
67 using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
68 #else
69 # if SANITIZER_FUCHSIA || defined(__powerpc64__)
70 const uptr kAllocatorSpace = ~(uptr)0;
71 #    if SANITIZER_RISCV64
72 // See the comments in compiler-rt/lib/asan/asan_allocator.h for why these
73 // values were chosen.
74 const uptr kAllocatorSize = UINT64_C(1) << 33;  // 8GB
75 using LSanSizeClassMap = SizeClassMap</*kNumBits=*/2,
76                                       /*kMinSizeLog=*/5,
77                                       /*kMidSizeLog=*/8,
78                                       /*kMaxSizeLog=*/18,
79                                       /*kNumCachedHintT=*/8,
80                                       /*kMaxBytesCachedLog=*/10>;
81 static_assert(LSanSizeClassMap::kNumClassesRounded <= 32,
82               "32 size classes is the optimal number to ensure tests run "
83               "effieciently on Fuchsia.");
84 #    else
85 const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
86 using LSanSizeClassMap = DefaultSizeClassMap;
87 #    endif
88 #  elif SANITIZER_RISCV64
89 const uptr kAllocatorSpace = ~(uptr)0;
90 const uptr kAllocatorSize = 0x2000000000ULL;  // 128G.
91 using LSanSizeClassMap = DefaultSizeClassMap;
92 #  elif SANITIZER_APPLE
93 const uptr kAllocatorSpace = 0x600000000000ULL;
94 const uptr kAllocatorSize  = 0x40000000000ULL;  // 4T.
95 using LSanSizeClassMap = DefaultSizeClassMap;
96 #  else
97 const uptr kAllocatorSpace = 0x500000000000ULL;
98 const uptr kAllocatorSize = 0x40000000000ULL;  // 4T.
99 using LSanSizeClassMap = DefaultSizeClassMap;
100 #  endif
101 template <typename AddressSpaceViewTy>
102 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
103   static const uptr kSpaceBeg = kAllocatorSpace;
104   static const uptr kSpaceSize = kAllocatorSize;
105   static const uptr kMetadataSize = sizeof(ChunkMetadata);
106   using SizeClassMap = LSanSizeClassMap;
107   typedef NoOpMapUnmapCallback MapUnmapCallback;
108   static const uptr kFlags = 0;
109   using AddressSpaceView = AddressSpaceViewTy;
110 };
111 
112 template <typename AddressSpaceView>
113 using PrimaryAllocatorASVT = SizeClassAllocator64<AP64<AddressSpaceView>>;
114 using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>;
115 #endif
116 
117 template <typename AddressSpaceView>
118 using AllocatorASVT = CombinedAllocator<PrimaryAllocatorASVT<AddressSpaceView>>;
119 using Allocator = AllocatorASVT<LocalAddressSpaceView>;
120 using AllocatorCache = Allocator::AllocatorCache;
121 
122 Allocator::AllocatorCache *GetAllocatorCache();
123 
124 int lsan_posix_memalign(void **memptr, uptr alignment, uptr size,
125                         const StackTrace &stack);
126 void *lsan_aligned_alloc(uptr alignment, uptr size, const StackTrace &stack);
127 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack);
128 void *lsan_malloc(uptr size, const StackTrace &stack);
129 void lsan_free(void *p);
130 void *lsan_realloc(void *p, uptr size, const StackTrace &stack);
131 void *lsan_reallocarray(void *p, uptr nmemb, uptr size,
132                         const StackTrace &stack);
133 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack);
134 void *lsan_valloc(uptr size, const StackTrace &stack);
135 void *lsan_pvalloc(uptr size, const StackTrace &stack);
136 uptr lsan_mz_size(const void *p);
137 
138 }  // namespace __lsan
139 
140 #endif  // LSAN_ALLOCATOR_H
141