• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- tsan_interceptors_mac.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 // Mac-specific interceptors.
13 //===----------------------------------------------------------------------===//
14 
15 #include "sanitizer_common/sanitizer_platform.h"
16 #if SANITIZER_MAC
17 
18 #include "interception/interception.h"
19 #include "tsan_interceptors.h"
20 #include "tsan_interface.h"
21 #include "tsan_interface_ann.h"
22 
23 #include <libkern/OSAtomic.h>
24 #include <xpc/xpc.h>
25 
26 typedef long long_t;  // NOLINT
27 
28 namespace __tsan {
29 
30 // The non-barrier versions of OSAtomic* functions are semantically mo_relaxed,
31 // but the two variants (e.g. OSAtomicAdd32 and OSAtomicAdd32Barrier) are
32 // actually aliases of each other, and we cannot have different interceptors for
33 // them, because they're actually the same function.  Thus, we have to stay
34 // conservative and treat the non-barrier versions as mo_acq_rel.
35 static const morder kMacOrderBarrier = mo_acq_rel;
36 static const morder kMacOrderNonBarrier = mo_acq_rel;
37 
38 #define OSATOMIC_INTERCEPTOR(return_t, t, tsan_t, f, tsan_atomic_f, mo) \
39   TSAN_INTERCEPTOR(return_t, f, t x, volatile t *ptr) {                 \
40     SCOPED_TSAN_INTERCEPTOR(f, x, ptr);                                 \
41     return tsan_atomic_f((volatile tsan_t *)ptr, x, mo);                \
42   }
43 
44 #define OSATOMIC_INTERCEPTOR_PLUS_X(return_t, t, tsan_t, f, tsan_atomic_f, mo) \
45   TSAN_INTERCEPTOR(return_t, f, t x, volatile t *ptr) {                        \
46     SCOPED_TSAN_INTERCEPTOR(f, x, ptr);                                        \
47     return tsan_atomic_f((volatile tsan_t *)ptr, x, mo) + x;                   \
48   }
49 
50 #define OSATOMIC_INTERCEPTOR_PLUS_1(return_t, t, tsan_t, f, tsan_atomic_f, mo) \
51   TSAN_INTERCEPTOR(return_t, f, volatile t *ptr) {                             \
52     SCOPED_TSAN_INTERCEPTOR(f, ptr);                                           \
53     return tsan_atomic_f((volatile tsan_t *)ptr, 1, mo) + 1;                   \
54   }
55 
56 #define OSATOMIC_INTERCEPTOR_MINUS_1(return_t, t, tsan_t, f, tsan_atomic_f, \
57                                      mo)                                    \
58   TSAN_INTERCEPTOR(return_t, f, volatile t *ptr) {                          \
59     SCOPED_TSAN_INTERCEPTOR(f, ptr);                                        \
60     return tsan_atomic_f((volatile tsan_t *)ptr, 1, mo) - 1;                \
61   }
62 
63 #define OSATOMIC_INTERCEPTORS_ARITHMETIC(f, tsan_atomic_f, m)                  \
64   m(int32_t, int32_t, a32, f##32, __tsan_atomic32_##tsan_atomic_f,             \
65     kMacOrderNonBarrier)                                                       \
66   m(int32_t, int32_t, a32, f##32##Barrier, __tsan_atomic32_##tsan_atomic_f,    \
67     kMacOrderBarrier)                                                          \
68   m(int64_t, int64_t, a64, f##64, __tsan_atomic64_##tsan_atomic_f,             \
69     kMacOrderNonBarrier)                                                       \
70   m(int64_t, int64_t, a64, f##64##Barrier, __tsan_atomic64_##tsan_atomic_f,    \
71     kMacOrderBarrier)
72 
73 #define OSATOMIC_INTERCEPTORS_BITWISE(f, tsan_atomic_f, m, m_orig)             \
74   m(int32_t, uint32_t, a32, f##32, __tsan_atomic32_##tsan_atomic_f,            \
75     kMacOrderNonBarrier)                                                       \
76   m(int32_t, uint32_t, a32, f##32##Barrier, __tsan_atomic32_##tsan_atomic_f,   \
77     kMacOrderBarrier)                                                          \
78   m_orig(int32_t, uint32_t, a32, f##32##Orig, __tsan_atomic32_##tsan_atomic_f, \
79     kMacOrderNonBarrier)                                                       \
80   m_orig(int32_t, uint32_t, a32, f##32##OrigBarrier,                           \
81     __tsan_atomic32_##tsan_atomic_f, kMacOrderBarrier)
82 
OSATOMIC_INTERCEPTORS_ARITHMETIC(OSAtomicAdd,fetch_add,OSATOMIC_INTERCEPTOR_PLUS_X)83 OSATOMIC_INTERCEPTORS_ARITHMETIC(OSAtomicAdd, fetch_add,
84                                  OSATOMIC_INTERCEPTOR_PLUS_X)
85 OSATOMIC_INTERCEPTORS_ARITHMETIC(OSAtomicIncrement, fetch_add,
86                                  OSATOMIC_INTERCEPTOR_PLUS_1)
87 OSATOMIC_INTERCEPTORS_ARITHMETIC(OSAtomicDecrement, fetch_sub,
88                                  OSATOMIC_INTERCEPTOR_MINUS_1)
89 OSATOMIC_INTERCEPTORS_BITWISE(OSAtomicOr, fetch_or, OSATOMIC_INTERCEPTOR_PLUS_X,
90                               OSATOMIC_INTERCEPTOR)
91 OSATOMIC_INTERCEPTORS_BITWISE(OSAtomicAnd, fetch_and,
92                               OSATOMIC_INTERCEPTOR_PLUS_X, OSATOMIC_INTERCEPTOR)
93 OSATOMIC_INTERCEPTORS_BITWISE(OSAtomicXor, fetch_xor,
94                               OSATOMIC_INTERCEPTOR_PLUS_X, OSATOMIC_INTERCEPTOR)
95 
96 #define OSATOMIC_INTERCEPTORS_CAS(f, tsan_atomic_f, tsan_t, t)              \
97   TSAN_INTERCEPTOR(bool, f, t old_value, t new_value, t volatile *ptr) {    \
98     SCOPED_TSAN_INTERCEPTOR(f, old_value, new_value, ptr);                  \
99     return tsan_atomic_f##_compare_exchange_strong(                         \
100         (tsan_t *)ptr, (tsan_t *)&old_value, (tsan_t)new_value,             \
101         kMacOrderNonBarrier, kMacOrderNonBarrier);                          \
102   }                                                                         \
103                                                                             \
104   TSAN_INTERCEPTOR(bool, f##Barrier, t old_value, t new_value,              \
105                    t volatile *ptr) {                                       \
106     SCOPED_TSAN_INTERCEPTOR(f##Barrier, old_value, new_value, ptr);         \
107     return tsan_atomic_f##_compare_exchange_strong(                         \
108         (tsan_t *)ptr, (tsan_t *)&old_value, (tsan_t)new_value,             \
109         kMacOrderBarrier, kMacOrderNonBarrier);                             \
110   }
111 
112 OSATOMIC_INTERCEPTORS_CAS(OSAtomicCompareAndSwapInt, __tsan_atomic32, a32, int)
113 OSATOMIC_INTERCEPTORS_CAS(OSAtomicCompareAndSwapLong, __tsan_atomic64, a64,
114                           long_t)
115 OSATOMIC_INTERCEPTORS_CAS(OSAtomicCompareAndSwapPtr, __tsan_atomic64, a64,
116                           void *)
117 OSATOMIC_INTERCEPTORS_CAS(OSAtomicCompareAndSwap32, __tsan_atomic32, a32,
118                           int32_t)
119 OSATOMIC_INTERCEPTORS_CAS(OSAtomicCompareAndSwap64, __tsan_atomic64, a64,
120                           int64_t)
121 
122 #define OSATOMIC_INTERCEPTOR_BITOP(f, op, m, mo)              \
123   TSAN_INTERCEPTOR(bool, f, uint32_t n, volatile void *ptr) { \
124     SCOPED_TSAN_INTERCEPTOR(f, n, ptr);                       \
125     char *byte_ptr = ((char *)ptr) + (n >> 3);                \
126     char bit_index = n & 7;                                   \
127     char mask = m;                                            \
128     char orig_byte = op((a8 *)byte_ptr, mask, mo);            \
129     return orig_byte & mask;                                  \
130   }
131 
132 #define OSATOMIC_INTERCEPTORS_BITOP(f, op, m)                     \
133   OSATOMIC_INTERCEPTOR_BITOP(f, op, m, kMacOrderNonBarrier)       \
134   OSATOMIC_INTERCEPTOR_BITOP(f##Barrier, op, m, kMacOrderBarrier)
135 
136 OSATOMIC_INTERCEPTORS_BITOP(OSAtomicTestAndSet, __tsan_atomic8_fetch_or,
137                             0x80u >> bit_index)
138 OSATOMIC_INTERCEPTORS_BITOP(OSAtomicTestAndClear, __tsan_atomic8_fetch_and,
139                             ~(0x80u >> bit_index))
140 
141 TSAN_INTERCEPTOR(void, OSAtomicEnqueue, OSQueueHead *list, void *item,
142                  size_t offset) {
143   SCOPED_TSAN_INTERCEPTOR(OSAtomicEnqueue, list, item, offset);
144   __tsan_release(item);
145   REAL(OSAtomicEnqueue)(list, item, offset);
146 }
147 
TSAN_INTERCEPTOR(void *,OSAtomicDequeue,OSQueueHead * list,size_t offset)148 TSAN_INTERCEPTOR(void *, OSAtomicDequeue, OSQueueHead *list, size_t offset) {
149   SCOPED_TSAN_INTERCEPTOR(OSAtomicDequeue, list, offset);
150   void *item = REAL(OSAtomicDequeue)(list, offset);
151   if (item) __tsan_acquire(item);
152   return item;
153 }
154 
155 // OSAtomicFifoEnqueue and OSAtomicFifoDequeue are only on OS X.
156 #if !SANITIZER_IOS
157 
TSAN_INTERCEPTOR(void,OSAtomicFifoEnqueue,OSFifoQueueHead * list,void * item,size_t offset)158 TSAN_INTERCEPTOR(void, OSAtomicFifoEnqueue, OSFifoQueueHead *list, void *item,
159                  size_t offset) {
160   SCOPED_TSAN_INTERCEPTOR(OSAtomicFifoEnqueue, list, item, offset);
161   __tsan_release(item);
162   REAL(OSAtomicFifoEnqueue)(list, item, offset);
163 }
164 
TSAN_INTERCEPTOR(void *,OSAtomicFifoDequeue,OSFifoQueueHead * list,size_t offset)165 TSAN_INTERCEPTOR(void *, OSAtomicFifoDequeue, OSFifoQueueHead *list,
166                  size_t offset) {
167   SCOPED_TSAN_INTERCEPTOR(OSAtomicFifoDequeue, list, offset);
168   void *item = REAL(OSAtomicFifoDequeue)(list, offset);
169   if (item) __tsan_acquire(item);
170   return item;
171 }
172 
173 #endif
174 
TSAN_INTERCEPTOR(void,OSSpinLockLock,volatile OSSpinLock * lock)175 TSAN_INTERCEPTOR(void, OSSpinLockLock, volatile OSSpinLock *lock) {
176   CHECK(!cur_thread()->is_dead);
177   if (!cur_thread()->is_inited) {
178     return REAL(OSSpinLockLock)(lock);
179   }
180   SCOPED_TSAN_INTERCEPTOR(OSSpinLockLock, lock);
181   REAL(OSSpinLockLock)(lock);
182   Acquire(thr, pc, (uptr)lock);
183 }
184 
TSAN_INTERCEPTOR(bool,OSSpinLockTry,volatile OSSpinLock * lock)185 TSAN_INTERCEPTOR(bool, OSSpinLockTry, volatile OSSpinLock *lock) {
186   CHECK(!cur_thread()->is_dead);
187   if (!cur_thread()->is_inited) {
188     return REAL(OSSpinLockTry)(lock);
189   }
190   SCOPED_TSAN_INTERCEPTOR(OSSpinLockTry, lock);
191   bool result = REAL(OSSpinLockTry)(lock);
192   if (result)
193     Acquire(thr, pc, (uptr)lock);
194   return result;
195 }
196 
TSAN_INTERCEPTOR(void,OSSpinLockUnlock,volatile OSSpinLock * lock)197 TSAN_INTERCEPTOR(void, OSSpinLockUnlock, volatile OSSpinLock *lock) {
198   CHECK(!cur_thread()->is_dead);
199   if (!cur_thread()->is_inited) {
200     return REAL(OSSpinLockUnlock)(lock);
201   }
202   SCOPED_TSAN_INTERCEPTOR(OSSpinLockUnlock, lock);
203   Release(thr, pc, (uptr)lock);
204   REAL(OSSpinLockUnlock)(lock);
205 }
206 
TSAN_INTERCEPTOR(void,os_lock_lock,void * lock)207 TSAN_INTERCEPTOR(void, os_lock_lock, void *lock) {
208   CHECK(!cur_thread()->is_dead);
209   if (!cur_thread()->is_inited) {
210     return REAL(os_lock_lock)(lock);
211   }
212   SCOPED_TSAN_INTERCEPTOR(os_lock_lock, lock);
213   REAL(os_lock_lock)(lock);
214   Acquire(thr, pc, (uptr)lock);
215 }
216 
TSAN_INTERCEPTOR(bool,os_lock_trylock,void * lock)217 TSAN_INTERCEPTOR(bool, os_lock_trylock, void *lock) {
218   CHECK(!cur_thread()->is_dead);
219   if (!cur_thread()->is_inited) {
220     return REAL(os_lock_trylock)(lock);
221   }
222   SCOPED_TSAN_INTERCEPTOR(os_lock_trylock, lock);
223   bool result = REAL(os_lock_trylock)(lock);
224   if (result)
225     Acquire(thr, pc, (uptr)lock);
226   return result;
227 }
228 
TSAN_INTERCEPTOR(void,os_lock_unlock,void * lock)229 TSAN_INTERCEPTOR(void, os_lock_unlock, void *lock) {
230   CHECK(!cur_thread()->is_dead);
231   if (!cur_thread()->is_inited) {
232     return REAL(os_lock_unlock)(lock);
233   }
234   SCOPED_TSAN_INTERCEPTOR(os_lock_unlock, lock);
235   Release(thr, pc, (uptr)lock);
236   REAL(os_lock_unlock)(lock);
237 }
238 
TSAN_INTERCEPTOR(void,xpc_connection_set_event_handler,xpc_connection_t connection,xpc_handler_t handler)239 TSAN_INTERCEPTOR(void, xpc_connection_set_event_handler,
240                  xpc_connection_t connection, xpc_handler_t handler) {
241   SCOPED_TSAN_INTERCEPTOR(xpc_connection_set_event_handler, connection,
242                           handler);
243   Release(thr, pc, (uptr)connection);
244   xpc_handler_t new_handler = ^(xpc_object_t object) {
245     {
246       SCOPED_INTERCEPTOR_RAW(xpc_connection_set_event_handler);
247       Acquire(thr, pc, (uptr)connection);
248     }
249     handler(object);
250   };
251   REAL(xpc_connection_set_event_handler)(connection, new_handler);
252 }
253 
TSAN_INTERCEPTOR(void,xpc_connection_send_barrier,xpc_connection_t connection,dispatch_block_t barrier)254 TSAN_INTERCEPTOR(void, xpc_connection_send_barrier, xpc_connection_t connection,
255                  dispatch_block_t barrier) {
256   SCOPED_TSAN_INTERCEPTOR(xpc_connection_send_barrier, connection, barrier);
257   Release(thr, pc, (uptr)connection);
258   dispatch_block_t new_barrier = ^() {
259     {
260       SCOPED_INTERCEPTOR_RAW(xpc_connection_send_barrier);
261       Acquire(thr, pc, (uptr)connection);
262     }
263     barrier();
264   };
265   REAL(xpc_connection_send_barrier)(connection, new_barrier);
266 }
267 
TSAN_INTERCEPTOR(void,xpc_connection_send_message_with_reply,xpc_connection_t connection,xpc_object_t message,dispatch_queue_t replyq,xpc_handler_t handler)268 TSAN_INTERCEPTOR(void, xpc_connection_send_message_with_reply,
269                  xpc_connection_t connection, xpc_object_t message,
270                  dispatch_queue_t replyq, xpc_handler_t handler) {
271   SCOPED_TSAN_INTERCEPTOR(xpc_connection_send_message_with_reply, connection,
272                           message, replyq, handler);
273   Release(thr, pc, (uptr)connection);
274   xpc_handler_t new_handler = ^(xpc_object_t object) {
275     {
276       SCOPED_INTERCEPTOR_RAW(xpc_connection_send_message_with_reply);
277       Acquire(thr, pc, (uptr)connection);
278     }
279     handler(object);
280   };
281   REAL(xpc_connection_send_message_with_reply)
282   (connection, message, replyq, new_handler);
283 }
284 
285 // On macOS, libc++ is always linked dynamically, so intercepting works the
286 // usual way.
287 #define STDCXX_INTERCEPTOR TSAN_INTERCEPTOR
288 
289 namespace {
290 struct fake_shared_weak_count {
291   volatile a64 shared_owners;
292   volatile a64 shared_weak_owners;
293   virtual void _unused_0x0() = 0;
294   virtual void _unused_0x8() = 0;
295   virtual void on_zero_shared() = 0;
296   virtual void _unused_0x18() = 0;
297   virtual void on_zero_shared_weak() = 0;
298 };
299 }  // namespace
300 
301 // This adds a libc++ interceptor for:
302 //     void __shared_weak_count::__release_shared() _NOEXCEPT;
303 // Shared and weak pointers in C++ maintain reference counts via atomics in
304 // libc++.dylib, which are TSan-invisible, and this leads to false positives in
305 // destructor code.  This interceptor re-implements the whole function so that
306 // the mo_acq_rel semantics of the atomic decrement are visible.
307 //
308 // Unfortunately, this interceptor cannot simply Acquire/Release some sync
309 // object and call the original function, because it would have a race between
310 // the sync and the destruction of the object.  Calling both under a lock will
311 // not work because the destructor can invoke this interceptor again (and even
312 // in a different thread, so recursive locks don't help).
STDCXX_INTERCEPTOR(void,_ZNSt3__119__shared_weak_count16__release_sharedEv,fake_shared_weak_count * o)313 STDCXX_INTERCEPTOR(void, _ZNSt3__119__shared_weak_count16__release_sharedEv,
314                    fake_shared_weak_count *o) {
315   if (!flags()->shared_ptr_interceptor)
316     return REAL(_ZNSt3__119__shared_weak_count16__release_sharedEv)(o);
317 
318   SCOPED_TSAN_INTERCEPTOR(_ZNSt3__119__shared_weak_count16__release_sharedEv,
319                           o);
320   if (__tsan_atomic64_fetch_add(&o->shared_owners, -1, mo_release) == 0) {
321     Acquire(thr, pc, (uptr)&o->shared_owners);
322     o->on_zero_shared();
323     if (__tsan_atomic64_fetch_add(&o->shared_weak_owners, -1, mo_release) ==
324         0) {
325       Acquire(thr, pc, (uptr)&o->shared_weak_owners);
326       o->on_zero_shared_weak();
327     }
328   }
329 }
330 
331 }  // namespace __tsan
332 
333 #endif  // SANITIZER_MAC
334