tsan_mman.cc revision 2d1fdb26e458c4ddc04155c1d421bced3ba90cd0 
1//===-- tsan_mman.cc ------------------------------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file is a part of ThreadSanitizer (TSan), a race detector.
11//
12//===----------------------------------------------------------------------===//
13#include "sanitizer_common/sanitizer_common.h"
14#include "sanitizer_common/sanitizer_placement_new.h"
15#include "tsan_mman.h"
16#include "tsan_rtl.h"
17#include "tsan_report.h"
18#include "tsan_flags.h"
19
20// May be overriden by front-end.
21extern "C" void WEAK __tsan_malloc_hook(void *ptr, uptr size) {
22  (void)ptr;
23  (void)size;
24}
25
26extern "C" void WEAK __tsan_free_hook(void *ptr) {
27  (void)ptr;
28}
29
30namespace __tsan {
31
32COMPILER_CHECK(sizeof(MBlock) == 16);
33
34void MBlock::Lock() {
35  atomic_uintptr_t *a = reinterpret_cast<atomic_uintptr_t*>(this);
36  uptr v = atomic_load(a, memory_order_relaxed);
37  for (int iter = 0;; iter++) {
38    if (v & 1) {
39      if (iter < 10)
40        proc_yield(20);
41      else
42        internal_sched_yield();
43      v = atomic_load(a, memory_order_relaxed);
44      continue;
45    }
46    if (atomic_compare_exchange_weak(a, &v, v | 1, memory_order_acquire))
47      break;
48  }
49}
50
51void MBlock::Unlock() {
52  atomic_uintptr_t *a = reinterpret_cast<atomic_uintptr_t*>(this);
53  uptr v = atomic_load(a, memory_order_relaxed);
54  DCHECK(v & 1);
55  atomic_store(a, v & ~1, memory_order_relaxed);
56}
57
58struct MapUnmapCallback {
59  void OnMap(uptr p, uptr size) const { }
60  void OnUnmap(uptr p, uptr size) const {
61    // We are about to unmap a chunk of user memory.
62    // Mark the corresponding shadow memory as not needed.
63    DontNeedShadowFor(p, size);
64  }
65};
66
67static char allocator_placeholder[sizeof(Allocator)] ALIGNED(64);
68Allocator *allocator() {
69  return reinterpret_cast<Allocator*>(&allocator_placeholder);
70}
71
72void InitializeAllocator() {
73  allocator()->Init();
74}
75
76void AllocatorThreadStart(ThreadState *thr) {
77  allocator()->InitCache(&thr->alloc_cache);
78  internal_allocator()->InitCache(&thr->internal_alloc_cache);
79}
80
81void AllocatorThreadFinish(ThreadState *thr) {
82  allocator()->DestroyCache(&thr->alloc_cache);
83  internal_allocator()->DestroyCache(&thr->internal_alloc_cache);
84}
85
86void AllocatorPrintStats() {
87  allocator()->PrintStats();
88}
89
90static void SignalUnsafeCall(ThreadState *thr, uptr pc) {
91  if (!thr->in_signal_handler || !flags()->report_signal_unsafe)
92    return;
93  StackTrace stack;
94  stack.ObtainCurrent(thr, pc);
95  ThreadRegistryLock l(ctx->thread_registry);
96  ScopedReport rep(ReportTypeSignalUnsafe);
97  if (!IsFiredSuppression(ctx, rep, stack)) {
98    rep.AddStack(&stack);
99    OutputReport(ctx, rep, rep.GetReport()->stacks[0]);
100  }
101}
102
103void *user_alloc(ThreadState *thr, uptr pc, uptr sz, uptr align) {
104  if ((sz >= (1ull << 40)) || (align >= (1ull << 40)))
105    return AllocatorReturnNull();
106  void *p = allocator()->Allocate(&thr->alloc_cache, sz, align);
107  if (p == 0)
108    return 0;
109  MBlock *b = new(allocator()->GetMetaData(p)) MBlock;
110  b->Init(sz, thr->tid, CurrentStackId(thr, pc));
111  if (ctx && ctx->initialized) {
112    if (thr->ignore_reads_and_writes == 0)
113      MemoryRangeImitateWrite(thr, pc, (uptr)p, sz);
114    else
115      MemoryResetRange(thr, pc, (uptr)p, sz);
116  }
117  DPrintf("#%d: alloc(%zu) = %p\n", thr->tid, sz, p);
118  SignalUnsafeCall(thr, pc);
119  return p;
120}
121
122void user_free(ThreadState *thr, uptr pc, void *p) {
123  CHECK_NE(p, (void*)0);
124  DPrintf("#%d: free(%p)\n", thr->tid, p);
125  MBlock *b = (MBlock*)allocator()->GetMetaData(p);
126  if (b->ListHead()) {
127    MBlock::ScopedLock l(b);
128    for (SyncVar *s = b->ListHead(); s;) {
129      SyncVar *res = s;
130      s = s->next;
131      StatInc(thr, StatSyncDestroyed);
132      res->mtx.Lock();
133      res->mtx.Unlock();
134      DestroyAndFree(res);
135    }
136    b->ListReset();
137  }
138  if (ctx && ctx->initialized) {
139    if (thr->ignore_reads_and_writes == 0)
140      MemoryRangeFreed(thr, pc, (uptr)p, b->Size());
141  }
142  allocator()->Deallocate(&thr->alloc_cache, p);
143  SignalUnsafeCall(thr, pc);
144}
145
146void *user_realloc(ThreadState *thr, uptr pc, void *p, uptr sz) {
147  void *p2 = 0;
148  // FIXME: Handle "shrinking" more efficiently,
149  // it seems that some software actually does this.
150  if (sz) {
151    p2 = user_alloc(thr, pc, sz);
152    if (p2 == 0)
153      return 0;
154    if (p) {
155      MBlock *b = user_mblock(thr, p);
156      CHECK_NE(b, 0);
157      internal_memcpy(p2, p, min(b->Size(), sz));
158    }
159  }
160  if (p)
161    user_free(thr, pc, p);
162  return p2;
163}
164
165uptr user_alloc_usable_size(ThreadState *thr, uptr pc, void *p) {
166  if (p == 0)
167    return 0;
168  MBlock *b = (MBlock*)allocator()->GetMetaData(p);
169  return b ? b->Size() : 0;
170}
171
172MBlock *user_mblock(ThreadState *thr, void *p) {
173  CHECK_NE(p, 0);
174  Allocator *a = allocator();
175  void *b = a->GetBlockBegin(p);
176  if (b == 0)
177    return 0;
178  return (MBlock*)a->GetMetaData(b);
179}
180
181void invoke_malloc_hook(void *ptr, uptr size) {
182  ThreadState *thr = cur_thread();
183  if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
184    return;
185  __tsan_malloc_hook(ptr, size);
186}
187
188void invoke_free_hook(void *ptr) {
189  ThreadState *thr = cur_thread();
190  if (ctx == 0 || !ctx->initialized || thr->ignore_interceptors)
191    return;
192  __tsan_free_hook(ptr);
193}
194
195void *internal_alloc(MBlockType typ, uptr sz) {
196  ThreadState *thr = cur_thread();
197  CHECK_LE(sz, InternalSizeClassMap::kMaxSize);
198  if (thr->nomalloc) {
199    thr->nomalloc = 0;  // CHECK calls internal_malloc().
200    CHECK(0);
201  }
202  return InternalAlloc(sz, &thr->internal_alloc_cache);
203}
204
205void internal_free(void *p) {
206  ThreadState *thr = cur_thread();
207  if (thr->nomalloc) {
208    thr->nomalloc = 0;  // CHECK calls internal_malloc().
209    CHECK(0);
210  }
211  InternalFree(p, &thr->internal_alloc_cache);
212}
213
214}  // namespace __tsan
215
216using namespace __tsan;
217
218extern "C" {
219uptr __tsan_get_current_allocated_bytes() {
220  u64 stats[AllocatorStatCount];
221  allocator()->GetStats(stats);
222  u64 m = stats[AllocatorStatMalloced];
223  u64 f = stats[AllocatorStatFreed];
224  return m >= f ? m - f : 1;
225}
226
227uptr __tsan_get_heap_size() {
228  u64 stats[AllocatorStatCount];
229  allocator()->GetStats(stats);
230  u64 m = stats[AllocatorStatMmapped];
231  u64 f = stats[AllocatorStatUnmapped];
232  return m >= f ? m - f : 1;
233}
234
235uptr __tsan_get_free_bytes() {
236  return 1;
237}
238
239uptr __tsan_get_unmapped_bytes() {
240  return 1;
241}
242
243uptr __tsan_get_estimated_allocated_size(uptr size) {
244  return size;
245}
246
247bool __tsan_get_ownership(void *p) {
248  return allocator()->GetBlockBegin(p) != 0;
249}
250
251uptr __tsan_get_allocated_size(void *p) {
252  if (p == 0)
253    return 0;
254  p = allocator()->GetBlockBegin(p);
255  if (p == 0)
256    return 0;
257  MBlock *b = (MBlock*)allocator()->GetMetaData(p);
258  return b->Size();
259}
260
261void __tsan_on_thread_idle() {
262  ThreadState *thr = cur_thread();
263  allocator()->SwallowCache(&thr->alloc_cache);
264  internal_allocator()->SwallowCache(&thr->internal_alloc_cache);
265}
266}  // extern "C"
267