1 //===-- tsan_rtl_report.cpp -----------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file is a part of ThreadSanitizer (TSan), a race detector. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "sanitizer_common/sanitizer_common.h" 14 #include "sanitizer_common/sanitizer_libc.h" 15 #include "sanitizer_common/sanitizer_placement_new.h" 16 #include "sanitizer_common/sanitizer_stackdepot.h" 17 #include "sanitizer_common/sanitizer_stacktrace.h" 18 #include "tsan_fd.h" 19 #include "tsan_flags.h" 20 #include "tsan_mman.h" 21 #include "tsan_platform.h" 22 #include "tsan_report.h" 23 #include "tsan_rtl.h" 24 #include "tsan_suppressions.h" 25 #include "tsan_symbolize.h" 26 #include "tsan_sync.h" 27 28 namespace __tsan { 29 30 using namespace __sanitizer; 31 32 static ReportStack *SymbolizeStack(StackTrace trace); 33 34 // Can be overriden by an application/test to intercept reports. 35 #ifdef TSAN_EXTERNAL_HOOKS 36 bool OnReport(const ReportDesc *rep, bool suppressed); 37 #else 38 SANITIZER_WEAK_CXX_DEFAULT_IMPL 39 bool OnReport(const ReportDesc *rep, bool suppressed) { 40 (void)rep; 41 return suppressed; 42 } 43 #endif 44 45 SANITIZER_WEAK_DEFAULT_IMPL 46 void __tsan_on_report(const ReportDesc *rep) { 47 (void)rep; 48 } 49 50 static void StackStripMain(SymbolizedStack *frames) { 51 SymbolizedStack *last_frame = nullptr; 52 SymbolizedStack *last_frame2 = nullptr; 53 for (SymbolizedStack *cur = frames; cur; cur = cur->next) { 54 last_frame2 = last_frame; 55 last_frame = cur; 56 } 57 58 if (last_frame2 == 0) 59 return; 60 #if !SANITIZER_GO 61 const char *last = last_frame->info.function; 62 const char *last2 = last_frame2->info.function; 63 // Strip frame above 'main' 64 if (last2 && 0 == internal_strcmp(last2, "main")) { 65 last_frame->ClearAll(); 66 last_frame2->next = nullptr; 67 // Strip our internal thread start routine. 68 } else if (last && 0 == internal_strcmp(last, "__tsan_thread_start_func")) { 69 last_frame->ClearAll(); 70 last_frame2->next = nullptr; 71 // Strip global ctors init, .preinit_array and main caller. 72 } else if (last && (0 == internal_strcmp(last, "__do_global_ctors_aux") || 73 0 == internal_strcmp(last, "__libc_csu_init") || 74 0 == internal_strcmp(last, "__libc_start_main"))) { 75 last_frame->ClearAll(); 76 last_frame2->next = nullptr; 77 // If both are 0, then we probably just failed to symbolize. 78 } else if (last || last2) { 79 // Ensure that we recovered stack completely. Trimmed stack 80 // can actually happen if we do not instrument some code, 81 // so it's only a debug print. However we must try hard to not miss it 82 // due to our fault. 83 DPrintf("Bottom stack frame is missed\n"); 84 } 85 #else 86 // The last frame always point into runtime (gosched0, goexit0, runtime.main). 87 last_frame->ClearAll(); 88 last_frame2->next = nullptr; 89 #endif 90 } 91 92 ReportStack *SymbolizeStackId(u32 stack_id) { 93 if (stack_id == 0) 94 return 0; 95 StackTrace stack = StackDepotGet(stack_id); 96 if (stack.trace == nullptr) 97 return nullptr; 98 return SymbolizeStack(stack); 99 } 100 101 static ReportStack *SymbolizeStack(StackTrace trace) { 102 if (trace.size == 0) 103 return 0; 104 SymbolizedStack *top = nullptr; 105 for (uptr si = 0; si < trace.size; si++) { 106 const uptr pc = trace.trace[si]; 107 uptr pc1 = pc; 108 // We obtain the return address, but we're interested in the previous 109 // instruction. 110 if ((pc & kExternalPCBit) == 0) 111 pc1 = StackTrace::GetPreviousInstructionPc(pc); 112 SymbolizedStack *ent = SymbolizeCode(pc1); 113 CHECK_NE(ent, 0); 114 SymbolizedStack *last = ent; 115 while (last->next) { 116 last->info.address = pc; // restore original pc for report 117 last = last->next; 118 } 119 last->info.address = pc; // restore original pc for report 120 last->next = top; 121 top = ent; 122 } 123 StackStripMain(top); 124 125 auto *stack = New<ReportStack>(); 126 stack->frames = top; 127 return stack; 128 } 129 130 bool ShouldReport(ThreadState *thr, ReportType typ) { 131 // We set thr->suppress_reports in the fork context. 132 // Taking any locking in the fork context can lead to deadlocks. 133 // If any locks are already taken, it's too late to do this check. 134 CheckedMutex::CheckNoLocks(); 135 // For the same reason check we didn't lock thread_registry yet. 136 if (SANITIZER_DEBUG) 137 ThreadRegistryLock l(&ctx->thread_registry); 138 if (!flags()->report_bugs || thr->suppress_reports) 139 return false; 140 switch (typ) { 141 case ReportTypeSignalUnsafe: 142 return flags()->report_signal_unsafe; 143 case ReportTypeThreadLeak: 144 #if !SANITIZER_GO 145 // It's impossible to join phantom threads 146 // in the child after fork. 147 if (ctx->after_multithreaded_fork) 148 return false; 149 #endif 150 return flags()->report_thread_leaks; 151 case ReportTypeMutexDestroyLocked: 152 return flags()->report_destroy_locked; 153 default: 154 return true; 155 } 156 } 157 158 ScopedReportBase::ScopedReportBase(ReportType typ, uptr tag) { 159 ctx->thread_registry.CheckLocked(); 160 rep_ = New<ReportDesc>(); 161 rep_->typ = typ; 162 rep_->tag = tag; 163 ctx->report_mtx.Lock(); 164 } 165 166 ScopedReportBase::~ScopedReportBase() { 167 ctx->report_mtx.Unlock(); 168 DestroyAndFree(rep_); 169 } 170 171 void ScopedReportBase::AddStack(StackTrace stack, bool suppressable) { 172 ReportStack **rs = rep_->stacks.PushBack(); 173 *rs = SymbolizeStack(stack); 174 (*rs)->suppressable = suppressable; 175 } 176 177 void ScopedReportBase::AddMemoryAccess(uptr addr, uptr external_tag, Shadow s, 178 Tid tid, StackTrace stack, 179 const MutexSet *mset) { 180 uptr addr0, size; 181 AccessType typ; 182 s.GetAccess(&addr0, &size, &typ); 183 auto *mop = New<ReportMop>(); 184 rep_->mops.PushBack(mop); 185 mop->tid = tid; 186 mop->addr = addr + addr0; 187 mop->size = size; 188 mop->write = !(typ & kAccessRead); 189 mop->atomic = typ & kAccessAtomic; 190 mop->stack = SymbolizeStack(stack); 191 mop->external_tag = external_tag; 192 if (mop->stack) 193 mop->stack->suppressable = true; 194 for (uptr i = 0; i < mset->Size(); i++) { 195 MutexSet::Desc d = mset->Get(i); 196 int id = this->AddMutex(d.addr, d.stack_id); 197 ReportMopMutex mtx = {id, d.write}; 198 mop->mset.PushBack(mtx); 199 } 200 } 201 202 void ScopedReportBase::AddUniqueTid(Tid unique_tid) { 203 rep_->unique_tids.PushBack(unique_tid); 204 } 205 206 void ScopedReportBase::AddThread(const ThreadContext *tctx, bool suppressable) { 207 for (uptr i = 0; i < rep_->threads.Size(); i++) { 208 if ((u32)rep_->threads[i]->id == tctx->tid) 209 return; 210 } 211 auto *rt = New<ReportThread>(); 212 rep_->threads.PushBack(rt); 213 rt->id = tctx->tid; 214 rt->os_id = tctx->os_id; 215 rt->running = (tctx->status == ThreadStatusRunning); 216 rt->name = internal_strdup(tctx->name); 217 rt->parent_tid = tctx->parent_tid; 218 rt->thread_type = tctx->thread_type; 219 rt->stack = 0; 220 rt->stack = SymbolizeStackId(tctx->creation_stack_id); 221 if (rt->stack) 222 rt->stack->suppressable = suppressable; 223 } 224 225 #if !SANITIZER_GO 226 static ThreadContext *FindThreadByTidLocked(Tid tid) { 227 ctx->thread_registry.CheckLocked(); 228 return static_cast<ThreadContext *>( 229 ctx->thread_registry.GetThreadLocked(tid)); 230 } 231 232 static bool IsInStackOrTls(ThreadContextBase *tctx_base, void *arg) { 233 uptr addr = (uptr)arg; 234 ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base); 235 if (tctx->status != ThreadStatusRunning) 236 return false; 237 ThreadState *thr = tctx->thr; 238 CHECK(thr); 239 return ((addr >= thr->stk_addr && addr < thr->stk_addr + thr->stk_size) || 240 (addr >= thr->tls_addr && addr < thr->tls_addr + thr->tls_size)); 241 } 242 243 ThreadContext *IsThreadStackOrTls(uptr addr, bool *is_stack) { 244 ctx->thread_registry.CheckLocked(); 245 ThreadContext *tctx = 246 static_cast<ThreadContext *>(ctx->thread_registry.FindThreadContextLocked( 247 IsInStackOrTls, (void *)addr)); 248 if (!tctx) 249 return 0; 250 ThreadState *thr = tctx->thr; 251 CHECK(thr); 252 *is_stack = (addr >= thr->stk_addr && addr < thr->stk_addr + thr->stk_size); 253 return tctx; 254 } 255 #endif 256 257 void ScopedReportBase::AddThread(Tid tid, bool suppressable) { 258 #if !SANITIZER_GO 259 if (const ThreadContext *tctx = FindThreadByTidLocked(tid)) 260 AddThread(tctx, suppressable); 261 #endif 262 } 263 264 int ScopedReportBase::AddMutex(uptr addr, StackID creation_stack_id) { 265 for (uptr i = 0; i < rep_->mutexes.Size(); i++) { 266 if (rep_->mutexes[i]->addr == addr) 267 return rep_->mutexes[i]->id; 268 } 269 auto *rm = New<ReportMutex>(); 270 rep_->mutexes.PushBack(rm); 271 rm->id = rep_->mutexes.Size() - 1; 272 rm->addr = addr; 273 rm->stack = SymbolizeStackId(creation_stack_id); 274 return rm->id; 275 } 276 277 void ScopedReportBase::AddLocation(uptr addr, uptr size) { 278 if (addr == 0) 279 return; 280 #if !SANITIZER_GO 281 int fd = -1; 282 Tid creat_tid = kInvalidTid; 283 StackID creat_stack = 0; 284 bool closed = false; 285 if (FdLocation(addr, &fd, &creat_tid, &creat_stack, &closed)) { 286 auto *loc = New<ReportLocation>(); 287 loc->type = ReportLocationFD; 288 loc->fd_closed = closed; 289 loc->fd = fd; 290 loc->tid = creat_tid; 291 loc->stack = SymbolizeStackId(creat_stack); 292 rep_->locs.PushBack(loc); 293 AddThread(creat_tid); 294 return; 295 } 296 MBlock *b = 0; 297 uptr block_begin = 0; 298 Allocator *a = allocator(); 299 if (a->PointerIsMine((void*)addr)) { 300 block_begin = (uptr)a->GetBlockBegin((void *)addr); 301 if (block_begin) 302 b = ctx->metamap.GetBlock(block_begin); 303 } 304 if (!b) 305 b = JavaHeapBlock(addr, &block_begin); 306 if (b != 0) { 307 auto *loc = New<ReportLocation>(); 308 loc->type = ReportLocationHeap; 309 loc->heap_chunk_start = block_begin; 310 loc->heap_chunk_size = b->siz; 311 loc->external_tag = b->tag; 312 loc->tid = b->tid; 313 loc->stack = SymbolizeStackId(b->stk); 314 rep_->locs.PushBack(loc); 315 AddThread(b->tid); 316 return; 317 } 318 bool is_stack = false; 319 if (ThreadContext *tctx = IsThreadStackOrTls(addr, &is_stack)) { 320 auto *loc = New<ReportLocation>(); 321 loc->type = is_stack ? ReportLocationStack : ReportLocationTLS; 322 loc->tid = tctx->tid; 323 rep_->locs.PushBack(loc); 324 AddThread(tctx); 325 } 326 #endif 327 if (ReportLocation *loc = SymbolizeData(addr)) { 328 loc->suppressable = true; 329 rep_->locs.PushBack(loc); 330 return; 331 } 332 } 333 334 #if !SANITIZER_GO 335 void ScopedReportBase::AddSleep(StackID stack_id) { 336 rep_->sleep = SymbolizeStackId(stack_id); 337 } 338 #endif 339 340 void ScopedReportBase::SetCount(int count) { rep_->count = count; } 341 342 void ScopedReportBase::SetSigNum(int sig) { rep_->signum = sig; } 343 344 const ReportDesc *ScopedReportBase::GetReport() const { return rep_; } 345 346 ScopedReport::ScopedReport(ReportType typ, uptr tag) 347 : ScopedReportBase(typ, tag) {} 348 349 ScopedReport::~ScopedReport() {} 350 351 // Replays the trace up to last_pos position in the last part 352 // or up to the provided epoch/sid (whichever is earlier) 353 // and calls the provided function f for each event. 354 template <typename Func> 355 void TraceReplay(Trace *trace, TracePart *last, Event *last_pos, Sid sid, 356 Epoch epoch, Func f) { 357 TracePart *part = trace->parts.Front(); 358 Sid ev_sid = kFreeSid; 359 Epoch ev_epoch = kEpochOver; 360 for (;;) { 361 DCHECK_EQ(part->trace, trace); 362 // Note: an event can't start in the last element. 363 // Since an event can take up to 2 elements, 364 // we ensure we have at least 2 before adding an event. 365 Event *end = &part->events[TracePart::kSize - 1]; 366 if (part == last) 367 end = last_pos; 368 f(kFreeSid, kEpochOver, nullptr); // notify about part start 369 for (Event *evp = &part->events[0]; evp < end; evp++) { 370 Event *evp0 = evp; 371 if (!evp->is_access && !evp->is_func) { 372 switch (evp->type) { 373 case EventType::kTime: { 374 auto *ev = reinterpret_cast<EventTime *>(evp); 375 ev_sid = static_cast<Sid>(ev->sid); 376 ev_epoch = static_cast<Epoch>(ev->epoch); 377 if (ev_sid == sid && ev_epoch > epoch) 378 return; 379 break; 380 } 381 case EventType::kAccessExt: 382 FALLTHROUGH; 383 case EventType::kAccessRange: 384 FALLTHROUGH; 385 case EventType::kLock: 386 FALLTHROUGH; 387 case EventType::kRLock: 388 // These take 2 Event elements. 389 evp++; 390 break; 391 case EventType::kUnlock: 392 // This takes 1 Event element. 393 break; 394 } 395 } 396 CHECK_NE(ev_sid, kFreeSid); 397 CHECK_NE(ev_epoch, kEpochOver); 398 f(ev_sid, ev_epoch, evp0); 399 } 400 if (part == last) 401 return; 402 part = trace->parts.Next(part); 403 CHECK(part); 404 } 405 CHECK(0); 406 } 407 408 static void RestoreStackMatch(VarSizeStackTrace *pstk, MutexSet *pmset, 409 Vector<uptr> *stack, MutexSet *mset, uptr pc, 410 bool *found) { 411 DPrintf2(" MATCHED\n"); 412 *pmset = *mset; 413 stack->PushBack(pc); 414 pstk->Init(&(*stack)[0], stack->Size()); 415 stack->PopBack(); 416 *found = true; 417 } 418 419 // Checks if addr1|size1 is fully contained in addr2|size2. 420 // We check for fully contained instread of just overlapping 421 // because a memory access is always traced once, but can be 422 // split into multiple accesses in the shadow. 423 static constexpr bool IsWithinAccess(uptr addr1, uptr size1, uptr addr2, 424 uptr size2) { 425 return addr1 >= addr2 && addr1 + size1 <= addr2 + size2; 426 } 427 428 // Replays the trace of slot sid up to the target event identified 429 // by epoch/addr/size/typ and restores and returns tid, stack, mutex set 430 // and tag for that event. If there are multiple such events, it returns 431 // the last one. Returns false if the event is not present in the trace. 432 bool RestoreStack(EventType type, Sid sid, Epoch epoch, uptr addr, uptr size, 433 AccessType typ, Tid *ptid, VarSizeStackTrace *pstk, 434 MutexSet *pmset, uptr *ptag) { 435 // This function restores stack trace and mutex set for the thread/epoch. 436 // It does so by getting stack trace and mutex set at the beginning of 437 // trace part, and then replaying the trace till the given epoch. 438 DPrintf2("RestoreStack: sid=%u@%u addr=0x%zx/%zu typ=%x\n", 439 static_cast<int>(sid), static_cast<int>(epoch), addr, size, 440 static_cast<int>(typ)); 441 ctx->slot_mtx.CheckLocked(); // needed to prevent trace part recycling 442 ctx->thread_registry.CheckLocked(); 443 TidSlot *slot = &ctx->slots[static_cast<uptr>(sid)]; 444 Tid tid = kInvalidTid; 445 // Need to lock the slot mutex as it protects slot->journal. 446 slot->mtx.CheckLocked(); 447 for (uptr i = 0; i < slot->journal.Size(); i++) { 448 DPrintf2(" journal: epoch=%d tid=%d\n", 449 static_cast<int>(slot->journal[i].epoch), slot->journal[i].tid); 450 if (i == slot->journal.Size() - 1 || slot->journal[i + 1].epoch > epoch) { 451 tid = slot->journal[i].tid; 452 break; 453 } 454 } 455 if (tid == kInvalidTid) 456 return false; 457 *ptid = tid; 458 ThreadContext *tctx = 459 static_cast<ThreadContext *>(ctx->thread_registry.GetThreadLocked(tid)); 460 Trace *trace = &tctx->trace; 461 // Snapshot first/last parts and the current position in the last part. 462 TracePart *first_part; 463 TracePart *last_part; 464 Event *last_pos; 465 { 466 Lock lock(&trace->mtx); 467 first_part = trace->parts.Front(); 468 if (!first_part) { 469 DPrintf2("RestoreStack: tid=%d trace=%p no trace parts\n", tid, trace); 470 return false; 471 } 472 last_part = trace->parts.Back(); 473 last_pos = trace->final_pos; 474 if (tctx->thr) 475 last_pos = (Event *)atomic_load_relaxed(&tctx->thr->trace_pos); 476 } 477 DynamicMutexSet mset; 478 Vector<uptr> stack; 479 uptr prev_pc = 0; 480 bool found = false; 481 bool is_read = typ & kAccessRead; 482 bool is_atomic = typ & kAccessAtomic; 483 bool is_free = typ & kAccessFree; 484 DPrintf2("RestoreStack: tid=%d parts=[%p-%p] last_pos=%p\n", tid, 485 trace->parts.Front(), last_part, last_pos); 486 TraceReplay( 487 trace, last_part, last_pos, sid, epoch, 488 [&](Sid ev_sid, Epoch ev_epoch, Event *evp) { 489 if (evp == nullptr) { 490 // Each trace part is self-consistent, so we reset state. 491 stack.Resize(0); 492 mset->Reset(); 493 prev_pc = 0; 494 return; 495 } 496 bool match = ev_sid == sid && ev_epoch == epoch; 497 if (evp->is_access) { 498 if (evp->is_func == 0 && evp->type == EventType::kAccessExt && 499 evp->_ == 0) // NopEvent 500 return; 501 auto *ev = reinterpret_cast<EventAccess *>(evp); 502 uptr ev_addr = RestoreAddr(ev->addr); 503 uptr ev_size = 1 << ev->size_log; 504 uptr ev_pc = 505 prev_pc + ev->pc_delta - (1 << (EventAccess::kPCBits - 1)); 506 prev_pc = ev_pc; 507 DPrintf2(" Access: pc=0x%zx addr=0x%zx/%zu type=%u/%u\n", ev_pc, 508 ev_addr, ev_size, ev->is_read, ev->is_atomic); 509 if (match && type == EventType::kAccessExt && 510 IsWithinAccess(addr, size, ev_addr, ev_size) && 511 is_read == ev->is_read && is_atomic == ev->is_atomic && !is_free) 512 RestoreStackMatch(pstk, pmset, &stack, mset, ev_pc, &found); 513 return; 514 } 515 if (evp->is_func) { 516 auto *ev = reinterpret_cast<EventFunc *>(evp); 517 if (ev->pc) { 518 DPrintf2(" FuncEnter: pc=0x%llx\n", ev->pc); 519 stack.PushBack(ev->pc); 520 } else { 521 DPrintf2(" FuncExit\n"); 522 // We don't log pathologically large stacks in each part, 523 // if the stack was truncated we can have more func exits than 524 // entries. 525 if (stack.Size()) 526 stack.PopBack(); 527 } 528 return; 529 } 530 switch (evp->type) { 531 case EventType::kAccessExt: { 532 auto *ev = reinterpret_cast<EventAccessExt *>(evp); 533 uptr ev_addr = RestoreAddr(ev->addr); 534 uptr ev_size = 1 << ev->size_log; 535 prev_pc = ev->pc; 536 DPrintf2(" AccessExt: pc=0x%llx addr=0x%zx/%zu type=%u/%u\n", 537 ev->pc, ev_addr, ev_size, ev->is_read, ev->is_atomic); 538 if (match && type == EventType::kAccessExt && 539 IsWithinAccess(addr, size, ev_addr, ev_size) && 540 is_read == ev->is_read && is_atomic == ev->is_atomic && 541 !is_free) 542 RestoreStackMatch(pstk, pmset, &stack, mset, ev->pc, &found); 543 break; 544 } 545 case EventType::kAccessRange: { 546 auto *ev = reinterpret_cast<EventAccessRange *>(evp); 547 uptr ev_addr = RestoreAddr(ev->addr); 548 uptr ev_size = 549 (ev->size_hi << EventAccessRange::kSizeLoBits) + ev->size_lo; 550 uptr ev_pc = RestoreAddr(ev->pc); 551 prev_pc = ev_pc; 552 DPrintf2(" Range: pc=0x%zx addr=0x%zx/%zu type=%u/%u\n", ev_pc, 553 ev_addr, ev_size, ev->is_read, ev->is_free); 554 if (match && type == EventType::kAccessExt && 555 IsWithinAccess(addr, size, ev_addr, ev_size) && 556 is_read == ev->is_read && !is_atomic && is_free == ev->is_free) 557 RestoreStackMatch(pstk, pmset, &stack, mset, ev_pc, &found); 558 break; 559 } 560 case EventType::kLock: 561 FALLTHROUGH; 562 case EventType::kRLock: { 563 auto *ev = reinterpret_cast<EventLock *>(evp); 564 bool is_write = ev->type == EventType::kLock; 565 uptr ev_addr = RestoreAddr(ev->addr); 566 uptr ev_pc = RestoreAddr(ev->pc); 567 StackID stack_id = 568 (ev->stack_hi << EventLock::kStackIDLoBits) + ev->stack_lo; 569 DPrintf2(" Lock: pc=0x%zx addr=0x%zx stack=%u write=%d\n", ev_pc, 570 ev_addr, stack_id, is_write); 571 mset->AddAddr(ev_addr, stack_id, is_write); 572 // Events with ev_pc == 0 are written to the beginning of trace 573 // part as initial mutex set (are not real). 574 if (match && type == EventType::kLock && addr == ev_addr && ev_pc) 575 RestoreStackMatch(pstk, pmset, &stack, mset, ev_pc, &found); 576 break; 577 } 578 case EventType::kUnlock: { 579 auto *ev = reinterpret_cast<EventUnlock *>(evp); 580 uptr ev_addr = RestoreAddr(ev->addr); 581 DPrintf2(" Unlock: addr=0x%zx\n", ev_addr); 582 mset->DelAddr(ev_addr); 583 break; 584 } 585 case EventType::kTime: 586 // TraceReplay already extracted sid/epoch from it, 587 // nothing else to do here. 588 break; 589 } 590 }); 591 ExtractTagFromStack(pstk, ptag); 592 return found; 593 } 594 595 bool RacyStacks::operator==(const RacyStacks &other) const { 596 if (hash[0] == other.hash[0] && hash[1] == other.hash[1]) 597 return true; 598 if (hash[0] == other.hash[1] && hash[1] == other.hash[0]) 599 return true; 600 return false; 601 } 602 603 static bool FindRacyStacks(const RacyStacks &hash) { 604 for (uptr i = 0; i < ctx->racy_stacks.Size(); i++) { 605 if (hash == ctx->racy_stacks[i]) { 606 VPrintf(2, "ThreadSanitizer: suppressing report as doubled (stack)\n"); 607 return true; 608 } 609 } 610 return false; 611 } 612 613 static bool HandleRacyStacks(ThreadState *thr, VarSizeStackTrace traces[2]) { 614 if (!flags()->suppress_equal_stacks) 615 return false; 616 RacyStacks hash; 617 hash.hash[0] = md5_hash(traces[0].trace, traces[0].size * sizeof(uptr)); 618 hash.hash[1] = md5_hash(traces[1].trace, traces[1].size * sizeof(uptr)); 619 { 620 ReadLock lock(&ctx->racy_mtx); 621 if (FindRacyStacks(hash)) 622 return true; 623 } 624 Lock lock(&ctx->racy_mtx); 625 if (FindRacyStacks(hash)) 626 return true; 627 ctx->racy_stacks.PushBack(hash); 628 return false; 629 } 630 631 bool OutputReport(ThreadState *thr, const ScopedReport &srep) { 632 // These should have been checked in ShouldReport. 633 // It's too late to check them here, we have already taken locks. 634 CHECK(flags()->report_bugs); 635 CHECK(!thr->suppress_reports); 636 atomic_store_relaxed(&ctx->last_symbolize_time_ns, NanoTime()); 637 const ReportDesc *rep = srep.GetReport(); 638 CHECK_EQ(thr->current_report, nullptr); 639 thr->current_report = rep; 640 Suppression *supp = 0; 641 uptr pc_or_addr = 0; 642 for (uptr i = 0; pc_or_addr == 0 && i < rep->mops.Size(); i++) 643 pc_or_addr = IsSuppressed(rep->typ, rep->mops[i]->stack, &supp); 644 for (uptr i = 0; pc_or_addr == 0 && i < rep->stacks.Size(); i++) 645 pc_or_addr = IsSuppressed(rep->typ, rep->stacks[i], &supp); 646 for (uptr i = 0; pc_or_addr == 0 && i < rep->threads.Size(); i++) 647 pc_or_addr = IsSuppressed(rep->typ, rep->threads[i]->stack, &supp); 648 for (uptr i = 0; pc_or_addr == 0 && i < rep->locs.Size(); i++) 649 pc_or_addr = IsSuppressed(rep->typ, rep->locs[i], &supp); 650 if (pc_or_addr != 0) { 651 Lock lock(&ctx->fired_suppressions_mtx); 652 FiredSuppression s = {srep.GetReport()->typ, pc_or_addr, supp}; 653 ctx->fired_suppressions.push_back(s); 654 } 655 { 656 bool suppressed = OnReport(rep, pc_or_addr != 0); 657 if (suppressed) { 658 thr->current_report = nullptr; 659 return false; 660 } 661 } 662 PrintReport(rep); 663 __tsan_on_report(rep); 664 ctx->nreported++; 665 if (flags()->halt_on_error) 666 Die(); 667 thr->current_report = nullptr; 668 return true; 669 } 670 671 bool IsFiredSuppression(Context *ctx, ReportType type, StackTrace trace) { 672 ReadLock lock(&ctx->fired_suppressions_mtx); 673 for (uptr k = 0; k < ctx->fired_suppressions.size(); k++) { 674 if (ctx->fired_suppressions[k].type != type) 675 continue; 676 for (uptr j = 0; j < trace.size; j++) { 677 FiredSuppression *s = &ctx->fired_suppressions[k]; 678 if (trace.trace[j] == s->pc_or_addr) { 679 if (s->supp) 680 atomic_fetch_add(&s->supp->hit_count, 1, memory_order_relaxed); 681 return true; 682 } 683 } 684 } 685 return false; 686 } 687 688 static bool IsFiredSuppression(Context *ctx, ReportType type, uptr addr) { 689 ReadLock lock(&ctx->fired_suppressions_mtx); 690 for (uptr k = 0; k < ctx->fired_suppressions.size(); k++) { 691 if (ctx->fired_suppressions[k].type != type) 692 continue; 693 FiredSuppression *s = &ctx->fired_suppressions[k]; 694 if (addr == s->pc_or_addr) { 695 if (s->supp) 696 atomic_fetch_add(&s->supp->hit_count, 1, memory_order_relaxed); 697 return true; 698 } 699 } 700 return false; 701 } 702 703 static bool SpuriousRace(Shadow old) { 704 Shadow last(LoadShadow(&ctx->last_spurious_race)); 705 return last.sid() == old.sid() && last.epoch() == old.epoch(); 706 } 707 708 void ReportRace(ThreadState *thr, RawShadow *shadow_mem, Shadow cur, Shadow old, 709 AccessType typ0) { 710 CheckedMutex::CheckNoLocks(); 711 712 // Symbolizer makes lots of intercepted calls. If we try to process them, 713 // at best it will cause deadlocks on internal mutexes. 714 ScopedIgnoreInterceptors ignore; 715 716 uptr addr = ShadowToMem(shadow_mem); 717 DPrintf("#%d: ReportRace %p\n", thr->tid, (void *)addr); 718 if (!ShouldReport(thr, ReportTypeRace)) 719 return; 720 uptr addr_off0, size0; 721 cur.GetAccess(&addr_off0, &size0, nullptr); 722 uptr addr_off1, size1, typ1; 723 old.GetAccess(&addr_off1, &size1, &typ1); 724 if (!flags()->report_atomic_races && 725 ((typ0 & kAccessAtomic) || (typ1 & kAccessAtomic)) && 726 !(typ0 & kAccessFree) && !(typ1 & kAccessFree)) 727 return; 728 if (SpuriousRace(old)) 729 return; 730 731 const uptr kMop = 2; 732 Shadow s[kMop] = {cur, old}; 733 uptr addr0 = addr + addr_off0; 734 uptr addr1 = addr + addr_off1; 735 uptr end0 = addr0 + size0; 736 uptr end1 = addr1 + size1; 737 uptr addr_min = min(addr0, addr1); 738 uptr addr_max = max(end0, end1); 739 if (IsExpectedReport(addr_min, addr_max - addr_min)) 740 return; 741 742 ReportType rep_typ = ReportTypeRace; 743 if ((typ0 & kAccessVptr) && (typ1 & kAccessFree)) 744 rep_typ = ReportTypeVptrUseAfterFree; 745 else if (typ0 & kAccessVptr) 746 rep_typ = ReportTypeVptrRace; 747 else if (typ1 & kAccessFree) 748 rep_typ = ReportTypeUseAfterFree; 749 750 if (IsFiredSuppression(ctx, rep_typ, addr)) 751 return; 752 753 VarSizeStackTrace traces[kMop]; 754 Tid tids[kMop] = {thr->tid, kInvalidTid}; 755 uptr tags[kMop] = {kExternalTagNone, kExternalTagNone}; 756 757 ObtainCurrentStack(thr, thr->trace_prev_pc, &traces[0], &tags[0]); 758 if (IsFiredSuppression(ctx, rep_typ, traces[0])) 759 return; 760 761 DynamicMutexSet mset1; 762 MutexSet *mset[kMop] = {&thr->mset, mset1}; 763 764 // We need to lock the slot during RestoreStack because it protects 765 // the slot journal. 766 Lock slot_lock(&ctx->slots[static_cast<uptr>(s[1].sid())].mtx); 767 ThreadRegistryLock l0(&ctx->thread_registry); 768 Lock slots_lock(&ctx->slot_mtx); 769 if (SpuriousRace(old)) 770 return; 771 if (!RestoreStack(EventType::kAccessExt, s[1].sid(), s[1].epoch(), addr1, 772 size1, typ1, &tids[1], &traces[1], mset[1], &tags[1])) { 773 StoreShadow(&ctx->last_spurious_race, old.raw()); 774 return; 775 } 776 777 if (IsFiredSuppression(ctx, rep_typ, traces[1])) 778 return; 779 780 if (HandleRacyStacks(thr, traces)) 781 return; 782 783 // If any of the accesses has a tag, treat this as an "external" race. 784 uptr tag = kExternalTagNone; 785 for (uptr i = 0; i < kMop; i++) { 786 if (tags[i] != kExternalTagNone) { 787 rep_typ = ReportTypeExternalRace; 788 tag = tags[i]; 789 break; 790 } 791 } 792 793 ScopedReport rep(rep_typ, tag); 794 for (uptr i = 0; i < kMop; i++) 795 rep.AddMemoryAccess(addr, tags[i], s[i], tids[i], traces[i], mset[i]); 796 797 for (uptr i = 0; i < kMop; i++) { 798 ThreadContext *tctx = static_cast<ThreadContext *>( 799 ctx->thread_registry.GetThreadLocked(tids[i])); 800 rep.AddThread(tctx); 801 } 802 803 rep.AddLocation(addr_min, addr_max - addr_min); 804 805 if (flags()->print_full_thread_history) { 806 const ReportDesc *rep_desc = rep.GetReport(); 807 for (uptr i = 0; i < rep_desc->threads.Size(); i++) { 808 Tid parent_tid = rep_desc->threads[i]->parent_tid; 809 if (parent_tid == kMainTid || parent_tid == kInvalidTid) 810 continue; 811 ThreadContext *parent_tctx = static_cast<ThreadContext *>( 812 ctx->thread_registry.GetThreadLocked(parent_tid)); 813 rep.AddThread(parent_tctx); 814 } 815 } 816 817 #if !SANITIZER_GO 818 if (!((typ0 | typ1) & kAccessFree) && 819 s[1].epoch() <= thr->last_sleep_clock.Get(s[1].sid())) 820 rep.AddSleep(thr->last_sleep_stack_id); 821 #endif 822 OutputReport(thr, rep); 823 } 824 825 void PrintCurrentStack(ThreadState *thr, uptr pc) { 826 VarSizeStackTrace trace; 827 ObtainCurrentStack(thr, pc, &trace); 828 PrintStack(SymbolizeStack(trace)); 829 } 830 831 // Always inlining PrintCurrentStackSlow, because LocatePcInTrace assumes 832 // __sanitizer_print_stack_trace exists in the actual unwinded stack, but 833 // tail-call to PrintCurrentStackSlow breaks this assumption because 834 // __sanitizer_print_stack_trace disappears after tail-call. 835 // However, this solution is not reliable enough, please see dvyukov's comment 836 // http://reviews.llvm.org/D19148#406208 837 // Also see PR27280 comment 2 and 3 for breaking examples and analysis. 838 ALWAYS_INLINE USED void PrintCurrentStackSlow(uptr pc) { 839 #if !SANITIZER_GO 840 uptr bp = GET_CURRENT_FRAME(); 841 auto *ptrace = New<BufferedStackTrace>(); 842 ptrace->Unwind(pc, bp, nullptr, false); 843 844 for (uptr i = 0; i < ptrace->size / 2; i++) { 845 uptr tmp = ptrace->trace_buffer[i]; 846 ptrace->trace_buffer[i] = ptrace->trace_buffer[ptrace->size - i - 1]; 847 ptrace->trace_buffer[ptrace->size - i - 1] = tmp; 848 } 849 PrintStack(SymbolizeStack(*ptrace)); 850 #endif 851 } 852 853 } // namespace __tsan 854 855 using namespace __tsan; 856 857 extern "C" { 858 SANITIZER_INTERFACE_ATTRIBUTE 859 void __sanitizer_print_stack_trace() { 860 PrintCurrentStackSlow(StackTrace::GetCurrentPc()); 861 } 862 } // extern "C" 863