tsan_rtl_thread.cc revision 9743d74426ae43898e4da55e591b09be18f8aa6e 
1//===-- tsan_rtl_thread.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
14#include "sanitizer_common/sanitizer_placement_new.h"
15#include "tsan_rtl.h"
16#include "tsan_mman.h"
17#include "tsan_platform.h"
18#include "tsan_report.h"
19#include "tsan_sync.h"
20
21namespace __tsan {
22
23// ThreadContext implementation.
24
25ThreadContext::ThreadContext(int tid)
26  : ThreadContextBase(tid)
27  , thr()
28  , sync()
29  , epoch0()
30  , epoch1() {
31}
32
33#ifndef TSAN_GO
34ThreadContext::~ThreadContext() {
35}
36#endif
37
38void ThreadContext::OnDead() {
39  sync.Reset();
40}
41
42void ThreadContext::OnJoined(void *arg) {
43  ThreadState *caller_thr = static_cast<ThreadState *>(arg);
44  caller_thr->clock.acquire(&sync);
45  StatInc(caller_thr, StatSyncAcquire);
46  sync.Reset();
47}
48
49struct OnCreatedArgs {
50  ThreadState *thr;
51  uptr pc;
52};
53
54void ThreadContext::OnCreated(void *arg) {
55  thr = 0;
56  if (tid == 0)
57    return;
58  OnCreatedArgs *args = static_cast<OnCreatedArgs *>(arg);
59  args->thr->fast_state.IncrementEpoch();
60  // Can't increment epoch w/o writing to the trace as well.
61  TraceAddEvent(args->thr, args->thr->fast_state, EventTypeMop, 0);
62  args->thr->clock.set(args->thr->tid, args->thr->fast_state.epoch());
63  args->thr->fast_synch_epoch = args->thr->fast_state.epoch();
64  args->thr->clock.release(&sync);
65  StatInc(args->thr, StatSyncRelease);
66#ifdef TSAN_GO
67  creation_stack.ObtainCurrent(args->thr, args->pc);
68#else
69  creation_stack_id = CurrentStackId(args->thr, args->pc);
70#endif
71  if (reuse_count == 0)
72    StatInc(args->thr, StatThreadMaxTid);
73}
74
75void ThreadContext::OnReset() {
76  sync.Reset();
77  FlushUnneededShadowMemory(GetThreadTrace(tid), TraceSize() * sizeof(Event));
78  //!!! FlushUnneededShadowMemory(GetThreadTraceHeader(tid), sizeof(Trace));
79}
80
81struct OnStartedArgs {
82  ThreadState *thr;
83  uptr stk_addr;
84  uptr stk_size;
85  uptr tls_addr;
86  uptr tls_size;
87};
88
89void ThreadContext::OnStarted(void *arg) {
90  OnStartedArgs *args = static_cast<OnStartedArgs*>(arg);
91  thr = args->thr;
92  // RoundUp so that one trace part does not contain events
93  // from different threads.
94  epoch0 = RoundUp(epoch1 + 1, kTracePartSize);
95  epoch1 = (u64)-1;
96  new(thr) ThreadState(CTX(), tid, unique_id,
97      epoch0, args->stk_addr, args->stk_size, args->tls_addr, args->tls_size);
98#ifdef TSAN_GO
99  // Setup dynamic shadow stack.
100  const int kInitStackSize = 8;
101  args->thr->shadow_stack = (uptr*)internal_alloc(MBlockShadowStack,
102      kInitStackSize * sizeof(uptr));
103  args->thr->shadow_stack_pos = thr->shadow_stack;
104  args->thr->shadow_stack_end = thr->shadow_stack + kInitStackSize;
105#endif
106#ifndef TSAN_GO
107  AllocatorThreadStart(args->thr);
108#endif
109  thr = args->thr;
110  thr->fast_synch_epoch = epoch0;
111  thr->clock.set(tid, epoch0);
112  thr->clock.acquire(&sync);
113  thr->fast_state.SetHistorySize(flags()->history_size);
114  const uptr trace = (epoch0 / kTracePartSize) % TraceParts();
115  Trace *thr_trace = ThreadTrace(thr->tid);
116  thr_trace->headers[trace].epoch0 = epoch0;
117  StatInc(thr, StatSyncAcquire);
118  sync.Reset();
119  DPrintf("#%d: ThreadStart epoch=%zu stk_addr=%zx stk_size=%zx "
120          "tls_addr=%zx tls_size=%zx\n",
121          tid, (uptr)epoch0, args->stk_addr, args->stk_size,
122          args->tls_addr, args->tls_size);
123  thr->is_alive = true;
124}
125
126void ThreadContext::OnFinished() {
127  if (!detached) {
128    thr->fast_state.IncrementEpoch();
129    // Can't increment epoch w/o writing to the trace as well.
130    TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0);
131    thr->clock.set(thr->tid, thr->fast_state.epoch());
132    thr->fast_synch_epoch = thr->fast_state.epoch();
133    thr->clock.release(&sync);
134    StatInc(thr, StatSyncRelease);
135  }
136  epoch1 = thr->fast_state.epoch();
137
138#ifndef TSAN_GO
139  AllocatorThreadFinish(thr);
140#endif
141  thr->~ThreadState();
142  StatAggregate(CTX()->stat, thr->stat);
143  thr = 0;
144}
145
146static void MaybeReportThreadLeak(ThreadContextBase *tctx_base, void *unused) {
147  ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base);
148  if (tctx->detached)
149    return;
150  if (tctx->status != ThreadStatusCreated
151      && tctx->status != ThreadStatusRunning
152      && tctx->status != ThreadStatusFinished)
153    return;
154  ScopedReport rep(ReportTypeThreadLeak);
155  rep.AddThread(tctx);
156  OutputReport(CTX(), rep);
157}
158
159void ThreadFinalize(ThreadState *thr) {
160  CHECK_GT(thr->in_rtl, 0);
161  if (!flags()->report_thread_leaks)
162    return;
163  ThreadRegistryLock l(CTX()->thread_registry);
164  CTX()->thread_registry->RunCallbackForEachThreadLocked(
165      MaybeReportThreadLeak, 0);
166}
167
168int ThreadCount(ThreadState *thr) {
169  CHECK_GT(thr->in_rtl, 0);
170  Context *ctx = CTX();
171  uptr result;
172  ctx->thread_registry->GetNumberOfThreads(0, 0, &result);
173  return (int)result;
174}
175
176int ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached) {
177  CHECK_GT(thr->in_rtl, 0);
178  StatInc(thr, StatThreadCreate);
179  Context *ctx = CTX();
180  OnCreatedArgs args = { thr, pc };
181  int tid = ctx->thread_registry->CreateThread(uid, detached, thr->tid, &args);
182  DPrintf("#%d: ThreadCreate tid=%d uid=%zu\n", thr->tid, tid, uid);
183  StatSet(thr, StatThreadMaxAlive, ctx->thread_registry->GetMaxAliveThreads());
184  return tid;
185}
186
187void ThreadStart(ThreadState *thr, int tid, uptr os_id) {
188  CHECK_GT(thr->in_rtl, 0);
189  uptr stk_addr = 0;
190  uptr stk_size = 0;
191  uptr tls_addr = 0;
192  uptr tls_size = 0;
193  GetThreadStackAndTls(tid == 0, &stk_addr, &stk_size, &tls_addr, &tls_size);
194
195  if (tid) {
196    if (stk_addr && stk_size)
197      MemoryRangeImitateWrite(thr, /*pc=*/ 1, stk_addr, stk_size);
198
199    if (tls_addr && tls_size) {
200      // Check that the thr object is in tls;
201      const uptr thr_beg = (uptr)thr;
202      const uptr thr_end = (uptr)thr + sizeof(*thr);
203      CHECK_GE(thr_beg, tls_addr);
204      CHECK_LE(thr_beg, tls_addr + tls_size);
205      CHECK_GE(thr_end, tls_addr);
206      CHECK_LE(thr_end, tls_addr + tls_size);
207      // Since the thr object is huge, skip it.
208      MemoryRangeImitateWrite(thr, /*pc=*/ 2, tls_addr, thr_beg - tls_addr);
209      MemoryRangeImitateWrite(thr, /*pc=*/ 2,
210          thr_end, tls_addr + tls_size - thr_end);
211    }
212  }
213
214  OnStartedArgs args = { thr, stk_addr, stk_size, tls_addr, tls_size };
215  CTX()->thread_registry->StartThread(tid, os_id, &args);
216}
217
218void ThreadFinish(ThreadState *thr) {
219  CHECK_GT(thr->in_rtl, 0);
220  StatInc(thr, StatThreadFinish);
221  if (thr->stk_addr && thr->stk_size)
222    DontNeedShadowFor(thr->stk_addr, thr->stk_size);
223  if (thr->tls_addr && thr->tls_size)
224    DontNeedShadowFor(thr->tls_addr, thr->tls_size);
225  thr->is_alive = false;
226  Context *ctx = CTX();
227  ctx->thread_registry->FinishThread(thr->tid);
228}
229
230static bool FindThreadByUid(ThreadContextBase *tctx, void *arg) {
231  uptr uid = (uptr)arg;
232  if (tctx->user_id == uid && tctx->status != ThreadStatusInvalid) {
233    tctx->user_id = 0;
234    return true;
235  }
236  return false;
237}
238
239int ThreadTid(ThreadState *thr, uptr pc, uptr uid) {
240  CHECK_GT(thr->in_rtl, 0);
241  Context *ctx = CTX();
242  int res = ctx->thread_registry->FindThread(FindThreadByUid, (void*)uid);
243  DPrintf("#%d: ThreadTid uid=%zu tid=%d\n", thr->tid, uid, res);
244  return res;
245}
246
247void ThreadJoin(ThreadState *thr, uptr pc, int tid) {
248  CHECK_GT(thr->in_rtl, 0);
249  CHECK_GT(tid, 0);
250  CHECK_LT(tid, kMaxTid);
251  DPrintf("#%d: ThreadJoin tid=%d\n", thr->tid, tid);
252  Context *ctx = CTX();
253  ctx->thread_registry->JoinThread(tid, thr);
254}
255
256void ThreadDetach(ThreadState *thr, uptr pc, int tid) {
257  CHECK_GT(thr->in_rtl, 0);
258  CHECK_GT(tid, 0);
259  CHECK_LT(tid, kMaxTid);
260  Context *ctx = CTX();
261  ctx->thread_registry->DetachThread(tid);
262}
263
264void ThreadSetName(ThreadState *thr, const char *name) {
265  CHECK_GT(thr->in_rtl, 0);
266  CTX()->thread_registry->SetThreadName(thr->tid, name);
267}
268
269void MemoryAccessRange(ThreadState *thr, uptr pc, uptr addr,
270                       uptr size, bool is_write) {
271  if (size == 0)
272    return;
273
274  u64 *shadow_mem = (u64*)MemToShadow(addr);
275  DPrintf2("#%d: MemoryAccessRange: @%p %p size=%d is_write=%d\n",
276      thr->tid, (void*)pc, (void*)addr,
277      (int)size, is_write);
278
279#if TSAN_DEBUG
280  if (!IsAppMem(addr)) {
281    Printf("Access to non app mem %zx\n", addr);
282    DCHECK(IsAppMem(addr));
283  }
284  if (!IsAppMem(addr + size - 1)) {
285    Printf("Access to non app mem %zx\n", addr + size - 1);
286    DCHECK(IsAppMem(addr + size - 1));
287  }
288  if (!IsShadowMem((uptr)shadow_mem)) {
289    Printf("Bad shadow addr %p (%zx)\n", shadow_mem, addr);
290    DCHECK(IsShadowMem((uptr)shadow_mem));
291  }
292  if (!IsShadowMem((uptr)(shadow_mem + size * kShadowCnt / 8 - 1))) {
293    Printf("Bad shadow addr %p (%zx)\n",
294               shadow_mem + size * kShadowCnt / 8 - 1, addr + size - 1);
295    DCHECK(IsShadowMem((uptr)(shadow_mem + size * kShadowCnt / 8 - 1)));
296  }
297#endif
298
299  StatInc(thr, StatMopRange);
300
301  FastState fast_state = thr->fast_state;
302  if (fast_state.GetIgnoreBit())
303    return;
304
305  fast_state.IncrementEpoch();
306  thr->fast_state = fast_state;
307  TraceAddEvent(thr, fast_state, EventTypeMop, pc);
308
309  bool unaligned = (addr % kShadowCell) != 0;
310
311  // Handle unaligned beginning, if any.
312  for (; addr % kShadowCell && size; addr++, size--) {
313    int const kAccessSizeLog = 0;
314    Shadow cur(fast_state);
315    cur.SetWrite(is_write);
316    cur.SetAddr0AndSizeLog(addr & (kShadowCell - 1), kAccessSizeLog);
317    MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, false,
318        shadow_mem, cur);
319  }
320  if (unaligned)
321    shadow_mem += kShadowCnt;
322  // Handle middle part, if any.
323  for (; size >= kShadowCell; addr += kShadowCell, size -= kShadowCell) {
324    int const kAccessSizeLog = 3;
325    Shadow cur(fast_state);
326    cur.SetWrite(is_write);
327    cur.SetAddr0AndSizeLog(0, kAccessSizeLog);
328    MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, false,
329        shadow_mem, cur);
330    shadow_mem += kShadowCnt;
331  }
332  // Handle ending, if any.
333  for (; size; addr++, size--) {
334    int const kAccessSizeLog = 0;
335    Shadow cur(fast_state);
336    cur.SetWrite(is_write);
337    cur.SetAddr0AndSizeLog(addr & (kShadowCell - 1), kAccessSizeLog);
338    MemoryAccessImpl(thr, addr, kAccessSizeLog, is_write, false,
339        shadow_mem, cur);
340  }
341}
342
343void MemoryAccessRangeStep(ThreadState *thr, uptr pc, uptr addr,
344    uptr size, uptr step, bool is_write) {
345  if (size == 0)
346    return;
347  FastState fast_state = thr->fast_state;
348  if (fast_state.GetIgnoreBit())
349    return;
350  StatInc(thr, StatMopRange);
351  fast_state.IncrementEpoch();
352  thr->fast_state = fast_state;
353  TraceAddEvent(thr, fast_state, EventTypeMop, pc);
354
355  for (uptr addr_end = addr + size; addr < addr_end; addr += step) {
356    u64 *shadow_mem = (u64*)MemToShadow(addr);
357    Shadow cur(fast_state);
358    cur.SetWrite(is_write);
359    cur.SetAddr0AndSizeLog(addr & (kShadowCell - 1), kSizeLog1);
360    MemoryAccessImpl(thr, addr, kSizeLog1, is_write, false,
361        shadow_mem, cur);
362  }
363}
364}  // namespace __tsan
365