libsanitizer/tsan/tsan_interface_ann.cc

   1 //===-- tsan_interface_ann.cc ---------------------------------------------===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is a part of ThreadSanitizer (TSan), a race detector.
   9 //
  10 //===----------------------------------------------------------------------===//
  11 #include "sanitizer_common/sanitizer_libc.h"
  12 #include "sanitizer_common/sanitizer_internal_defs.h"
  13 #include "sanitizer_common/sanitizer_placement_new.h"
  14 #include "sanitizer_common/sanitizer_stacktrace.h"
  15 #include "tsan_interface_ann.h"
  16 #include "tsan_mutex.h"
  17 #include "tsan_report.h"
  18 #include "tsan_rtl.h"
  19 #include "tsan_mman.h"
  20 #include "tsan_flags.h"
  21 #include "tsan_platform.h"
  22 #include "tsan_vector.h"
  23
  24 #define CALLERPC ((uptr)__builtin_return_address(0))
  25
  26 using namespace __tsan;  // NOLINT
  27
  28 namespace __tsan {
  29
  30 class ScopedAnnotation {
  31  public:
  32   ScopedAnnotation(ThreadState *thr, const char *aname, const char *f, int l,
  33                    uptr pc)
  34       : thr_(thr) {
  35     FuncEntry(thr_, pc);
  36     DPrintf("#%d: annotation %s() %s:%d\n", thr_->tid, aname, f, l);
  37   }
  38
  39   ~ScopedAnnotation() {
  40     FuncExit(thr_);
  41     CheckNoLocks(thr_);
  42   }
  43  private:
  44   ThreadState *const thr_;
  45 };
  46
  47 #define SCOPED_ANNOTATION(typ) \
  48     if (!flags()->enable_annotations) \
  49       return; \
  50     ThreadState *thr = cur_thread(); \
  51     const uptr caller_pc = (uptr)__builtin_return_address(0); \
  52     StatInc(thr, StatAnnotation); \
  53     StatInc(thr, Stat##typ); \
  54     ScopedAnnotation sa(thr, __func__, f, l, caller_pc); \
  55     const uptr pc = StackTrace::GetCurrentPc(); \
  56     (void)pc; \
  57 /**/
  58
  59 static const int kMaxDescLen = 128;
  60
  61 struct ExpectRace {
  62   ExpectRace *next;
  63   ExpectRace *prev;
  64   atomic_uintptr_t hitcount;
  65   atomic_uintptr_t addcount;
  66   uptr addr;
  67   uptr size;
  68   char *file;
  69   int line;
  70   char desc[kMaxDescLen];
  71 };
  72
  73 struct DynamicAnnContext {
  74   Mutex mtx;
  75   ExpectRace expect;
  76   ExpectRace benign;
  77
  78   DynamicAnnContext()
  79     : mtx(MutexTypeAnnotations, StatMtxAnnotations) {
  80   }
  81 };
  82
  83 static DynamicAnnContext *dyn_ann_ctx;
  84 static char dyn_ann_ctx_placeholder[sizeof(DynamicAnnContext)] ALIGNED(64);
  85
  86 static void AddExpectRace(ExpectRace *list,
  87     char *f, int l, uptr addr, uptr size, char *desc) {
  88   ExpectRace *race = list->next;
  89   for (; race != list; race = race->next) {
  90     if (race->addr == addr && race->size == size) {
  91       atomic_store_relaxed(&race->addcount,
  92           atomic_load_relaxed(&race->addcount) + 1);
  93       return;
  94     }
  95   }
  96   race = (ExpectRace*)internal_alloc(MBlockExpectRace, sizeof(ExpectRace));
  97   race->addr = addr;
  98   race->size = size;
  99   race->file = f;
 100   race->line = l;
 101   race->desc[0] = 0;
 102   atomic_store_relaxed(&race->hitcount, 0);
 103   atomic_store_relaxed(&race->addcount, 1);
 104   if (desc) {
 105     int i = 0;
 106     for (; i < kMaxDescLen - 1 && desc[i]; i++)
 107       race->desc[i] = desc[i];
 108     race->desc[i] = 0;
 109   }
 110   race->prev = list;
 111   race->next = list->next;
 112   race->next->prev = race;
 113   list->next = race;
 114 }
 115
 116 static ExpectRace *FindRace(ExpectRace *list, uptr addr, uptr size) {
 117   for (ExpectRace *race = list->next; race != list; race = race->next) {
 118     uptr maxbegin = max(race->addr, addr);
 119     uptr minend = min(race->addr + race->size, addr + size);
 120     if (maxbegin < minend)
 121       return race;
 122   }
 123   return 0;
 124 }
 125
 126 static bool CheckContains(ExpectRace *list, uptr addr, uptr size) {
 127   ExpectRace *race = FindRace(list, addr, size);
 128   if (race == 0)
 129     return false;
 130   DPrintf("Hit expected/benign race: %s addr=%zx:%d %s:%d\n",
 131       race->desc, race->addr, (int)race->size, race->file, race->line);
 132   atomic_fetch_add(&race->hitcount, 1, memory_order_relaxed);
 133   return true;
 134 }
 135
 136 static void InitList(ExpectRace *list) {
 137   list->next = list;
 138   list->prev = list;
 139 }
 140
 141 void InitializeDynamicAnnotations() {
 142   dyn_ann_ctx = new(dyn_ann_ctx_placeholder) DynamicAnnContext;
 143   InitList(&dyn_ann_ctx->expect);
 144   InitList(&dyn_ann_ctx->benign);
 145 }
 146
 147 bool IsExpectedReport(uptr addr, uptr size) {
 148   ReadLock lock(&dyn_ann_ctx->mtx);
 149   if (CheckContains(&dyn_ann_ctx->expect, addr, size))
 150     return true;
 151   if (CheckContains(&dyn_ann_ctx->benign, addr, size))
 152     return true;
 153   return false;
 154 }
 155
 156 static void CollectMatchedBenignRaces(Vector<ExpectRace> *matched,
 157     int *unique_count, int *hit_count, atomic_uintptr_t ExpectRace::*counter) {
 158   ExpectRace *list = &dyn_ann_ctx->benign;
 159   for (ExpectRace *race = list->next; race != list; race = race->next) {
 160     (*unique_count)++;
 161     const uptr cnt = atomic_load_relaxed(&(race->*counter));
 162     if (cnt == 0)
 163       continue;
 164     *hit_count += cnt;
 165     uptr i = 0;
 166     for (; i < matched->Size(); i++) {
 167       ExpectRace *race0 = &(*matched)[i];
 168       if (race->line == race0->line
 169           && internal_strcmp(race->file, race0->file) == 0
 170           && internal_strcmp(race->desc, race0->desc) == 0) {
 171         atomic_fetch_add(&(race0->*counter), cnt, memory_order_relaxed);
 172         break;
 173       }
 174     }
 175     if (i == matched->Size())
 176       matched->PushBack(*race);
 177   }
 178 }
 179
 180 void PrintMatchedBenignRaces() {
 181   Lock lock(&dyn_ann_ctx->mtx);
 182   int unique_count = 0;
 183   int hit_count = 0;
 184   int add_count = 0;
 185   Vector<ExpectRace> hit_matched(MBlockScopedBuf);
 186   CollectMatchedBenignRaces(&hit_matched, &unique_count, &hit_count,
 187       &ExpectRace::hitcount);
 188   Vector<ExpectRace> add_matched(MBlockScopedBuf);
 189   CollectMatchedBenignRaces(&add_matched, &unique_count, &add_count,
 190       &ExpectRace::addcount);
 191   if (hit_matched.Size()) {
 192     Printf("ThreadSanitizer: Matched %d \"benign\" races (pid=%d):\n",
 193         hit_count, (int)internal_getpid());
 194     for (uptr i = 0; i < hit_matched.Size(); i++) {
 195       Printf("%d %s:%d %s\n",
 196           atomic_load_relaxed(&hit_matched[i].hitcount),
 197           hit_matched[i].file, hit_matched[i].line, hit_matched[i].desc);
 198     }
 199   }
 200   if (hit_matched.Size()) {
 201     Printf("ThreadSanitizer: Annotated %d \"benign\" races, %d unique"
 202            " (pid=%d):\n",
 203         add_count, unique_count, (int)internal_getpid());
 204     for (uptr i = 0; i < add_matched.Size(); i++) {
 205       Printf("%d %s:%d %s\n",
 206           atomic_load_relaxed(&add_matched[i].addcount),
 207           add_matched[i].file, add_matched[i].line, add_matched[i].desc);
 208     }
 209   }
 210 }
 211
 212 static void ReportMissedExpectedRace(ExpectRace *race) {
 213   Printf("==================\n");
 214   Printf("WARNING: ThreadSanitizer: missed expected data race\n");
 215   Printf("  %s addr=%zx %s:%d\n",
 216       race->desc, race->addr, race->file, race->line);
 217   Printf("==================\n");
 218 }
 219 }  // namespace __tsan
 220
 221 using namespace __tsan;  // NOLINT
 222
 223 extern "C" {
 224 void INTERFACE_ATTRIBUTE AnnotateHappensBefore(char *f, int l, uptr addr) {
 225   SCOPED_ANNOTATION(AnnotateHappensBefore);
 226   Release(thr, pc, addr);
 227 }
 228
 229 void INTERFACE_ATTRIBUTE AnnotateHappensAfter(char *f, int l, uptr addr) {
 230   SCOPED_ANNOTATION(AnnotateHappensAfter);
 231   Acquire(thr, pc, addr);
 232 }
 233
 234 void INTERFACE_ATTRIBUTE AnnotateCondVarSignal(char *f, int l, uptr cv) {
 235   SCOPED_ANNOTATION(AnnotateCondVarSignal);
 236 }
 237
 238 void INTERFACE_ATTRIBUTE AnnotateCondVarSignalAll(char *f, int l, uptr cv) {
 239   SCOPED_ANNOTATION(AnnotateCondVarSignalAll);
 240 }
 241
 242 void INTERFACE_ATTRIBUTE AnnotateMutexIsNotPHB(char *f, int l, uptr mu) {
 243   SCOPED_ANNOTATION(AnnotateMutexIsNotPHB);
 244 }
 245
 246 void INTERFACE_ATTRIBUTE AnnotateCondVarWait(char *f, int l, uptr cv,
 247                                              uptr lock) {
 248   SCOPED_ANNOTATION(AnnotateCondVarWait);
 249 }
 250
 251 void INTERFACE_ATTRIBUTE AnnotateRWLockCreate(char *f, int l, uptr m) {
 252   SCOPED_ANNOTATION(AnnotateRWLockCreate);
 253   MutexCreate(thr, pc, m, true, true, false);
 254 }
 255
 256 void INTERFACE_ATTRIBUTE AnnotateRWLockCreateStatic(char *f, int l, uptr m) {
 257   SCOPED_ANNOTATION(AnnotateRWLockCreateStatic);
 258   MutexCreate(thr, pc, m, true, true, true);
 259 }
 260
 261 void INTERFACE_ATTRIBUTE AnnotateRWLockDestroy(char *f, int l, uptr m) {
 262   SCOPED_ANNOTATION(AnnotateRWLockDestroy);
 263   MutexDestroy(thr, pc, m);
 264 }
 265
 266 void INTERFACE_ATTRIBUTE AnnotateRWLockAcquired(char *f, int l, uptr m,
 267                                                 uptr is_w) {
 268   SCOPED_ANNOTATION(AnnotateRWLockAcquired);
 269   if (is_w)
 270     MutexLock(thr, pc, m);
 271   else
 272     MutexReadLock(thr, pc, m);
 273 }
 274
 275 void INTERFACE_ATTRIBUTE AnnotateRWLockReleased(char *f, int l, uptr m,
 276                                                 uptr is_w) {
 277   SCOPED_ANNOTATION(AnnotateRWLockReleased);
 278   if (is_w)
 279     MutexUnlock(thr, pc, m);
 280   else
 281     MutexReadUnlock(thr, pc, m);
 282 }
 283
 284 void INTERFACE_ATTRIBUTE AnnotateTraceMemory(char *f, int l, uptr mem) {
 285   SCOPED_ANNOTATION(AnnotateTraceMemory);
 286 }
 287
 288 void INTERFACE_ATTRIBUTE AnnotateFlushState(char *f, int l) {
 289   SCOPED_ANNOTATION(AnnotateFlushState);
 290 }
 291
 292 void INTERFACE_ATTRIBUTE AnnotateNewMemory(char *f, int l, uptr mem,
 293                                            uptr size) {
 294   SCOPED_ANNOTATION(AnnotateNewMemory);
 295 }
 296
 297 void INTERFACE_ATTRIBUTE AnnotateNoOp(char *f, int l, uptr mem) {
 298   SCOPED_ANNOTATION(AnnotateNoOp);
 299 }
 300
 301 void INTERFACE_ATTRIBUTE AnnotateFlushExpectedRaces(char *f, int l) {
 302   SCOPED_ANNOTATION(AnnotateFlushExpectedRaces);
 303   Lock lock(&dyn_ann_ctx->mtx);
 304   while (dyn_ann_ctx->expect.next != &dyn_ann_ctx->expect) {
 305     ExpectRace *race = dyn_ann_ctx->expect.next;
 306     if (atomic_load_relaxed(&race->hitcount) == 0) {
 307       ctx->nmissed_expected++;
 308       ReportMissedExpectedRace(race);
 309     }
 310     race->prev->next = race->next;
 311     race->next->prev = race->prev;
 312     internal_free(race);
 313   }
 314 }
 315
 316 void INTERFACE_ATTRIBUTE AnnotateEnableRaceDetection(
 317     char *f, int l, int enable) {
 318   SCOPED_ANNOTATION(AnnotateEnableRaceDetection);
 319   // FIXME: Reconsider this functionality later. It may be irrelevant.
 320 }
 321
 322 void INTERFACE_ATTRIBUTE AnnotateMutexIsUsedAsCondVar(
 323     char *f, int l, uptr mu) {
 324   SCOPED_ANNOTATION(AnnotateMutexIsUsedAsCondVar);
 325 }
 326
 327 void INTERFACE_ATTRIBUTE AnnotatePCQGet(
 328     char *f, int l, uptr pcq) {
 329   SCOPED_ANNOTATION(AnnotatePCQGet);
 330 }
 331
 332 void INTERFACE_ATTRIBUTE AnnotatePCQPut(
 333     char *f, int l, uptr pcq) {
 334   SCOPED_ANNOTATION(AnnotatePCQPut);
 335 }
 336
 337 void INTERFACE_ATTRIBUTE AnnotatePCQDestroy(
 338     char *f, int l, uptr pcq) {
 339   SCOPED_ANNOTATION(AnnotatePCQDestroy);
 340 }
 341
 342 void INTERFACE_ATTRIBUTE AnnotatePCQCreate(
 343     char *f, int l, uptr pcq) {
 344   SCOPED_ANNOTATION(AnnotatePCQCreate);
 345 }
 346
 347 void INTERFACE_ATTRIBUTE AnnotateExpectRace(
 348     char *f, int l, uptr mem, char *desc) {
 349   SCOPED_ANNOTATION(AnnotateExpectRace);
 350   Lock lock(&dyn_ann_ctx->mtx);
 351   AddExpectRace(&dyn_ann_ctx->expect,
 352                 f, l, mem, 1, desc);
 353   DPrintf("Add expected race: %s addr=%zx %s:%d\n", desc, mem, f, l);
 354 }
 355
 356 static void BenignRaceImpl(
 357     char *f, int l, uptr mem, uptr size, char *desc) {
 358   Lock lock(&dyn_ann_ctx->mtx);
 359   AddExpectRace(&dyn_ann_ctx->benign,
 360                 f, l, mem, size, desc);
 361   DPrintf("Add benign race: %s addr=%zx %s:%d\n", desc, mem, f, l);
 362 }
 363
 364 // FIXME: Turn it off later. WTF is benign race?1?? Go talk to Hans Boehm.
 365 void INTERFACE_ATTRIBUTE AnnotateBenignRaceSized(
 366     char *f, int l, uptr mem, uptr size, char *desc) {
 367   SCOPED_ANNOTATION(AnnotateBenignRaceSized);
 368   BenignRaceImpl(f, l, mem, size, desc);
 369 }
 370
 371 void INTERFACE_ATTRIBUTE AnnotateBenignRace(
 372     char *f, int l, uptr mem, char *desc) {
 373   SCOPED_ANNOTATION(AnnotateBenignRace);
 374   BenignRaceImpl(f, l, mem, 1, desc);
 375 }
 376
 377 void INTERFACE_ATTRIBUTE AnnotateIgnoreReadsBegin(char *f, int l) {
 378   SCOPED_ANNOTATION(AnnotateIgnoreReadsBegin);
 379   ThreadIgnoreBegin(thr, pc);
 380 }
 381
 382 void INTERFACE_ATTRIBUTE AnnotateIgnoreReadsEnd(char *f, int l) {
 383   SCOPED_ANNOTATION(AnnotateIgnoreReadsEnd);
 384   ThreadIgnoreEnd(thr, pc);
 385 }
 386
 387 void INTERFACE_ATTRIBUTE AnnotateIgnoreWritesBegin(char *f, int l) {
 388   SCOPED_ANNOTATION(AnnotateIgnoreWritesBegin);
 389   ThreadIgnoreBegin(thr, pc);
 390 }
 391
 392 void INTERFACE_ATTRIBUTE AnnotateIgnoreWritesEnd(char *f, int l) {
 393   SCOPED_ANNOTATION(AnnotateIgnoreWritesEnd);
 394   ThreadIgnoreEnd(thr, pc);
 395 }
 396
 397 void INTERFACE_ATTRIBUTE AnnotateIgnoreSyncBegin(char *f, int l) {
 398   SCOPED_ANNOTATION(AnnotateIgnoreSyncBegin);
 399   ThreadIgnoreSyncBegin(thr, pc);
 400 }
 401
 402 void INTERFACE_ATTRIBUTE AnnotateIgnoreSyncEnd(char *f, int l) {
 403   SCOPED_ANNOTATION(AnnotateIgnoreSyncEnd);
 404   ThreadIgnoreSyncEnd(thr, pc);
 405 }
 406
 407 void INTERFACE_ATTRIBUTE AnnotatePublishMemoryRange(
 408     char *f, int l, uptr addr, uptr size) {
 409   SCOPED_ANNOTATION(AnnotatePublishMemoryRange);
 410 }
 411
 412 void INTERFACE_ATTRIBUTE AnnotateUnpublishMemoryRange(
 413     char *f, int l, uptr addr, uptr size) {
 414   SCOPED_ANNOTATION(AnnotateUnpublishMemoryRange);
 415 }
 416
 417 void INTERFACE_ATTRIBUTE AnnotateThreadName(
 418     char *f, int l, char *name) {
 419   SCOPED_ANNOTATION(AnnotateThreadName);
 420   ThreadSetName(thr, name);
 421 }
 422
 423 // We deliberately omit the implementation of WTFAnnotateHappensBefore() and
 424 // WTFAnnotateHappensAfter(). Those are being used by Webkit to annotate
 425 // atomic operations, which should be handled by ThreadSanitizer correctly.
 426 void INTERFACE_ATTRIBUTE WTFAnnotateHappensBefore(char *f, int l, uptr addr) {
 427   SCOPED_ANNOTATION(AnnotateHappensBefore);
 428 }
 429
 430 void INTERFACE_ATTRIBUTE WTFAnnotateHappensAfter(char *f, int l, uptr addr) {
 431   SCOPED_ANNOTATION(AnnotateHappensAfter);
 432 }
 433
 434 void INTERFACE_ATTRIBUTE WTFAnnotateBenignRaceSized(
 435     char *f, int l, uptr mem, uptr sz, char *desc) {
 436   SCOPED_ANNOTATION(AnnotateBenignRaceSized);
 437   BenignRaceImpl(f, l, mem, sz, desc);
 438 }
 439
 440 int INTERFACE_ATTRIBUTE RunningOnValgrind() {
 441   return flags()->running_on_valgrind;
 442 }
 443
 444 double __attribute__((weak)) INTERFACE_ATTRIBUTE ValgrindSlowdown(void) {
 445   return 10.0;
 446 }
 447
 448 const char INTERFACE_ATTRIBUTE* ThreadSanitizerQuery(const char *query) {
 449   if (internal_strcmp(query, "pure_happens_before") == 0)
 450     return "1";
 451   else
 452     return "0";
 453 }
 454
 455 void INTERFACE_ATTRIBUTE
 456 AnnotateMemoryIsInitialized(char *f, int l, uptr mem, uptr sz) {}
 457 void INTERFACE_ATTRIBUTE
 458 AnnotateMemoryIsUninitialized(char *f, int l, uptr mem, uptr sz) {}
 459 }  // extern "C"