Branch data Line data Source code
1 : : // Copyright (c) 2016-2022 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <support/lockedpool.h>
6 : : #include <support/cleanse.h>
7 : :
8 : : #if defined(HAVE_CONFIG_H)
9 : : #include <config/bitcoin-config.h>
10 : : #endif
11 : :
12 : : #ifdef WIN32
13 : : #include <windows.h>
14 : : #else
15 : : #include <sys/mman.h> // for mmap
16 : : #include <sys/resource.h> // for getrlimit
17 : : #include <limits.h> // for PAGESIZE
18 : : #include <unistd.h> // for sysconf
19 : : #endif
20 : :
21 : : #include <algorithm>
22 : : #include <limits>
23 : : #include <stdexcept>
24 : : #include <utility>
25 : : #ifdef ARENA_DEBUG
26 : : #include <iomanip>
27 : : #include <iostream>
28 : : #endif
29 : :
30 : : LockedPoolManager* LockedPoolManager::_instance = nullptr;
31 : :
32 : : /*******************************************************************************/
33 : : // Utilities
34 : : //
35 : : /** Align up to power of 2 */
36 : 29903 : static inline size_t align_up(size_t x, size_t align)
37 : : {
38 : 29903 : return (x + align - 1) & ~(align - 1);
39 : : }
40 : :
41 : : /*******************************************************************************/
42 : : // Implementation: Arena
43 : :
44 : 4 : Arena::Arena(void *base_in, size_t size_in, size_t alignment_in):
45 : 2 : base(base_in), end(static_cast<char*>(base_in) + size_in), alignment(alignment_in)
46 : 2 : {
47 : : // Start with one free chunk that covers the entire arena
48 [ + - ]: 2 : auto it = size_to_free_chunk.emplace(size_in, base);
49 [ + - ]: 2 : chunks_free.emplace(base, it);
50 [ + - ]: 2 : chunks_free_end.emplace(static_cast<char*>(base) + size_in, it);
51 : 2 : }
52 : :
53 : 2 : Arena::~Arena()
54 : 2 : {
55 : 2 : }
56 : :
57 : 29899 : void* Arena::alloc(size_t size)
58 : : {
59 : : // Round to next multiple of alignment
60 : 29899 : size = align_up(size, alignment);
61 : :
62 : : // Don't handle zero-sized chunks
63 [ + - ]: 29899 : if (size == 0)
64 : 0 : return nullptr;
65 : :
66 : : // Pick a large enough free-chunk. Returns an iterator pointing to the first element that is not less than key.
67 : : // This allocation strategy is best-fit. According to "Dynamic Storage Allocation: A Survey and Critical Review",
68 : : // Wilson et. al. 1995, https://www.scs.stanford.edu/14wi-cs140/sched/readings/wilson.pdf, best-fit and first-fit
69 : : // policies seem to work well in practice.
70 : 29899 : auto size_ptr_it = size_to_free_chunk.lower_bound(size);
71 [ - + ]: 29899 : if (size_ptr_it == size_to_free_chunk.end())
72 : 0 : return nullptr;
73 : :
74 : : // Create the used-chunk, taking its space from the end of the free-chunk
75 : 29899 : const size_t size_remaining = size_ptr_it->first - size;
76 : 29899 : char* const free_chunk = static_cast<char*>(size_ptr_it->second);
77 : 29899 : auto allocated = chunks_used.emplace(free_chunk + size_remaining, size).first;
78 : 29899 : chunks_free_end.erase(free_chunk + size_ptr_it->first);
79 [ + + ]: 29899 : if (size_ptr_it->first == size) {
80 : : // whole chunk is used up
81 : 23433 : chunks_free.erase(size_ptr_it->second);
82 : 23433 : } else {
83 : : // still some memory left in the chunk
84 : 6466 : auto it_remaining = size_to_free_chunk.emplace(size_remaining, size_ptr_it->second);
85 : 6466 : chunks_free[size_ptr_it->second] = it_remaining;
86 : 6466 : chunks_free_end.emplace(free_chunk + size_remaining, it_remaining);
87 : : }
88 : 29899 : size_to_free_chunk.erase(size_ptr_it);
89 : :
90 : 29899 : return allocated->first;
91 : 29899 : }
92 : :
93 : 29899 : void Arena::free(void *ptr)
94 : : {
95 : : // Freeing the nullptr pointer is OK.
96 [ + - ]: 29899 : if (ptr == nullptr) {
97 : 0 : return;
98 : : }
99 : :
100 : : // Remove chunk from used map
101 : 29899 : auto i = chunks_used.find(ptr);
102 [ + - ]: 29899 : if (i == chunks_used.end()) {
103 [ # # ]: 0 : throw std::runtime_error("Arena: invalid or double free");
104 : : }
105 : 29899 : auto freed = std::make_pair(static_cast<char*>(i->first), i->second);
106 : 29899 : chunks_used.erase(i);
107 : :
108 : : // coalesce freed with previous chunk
109 : 29899 : auto prev = chunks_free_end.find(freed.first);
110 [ + + ]: 29899 : if (prev != chunks_free_end.end()) {
111 : 6111 : freed.first -= prev->second->first;
112 : 6111 : freed.second += prev->second->first;
113 : 6111 : size_to_free_chunk.erase(prev->second);
114 : 6111 : chunks_free_end.erase(prev);
115 : 6111 : }
116 : :
117 : : // coalesce freed with chunk after freed
118 : 29899 : auto next = chunks_free.find(freed.first + freed.second);
119 [ + + ]: 29899 : if (next != chunks_free.end()) {
120 : 355 : freed.second += next->second->first;
121 : 355 : size_to_free_chunk.erase(next->second);
122 : 355 : chunks_free.erase(next);
123 : 355 : }
124 : :
125 : : // Add/set space with coalesced free chunk
126 : 29899 : auto it = size_to_free_chunk.emplace(freed.second, freed.first);
127 : 29899 : chunks_free[freed.first] = it;
128 : 29899 : chunks_free_end[freed.first + freed.second] = it;
129 : 29899 : }
130 : :
131 : 0 : Arena::Stats Arena::stats() const
132 : : {
133 : 0 : Arena::Stats r{ 0, 0, 0, chunks_used.size(), chunks_free.size() };
134 [ # # ]: 0 : for (const auto& chunk: chunks_used)
135 : 0 : r.used += chunk.second;
136 [ # # ]: 0 : for (const auto& chunk: chunks_free)
137 : 0 : r.free += chunk.second->first;
138 : 0 : r.total = r.used + r.free;
139 : 0 : return r;
140 : : }
141 : :
142 : : #ifdef ARENA_DEBUG
143 : : static void printchunk(void* base, size_t sz, bool used) {
144 : : std::cout <<
145 : : "0x" << std::hex << std::setw(16) << std::setfill('0') << base <<
146 : : " 0x" << std::hex << std::setw(16) << std::setfill('0') << sz <<
147 : : " 0x" << used << std::endl;
148 : : }
149 : : void Arena::walk() const
150 : : {
151 : : for (const auto& chunk: chunks_used)
152 : : printchunk(chunk.first, chunk.second, true);
153 : : std::cout << std::endl;
154 : : for (const auto& chunk: chunks_free)
155 : : printchunk(chunk.first, chunk.second->first, false);
156 : : std::cout << std::endl;
157 : : }
158 : : #endif
159 : :
160 : : /*******************************************************************************/
161 : : // Implementation: Win32LockedPageAllocator
162 : :
163 : : #ifdef WIN32
164 : : /** LockedPageAllocator specialized for Windows.
165 : : */
166 : : class Win32LockedPageAllocator: public LockedPageAllocator
167 : : {
168 : : public:
169 : : Win32LockedPageAllocator();
170 : : void* AllocateLocked(size_t len, bool *lockingSuccess) override;
171 : : void FreeLocked(void* addr, size_t len) override;
172 : : size_t GetLimit() override;
173 : : private:
174 : : size_t page_size;
175 : : };
176 : :
177 : : Win32LockedPageAllocator::Win32LockedPageAllocator()
178 : : {
179 : : // Determine system page size in bytes
180 : : SYSTEM_INFO sSysInfo;
181 : : GetSystemInfo(&sSysInfo);
182 : : page_size = sSysInfo.dwPageSize;
183 : : }
184 : : void *Win32LockedPageAllocator::AllocateLocked(size_t len, bool *lockingSuccess)
185 : : {
186 : : len = align_up(len, page_size);
187 : : void *addr = VirtualAlloc(nullptr, len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
188 : : if (addr) {
189 : : // VirtualLock is used to attempt to keep keying material out of swap. Note
190 : : // that it does not provide this as a guarantee, but, in practice, memory
191 : : // that has been VirtualLock'd almost never gets written to the pagefile
192 : : // except in rare circumstances where memory is extremely low.
193 : : *lockingSuccess = VirtualLock(const_cast<void*>(addr), len) != 0;
194 : : }
195 : : return addr;
196 : : }
197 : : void Win32LockedPageAllocator::FreeLocked(void* addr, size_t len)
198 : : {
199 : : len = align_up(len, page_size);
200 : : memory_cleanse(addr, len);
201 : 2 : VirtualUnlock(const_cast<void*>(addr), len);
202 : : }
203 : :
204 : : size_t Win32LockedPageAllocator::GetLimit()
205 : : {
206 : : size_t min, max;
207 : : if(GetProcessWorkingSetSize(GetCurrentProcess(), &min, &max) != 0) {
208 : : return min;
209 : : }
210 : : return std::numeric_limits<size_t>::max();
211 : : }
212 : : #endif
213 : :
214 : : /*******************************************************************************/
215 : : // Implementation: PosixLockedPageAllocator
216 : :
217 : : #ifndef WIN32
218 : : /** LockedPageAllocator specialized for OSes that don't try to be
219 : : * special snowflakes.
220 : : */
221 : 0 : class PosixLockedPageAllocator: public LockedPageAllocator
222 : : {
223 : : public:
224 : : PosixLockedPageAllocator();
225 : : void* AllocateLocked(size_t len, bool *lockingSuccess) override;
226 : : void FreeLocked(void* addr, size_t len) override;
227 : : size_t GetLimit() override;
228 : : private:
229 : : size_t page_size;
230 : : };
231 : :
232 : 2 : PosixLockedPageAllocator::PosixLockedPageAllocator()
233 : 2 : {
234 : : // Determine system page size in bytes
235 : : #if defined(PAGESIZE) // defined in limits.h
236 : : page_size = PAGESIZE;
237 : : #else // assume some POSIX OS
238 : 2 : page_size = sysconf(_SC_PAGESIZE);
239 : : #endif
240 : 2 : }
241 : :
242 : 2 : void *PosixLockedPageAllocator::AllocateLocked(size_t len, bool *lockingSuccess)
243 : : {
244 : : void *addr;
245 : 2 : len = align_up(len, page_size);
246 : 2 : addr = mmap(nullptr, len, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
247 [ - + ]: 2 : if (addr == MAP_FAILED) {
248 : 0 : return nullptr;
249 : : }
250 [ - + ]: 2 : if (addr) {
251 : 2 : *lockingSuccess = mlock(addr, len) == 0;
252 : : #if defined(MADV_DONTDUMP) // Linux
253 : 2 : madvise(addr, len, MADV_DONTDUMP);
254 : : #elif defined(MADV_NOCORE) // FreeBSD
255 : : madvise(addr, len, MADV_NOCORE);
256 : : #endif
257 : 2 : }
258 : 2 : return addr;
259 : 2 : }
260 : 2 : void PosixLockedPageAllocator::FreeLocked(void* addr, size_t len)
261 : : {
262 : 2 : len = align_up(len, page_size);
263 : 2 : memory_cleanse(addr, len);
264 : 2 : munlock(addr, len);
265 : 2 : munmap(addr, len);
266 : 2 : }
267 : 2 : size_t PosixLockedPageAllocator::GetLimit()
268 : : {
269 : : #ifdef RLIMIT_MEMLOCK
270 : : struct rlimit rlim;
271 [ - + ]: 2 : if (getrlimit(RLIMIT_MEMLOCK, &rlim) == 0) {
272 [ - + ]: 2 : if (rlim.rlim_cur != RLIM_INFINITY) {
273 : 2 : return rlim.rlim_cur;
274 : : }
275 : 0 : }
276 : : #endif
277 : 0 : return std::numeric_limits<size_t>::max();
278 : 2 : }
279 : : #endif
280 : :
281 : : /*******************************************************************************/
282 : : // Implementation: LockedPool
283 : :
284 : 6 : LockedPool::LockedPool(std::unique_ptr<LockedPageAllocator> allocator_in, LockingFailed_Callback lf_cb_in)
285 : 4 : : allocator(std::move(allocator_in)), lf_cb(lf_cb_in)
286 : : {
287 : 2 : }
288 : :
289 : 2 : LockedPool::~LockedPool() = default;
290 : :
291 : 29899 : void* LockedPool::alloc(size_t size)
292 : : {
293 : 29899 : std::lock_guard<std::mutex> lock(mutex);
294 : :
295 : : // Don't handle impossible sizes
296 [ + - ][ - + ]: 29899 : if (size == 0 || size > ARENA_SIZE)
297 : 0 : return nullptr;
298 : :
299 : : // Try allocating from each current arena
300 [ + + ]: 29899 : for (auto &arena: arenas) {
301 [ + - ]: 29897 : void *addr = arena.alloc(size);
302 [ - + ]: 29897 : if (addr) {
303 : 29897 : return addr;
304 : : }
305 : : }
306 : : // If that fails, create a new one
307 [ + - ][ + - ]: 2 : if (new_arena(ARENA_SIZE, ARENA_ALIGN)) {
308 [ + - ]: 2 : return arenas.back().alloc(size);
309 : : }
310 : 0 : return nullptr;
311 : 29899 : }
312 : :
313 : 29899 : void LockedPool::free(void *ptr)
314 : : {
315 : 29899 : std::lock_guard<std::mutex> lock(mutex);
316 : : // TODO we can do better than this linear search by keeping a map of arena
317 : : // extents to arena, and looking up the address.
318 [ + - ]: 29899 : for (auto &arena: arenas) {
319 [ + - ][ + - ]: 29899 : if (arena.addressInArena(ptr)) {
320 [ + - ]: 29899 : arena.free(ptr);
321 : : return;
322 : : }
323 : : }
324 [ # # ][ # # ]: 0 : throw std::runtime_error("LockedPool: invalid address not pointing to any arena");
325 : 29899 : }
326 : :
327 : 0 : LockedPool::Stats LockedPool::stats() const
328 : : {
329 : 0 : std::lock_guard<std::mutex> lock(mutex);
330 : 0 : LockedPool::Stats r{0, 0, 0, cumulative_bytes_locked, 0, 0};
331 [ # # ]: 0 : for (const auto &arena: arenas) {
332 : 0 : Arena::Stats i = arena.stats();
333 : 0 : r.used += i.used;
334 : 0 : r.free += i.free;
335 : 0 : r.total += i.total;
336 : 0 : r.chunks_used += i.chunks_used;
337 : 0 : r.chunks_free += i.chunks_free;
338 : : }
339 : : return r;
340 : 0 : }
341 : :
342 : 2 : bool LockedPool::new_arena(size_t size, size_t align)
343 : : {
344 : : bool locked;
345 : : // If this is the first arena, handle this specially: Cap the upper size
346 : : // by the process limit. This makes sure that the first arena will at least
347 : : // be locked. An exception to this is if the process limit is 0:
348 : : // in this case no memory can be locked at all so we'll skip past this logic.
349 [ - + ]: 2 : if (arenas.empty()) {
350 : 2 : size_t limit = allocator->GetLimit();
351 [ - + ]: 2 : if (limit > 0) {
352 : 2 : size = std::min(size, limit);
353 : 2 : }
354 : 2 : }
355 : 2 : void *addr = allocator->AllocateLocked(size, &locked);
356 [ + - ]: 2 : if (!addr) {
357 : 0 : return false;
358 : : }
359 [ + - ]: 2 : if (locked) {
360 : 2 : cumulative_bytes_locked += size;
361 [ # # ]: 2 : } else if (lf_cb) { // Call the locking-failed callback if locking failed
362 [ # # ]: 0 : if (!lf_cb()) { // If the callback returns false, free the memory and fail, otherwise consider the user warned and proceed.
363 : 0 : allocator->FreeLocked(addr, size);
364 : 0 : return false;
365 : : }
366 : 0 : }
367 : 2 : arenas.emplace_back(allocator.get(), addr, size, align);
368 : 2 : return true;
369 : 2 : }
370 : :
371 : 2 : LockedPool::LockedPageArena::LockedPageArena(LockedPageAllocator *allocator_in, void *base_in, size_t size_in, size_t align_in):
372 : 4 : Arena(base_in, size_in, align_in), base(base_in), size(size_in), allocator(allocator_in)
373 : 2 : {
374 : 2 : }
375 : 2 : LockedPool::LockedPageArena::~LockedPageArena()
376 : 2 : {
377 [ + - ]: 2 : allocator->FreeLocked(base, size);
378 : 2 : }
379 : :
380 : : /*******************************************************************************/
381 : : // Implementation: LockedPoolManager
382 : : //
383 : 2 : LockedPoolManager::LockedPoolManager(std::unique_ptr<LockedPageAllocator> allocator_in):
384 : 2 : LockedPool(std::move(allocator_in), &LockedPoolManager::LockingFailed)
385 : : {
386 : 2 : }
387 : :
388 : 0 : bool LockedPoolManager::LockingFailed()
389 : : {
390 : : // TODO: log something but how? without including util.h
391 : 0 : return true;
392 : : }
393 : :
394 : 2 : void LockedPoolManager::CreateInstance()
395 : : {
396 : : // Using a local static instance guarantees that the object is initialized
397 : : // when it's first needed and also deinitialized after all objects that use
398 : : // it are done with it. I can think of one unlikely scenario where we may
399 : : // have a static deinitialization order/problem, but the check in
400 : : // LockedPoolManagerBase's destructor helps us detect if that ever happens.
401 : : #ifdef WIN32
402 : : std::unique_ptr<LockedPageAllocator> allocator(new Win32LockedPageAllocator());
403 : : #else
404 [ + - ]: 2 : std::unique_ptr<LockedPageAllocator> allocator(new PosixLockedPageAllocator());
405 : : #endif
406 [ + - ][ - + ]: 2 : static LockedPoolManager instance(std::move(allocator));
[ - + ]
407 : 2 : LockedPoolManager::_instance = &instance;
408 : 2 : }
|
