1 //===-- tsan_rtl_mutex.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_deadlock_detector_interface.h> 15 #include <sanitizer_common/sanitizer_stackdepot.h> 16 17 #include "tsan_rtl.h" 18 #include "tsan_flags.h" 19 #include "tsan_sync.h" 20 #include "tsan_report.h" 21 #include "tsan_symbolize.h" 22 #include "tsan_platform.h" 23 24 namespace __tsan { 25 26 void ReportDeadlock(ThreadState *thr, uptr pc, DDReport *r); 27 28 struct Callback : DDCallback { 29 ThreadState *thr; 30 uptr pc; 31 32 Callback(ThreadState *thr, uptr pc) 33 : thr(thr) 34 , pc(pc) { 35 DDCallback::pt = thr->dd_pt; 36 DDCallback::lt = thr->dd_lt; 37 } 38 39 u32 Unwind() override { return CurrentStackId(thr, pc); } 40 int UniqueTid() override { return thr->unique_id; } 41 }; 42 43 void DDMutexInit(ThreadState *thr, uptr pc, SyncVar *s) { 44 Callback cb(thr, pc); 45 ctx->dd->MutexInit(&cb, &s->dd); 46 s->dd.ctx = s->GetId(); 47 } 48 49 static void ReportMutexMisuse(ThreadState *thr, uptr pc, ReportType typ, 50 uptr addr, u64 mid) { 51 // In Go, these misuses are either impossible, or detected by std lib, 52 // or false positives (e.g. unlock in a different thread). 53 if (kGoMode) 54 return; 55 ThreadRegistryLock l(ctx->thread_registry); 56 ScopedReport rep(typ); 57 rep.AddMutex(mid); 58 VarSizeStackTrace trace; 59 ObtainCurrentStack(thr, pc, &trace); 60 rep.AddStack(trace, true); 61 rep.AddLocation(addr, 1); 62 OutputReport(thr, rep); 63 } 64 65 void MutexCreate(ThreadState *thr, uptr pc, uptr addr, 66 bool rw, bool recursive, bool linker_init) { 67 DPrintf("#%d: MutexCreate %zx\n", thr->tid, addr); 68 StatInc(thr, StatMutexCreate); 69 if (!linker_init && IsAppMem(addr)) { 70 CHECK(!thr->is_freeing); 71 thr->is_freeing = true; 72 MemoryWrite(thr, pc, addr, kSizeLog1); 73 thr->is_freeing = false; 74 } 75 SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true); 76 s->is_rw = rw; 77 s->is_recursive = recursive; 78 s->is_linker_init = linker_init; 79 if (kCppMode && s->creation_stack_id == 0) 80 s->creation_stack_id = CurrentStackId(thr, pc); 81 s->mtx.Unlock(); 82 } 83 84 void MutexDestroy(ThreadState *thr, uptr pc, uptr addr) { 85 DPrintf("#%d: MutexDestroy %zx\n", thr->tid, addr); 86 StatInc(thr, StatMutexDestroy); 87 #ifndef SANITIZER_GO 88 // Global mutexes not marked as LINKER_INITIALIZED 89 // cause tons of not interesting reports, so just ignore it. 90 if (IsGlobalVar(addr)) 91 return; 92 #endif 93 if (IsAppMem(addr)) { 94 CHECK(!thr->is_freeing); 95 thr->is_freeing = true; 96 MemoryWrite(thr, pc, addr, kSizeLog1); 97 thr->is_freeing = false; 98 } 99 SyncVar *s = ctx->metamap.GetIfExistsAndLock(addr); 100 if (s == 0) 101 return; 102 if (common_flags()->detect_deadlocks) { 103 Callback cb(thr, pc); 104 ctx->dd->MutexDestroy(&cb, &s->dd); 105 ctx->dd->MutexInit(&cb, &s->dd); 106 } 107 bool unlock_locked = false; 108 if (flags()->report_destroy_locked 109 && s->owner_tid != SyncVar::kInvalidTid 110 && !s->is_broken) { 111 s->is_broken = true; 112 unlock_locked = true; 113 } 114 u64 mid = s->GetId(); 115 u32 last_lock = s->last_lock; 116 if (!unlock_locked) 117 s->Reset(thr); // must not reset it before the report is printed 118 s->mtx.Unlock(); 119 if (unlock_locked) { 120 ThreadRegistryLock l(ctx->thread_registry); 121 ScopedReport rep(ReportTypeMutexDestroyLocked); 122 rep.AddMutex(mid); 123 VarSizeStackTrace trace; 124 ObtainCurrentStack(thr, pc, &trace); 125 rep.AddStack(trace); 126 FastState last(last_lock); 127 RestoreStack(last.tid(), last.epoch(), &trace, 0); 128 rep.AddStack(trace, true); 129 rep.AddLocation(addr, 1); 130 OutputReport(thr, rep); 131 } 132 if (unlock_locked) { 133 SyncVar *s = ctx->metamap.GetIfExistsAndLock(addr); 134 if (s != 0) { 135 s->Reset(thr); 136 s->mtx.Unlock(); 137 } 138 } 139 thr->mset.Remove(mid); 140 // s will be destroyed and freed in MetaMap::FreeBlock. 141 } 142 143 void MutexLock(ThreadState *thr, uptr pc, uptr addr, int rec, bool try_lock) { 144 DPrintf("#%d: MutexLock %zx rec=%d\n", thr->tid, addr, rec); 145 CHECK_GT(rec, 0); 146 if (IsAppMem(addr)) 147 MemoryReadAtomic(thr, pc, addr, kSizeLog1); 148 SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true); 149 thr->fast_state.IncrementEpoch(); 150 TraceAddEvent(thr, thr->fast_state, EventTypeLock, s->GetId()); 151 bool report_double_lock = false; 152 if (s->owner_tid == SyncVar::kInvalidTid) { 153 CHECK_EQ(s->recursion, 0); 154 s->owner_tid = thr->tid; 155 s->last_lock = thr->fast_state.raw(); 156 } else if (s->owner_tid == thr->tid) { 157 CHECK_GT(s->recursion, 0); 158 } else if (flags()->report_mutex_bugs && !s->is_broken) { 159 s->is_broken = true; 160 report_double_lock = true; 161 } 162 if (s->recursion == 0) { 163 StatInc(thr, StatMutexLock); 164 AcquireImpl(thr, pc, &s->clock); 165 AcquireImpl(thr, pc, &s->read_clock); 166 } else if (!s->is_recursive) { 167 StatInc(thr, StatMutexRecLock); 168 } 169 s->recursion += rec; 170 thr->mset.Add(s->GetId(), true, thr->fast_state.epoch()); 171 if (common_flags()->detect_deadlocks && (s->recursion - rec) == 0) { 172 Callback cb(thr, pc); 173 if (!try_lock) 174 ctx->dd->MutexBeforeLock(&cb, &s->dd, true); 175 ctx->dd->MutexAfterLock(&cb, &s->dd, true, try_lock); 176 } 177 u64 mid = s->GetId(); 178 s->mtx.Unlock(); 179 // Can't touch s after this point. 180 if (report_double_lock) 181 ReportMutexMisuse(thr, pc, ReportTypeMutexDoubleLock, addr, mid); 182 if (common_flags()->detect_deadlocks) { 183 Callback cb(thr, pc); 184 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb)); 185 } 186 } 187 188 int MutexUnlock(ThreadState *thr, uptr pc, uptr addr, bool all) { 189 DPrintf("#%d: MutexUnlock %zx all=%d\n", thr->tid, addr, all); 190 if (IsAppMem(addr)) 191 MemoryReadAtomic(thr, pc, addr, kSizeLog1); 192 SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true); 193 thr->fast_state.IncrementEpoch(); 194 TraceAddEvent(thr, thr->fast_state, EventTypeUnlock, s->GetId()); 195 int rec = 0; 196 bool report_bad_unlock = false; 197 if (kCppMode && (s->recursion == 0 || s->owner_tid != thr->tid)) { 198 if (flags()->report_mutex_bugs && !s->is_broken) { 199 s->is_broken = true; 200 report_bad_unlock = true; 201 } 202 } else { 203 rec = all ? s->recursion : 1; 204 s->recursion -= rec; 205 if (s->recursion == 0) { 206 StatInc(thr, StatMutexUnlock); 207 s->owner_tid = SyncVar::kInvalidTid; 208 ReleaseStoreImpl(thr, pc, &s->clock); 209 } else { 210 StatInc(thr, StatMutexRecUnlock); 211 } 212 } 213 thr->mset.Del(s->GetId(), true); 214 if (common_flags()->detect_deadlocks && s->recursion == 0 && 215 !report_bad_unlock) { 216 Callback cb(thr, pc); 217 ctx->dd->MutexBeforeUnlock(&cb, &s->dd, true); 218 } 219 u64 mid = s->GetId(); 220 s->mtx.Unlock(); 221 // Can't touch s after this point. 222 if (report_bad_unlock) 223 ReportMutexMisuse(thr, pc, ReportTypeMutexBadUnlock, addr, mid); 224 if (common_flags()->detect_deadlocks && !report_bad_unlock) { 225 Callback cb(thr, pc); 226 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb)); 227 } 228 return rec; 229 } 230 231 void MutexReadLock(ThreadState *thr, uptr pc, uptr addr, bool trylock) { 232 DPrintf("#%d: MutexReadLock %zx\n", thr->tid, addr); 233 StatInc(thr, StatMutexReadLock); 234 if (IsAppMem(addr)) 235 MemoryReadAtomic(thr, pc, addr, kSizeLog1); 236 SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, false); 237 thr->fast_state.IncrementEpoch(); 238 TraceAddEvent(thr, thr->fast_state, EventTypeRLock, s->GetId()); 239 bool report_bad_lock = false; 240 if (s->owner_tid != SyncVar::kInvalidTid) { 241 if (flags()->report_mutex_bugs && !s->is_broken) { 242 s->is_broken = true; 243 report_bad_lock = true; 244 } 245 } 246 AcquireImpl(thr, pc, &s->clock); 247 s->last_lock = thr->fast_state.raw(); 248 thr->mset.Add(s->GetId(), false, thr->fast_state.epoch()); 249 if (common_flags()->detect_deadlocks && s->recursion == 0) { 250 Callback cb(thr, pc); 251 if (!trylock) 252 ctx->dd->MutexBeforeLock(&cb, &s->dd, false); 253 ctx->dd->MutexAfterLock(&cb, &s->dd, false, trylock); 254 } 255 u64 mid = s->GetId(); 256 s->mtx.ReadUnlock(); 257 // Can't touch s after this point. 258 if (report_bad_lock) 259 ReportMutexMisuse(thr, pc, ReportTypeMutexBadReadLock, addr, mid); 260 if (common_flags()->detect_deadlocks) { 261 Callback cb(thr, pc); 262 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb)); 263 } 264 } 265 266 void MutexReadUnlock(ThreadState *thr, uptr pc, uptr addr) { 267 DPrintf("#%d: MutexReadUnlock %zx\n", thr->tid, addr); 268 StatInc(thr, StatMutexReadUnlock); 269 if (IsAppMem(addr)) 270 MemoryReadAtomic(thr, pc, addr, kSizeLog1); 271 SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true); 272 thr->fast_state.IncrementEpoch(); 273 TraceAddEvent(thr, thr->fast_state, EventTypeRUnlock, s->GetId()); 274 bool report_bad_unlock = false; 275 if (s->owner_tid != SyncVar::kInvalidTid) { 276 if (flags()->report_mutex_bugs && !s->is_broken) { 277 s->is_broken = true; 278 report_bad_unlock = true; 279 } 280 } 281 ReleaseImpl(thr, pc, &s->read_clock); 282 if (common_flags()->detect_deadlocks && s->recursion == 0) { 283 Callback cb(thr, pc); 284 ctx->dd->MutexBeforeUnlock(&cb, &s->dd, false); 285 } 286 u64 mid = s->GetId(); 287 s->mtx.Unlock(); 288 // Can't touch s after this point. 289 thr->mset.Del(mid, false); 290 if (report_bad_unlock) 291 ReportMutexMisuse(thr, pc, ReportTypeMutexBadReadUnlock, addr, mid); 292 if (common_flags()->detect_deadlocks) { 293 Callback cb(thr, pc); 294 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb)); 295 } 296 } 297 298 void MutexReadOrWriteUnlock(ThreadState *thr, uptr pc, uptr addr) { 299 DPrintf("#%d: MutexReadOrWriteUnlock %zx\n", thr->tid, addr); 300 if (IsAppMem(addr)) 301 MemoryReadAtomic(thr, pc, addr, kSizeLog1); 302 SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true); 303 bool write = true; 304 bool report_bad_unlock = false; 305 if (s->owner_tid == SyncVar::kInvalidTid) { 306 // Seems to be read unlock. 307 write = false; 308 StatInc(thr, StatMutexReadUnlock); 309 thr->fast_state.IncrementEpoch(); 310 TraceAddEvent(thr, thr->fast_state, EventTypeRUnlock, s->GetId()); 311 ReleaseImpl(thr, pc, &s->read_clock); 312 } else if (s->owner_tid == thr->tid) { 313 // Seems to be write unlock. 314 thr->fast_state.IncrementEpoch(); 315 TraceAddEvent(thr, thr->fast_state, EventTypeUnlock, s->GetId()); 316 CHECK_GT(s->recursion, 0); 317 s->recursion--; 318 if (s->recursion == 0) { 319 StatInc(thr, StatMutexUnlock); 320 s->owner_tid = SyncVar::kInvalidTid; 321 ReleaseImpl(thr, pc, &s->clock); 322 } else { 323 StatInc(thr, StatMutexRecUnlock); 324 } 325 } else if (!s->is_broken) { 326 s->is_broken = true; 327 report_bad_unlock = true; 328 } 329 thr->mset.Del(s->GetId(), write); 330 if (common_flags()->detect_deadlocks && s->recursion == 0) { 331 Callback cb(thr, pc); 332 ctx->dd->MutexBeforeUnlock(&cb, &s->dd, write); 333 } 334 u64 mid = s->GetId(); 335 s->mtx.Unlock(); 336 // Can't touch s after this point. 337 if (report_bad_unlock) 338 ReportMutexMisuse(thr, pc, ReportTypeMutexBadUnlock, addr, mid); 339 if (common_flags()->detect_deadlocks) { 340 Callback cb(thr, pc); 341 ReportDeadlock(thr, pc, ctx->dd->GetReport(&cb)); 342 } 343 } 344 345 void MutexRepair(ThreadState *thr, uptr pc, uptr addr) { 346 DPrintf("#%d: MutexRepair %zx\n", thr->tid, addr); 347 SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true); 348 s->owner_tid = SyncVar::kInvalidTid; 349 s->recursion = 0; 350 s->mtx.Unlock(); 351 } 352 353 void Acquire(ThreadState *thr, uptr pc, uptr addr) { 354 DPrintf("#%d: Acquire %zx\n", thr->tid, addr); 355 if (thr->ignore_sync) 356 return; 357 SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, false); 358 AcquireImpl(thr, pc, &s->clock); 359 s->mtx.ReadUnlock(); 360 } 361 362 static void UpdateClockCallback(ThreadContextBase *tctx_base, void *arg) { 363 ThreadState *thr = reinterpret_cast<ThreadState*>(arg); 364 ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base); 365 if (tctx->status == ThreadStatusRunning) 366 thr->clock.set(tctx->tid, tctx->thr->fast_state.epoch()); 367 else 368 thr->clock.set(tctx->tid, tctx->epoch1); 369 } 370 371 void AcquireGlobal(ThreadState *thr, uptr pc) { 372 DPrintf("#%d: AcquireGlobal\n", thr->tid); 373 if (thr->ignore_sync) 374 return; 375 ThreadRegistryLock l(ctx->thread_registry); 376 ctx->thread_registry->RunCallbackForEachThreadLocked( 377 UpdateClockCallback, thr); 378 } 379 380 void Release(ThreadState *thr, uptr pc, uptr addr) { 381 DPrintf("#%d: Release %zx\n", thr->tid, addr); 382 if (thr->ignore_sync) 383 return; 384 SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true); 385 thr->fast_state.IncrementEpoch(); 386 // Can't increment epoch w/o writing to the trace as well. 387 TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0); 388 ReleaseImpl(thr, pc, &s->clock); 389 s->mtx.Unlock(); 390 } 391 392 void ReleaseStore(ThreadState *thr, uptr pc, uptr addr) { 393 DPrintf("#%d: ReleaseStore %zx\n", thr->tid, addr); 394 if (thr->ignore_sync) 395 return; 396 SyncVar *s = ctx->metamap.GetOrCreateAndLock(thr, pc, addr, true); 397 thr->fast_state.IncrementEpoch(); 398 // Can't increment epoch w/o writing to the trace as well. 399 TraceAddEvent(thr, thr->fast_state, EventTypeMop, 0); 400 ReleaseStoreImpl(thr, pc, &s->clock); 401 s->mtx.Unlock(); 402 } 403 404 #ifndef SANITIZER_GO 405 static void UpdateSleepClockCallback(ThreadContextBase *tctx_base, void *arg) { 406 ThreadState *thr = reinterpret_cast<ThreadState*>(arg); 407 ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base); 408 if (tctx->status == ThreadStatusRunning) 409 thr->last_sleep_clock.set(tctx->tid, tctx->thr->fast_state.epoch()); 410 else 411 thr->last_sleep_clock.set(tctx->tid, tctx->epoch1); 412 } 413 414 void AfterSleep(ThreadState *thr, uptr pc) { 415 DPrintf("#%d: AfterSleep %zx\n", thr->tid); 416 if (thr->ignore_sync) 417 return; 418 thr->last_sleep_stack_id = CurrentStackId(thr, pc); 419 ThreadRegistryLock l(ctx->thread_registry); 420 ctx->thread_registry->RunCallbackForEachThreadLocked( 421 UpdateSleepClockCallback, thr); 422 } 423 #endif 424 425 void AcquireImpl(ThreadState *thr, uptr pc, SyncClock *c) { 426 if (thr->ignore_sync) 427 return; 428 thr->clock.set(thr->fast_state.epoch()); 429 thr->clock.acquire(&thr->clock_cache, c); 430 StatInc(thr, StatSyncAcquire); 431 } 432 433 void ReleaseImpl(ThreadState *thr, uptr pc, SyncClock *c) { 434 if (thr->ignore_sync) 435 return; 436 thr->clock.set(thr->fast_state.epoch()); 437 thr->fast_synch_epoch = thr->fast_state.epoch(); 438 thr->clock.release(&thr->clock_cache, c); 439 StatInc(thr, StatSyncRelease); 440 } 441 442 void ReleaseStoreImpl(ThreadState *thr, uptr pc, SyncClock *c) { 443 if (thr->ignore_sync) 444 return; 445 thr->clock.set(thr->fast_state.epoch()); 446 thr->fast_synch_epoch = thr->fast_state.epoch(); 447 thr->clock.ReleaseStore(&thr->clock_cache, c); 448 StatInc(thr, StatSyncRelease); 449 } 450 451 void AcquireReleaseImpl(ThreadState *thr, uptr pc, SyncClock *c) { 452 if (thr->ignore_sync) 453 return; 454 thr->clock.set(thr->fast_state.epoch()); 455 thr->fast_synch_epoch = thr->fast_state.epoch(); 456 thr->clock.acq_rel(&thr->clock_cache, c); 457 StatInc(thr, StatSyncAcquire); 458 StatInc(thr, StatSyncRelease); 459 } 460 461 void ReportDeadlock(ThreadState *thr, uptr pc, DDReport *r) { 462 if (r == 0) 463 return; 464 ThreadRegistryLock l(ctx->thread_registry); 465 ScopedReport rep(ReportTypeDeadlock); 466 for (int i = 0; i < r->n; i++) { 467 rep.AddMutex(r->loop[i].mtx_ctx0); 468 rep.AddUniqueTid((int)r->loop[i].thr_ctx); 469 rep.AddThread((int)r->loop[i].thr_ctx); 470 } 471 uptr dummy_pc = 0x42; 472 for (int i = 0; i < r->n; i++) { 473 for (int j = 0; j < (flags()->second_deadlock_stack ? 2 : 1); j++) { 474 u32 stk = r->loop[i].stk[j]; 475 if (stk) { 476 rep.AddStack(StackDepotGet(stk), true); 477 } else { 478 // Sometimes we fail to extract the stack trace (FIXME: investigate), 479 // but we should still produce some stack trace in the report. 480 rep.AddStack(StackTrace(&dummy_pc, 1), true); 481 } 482 } 483 } 484 OutputReport(thr, rep); 485 } 486 487 } // namespace __tsan 488
