libsanitizer/tsan/tsan_rtl_thread.cc

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