lib/tsan/rtl/tsan_rtl_report.cc

   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 "tsan_platform.h"
  18 #include "tsan_rtl.h"
  19 #include "tsan_suppressions.h"
  20 #include "tsan_symbolize.h"
  21 #include "tsan_report.h"
  22 #include "tsan_sync.h"
  23 #include "tsan_mman.h"
  24 #include "tsan_flags.h"
  25
  26 namespace __tsan {
  27
  28 void TsanCheckFailed(const char *file, int line, const char *cond,
  29                      u64 v1, u64 v2) {
  30   ScopedInRtl in_rtl;
  31   Printf("FATAL: ThreadSanitizer CHECK failed: "
  32          "%s:%d \"%s\" (0x%zx, 0x%zx)\n",
  33          file, line, cond, (uptr)v1, (uptr)v2);
  34   Die();
  35 }
  36
  37 // Can be overriden by an application/test to intercept reports.
  38 #ifdef TSAN_EXTERNAL_HOOKS
  39 bool OnReport(const ReportDesc *rep, bool suppressed);
  40 #else
  41 SANITIZER_INTERFACE_ATTRIBUTE
  42 bool WEAK OnReport(const ReportDesc *rep, bool suppressed) {
  43   (void)rep;
  44   return suppressed;
  45 }
  46 #endif
  47
  48 static void StackStripMain(ReportStack *stack) {
  49   ReportStack *last_frame = 0;
  50   ReportStack *last_frame2 = 0;
  51   const char *prefix = "__interceptor_";
  52   uptr prefix_len = internal_strlen(prefix);
  53   const char *path_prefix = flags()->strip_path_prefix;
  54   uptr path_prefix_len = internal_strlen(path_prefix);
  55   char *pos;
  56   for (ReportStack *ent = stack; ent; ent = ent->next) {
  57     if (ent->func && 0 == internal_strncmp(ent->func, prefix, prefix_len))
  58       ent->func += prefix_len;
  59     if (ent->file && (pos = internal_strstr(ent->file, path_prefix)))
  60       ent->file = pos + path_prefix_len;
  61     if (ent->file && ent->file[0] == '.' && ent->file[1] == '/')
  62       ent->file += 2;
  63     last_frame2 = last_frame;
  64     last_frame = ent;
  65   }
  66
  67   if (last_frame2 == 0)
  68     return;
  69   const char *last = last_frame->func;
  70 #ifndef TSAN_GO
  71   const char *last2 = last_frame2->func;
  72   // Strip frame above 'main'
  73   if (last2 && 0 == internal_strcmp(last2, "main")) {
  74     last_frame2->next = 0;
  75   // Strip our internal thread start routine.
  76   } else if (last && 0 == internal_strcmp(last, "__tsan_thread_start_func")) {
  77     last_frame2->next = 0;
  78   // Strip global ctors init.
  79   } else if (last && 0 == internal_strcmp(last, "__do_global_ctors_aux")) {
  80     last_frame2->next = 0;
  81   // If both are 0, then we probably just failed to symbolize.
  82   } else if (last || last2) {
  83     // Ensure that we recovered stack completely. Trimmed stack
  84     // can actually happen if we do not instrument some code,
  85     // so it's only a debug print. However we must try hard to not miss it
  86     // due to our fault.
  87     DPrintf("Bottom stack frame of stack %zx is missed\n", stack->pc);
  88   }
  89 #else
  90   if (last && 0 == internal_strcmp(last, "schedunlock"))
  91     last_frame2->next = 0;
  92 #endif
  93 }
  94
  95 static ReportStack *SymbolizeStack(const StackTrace& trace) {
  96   if (trace.IsEmpty())
  97     return 0;
  98   ReportStack *stack = 0;
  99   for (uptr si = 0; si < trace.Size(); si++) {
 100     // We obtain the return address, that is, address of the next instruction,
 101     // so offset it by 1 byte.
 102     bool is_last = (si == trace.Size() - 1);
 103     ReportStack *ent = SymbolizeCode(trace.Get(si) - !is_last);
 104     CHECK_NE(ent, 0);
 105     ReportStack *last = ent;
 106     while (last->next) {
 107       last->pc += !is_last;
 108       last = last->next;
 109     }
 110     last->pc += !is_last;
 111     last->next = stack;
 112     stack = ent;
 113   }
 114   StackStripMain(stack);
 115   return stack;
 116 }
 117
 118 ScopedReport::ScopedReport(ReportType typ) {
 119   ctx_ = CTX();
 120   void *mem = internal_alloc(MBlockReport, sizeof(ReportDesc));
 121   rep_ = new(mem) ReportDesc;
 122   rep_->typ = typ;
 123   ctx_->report_mtx.Lock();
 124 }
 125
 126 ScopedReport::~ScopedReport() {
 127   ctx_->report_mtx.Unlock();
 128   rep_->~ReportDesc();
 129   internal_free(rep_);
 130 }
 131
 132 void ScopedReport::AddStack(const StackTrace *stack) {
 133   ReportStack **rs = rep_->stacks.PushBack();
 134   *rs = SymbolizeStack(*stack);
 135 }
 136
 137 void ScopedReport::AddMemoryAccess(uptr addr, Shadow s,
 138                                    const StackTrace *stack) {
 139   void *mem = internal_alloc(MBlockReportMop, sizeof(ReportMop));
 140   ReportMop *mop = new(mem) ReportMop;
 141   rep_->mops.PushBack(mop);
 142   mop->tid = s.tid();
 143   mop->addr = addr + s.addr0();
 144   mop->size = s.size();
 145   mop->write = s.is_write();
 146   mop->nmutex = 0;
 147   mop->stack = SymbolizeStack(*stack);
 148 }
 149
 150 void ScopedReport::AddThread(const ThreadContext *tctx) {
 151   for (uptr i = 0; i < rep_->threads.Size(); i++) {
 152     if (rep_->threads[i]->id == tctx->tid)
 153       return;
 154   }
 155   void *mem = internal_alloc(MBlockReportThread, sizeof(ReportThread));
 156   ReportThread *rt = new(mem) ReportThread();
 157   rep_->threads.PushBack(rt);
 158   rt->id = tctx->tid;
 159   rt->pid = tctx->os_id;
 160   rt->running = (tctx->status == ThreadStatusRunning);
 161   rt->stack = SymbolizeStack(tctx->creation_stack);
 162 }
 163
 164 #ifndef TSAN_GO
 165 static ThreadContext *FindThread(int unique_id) {
 166   CTX()->thread_mtx.CheckLocked();
 167   for (unsigned i = 0; i < kMaxTid; i++) {
 168     ThreadContext *tctx = CTX()->threads[i];
 169     if (tctx && tctx->unique_id == unique_id) {
 170       return tctx;
 171     }
 172   }
 173   return 0;
 174 }
 175 #endif
 176
 177 void ScopedReport::AddMutex(const SyncVar *s) {
 178   void *mem = internal_alloc(MBlockReportMutex, sizeof(ReportMutex));
 179   ReportMutex *rm = new(mem) ReportMutex();
 180   rep_->mutexes.PushBack(rm);
 181   rm->id = 42;
 182   rm->stack = SymbolizeStack(s->creation_stack);
 183 }
 184
 185 void ScopedReport::AddLocation(uptr addr, uptr size) {
 186   if (addr == 0)
 187     return;
 188 #ifndef TSAN_GO
 189   if (allocator()->PointerIsMine((void*)addr)) {
 190     MBlock *b = user_mblock(0, (void*)addr);
 191     ThreadContext *tctx = FindThread(b->alloc_tid);
 192     void *mem = internal_alloc(MBlockReportLoc, sizeof(ReportLocation));
 193     ReportLocation *loc = new(mem) ReportLocation();
 194     rep_->locs.PushBack(loc);
 195     loc->type = ReportLocationHeap;
 196     loc->addr = (uptr)allocator()->GetBlockBegin((void*)addr);
 197     loc->size = b->size;
 198     loc->tid = tctx ? tctx->tid : b->alloc_tid;
 199     loc->name = 0;
 200     loc->file = 0;
 201     loc->line = 0;
 202     loc->stack = 0;
 203     uptr ssz = 0;
 204     const uptr *stack = StackDepotGet(b->alloc_stack_id, &ssz);
 205     if (stack) {
 206       StackTrace trace;
 207       trace.Init(stack, ssz);
 208       loc->stack = SymbolizeStack(trace);
 209     }
 210     if (tctx)
 211       AddThread(tctx);
 212     return;
 213   }
 214 #endif
 215   ReportStack *symb = SymbolizeData(addr);
 216   if (symb) {
 217     void *mem = internal_alloc(MBlockReportLoc, sizeof(ReportLocation));
 218     ReportLocation *loc = new(mem) ReportLocation();
 219     rep_->locs.PushBack(loc);
 220     loc->type = ReportLocationGlobal;
 221     loc->addr = addr;
 222     loc->size = size;
 223     loc->tid = 0;
 224     loc->name = symb->func;
 225     loc->file = symb->file;
 226     loc->line = symb->line;
 227     loc->stack = 0;
 228     internal_free(symb);
 229     return;
 230   }
 231 }
 232
 233 #ifndef TSAN_GO
 234 void ScopedReport::AddSleep(u32 stack_id) {
 235   uptr ssz = 0;
 236   const uptr *stack = StackDepotGet(stack_id, &ssz);
 237   if (stack) {
 238     StackTrace trace;
 239     trace.Init(stack, ssz);
 240     rep_->sleep = SymbolizeStack(trace);
 241   }
 242 }
 243 #endif
 244
 245 const ReportDesc *ScopedReport::GetReport() const {
 246   return rep_;
 247 }
 248
 249 void RestoreStack(int tid, const u64 epoch, StackTrace *stk) {
 250   ThreadContext *tctx = CTX()->threads[tid];
 251   if (tctx == 0)
 252     return;
 253   Trace* trace = 0;
 254   if (tctx->status == ThreadStatusRunning) {
 255     CHECK(tctx->thr);
 256     trace = &tctx->thr->trace;
 257   } else if (tctx->status == ThreadStatusFinished
 258       || tctx->status == ThreadStatusDead) {
 259     if (tctx->dead_info == 0)
 260       return;
 261     trace = &tctx->dead_info->trace;
 262   } else {
 263     return;
 264   }
 265   Lock l(&trace->mtx);
 266   const int partidx = (epoch / (TraceSize() / kTraceParts)) % kTraceParts;
 267   TraceHeader* hdr = &trace->headers[partidx];
 268   if (epoch < hdr->epoch0)
 269     return;
 270   const u64 eend = epoch % TraceSize();
 271   const u64 ebegin = eend / kTracePartSize * kTracePartSize;
 272   DPrintf("#%d: RestoreStack epoch=%zu ebegin=%zu eend=%zu partidx=%d\n",
 273           tid, (uptr)epoch, (uptr)ebegin, (uptr)eend, partidx);
 274   InternalScopedBuffer<uptr> stack(1024);  // FIXME: de-hardcode 1024
 275   for (uptr i = 0; i < hdr->stack0.Size(); i++) {
 276     stack[i] = hdr->stack0.Get(i);
 277     DPrintf2("  #%02lu: pc=%zx\n", i, stack[i]);
 278   }
 279   uptr pos = hdr->stack0.Size();
 280   Event *events = (Event*)GetThreadTrace(tid);
 281   for (uptr i = ebegin; i <= eend; i++) {
 282     Event ev = events[i];
 283     EventType typ = (EventType)(ev >> 61);
 284     uptr pc = (uptr)(ev & 0xffffffffffffull);
 285     DPrintf2("  %zu typ=%d pc=%zx\n", i, typ, pc);
 286     if (typ == EventTypeMop) {
 287       stack[pos] = pc;
 288     } else if (typ == EventTypeFuncEnter) {
 289       stack[pos++] = pc;
 290     } else if (typ == EventTypeFuncExit) {
 291       if (pos > 0)
 292         pos--;
 293     }
 294     for (uptr j = 0; j <= pos; j++)
 295       DPrintf2("      #%zu: %zx\n", j, stack[j]);
 296   }
 297   if (pos == 0 && stack[0] == 0)
 298     return;
 299   pos++;
 300   stk->Init(stack.data(), pos);
 301 }
 302
 303 static bool HandleRacyStacks(ThreadState *thr, const StackTrace (&traces)[2],
 304     uptr addr_min, uptr addr_max) {
 305   Context *ctx = CTX();
 306   bool equal_stack = false;
 307   RacyStacks hash = {};
 308   if (flags()->suppress_equal_stacks) {
 309     hash.hash[0] = md5_hash(traces[0].Begin(), traces[0].Size() * sizeof(uptr));
 310     hash.hash[1] = md5_hash(traces[1].Begin(), traces[1].Size() * sizeof(uptr));
 311     for (uptr i = 0; i < ctx->racy_stacks.Size(); i++) {
 312       if (hash == ctx->racy_stacks[i]) {
 313         DPrintf("ThreadSanitizer: suppressing report as doubled (stack)\n");
 314         equal_stack = true;
 315         break;
 316       }
 317     }
 318   }
 319   bool equal_address = false;
 320   RacyAddress ra0 = {addr_min, addr_max};
 321   if (flags()->suppress_equal_addresses) {
 322     for (uptr i = 0; i < ctx->racy_addresses.Size(); i++) {
 323       RacyAddress ra2 = ctx->racy_addresses[i];
 324       uptr maxbeg = max(ra0.addr_min, ra2.addr_min);
 325       uptr minend = min(ra0.addr_max, ra2.addr_max);
 326       if (maxbeg < minend) {
 327         DPrintf("ThreadSanitizer: suppressing report as doubled (addr)\n");
 328         equal_address = true;
 329         break;
 330       }
 331     }
 332   }
 333   if (equal_stack || equal_address) {
 334     if (!equal_stack)
 335       ctx->racy_stacks.PushBack(hash);
 336     if (!equal_address)
 337       ctx->racy_addresses.PushBack(ra0);
 338     return true;
 339   }
 340   return false;
 341 }
 342
 343 static void AddRacyStacks(ThreadState *thr, const StackTrace (&traces)[2],
 344     uptr addr_min, uptr addr_max) {
 345   Context *ctx = CTX();
 346   if (flags()->suppress_equal_stacks) {
 347     RacyStacks hash;
 348     hash.hash[0] = md5_hash(traces[0].Begin(), traces[0].Size() * sizeof(uptr));
 349     hash.hash[1] = md5_hash(traces[1].Begin(), traces[1].Size() * sizeof(uptr));
 350     ctx->racy_stacks.PushBack(hash);
 351   }
 352   if (flags()->suppress_equal_addresses) {
 353     RacyAddress ra0 = {addr_min, addr_max};
 354     ctx->racy_addresses.PushBack(ra0);
 355   }
 356 }
 357
 358 bool OutputReport(Context *ctx,
 359                   const ScopedReport &srep,
 360                   const ReportStack *suppress_stack) {
 361   const ReportDesc *rep = srep.GetReport();
 362   const uptr suppress_pc = IsSuppressed(rep->typ, suppress_stack);
 363   if (suppress_pc != 0) {
 364     FiredSuppression supp = {srep.GetReport()->typ, suppress_pc};
 365     ctx->fired_suppressions.PushBack(supp);
 366   }
 367   if (OnReport(rep, suppress_pc != 0))
 368     return false;
 369   PrintReport(rep);
 370   CTX()->nreported++;
 371   return true;
 372 }
 373
 374 bool IsFiredSuppression(Context *ctx,
 375                         const ScopedReport &srep,
 376                         const StackTrace &trace) {
 377   for (uptr k = 0; k < ctx->fired_suppressions.Size(); k++) {
 378     if (ctx->fired_suppressions[k].type != srep.GetReport()->typ)
 379       continue;
 380     for (uptr j = 0; j < trace.Size(); j++) {
 381       if (trace.Get(j) == ctx->fired_suppressions[k].pc)
 382         return true;
 383     }
 384   }
 385   return false;
 386 }
 387
 388 // On programs that use Java we see weird reports like:
 389 // WARNING: ThreadSanitizer: data race (pid=22512)
 390 //   Read of size 8 at 0x7d2b00084318 by thread 100:
 391 //     #0 memcpy tsan_interceptors.cc:406 (foo+0x00000d8dfae3)
 392 //     #1 <null> <null>:0 (0x7f7ad9b40193)
 393 //   Previous write of size 8 at 0x7d2b00084318 by thread 105:
 394 //     #0 strncpy tsan_interceptors.cc:501 (foo+0x00000d8e0919)
 395 //     #1 <null> <null>:0 (0x7f7ad9b42707)
 396 static bool IsJavaNonsense(const ReportDesc *rep) {
 397   for (uptr i = 0; i < rep->mops.Size(); i++) {
 398     ReportMop *mop = rep->mops[i];
 399     ReportStack *frame = mop->stack;
 400     if (frame != 0 && frame->func != 0
 401         && (internal_strcmp(frame->func, "memset") == 0
 402         || internal_strcmp(frame->func, "memcpy") == 0
 403         || internal_strcmp(frame->func, "strcmp") == 0
 404         || internal_strcmp(frame->func, "strncpy") == 0
 405         || internal_strcmp(frame->func, "pthread_mutex_lock") == 0)) {
 406       frame = frame->next;
 407       if (frame == 0
 408           || (frame->func == 0 && frame->file == 0 && frame->line == 0
 409             && frame->module == 0)) {
 410         if (frame) {
 411           FiredSuppression supp = {rep->typ, frame->pc};
 412           CTX()->fired_suppressions.PushBack(supp);
 413         }
 414         return true;
 415       }
 416     }
 417   }
 418   return false;
 419 }
 420
 421 void ReportRace(ThreadState *thr) {
 422   if (!flags()->report_bugs)
 423     return;
 424   ScopedInRtl in_rtl;
 425
 426   bool freed = false;
 427   {
 428     Shadow s(thr->racy_state[1]);
 429     freed = s.GetFreedAndReset();
 430     thr->racy_state[1] = s.raw();
 431   }
 432
 433   uptr addr = ShadowToMem((uptr)thr->racy_shadow_addr);
 434   uptr addr_min = 0;
 435   uptr addr_max = 0;
 436   {
 437     uptr a0 = addr + Shadow(thr->racy_state[0]).addr0();
 438     uptr a1 = addr + Shadow(thr->racy_state[1]).addr0();
 439     uptr e0 = a0 + Shadow(thr->racy_state[0]).size();
 440     uptr e1 = a1 + Shadow(thr->racy_state[1]).size();
 441     addr_min = min(a0, a1);
 442     addr_max = max(e0, e1);
 443     if (IsExpectedReport(addr_min, addr_max - addr_min))
 444       return;
 445   }
 446
 447   Context *ctx = CTX();
 448   Lock l0(&ctx->thread_mtx);
 449
 450   ScopedReport rep(freed ? ReportTypeUseAfterFree : ReportTypeRace);
 451   const uptr kMop = 2;
 452   StackTrace traces[kMop];
 453   const uptr toppc = TraceTopPC(thr);
 454   traces[0].ObtainCurrent(thr, toppc);
 455   if (IsFiredSuppression(ctx, rep, traces[0]))
 456     return;
 457   Shadow s2(thr->racy_state[1]);
 458   RestoreStack(s2.tid(), s2.epoch(), &traces[1]);
 459
 460   if (HandleRacyStacks(thr, traces, addr_min, addr_max))
 461     return;
 462
 463   for (uptr i = 0; i < kMop; i++) {
 464     Shadow s(thr->racy_state[i]);
 465     rep.AddMemoryAccess(addr, s, &traces[i]);
 466   }
 467
 468   if (flags()->suppress_java && IsJavaNonsense(rep.GetReport()))
 469     return;
 470
 471   for (uptr i = 0; i < kMop; i++) {
 472     FastState s(thr->racy_state[i]);
 473     ThreadContext *tctx = ctx->threads[s.tid()];
 474     if (s.epoch() < tctx->epoch0 || s.epoch() > tctx->epoch1)
 475       continue;
 476     rep.AddThread(tctx);
 477   }
 478
 479   rep.AddLocation(addr_min, addr_max - addr_min);
 480
 481 #ifndef TSAN_GO
 482   {  // NOLINT
 483     Shadow s(thr->racy_state[1]);
 484     if (s.epoch() <= thr->last_sleep_clock.get(s.tid()))
 485       rep.AddSleep(thr->last_sleep_stack_id);
 486   }
 487 #endif
 488
 489   if (!OutputReport(ctx, rep, rep.GetReport()->mops[0]->stack))
 490     return;
 491
 492   AddRacyStacks(thr, traces, addr_min, addr_max);
 493 }
 494
 495 void PrintCurrentStack(ThreadState *thr, uptr pc) {
 496   StackTrace trace;
 497   trace.ObtainCurrent(thr, pc);
 498   PrintStack(SymbolizeStack(trace));
 499 }
 500
 501 }  // namespace __tsan