1 //===-- common.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 #ifndef SCUDO_COMMON_H_
10 #define SCUDO_COMMON_H_
11
12 #include "internal_defs.h"
13
14 #include "fuchsia.h"
15 #include "linux.h"
16 #include "trusty.h"
17
18 #include <stddef.h>
19 #include <string.h>
20 #include <unistd.h>
21
22 namespace scudo {
23
bit_cast(const Source & S)24 template <class Dest, class Source> inline Dest bit_cast(const Source &S) {
25 static_assert(sizeof(Dest) == sizeof(Source), "");
26 Dest D;
27 memcpy(&D, &S, sizeof(D));
28 return D;
29 }
30
isPowerOfTwo(uptr X)31 inline constexpr bool isPowerOfTwo(uptr X) {
32 if (X == 0)
33 return false;
34 return (X & (X - 1)) == 0;
35 }
36
roundUp(uptr X,uptr Boundary)37 inline constexpr uptr roundUp(uptr X, uptr Boundary) {
38 DCHECK(isPowerOfTwo(Boundary));
39 return (X + Boundary - 1) & ~(Boundary - 1);
40 }
roundUpSlow(uptr X,uptr Boundary)41 inline constexpr uptr roundUpSlow(uptr X, uptr Boundary) {
42 return ((X + Boundary - 1) / Boundary) * Boundary;
43 }
44
roundDown(uptr X,uptr Boundary)45 inline constexpr uptr roundDown(uptr X, uptr Boundary) {
46 DCHECK(isPowerOfTwo(Boundary));
47 return X & ~(Boundary - 1);
48 }
roundDownSlow(uptr X,uptr Boundary)49 inline constexpr uptr roundDownSlow(uptr X, uptr Boundary) {
50 return (X / Boundary) * Boundary;
51 }
52
isAligned(uptr X,uptr Alignment)53 inline constexpr bool isAligned(uptr X, uptr Alignment) {
54 DCHECK(isPowerOfTwo(Alignment));
55 return (X & (Alignment - 1)) == 0;
56 }
isAlignedSlow(uptr X,uptr Alignment)57 inline constexpr bool isAlignedSlow(uptr X, uptr Alignment) {
58 return X % Alignment == 0;
59 }
60
Min(T A,T B)61 template <class T> constexpr T Min(T A, T B) { return A < B ? A : B; }
62
Max(T A,T B)63 template <class T> constexpr T Max(T A, T B) { return A > B ? A : B; }
64
Swap(T & A,T & B)65 template <class T> void Swap(T &A, T &B) {
66 T Tmp = A;
67 A = B;
68 B = Tmp;
69 }
70
getMostSignificantSetBitIndex(uptr X)71 inline uptr getMostSignificantSetBitIndex(uptr X) {
72 DCHECK_NE(X, 0U);
73 return SCUDO_WORDSIZE - 1U - static_cast<uptr>(__builtin_clzl(X));
74 }
75
roundUpPowerOfTwo(uptr Size)76 inline uptr roundUpPowerOfTwo(uptr Size) {
77 DCHECK(Size);
78 if (isPowerOfTwo(Size))
79 return Size;
80 const uptr Up = getMostSignificantSetBitIndex(Size);
81 DCHECK_LT(Size, (1UL << (Up + 1)));
82 DCHECK_GT(Size, (1UL << Up));
83 return 1UL << (Up + 1);
84 }
85
getLeastSignificantSetBitIndex(uptr X)86 inline uptr getLeastSignificantSetBitIndex(uptr X) {
87 DCHECK_NE(X, 0U);
88 return static_cast<uptr>(__builtin_ctzl(X));
89 }
90
getLog2(uptr X)91 inline uptr getLog2(uptr X) {
92 DCHECK(isPowerOfTwo(X));
93 return getLeastSignificantSetBitIndex(X);
94 }
95
getRandomU32(u32 * State)96 inline u32 getRandomU32(u32 *State) {
97 // ANSI C linear congruential PRNG (16-bit output).
98 // return (*State = *State * 1103515245 + 12345) >> 16;
99 // XorShift (32-bit output).
100 *State ^= *State << 13;
101 *State ^= *State >> 17;
102 *State ^= *State << 5;
103 return *State;
104 }
105
getRandomModN(u32 * State,u32 N)106 inline u32 getRandomModN(u32 *State, u32 N) {
107 return getRandomU32(State) % N; // [0, N)
108 }
109
shuffle(T * A,u32 N,u32 * RandState)110 template <typename T> inline void shuffle(T *A, u32 N, u32 *RandState) {
111 if (N <= 1)
112 return;
113 u32 State = *RandState;
114 for (u32 I = N - 1; I > 0; I--)
115 Swap(A[I], A[getRandomModN(&State, I + 1)]);
116 *RandState = State;
117 }
118
computePercentage(uptr Numerator,uptr Denominator,uptr * Integral,uptr * Fractional)119 inline void computePercentage(uptr Numerator, uptr Denominator, uptr *Integral,
120 uptr *Fractional) {
121 constexpr uptr Digits = 100;
122 if (Denominator == 0) {
123 *Integral = 100;
124 *Fractional = 0;
125 return;
126 }
127
128 *Integral = Numerator * Digits / Denominator;
129 *Fractional =
130 (((Numerator * Digits) % Denominator) * Digits + Denominator / 2) /
131 Denominator;
132 }
133
134 // Platform specific functions.
135
136 extern uptr PageSizeCached;
137 uptr getPageSizeSlow();
getPageSizeCached()138 inline uptr getPageSizeCached() {
139 #if SCUDO_ANDROID && defined(PAGE_SIZE)
140 // Most Android builds have a build-time constant page size.
141 return PAGE_SIZE;
142 #endif
143 if (LIKELY(PageSizeCached))
144 return PageSizeCached;
145 return getPageSizeSlow();
146 }
147
148 // Returns 0 if the number of CPUs could not be determined.
149 u32 getNumberOfCPUs();
150
151 const char *getEnv(const char *Name);
152
153 u64 getMonotonicTime();
154 // Gets the time faster but with less accuracy. Can call getMonotonicTime
155 // if no fast version is available.
156 u64 getMonotonicTimeFast();
157
158 u32 getThreadID();
159
160 // Our randomness gathering function is limited to 256 bytes to ensure we get
161 // as many bytes as requested, and avoid interruptions (on Linux).
162 constexpr uptr MaxRandomLength = 256U;
163 bool getRandom(void *Buffer, uptr Length, bool Blocking = false);
164
165 // Platform memory mapping functions.
166
167 #define MAP_ALLOWNOMEM (1U << 0)
168 #define MAP_NOACCESS (1U << 1)
169 #define MAP_RESIZABLE (1U << 2)
170 #define MAP_MEMTAG (1U << 3)
171 #define MAP_PRECOMMIT (1U << 4)
172
173 // Our platform memory mapping use is restricted to 3 scenarios:
174 // - reserve memory at a random address (MAP_NOACCESS);
175 // - commit memory in a previously reserved space;
176 // - commit memory at a random address.
177 // As such, only a subset of parameters combinations is valid, which is checked
178 // by the function implementation. The Data parameter allows to pass opaque
179 // platform specific data to the function.
180 // Returns nullptr on error or dies if MAP_ALLOWNOMEM is not specified.
181 void *map(void *Addr, uptr Size, const char *Name, uptr Flags = 0,
182 MapPlatformData *Data = nullptr);
183
184 // Indicates that we are getting rid of the whole mapping, which might have
185 // further consequences on Data, depending on the platform.
186 #define UNMAP_ALL (1U << 0)
187
188 void unmap(void *Addr, uptr Size, uptr Flags = 0,
189 MapPlatformData *Data = nullptr);
190
191 void setMemoryPermission(uptr Addr, uptr Size, uptr Flags,
192 MapPlatformData *Data = nullptr);
193
194 void releasePagesToOS(uptr BaseAddress, uptr Offset, uptr Size,
195 MapPlatformData *Data = nullptr);
196
197 // Logging related functions.
198
199 void setAbortMessage(const char *Message);
200
201 struct BlockInfo {
202 uptr BlockBegin;
203 uptr BlockSize;
204 uptr RegionBegin;
205 uptr RegionEnd;
206 };
207
208 enum class Option : u8 {
209 ReleaseInterval, // Release to OS interval in milliseconds.
210 MemtagTuning, // Whether to tune tagging for UAF or overflow.
211 ThreadDisableMemInit, // Whether to disable automatic heap initialization and,
212 // where possible, memory tagging, on this thread.
213 MaxCacheEntriesCount, // Maximum number of blocks that can be cached.
214 MaxCacheEntrySize, // Maximum size of a block that can be cached.
215 MaxTSDsCount, // Number of usable TSDs for the shared registry.
216 };
217
218 enum class ReleaseToOS : u8 {
219 Normal, // Follow the normal rules for releasing pages to the OS
220 Force, // Force release pages to the OS, but avoid cases that take too long.
221 ForceAll, // Force release every page possible regardless of how long it will
222 // take.
223 };
224
225 constexpr unsigned char PatternFillByte = 0xAB;
226
227 enum FillContentsMode {
228 NoFill = 0,
229 ZeroFill = 1,
230 PatternOrZeroFill = 2 // Pattern fill unless the memory is known to be
231 // zero-initialized already.
232 };
233
234 } // namespace scudo
235
236 #endif // SCUDO_COMMON_H_
237