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