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