1//===-- tsan_mman.cpp -----------------------------------------------------===//
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 ThreadSanitizer (TSan), a race detector.
10//
11//===----------------------------------------------------------------------===//
12#include "tsan_mman.h"
13
14#include "sanitizer_common/sanitizer_allocator_checks.h"
15#include "sanitizer_common/sanitizer_allocator_interface.h"
16#include "sanitizer_common/sanitizer_allocator_report.h"
17#include "sanitizer_common/sanitizer_common.h"
18#include "sanitizer_common/sanitizer_errno.h"
19#include "sanitizer_common/sanitizer_placement_new.h"
20#include "sanitizer_common/sanitizer_stackdepot.h"
21#include "tsan_flags.h"
22#include "tsan_interface.h"
23#include "tsan_report.h"
24#include "tsan_rtl.h"
25
26namespace __tsan {
27
28struct MapUnmapCallback {
29 void OnMap(uptr p, uptr size) const { }
30 void OnMapSecondary(uptr p, uptr size, uptr user_begin,
31 uptr user_size) const {};
32 void OnUnmap(uptr p, uptr size) const {
33 // We are about to unmap a chunk of user memory.
34 // Mark the corresponding shadow memory as not needed.
35 DontNeedShadowFor(addr: p, size);
36 // Mark the corresponding meta shadow memory as not needed.
37 // Note the block does not contain any meta info at this point
38 // (this happens after free).
39 const uptr kMetaRatio = kMetaShadowCell / kMetaShadowSize;
40 const uptr kPageSize = GetPageSizeCached() * kMetaRatio;
41 // Block came from LargeMmapAllocator, so must be large.
42 // We rely on this in the calculations below.
43 CHECK_GE(size, 2 * kPageSize);
44 uptr diff = RoundUp(p, align: kPageSize) - p;
45 if (diff != 0) {
46 p += diff;
47 size -= diff;
48 }
49 diff = p + size - RoundDown(p: p + size, align: kPageSize);
50 if (diff != 0)
51 size -= diff;
52 uptr p_meta = (uptr)MemToMeta(x: p);
53 ReleaseMemoryPagesToOS(beg: p_meta, end: p_meta + size / kMetaRatio);
54 }
55};
56
57alignas(64) static char allocator_placeholder[sizeof(Allocator)];
58Allocator *allocator() {
59 return reinterpret_cast<Allocator*>(&allocator_placeholder);
60}
61
62struct GlobalProc {
63 Mutex mtx;
64 Processor *proc;
65 // This mutex represents the internal allocator combined for
66 // the purposes of deadlock detection. The internal allocator
67 // uses multiple mutexes, moreover they are locked only occasionally
68 // and they are spin mutexes which don't support deadlock detection.
69 // So we use this fake mutex to serve as a substitute for these mutexes.
70 CheckedMutex internal_alloc_mtx;
71
72 GlobalProc()
73 : mtx(MutexTypeGlobalProc),
74 proc(ProcCreate()),
75 internal_alloc_mtx(MutexTypeInternalAlloc) {}
76};
77
78alignas(64) static char global_proc_placeholder[sizeof(GlobalProc)];
79GlobalProc *global_proc() {
80 return reinterpret_cast<GlobalProc*>(&global_proc_placeholder);
81}
82
83static void InternalAllocAccess() {
84 global_proc()->internal_alloc_mtx.Lock();
85 global_proc()->internal_alloc_mtx.Unlock();
86}
87
88ScopedGlobalProcessor::ScopedGlobalProcessor() {
89 GlobalProc *gp = global_proc();
90 ThreadState *thr = cur_thread();
91 if (thr->proc())
92 return;
93 // If we don't have a proc, use the global one.
94 // There are currently only two known case where this path is triggered:
95 // __interceptor_free
96 // __nptl_deallocate_tsd
97 // start_thread
98 // clone
99 // and:
100 // ResetRange
101 // __interceptor_munmap
102 // __deallocate_stack
103 // start_thread
104 // clone
105 // Ideally, we destroy thread state (and unwire proc) when a thread actually
106 // exits (i.e. when we join/wait it). Then we would not need the global proc
107 gp->mtx.Lock();
108 ProcWire(proc: gp->proc, thr);
109}
110
111ScopedGlobalProcessor::~ScopedGlobalProcessor() {
112 GlobalProc *gp = global_proc();
113 ThreadState *thr = cur_thread();
114 if (thr->proc() != gp->proc)
115 return;
116 ProcUnwire(proc: gp->proc, thr);
117 gp->mtx.Unlock();
118}
119
120void AllocatorLockBeforeFork() SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
121 global_proc()->internal_alloc_mtx.Lock();
122 InternalAllocatorLock();
123#if !SANITIZER_APPLE
124 // OS X allocates from hooks, see 6a3958247a.
125 allocator()->ForceLock();
126 StackDepotLockBeforeFork();
127#endif
128}
129
130void AllocatorUnlockAfterFork(bool child) SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
131#if !SANITIZER_APPLE
132 StackDepotUnlockAfterFork(fork_child: child);
133 allocator()->ForceUnlock();
134#endif
135 InternalAllocatorUnlock();
136 global_proc()->internal_alloc_mtx.Unlock();
137}
138
139void GlobalProcessorLock() SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
140 global_proc()->mtx.Lock();
141}
142
143void GlobalProcessorUnlock() SANITIZER_NO_THREAD_SAFETY_ANALYSIS {
144 global_proc()->mtx.Unlock();
145}
146
147static constexpr uptr kMaxAllowedMallocSize = 1ull << 40;
148static uptr max_user_defined_malloc_size;
149
150void InitializeAllocator() {
151 SetAllocatorMayReturnNull(common_flags()->allocator_may_return_null);
152 allocator()->Init(release_to_os_interval_ms: common_flags()->allocator_release_to_os_interval_ms);
153 max_user_defined_malloc_size = common_flags()->max_allocation_size_mb
154 ? common_flags()->max_allocation_size_mb
155 << 20
156 : kMaxAllowedMallocSize;
157}
158
159void InitializeAllocatorLate() {
160 new(global_proc()) GlobalProc();
161}
162
163void AllocatorProcStart(Processor *proc) {
164 allocator()->InitCache(cache: &proc->alloc_cache);
165 internal_allocator()->InitCache(cache: &proc->internal_alloc_cache);
166}
167
168void AllocatorProcFinish(Processor *proc) {
169 allocator()->DestroyCache(cache: &proc->alloc_cache);
170 internal_allocator()->DestroyCache(cache: &proc->internal_alloc_cache);
171}
172
173void AllocatorPrintStats() {
174 allocator()->PrintStats();
175}
176
177static void SignalUnsafeCall(ThreadState *thr, uptr pc) {
178 if (atomic_load_relaxed(a: &thr->in_signal_handler) == 0 ||
179 !ShouldReport(thr, typ: ReportTypeSignalUnsafe))
180 return;
181 VarSizeStackTrace stack;
182 ObtainCurrentStack(thr, toppc: pc, stack: &stack);
183 if (IsFiredSuppression(ctx, type: ReportTypeSignalUnsafe, trace: stack))
184 return;
185 ScopedReport rep(ReportTypeSignalUnsafe);
186 rep.AddStack(stack, suppressable: true);
187 OutputReport(thr, srep&: rep);
188}
189
190
191void *user_alloc_internal(ThreadState *thr, uptr pc, uptr sz, uptr align,
192 bool signal) {
193 if (sz >= kMaxAllowedMallocSize || align >= kMaxAllowedMallocSize ||
194 sz > max_user_defined_malloc_size) {
195 if (AllocatorMayReturnNull())
196 return nullptr;
197 uptr malloc_limit =
198 Min(a: kMaxAllowedMallocSize, b: max_user_defined_malloc_size);
199 GET_STACK_TRACE_FATAL(thr, pc);
200 ReportAllocationSizeTooBig(user_size: sz, max_size: malloc_limit, stack: &stack);
201 }
202 if (UNLIKELY(IsRssLimitExceeded())) {
203 if (AllocatorMayReturnNull())
204 return nullptr;
205 GET_STACK_TRACE_FATAL(thr, pc);
206 ReportRssLimitExceeded(stack: &stack);
207 }
208 void *p = allocator()->Allocate(cache: &thr->proc()->alloc_cache, size: sz, alignment: align);
209 if (UNLIKELY(!p)) {
210 SetAllocatorOutOfMemory();
211 if (AllocatorMayReturnNull())
212 return nullptr;
213 GET_STACK_TRACE_FATAL(thr, pc);
214 ReportOutOfMemory(requested_size: sz, stack: &stack);
215 }
216 if (ctx && ctx->initialized)
217 OnUserAlloc(thr, pc, p: (uptr)p, sz, write: true);
218 if (signal)
219 SignalUnsafeCall(thr, pc);
220 return p;
221}
222
223void user_free(ThreadState *thr, uptr pc, void *p, bool signal) {
224 ScopedGlobalProcessor sgp;
225 if (ctx && ctx->initialized)
226 OnUserFree(thr, pc, p: (uptr)p, write: true);
227 allocator()->Deallocate(cache: &thr->proc()->alloc_cache, p);
228 if (signal)
229 SignalUnsafeCall(thr, pc);
230}
231
232void *user_alloc(ThreadState *thr, uptr pc, uptr sz) {
233 return SetErrnoOnNull(user_alloc_internal(thr, pc, sz, align: kDefaultAlignment));
234}
235
236void *user_calloc(ThreadState *thr, uptr pc, uptr size, uptr n) {
237 if (UNLIKELY(CheckForCallocOverflow(size, n))) {
238 if (AllocatorMayReturnNull())
239 return SetErrnoOnNull(nullptr);
240 GET_STACK_TRACE_FATAL(thr, pc);
241 ReportCallocOverflow(count: n, size, stack: &stack);
242 }
243 void *p = user_alloc_internal(thr, pc, sz: n * size);
244 if (p)
245 internal_memset(s: p, c: 0, n: n * size);
246 return SetErrnoOnNull(p);
247}
248
249void *user_reallocarray(ThreadState *thr, uptr pc, void *p, uptr size, uptr n) {
250 if (UNLIKELY(CheckForCallocOverflow(size, n))) {
251 if (AllocatorMayReturnNull())
252 return SetErrnoOnNull(nullptr);
253 GET_STACK_TRACE_FATAL(thr, pc);
254 ReportReallocArrayOverflow(count: n, size, stack: &stack);
255 }
256 return user_realloc(thr, pc, p, sz: size * n);
257}
258
259void OnUserAlloc(ThreadState *thr, uptr pc, uptr p, uptr sz, bool write) {
260 DPrintf("#%d: alloc(%zu) = 0x%zx\n", thr->tid, sz, p);
261 // Note: this can run before thread initialization/after finalization.
262 // As a result this is not necessarily synchronized with DoReset,
263 // which iterates over and resets all sync objects,
264 // but it is fine to create new MBlocks in this context.
265 ctx->metamap.AllocBlock(thr, pc, p, sz);
266 // If this runs before thread initialization/after finalization
267 // and we don't have trace initialized, we can't imitate writes.
268 // In such case just reset the shadow range, it is fine since
269 // it affects only a small fraction of special objects.
270 if (write && thr->ignore_reads_and_writes == 0 &&
271 atomic_load_relaxed(a: &thr->trace_pos))
272 MemoryRangeImitateWrite(thr, pc, addr: (uptr)p, size: sz);
273 else
274 MemoryResetRange(thr, pc, addr: (uptr)p, size: sz);
275}
276
277void OnUserFree(ThreadState *thr, uptr pc, uptr p, bool write) {
278 CHECK_NE(p, (void*)0);
279 if (!thr->slot) {
280 // Very early/late in thread lifetime, or during fork.
281 UNUSED uptr sz = ctx->metamap.FreeBlock(proc: thr->proc(), p, reset: false);
282 DPrintf("#%d: free(0x%zx, %zu) (no slot)\n", thr->tid, p, sz);
283 return;
284 }
285 SlotLocker locker(thr);
286 uptr sz = ctx->metamap.FreeBlock(proc: thr->proc(), p, reset: true);
287 DPrintf("#%d: free(0x%zx, %zu)\n", thr->tid, p, sz);
288 if (write && thr->ignore_reads_and_writes == 0)
289 MemoryRangeFreed(thr, pc, addr: (uptr)p, size: sz);
290}
291
292void *user_realloc(ThreadState *thr, uptr pc, void *p, uptr sz) {
293 // FIXME: Handle "shrinking" more efficiently,
294 // it seems that some software actually does this.
295 if (!p)
296 return SetErrnoOnNull(user_alloc_internal(thr, pc, sz));
297 if (!sz) {
298 user_free(thr, pc, p);
299 return nullptr;
300 }
301 void *new_p = user_alloc_internal(thr, pc, sz);
302 if (new_p) {
303 uptr old_sz = user_alloc_usable_size(p);
304 internal_memcpy(dest: new_p, src: p, n: min(a: old_sz, b: sz));
305 user_free(thr, pc, p);
306 }
307 return SetErrnoOnNull(new_p);
308}
309
310void *user_memalign(ThreadState *thr, uptr pc, uptr align, uptr sz) {
311 if (UNLIKELY(!IsPowerOfTwo(align))) {
312 errno = errno_EINVAL;
313 if (AllocatorMayReturnNull())
314 return nullptr;
315 GET_STACK_TRACE_FATAL(thr, pc);
316 ReportInvalidAllocationAlignment(alignment: align, stack: &stack);
317 }
318 return SetErrnoOnNull(user_alloc_internal(thr, pc, sz, align));
319}
320
321int user_posix_memalign(ThreadState *thr, uptr pc, void **memptr, uptr align,
322 uptr sz) {
323 if (UNLIKELY(!CheckPosixMemalignAlignment(align))) {
324 if (AllocatorMayReturnNull())
325 return errno_EINVAL;
326 GET_STACK_TRACE_FATAL(thr, pc);
327 ReportInvalidPosixMemalignAlignment(alignment: align, stack: &stack);
328 }
329 void *ptr = user_alloc_internal(thr, pc, sz, align);
330 if (UNLIKELY(!ptr))
331 // OOM error is already taken care of by user_alloc_internal.
332 return errno_ENOMEM;
333 CHECK(IsAligned((uptr)ptr, align));
334 *memptr = ptr;
335 return 0;
336}
337
338void *user_aligned_alloc(ThreadState *thr, uptr pc, uptr align, uptr sz) {
339 if (UNLIKELY(!CheckAlignedAllocAlignmentAndSize(align, sz))) {
340 errno = errno_EINVAL;
341 if (AllocatorMayReturnNull())
342 return nullptr;
343 GET_STACK_TRACE_FATAL(thr, pc);
344 ReportInvalidAlignedAllocAlignment(size: sz, alignment: align, stack: &stack);
345 }
346 return SetErrnoOnNull(user_alloc_internal(thr, pc, sz, align));
347}
348
349void *user_valloc(ThreadState *thr, uptr pc, uptr sz) {
350 return SetErrnoOnNull(user_alloc_internal(thr, pc, sz, align: GetPageSizeCached()));
351}
352
353void *user_pvalloc(ThreadState *thr, uptr pc, uptr sz) {
354 uptr PageSize = GetPageSizeCached();
355 if (UNLIKELY(CheckForPvallocOverflow(sz, PageSize))) {
356 errno = errno_ENOMEM;
357 if (AllocatorMayReturnNull())
358 return nullptr;
359 GET_STACK_TRACE_FATAL(thr, pc);
360 ReportPvallocOverflow(size: sz, stack: &stack);
361 }
362 // pvalloc(0) should allocate one page.
363 sz = sz ? RoundUpTo(size: sz, boundary: PageSize) : PageSize;
364 return SetErrnoOnNull(user_alloc_internal(thr, pc, sz, align: PageSize));
365}
366
367static const void *user_alloc_begin(const void *p) {
368 if (p == nullptr || !IsAppMem(mem: (uptr)p))
369 return nullptr;
370 void *beg = allocator()->GetBlockBegin(p);
371 if (!beg)
372 return nullptr;
373
374 MBlock *b = ctx->metamap.GetBlock(p: (uptr)beg);
375 if (!b)
376 return nullptr; // Not a valid pointer.
377
378 return (const void *)beg;
379}
380
381uptr user_alloc_usable_size(const void *p) {
382 if (p == 0 || !IsAppMem(mem: (uptr)p))
383 return 0;
384 MBlock *b = ctx->metamap.GetBlock(p: (uptr)p);
385 if (!b)
386 return 0; // Not a valid pointer.
387 if (b->siz == 0)
388 return 1; // Zero-sized allocations are actually 1 byte.
389 return b->siz;
390}
391
392uptr user_alloc_usable_size_fast(const void *p) {
393 MBlock *b = ctx->metamap.GetBlock(p: (uptr)p);
394 // Static objects may have malloc'd before tsan completes
395 // initialization, and may believe returned ptrs to be valid.
396 if (!b)
397 return 0; // Not a valid pointer.
398 if (b->siz == 0)
399 return 1; // Zero-sized allocations are actually 1 byte.
400 return b->siz;
401}
402
403void invoke_malloc_hook(void *ptr, uptr size) {
404 ThreadState *thr = cur_thread();
405 if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
406 return;
407 RunMallocHooks(ptr, size);
408}
409
410void invoke_free_hook(void *ptr) {
411 ThreadState *thr = cur_thread();
412 if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
413 return;
414 RunFreeHooks(ptr);
415}
416
417void *Alloc(uptr sz) {
418 ThreadState *thr = cur_thread();
419 if (thr->nomalloc) {
420 thr->nomalloc = 0; // CHECK calls internal_malloc().
421 CHECK(0);
422 }
423 InternalAllocAccess();
424 return InternalAlloc(size: sz, cache: &thr->proc()->internal_alloc_cache);
425}
426
427void FreeImpl(void *p) {
428 ThreadState *thr = cur_thread();
429 if (thr->nomalloc) {
430 thr->nomalloc = 0; // CHECK calls internal_malloc().
431 CHECK(0);
432 }
433 InternalAllocAccess();
434 InternalFree(p, cache: &thr->proc()->internal_alloc_cache);
435}
436
437} // namespace __tsan
438
439using namespace __tsan;
440
441extern "C" {
442uptr __sanitizer_get_current_allocated_bytes() {
443 uptr stats[AllocatorStatCount];
444 allocator()->GetStats(s: stats);
445 return stats[AllocatorStatAllocated];
446}
447
448uptr __sanitizer_get_heap_size() {
449 uptr stats[AllocatorStatCount];
450 allocator()->GetStats(s: stats);
451 return stats[AllocatorStatMapped];
452}
453
454uptr __sanitizer_get_free_bytes() {
455 return 1;
456}
457
458uptr __sanitizer_get_unmapped_bytes() {
459 return 1;
460}
461
462uptr __sanitizer_get_estimated_allocated_size(uptr size) {
463 return size;
464}
465
466int __sanitizer_get_ownership(const void *p) {
467 return allocator()->GetBlockBegin(p) != 0;
468}
469
470const void *__sanitizer_get_allocated_begin(const void *p) {
471 return user_alloc_begin(p);
472}
473
474uptr __sanitizer_get_allocated_size(const void *p) {
475 return user_alloc_usable_size(p);
476}
477
478uptr __sanitizer_get_allocated_size_fast(const void *p) {
479 DCHECK_EQ(p, __sanitizer_get_allocated_begin(p));
480 uptr ret = user_alloc_usable_size_fast(p);
481 DCHECK_EQ(ret, __sanitizer_get_allocated_size(p));
482 return ret;
483}
484
485void __sanitizer_purge_allocator() {
486 allocator()->ForceReleaseToOS();
487}
488
489void __tsan_on_thread_idle() {
490 ThreadState *thr = cur_thread();
491 allocator()->SwallowCache(cache: &thr->proc()->alloc_cache);
492 internal_allocator()->SwallowCache(cache: &thr->proc()->internal_alloc_cache);
493 ctx->metamap.OnProcIdle(proc: thr->proc());
494}
495} // extern "C"
496