1 //===-- tsan_rtl_report.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_libc.h" 15 #include "sanitizer_common/sanitizer_placement_new.h" 16 #include "sanitizer_common/sanitizer_stackdepot.h" 17 #include "sanitizer_common/sanitizer_common.h" 18 #include "sanitizer_common/sanitizer_stacktrace.h" 19 #include "tsan_platform.h" 20 #include "tsan_rtl.h" 21 #include "tsan_suppressions.h" 22 #include "tsan_symbolize.h" 23 #include "tsan_report.h" 24 #include "tsan_sync.h" 25 #include "tsan_mman.h" 26 #include "tsan_flags.h" 27 #include "tsan_fd.h" 28 29 namespace __tsan { 30 31 using namespace __sanitizer; // NOLINT 32 33 static ReportStack *SymbolizeStack(const StackTrace& trace); 34 35 void TsanCheckFailed(const char *file, int line, const char *cond, 36 u64 v1, u64 v2) { 37 ScopedInRtl in_rtl; 38 Printf("FATAL: ThreadSanitizer CHECK failed: " 39 "%s:%d \"%s\" (0x%zx, 0x%zx)\n", 40 file, line, cond, (uptr)v1, (uptr)v2); 41 PrintCurrentStackSlow(); 42 Die(); 43 } 44 45 // Can be overriden by an application/test to intercept reports. 46 #ifdef TSAN_EXTERNAL_HOOKS 47 bool OnReport(const ReportDesc *rep, bool suppressed); 48 #else 49 SANITIZER_INTERFACE_ATTRIBUTE 50 bool WEAK OnReport(const ReportDesc *rep, bool suppressed) { 51 (void)rep; 52 return suppressed; 53 } 54 #endif 55 56 static void StackStripMain(ReportStack *stack) { 57 ReportStack *last_frame = 0; 58 ReportStack *last_frame2 = 0; 59 const char *prefix = "__interceptor_"; 60 uptr prefix_len = internal_strlen(prefix); 61 const char *path_prefix = flags()->strip_path_prefix; 62 uptr path_prefix_len = internal_strlen(path_prefix); 63 char *pos; 64 for (ReportStack *ent = stack; ent; ent = ent->next) { 65 if (ent->func && 0 == internal_strncmp(ent->func, prefix, prefix_len)) 66 ent->func += prefix_len; 67 if (ent->file && (pos = internal_strstr(ent->file, path_prefix))) 68 ent->file = pos + path_prefix_len; 69 if (ent->file && ent->file[0] == '.' && ent->file[1] == '/') 70 ent->file += 2; 71 last_frame2 = last_frame; 72 last_frame = ent; 73 } 74 75 if (last_frame2 == 0) 76 return; 77 const char *last = last_frame->func; 78 #ifndef TSAN_GO 79 const char *last2 = last_frame2->func; 80 // Strip frame above 'main' 81 if (last2 && 0 == internal_strcmp(last2, "main")) { 82 last_frame2->next = 0; 83 // Strip our internal thread start routine. 84 } else if (last && 0 == internal_strcmp(last, "__tsan_thread_start_func")) { 85 last_frame2->next = 0; 86 // Strip global ctors init. 87 } else if (last && 0 == internal_strcmp(last, "__do_global_ctors_aux")) { 88 last_frame2->next = 0; 89 // If both are 0, then we probably just failed to symbolize. 90 } else if (last || last2) { 91 // Ensure that we recovered stack completely. Trimmed stack 92 // can actually happen if we do not instrument some code, 93 // so it's only a debug print. However we must try hard to not miss it 94 // due to our fault. 95 DPrintf("Bottom stack frame of stack %zx is missed\n", stack->pc); 96 } 97 #else 98 if (last && 0 == internal_strcmp(last, "schedunlock")) 99 last_frame2->next = 0; 100 #endif 101 } 102 103 static ReportStack *SymbolizeStack(const StackTrace& trace) { 104 if (trace.IsEmpty()) 105 return 0; 106 ReportStack *stack = 0; 107 for (uptr si = 0; si < trace.Size(); si++) { 108 // We obtain the return address, that is, address of the next instruction, 109 // so offset it by 1 byte. 110 bool is_last = (si == trace.Size() - 1); 111 ReportStack *ent = SymbolizeCode(trace.Get(si) - !is_last); 112 CHECK_NE(ent, 0); 113 ReportStack *last = ent; 114 while (last->next) { 115 last->pc += !is_last; 116 last = last->next; 117 } 118 last->pc += !is_last; 119 last->next = stack; 120 stack = ent; 121 } 122 StackStripMain(stack); 123 return stack; 124 } 125 126 ScopedReport::ScopedReport(ReportType typ) { 127 ctx_ = CTX(); 128 ctx_->thread_registry->CheckLocked(); 129 void *mem = internal_alloc(MBlockReport, sizeof(ReportDesc)); 130 rep_ = new(mem) ReportDesc; 131 rep_->typ = typ; 132 ctx_->report_mtx.Lock(); 133 } 134 135 ScopedReport::~ScopedReport() { 136 ctx_->report_mtx.Unlock(); 137 DestroyAndFree(rep_); 138 } 139 140 void ScopedReport::AddStack(const StackTrace *stack) { 141 ReportStack **rs = rep_->stacks.PushBack(); 142 *rs = SymbolizeStack(*stack); 143 } 144 145 void ScopedReport::AddMemoryAccess(uptr addr, Shadow s, 146 const StackTrace *stack, const MutexSet *mset) { 147 void *mem = internal_alloc(MBlockReportMop, sizeof(ReportMop)); 148 ReportMop *mop = new(mem) ReportMop; 149 rep_->mops.PushBack(mop); 150 mop->tid = s.tid(); 151 mop->addr = addr + s.addr0(); 152 mop->size = s.size(); 153 mop->write = s.IsWrite(); 154 mop->atomic = s.IsAtomic(); 155 mop->stack = SymbolizeStack(*stack); 156 for (uptr i = 0; i < mset->Size(); i++) { 157 MutexSet::Desc d = mset->Get(i); 158 u64 uid = 0; 159 uptr addr = SyncVar::SplitId(d.id, &uid); 160 SyncVar *s = ctx_->synctab.GetIfExistsAndLock(addr, false); 161 // Check that the mutex is still alive. 162 // Another mutex can be created at the same address, 163 // so check uid as well. 164 if (s && s->CheckId(uid)) { 165 ReportMopMutex mtx = {s->uid, d.write}; 166 mop->mset.PushBack(mtx); 167 AddMutex(s); 168 } else { 169 ReportMopMutex mtx = {d.id, d.write}; 170 mop->mset.PushBack(mtx); 171 AddMutex(d.id); 172 } 173 if (s) 174 s->mtx.ReadUnlock(); 175 } 176 } 177 178 void ScopedReport::AddThread(const ThreadContext *tctx) { 179 for (uptr i = 0; i < rep_->threads.Size(); i++) { 180 if ((u32)rep_->threads[i]->id == tctx->tid) 181 return; 182 } 183 void *mem = internal_alloc(MBlockReportThread, sizeof(ReportThread)); 184 ReportThread *rt = new(mem) ReportThread(); 185 rep_->threads.PushBack(rt); 186 rt->id = tctx->tid; 187 rt->pid = tctx->os_id; 188 rt->running = (tctx->status == ThreadStatusRunning); 189 rt->name = tctx->name ? internal_strdup(tctx->name) : 0; 190 rt->parent_tid = tctx->parent_tid; 191 rt->stack = 0; 192 #ifdef TSAN_GO 193 rt->stack = SymbolizeStack(tctx->creation_stack); 194 #else 195 uptr ssz = 0; 196 const uptr *stack = StackDepotGet(tctx->creation_stack_id, &ssz); 197 if (stack) { 198 StackTrace trace; 199 trace.Init(stack, ssz); 200 rt->stack = SymbolizeStack(trace); 201 } 202 #endif 203 } 204 205 #ifndef TSAN_GO 206 static ThreadContext *FindThreadByUidLocked(int unique_id) { 207 Context *ctx = CTX(); 208 ctx->thread_registry->CheckLocked(); 209 for (unsigned i = 0; i < kMaxTid; i++) { 210 ThreadContext *tctx = static_cast<ThreadContext*>( 211 ctx->thread_registry->GetThreadLocked(i)); 212 if (tctx && tctx->unique_id == (u32)unique_id) { 213 return tctx; 214 } 215 } 216 return 0; 217 } 218 219 static ThreadContext *FindThreadByTidLocked(int tid) { 220 Context *ctx = CTX(); 221 ctx->thread_registry->CheckLocked(); 222 return static_cast<ThreadContext*>( 223 ctx->thread_registry->GetThreadLocked(tid)); 224 } 225 226 static bool IsInStackOrTls(ThreadContextBase *tctx_base, void *arg) { 227 uptr addr = (uptr)arg; 228 ThreadContext *tctx = static_cast<ThreadContext*>(tctx_base); 229 if (tctx->status != ThreadStatusRunning) 230 return false; 231 ThreadState *thr = tctx->thr; 232 CHECK(thr); 233 return ((addr >= thr->stk_addr && addr < thr->stk_addr + thr->stk_size) || 234 (addr >= thr->tls_addr && addr < thr->tls_addr + thr->tls_size)); 235 } 236 237 ThreadContext *IsThreadStackOrTls(uptr addr, bool *is_stack) { 238 Context *ctx = CTX(); 239 ctx->thread_registry->CheckLocked(); 240 ThreadContext *tctx = static_cast<ThreadContext*>( 241 ctx->thread_registry->FindThreadContextLocked(IsInStackOrTls, 242 (void*)addr)); 243 if (!tctx) 244 return 0; 245 ThreadState *thr = tctx->thr; 246 CHECK(thr); 247 *is_stack = (addr >= thr->stk_addr && addr < thr->stk_addr + thr->stk_size); 248 return tctx; 249 } 250 #endif 251 252 void ScopedReport::AddMutex(const SyncVar *s) { 253 for (uptr i = 0; i < rep_->mutexes.Size(); i++) { 254 if (rep_->mutexes[i]->id == s->uid) 255 return; 256 } 257 void *mem = internal_alloc(MBlockReportMutex, sizeof(ReportMutex)); 258 ReportMutex *rm = new(mem) ReportMutex(); 259 rep_->mutexes.PushBack(rm); 260 rm->id = s->uid; 261 rm->destroyed = false; 262 rm->stack = 0; 263 #ifndef TSAN_GO 264 uptr ssz = 0; 265 const uptr *stack = StackDepotGet(s->creation_stack_id, &ssz); 266 if (stack) { 267 StackTrace trace; 268 trace.Init(stack, ssz); 269 rm->stack = SymbolizeStack(trace); 270 } 271 #endif 272 } 273 274 void ScopedReport::AddMutex(u64 id) { 275 for (uptr i = 0; i < rep_->mutexes.Size(); i++) { 276 if (rep_->mutexes[i]->id == id) 277 return; 278 } 279 void *mem = internal_alloc(MBlockReportMutex, sizeof(ReportMutex)); 280 ReportMutex *rm = new(mem) ReportMutex(); 281 rep_->mutexes.PushBack(rm); 282 rm->id = id; 283 rm->destroyed = true; 284 rm->stack = 0; 285 } 286 287 void ScopedReport::AddLocation(uptr addr, uptr size) { 288 if (addr == 0) 289 return; 290 #ifndef TSAN_GO 291 int fd = -1; 292 int creat_tid = -1; 293 u32 creat_stack = 0; 294 if (FdLocation(addr, &fd, &creat_tid, &creat_stack) 295 || FdLocation(AlternativeAddress(addr), &fd, &creat_tid, &creat_stack)) { 296 void *mem = internal_alloc(MBlockReportLoc, sizeof(ReportLocation)); 297 ReportLocation *loc = new(mem) ReportLocation(); 298 rep_->locs.PushBack(loc); 299 loc->type = ReportLocationFD; 300 loc->fd = fd; 301 loc->tid = creat_tid; 302 uptr ssz = 0; 303 const uptr *stack = StackDepotGet(creat_stack, &ssz); 304 if (stack) { 305 StackTrace trace; 306 trace.Init(stack, ssz); 307 loc->stack = SymbolizeStack(trace); 308 } 309 ThreadContext *tctx = FindThreadByUidLocked(creat_tid); 310 if (tctx) 311 AddThread(tctx); 312 return; 313 } 314 if (allocator()->PointerIsMine((void*)addr)) { 315 MBlock *b = user_mblock(0, (void*)addr); 316 ThreadContext *tctx = FindThreadByTidLocked(b->Tid()); 317 void *mem = internal_alloc(MBlockReportLoc, sizeof(ReportLocation)); 318 ReportLocation *loc = new(mem) ReportLocation(); 319 rep_->locs.PushBack(loc); 320 loc->type = ReportLocationHeap; 321 loc->addr = (uptr)allocator()->GetBlockBegin((void*)addr); 322 loc->size = b->Size(); 323 loc->tid = tctx ? tctx->tid : b->Tid(); 324 loc->name = 0; 325 loc->file = 0; 326 loc->line = 0; 327 loc->stack = 0; 328 uptr ssz = 0; 329 const uptr *stack = StackDepotGet(b->StackId(), &ssz); 330 if (stack) { 331 StackTrace trace; 332 trace.Init(stack, ssz); 333 loc->stack = SymbolizeStack(trace); 334 } 335 if (tctx) 336 AddThread(tctx); 337 return; 338 } 339 bool is_stack = false; 340 if (ThreadContext *tctx = IsThreadStackOrTls(addr, &is_stack)) { 341 void *mem = internal_alloc(MBlockReportLoc, sizeof(ReportLocation)); 342 ReportLocation *loc = new(mem) ReportLocation(); 343 rep_->locs.PushBack(loc); 344 loc->type = is_stack ? ReportLocationStack : ReportLocationTLS; 345 loc->tid = tctx->tid; 346 AddThread(tctx); 347 } 348 ReportLocation *loc = SymbolizeData(addr); 349 if (loc) { 350 rep_->locs.PushBack(loc); 351 return; 352 } 353 #endif 354 } 355 356 #ifndef TSAN_GO 357 void ScopedReport::AddSleep(u32 stack_id) { 358 uptr ssz = 0; 359 const uptr *stack = StackDepotGet(stack_id, &ssz); 360 if (stack) { 361 StackTrace trace; 362 trace.Init(stack, ssz); 363 rep_->sleep = SymbolizeStack(trace); 364 } 365 } 366 #endif 367 368 const ReportDesc *ScopedReport::GetReport() const { 369 return rep_; 370 } 371 372 void RestoreStack(int tid, const u64 epoch, StackTrace *stk, MutexSet *mset) { 373 // This function restores stack trace and mutex set for the thread/epoch. 374 // It does so by getting stack trace and mutex set at the beginning of 375 // trace part, and then replaying the trace till the given epoch. 376 Context *ctx = CTX(); 377 ctx->thread_registry->CheckLocked(); 378 ThreadContext *tctx = static_cast<ThreadContext*>( 379 ctx->thread_registry->GetThreadLocked(tid)); 380 if (tctx == 0) 381 return; 382 Trace* trace = 0; 383 if (tctx->status == ThreadStatusRunning) { 384 CHECK(tctx->thr); 385 trace = &tctx->thr->trace; 386 } else if (tctx->status == ThreadStatusFinished 387 || tctx->status == ThreadStatusDead) { 388 if (tctx->dead_info == 0) 389 return; 390 trace = &tctx->dead_info->trace; 391 } else { 392 return; 393 } 394 Lock l(&trace->mtx); 395 const int partidx = (epoch / kTracePartSize) % TraceParts(); 396 TraceHeader* hdr = &trace->headers[partidx]; 397 if (epoch < hdr->epoch0) 398 return; 399 const u64 epoch0 = RoundDown(epoch, TraceSize()); 400 const u64 eend = epoch % TraceSize(); 401 const u64 ebegin = RoundDown(eend, kTracePartSize); 402 DPrintf("#%d: RestoreStack epoch=%zu ebegin=%zu eend=%zu partidx=%d\n", 403 tid, (uptr)epoch, (uptr)ebegin, (uptr)eend, partidx); 404 InternalScopedBuffer<uptr> stack(1024); // FIXME: de-hardcode 1024 405 for (uptr i = 0; i < hdr->stack0.Size(); i++) { 406 stack[i] = hdr->stack0.Get(i); 407 DPrintf2(" #%02lu: pc=%zx\n", i, stack[i]); 408 } 409 if (mset) 410 *mset = hdr->mset0; 411 uptr pos = hdr->stack0.Size(); 412 Event *events = (Event*)GetThreadTrace(tid); 413 for (uptr i = ebegin; i <= eend; i++) { 414 Event ev = events[i]; 415 EventType typ = (EventType)(ev >> 61); 416 uptr pc = (uptr)(ev & ((1ull << 61) - 1)); 417 DPrintf2(" %zu typ=%d pc=%zx\n", i, typ, pc); 418 if (typ == EventTypeMop) { 419 stack[pos] = pc; 420 } else if (typ == EventTypeFuncEnter) { 421 stack[pos++] = pc; 422 } else if (typ == EventTypeFuncExit) { 423 if (pos > 0) 424 pos--; 425 } 426 if (mset) { 427 if (typ == EventTypeLock) { 428 mset->Add(pc, true, epoch0 + i); 429 } else if (typ == EventTypeUnlock) { 430 mset->Del(pc, true); 431 } else if (typ == EventTypeRLock) { 432 mset->Add(pc, false, epoch0 + i); 433 } else if (typ == EventTypeRUnlock) { 434 mset->Del(pc, false); 435 } 436 } 437 for (uptr j = 0; j <= pos; j++) 438 DPrintf2(" #%zu: %zx\n", j, stack[j]); 439 } 440 if (pos == 0 && stack[0] == 0) 441 return; 442 pos++; 443 stk->Init(stack.data(), pos); 444 } 445 446 static bool HandleRacyStacks(ThreadState *thr, const StackTrace (&traces)[2], 447 uptr addr_min, uptr addr_max) { 448 Context *ctx = CTX(); 449 bool equal_stack = false; 450 RacyStacks hash; 451 if (flags()->suppress_equal_stacks) { 452 hash.hash[0] = md5_hash(traces[0].Begin(), traces[0].Size() * sizeof(uptr)); 453 hash.hash[1] = md5_hash(traces[1].Begin(), traces[1].Size() * sizeof(uptr)); 454 for (uptr i = 0; i < ctx->racy_stacks.Size(); i++) { 455 if (hash == ctx->racy_stacks[i]) { 456 DPrintf("ThreadSanitizer: suppressing report as doubled (stack)\n"); 457 equal_stack = true; 458 break; 459 } 460 } 461 } 462 bool equal_address = false; 463 RacyAddress ra0 = {addr_min, addr_max}; 464 if (flags()->suppress_equal_addresses) { 465 for (uptr i = 0; i < ctx->racy_addresses.Size(); i++) { 466 RacyAddress ra2 = ctx->racy_addresses[i]; 467 uptr maxbeg = max(ra0.addr_min, ra2.addr_min); 468 uptr minend = min(ra0.addr_max, ra2.addr_max); 469 if (maxbeg < minend) { 470 DPrintf("ThreadSanitizer: suppressing report as doubled (addr)\n"); 471 equal_address = true; 472 break; 473 } 474 } 475 } 476 if (equal_stack || equal_address) { 477 if (!equal_stack) 478 ctx->racy_stacks.PushBack(hash); 479 if (!equal_address) 480 ctx->racy_addresses.PushBack(ra0); 481 return true; 482 } 483 return false; 484 } 485 486 static void AddRacyStacks(ThreadState *thr, const StackTrace (&traces)[2], 487 uptr addr_min, uptr addr_max) { 488 Context *ctx = CTX(); 489 if (flags()->suppress_equal_stacks) { 490 RacyStacks hash; 491 hash.hash[0] = md5_hash(traces[0].Begin(), traces[0].Size() * sizeof(uptr)); 492 hash.hash[1] = md5_hash(traces[1].Begin(), traces[1].Size() * sizeof(uptr)); 493 ctx->racy_stacks.PushBack(hash); 494 } 495 if (flags()->suppress_equal_addresses) { 496 RacyAddress ra0 = {addr_min, addr_max}; 497 ctx->racy_addresses.PushBack(ra0); 498 } 499 } 500 501 bool OutputReport(Context *ctx, 502 const ScopedReport &srep, 503 const ReportStack *suppress_stack1, 504 const ReportStack *suppress_stack2) { 505 const ReportDesc *rep = srep.GetReport(); 506 uptr suppress_pc = IsSuppressed(rep->typ, suppress_stack1); 507 if (suppress_pc == 0) 508 suppress_pc = IsSuppressed(rep->typ, suppress_stack2); 509 if (suppress_pc != 0) { 510 FiredSuppression supp = {srep.GetReport()->typ, suppress_pc}; 511 ctx->fired_suppressions.PushBack(supp); 512 } 513 if (OnReport(rep, suppress_pc != 0)) 514 return false; 515 PrintReport(rep); 516 CTX()->nreported++; 517 return true; 518 } 519 520 bool IsFiredSuppression(Context *ctx, 521 const ScopedReport &srep, 522 const StackTrace &trace) { 523 for (uptr k = 0; k < ctx->fired_suppressions.Size(); k++) { 524 if (ctx->fired_suppressions[k].type != srep.GetReport()->typ) 525 continue; 526 for (uptr j = 0; j < trace.Size(); j++) { 527 if (trace.Get(j) == ctx->fired_suppressions[k].pc) 528 return true; 529 } 530 } 531 return false; 532 } 533 534 bool FrameIsInternal(const ReportStack *frame) { 535 return frame != 0 && frame->file != 0 536 && (internal_strstr(frame->file, "tsan_interceptors.cc") || 537 internal_strstr(frame->file, "sanitizer_common_interceptors.inc") || 538 internal_strstr(frame->file, "tsan_interface_")); 539 } 540 541 // On programs that use Java we see weird reports like: 542 // WARNING: ThreadSanitizer: data race (pid=22512) 543 // Read of size 8 at 0x7d2b00084318 by thread 100: 544 // #0 memcpy tsan_interceptors.cc:406 (foo+0x00000d8dfae3) 545 // #1 <null> <null>:0 (0x7f7ad9b40193) 546 // Previous write of size 8 at 0x7d2b00084318 by thread 105: 547 // #0 strncpy tsan_interceptors.cc:501 (foo+0x00000d8e0919) 548 // #1 <null> <null>:0 (0x7f7ad9b42707) 549 static bool IsJavaNonsense(const ReportDesc *rep) { 550 #ifndef TSAN_GO 551 for (uptr i = 0; i < rep->mops.Size(); i++) { 552 ReportMop *mop = rep->mops[i]; 553 ReportStack *frame = mop->stack; 554 if (frame == 0 555 || (frame->func == 0 && frame->file == 0 && frame->line == 0 556 && frame->module == 0)) { 557 return true; 558 } 559 if (FrameIsInternal(frame)) { 560 frame = frame->next; 561 if (frame == 0 562 || (frame->func == 0 && frame->file == 0 && frame->line == 0 563 && frame->module == 0)) { 564 if (frame) { 565 FiredSuppression supp = {rep->typ, frame->pc}; 566 CTX()->fired_suppressions.PushBack(supp); 567 } 568 return true; 569 } 570 } 571 } 572 #endif 573 return false; 574 } 575 576 static bool RaceBetweenAtomicAndFree(ThreadState *thr) { 577 Shadow s0(thr->racy_state[0]); 578 Shadow s1(thr->racy_state[1]); 579 CHECK(!(s0.IsAtomic() && s1.IsAtomic())); 580 if (!s0.IsAtomic() && !s1.IsAtomic()) 581 return true; 582 if (s0.IsAtomic() && s1.IsFreed()) 583 return true; 584 if (s1.IsAtomic() && thr->is_freeing) 585 return true; 586 return false; 587 } 588 589 void ReportRace(ThreadState *thr) { 590 if (!flags()->report_bugs) 591 return; 592 ScopedInRtl in_rtl; 593 594 if (!flags()->report_atomic_races && !RaceBetweenAtomicAndFree(thr)) 595 return; 596 597 if (thr->in_signal_handler) 598 Printf("ThreadSanitizer: printing report from signal handler." 599 " Can crash or hang.\n"); 600 601 bool freed = false; 602 { 603 Shadow s(thr->racy_state[1]); 604 freed = s.GetFreedAndReset(); 605 thr->racy_state[1] = s.raw(); 606 } 607 608 uptr addr = ShadowToMem((uptr)thr->racy_shadow_addr); 609 uptr addr_min = 0; 610 uptr addr_max = 0; 611 { 612 uptr a0 = addr + Shadow(thr->racy_state[0]).addr0(); 613 uptr a1 = addr + Shadow(thr->racy_state[1]).addr0(); 614 uptr e0 = a0 + Shadow(thr->racy_state[0]).size(); 615 uptr e1 = a1 + Shadow(thr->racy_state[1]).size(); 616 addr_min = min(a0, a1); 617 addr_max = max(e0, e1); 618 if (IsExpectedReport(addr_min, addr_max - addr_min)) 619 return; 620 } 621 622 Context *ctx = CTX(); 623 ThreadRegistryLock l0(ctx->thread_registry); 624 625 ScopedReport rep(freed ? ReportTypeUseAfterFree : ReportTypeRace); 626 const uptr kMop = 2; 627 StackTrace traces[kMop]; 628 const uptr toppc = TraceTopPC(thr); 629 traces[0].ObtainCurrent(thr, toppc); 630 if (IsFiredSuppression(ctx, rep, traces[0])) 631 return; 632 InternalScopedBuffer<MutexSet> mset2(1); 633 new(mset2.data()) MutexSet(); 634 Shadow s2(thr->racy_state[1]); 635 RestoreStack(s2.tid(), s2.epoch(), &traces[1], mset2.data()); 636 637 if (HandleRacyStacks(thr, traces, addr_min, addr_max)) 638 return; 639 640 for (uptr i = 0; i < kMop; i++) { 641 Shadow s(thr->racy_state[i]); 642 rep.AddMemoryAccess(addr, s, &traces[i], 643 i == 0 ? &thr->mset : mset2.data()); 644 } 645 646 if (flags()->suppress_java && IsJavaNonsense(rep.GetReport())) 647 return; 648 649 for (uptr i = 0; i < kMop; i++) { 650 FastState s(thr->racy_state[i]); 651 ThreadContext *tctx = static_cast<ThreadContext*>( 652 ctx->thread_registry->GetThreadLocked(s.tid())); 653 if (s.epoch() < tctx->epoch0 || s.epoch() > tctx->epoch1) 654 continue; 655 rep.AddThread(tctx); 656 } 657 658 rep.AddLocation(addr_min, addr_max - addr_min); 659 660 #ifndef TSAN_GO 661 { // NOLINT 662 Shadow s(thr->racy_state[1]); 663 if (s.epoch() <= thr->last_sleep_clock.get(s.tid())) 664 rep.AddSleep(thr->last_sleep_stack_id); 665 } 666 #endif 667 668 if (!OutputReport(ctx, rep, rep.GetReport()->mops[0]->stack, 669 rep.GetReport()->mops[1]->stack)) 670 return; 671 672 AddRacyStacks(thr, traces, addr_min, addr_max); 673 } 674 675 void PrintCurrentStack(ThreadState *thr, uptr pc) { 676 StackTrace trace; 677 trace.ObtainCurrent(thr, pc); 678 PrintStack(SymbolizeStack(trace)); 679 } 680 681 void PrintCurrentStackSlow() { 682 #ifndef TSAN_GO 683 __sanitizer::StackTrace *ptrace = new(internal_alloc(MBlockStackTrace, 684 sizeof(__sanitizer::StackTrace))) __sanitizer::StackTrace; 685 ptrace->SlowUnwindStack(__sanitizer::StackTrace::GetCurrentPc(), 686 kStackTraceMax); 687 StackTrace trace; 688 trace.Init(ptrace->trace, ptrace->size); 689 PrintStack(SymbolizeStack(trace)); 690 #endif 691 } 692 693 } // namespace __tsan 694
