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