diff --git a/compiler-rt/lib/asan/asan_interceptors.cpp b/compiler-rt/lib/asan/asan_interceptors.cpp --- a/compiler-rt/lib/asan/asan_interceptors.cpp +++ b/compiler-rt/lib/asan/asan_interceptors.cpp @@ -196,8 +196,8 @@ return t->ThreadStart(GetTid()); } -INTERCEPTOR(int, pthread_create, void *thread, - void *attr, void *(*start_routine)(void*), void *arg) { +INTERCEPTOR_PTHREAD(int, create, void *thread, void *attr, + void *(*start_routine)(void *), void *arg) { EnsureMainThreadIDIsCorrect(); // Strict init-order checking is thread-hostile. if (flags()->strict_init_order) @@ -231,7 +231,7 @@ return result; } -INTERCEPTOR(int, pthread_join, void *t, void **arg) { +INTERCEPTOR_PTHREAD(int, join, void *t, void **arg) { return real_pthread_join(t, arg); } @@ -592,8 +592,8 @@ void (*child)()); }; -INTERCEPTOR(int, pthread_atfork, void (*prepare)(), void (*parent)(), - void (*child)()) { +INTERCEPTOR_PTHREAD(int, atfork, void (*prepare)(), void (*parent)(), + void (*child)()) { #if CAN_SANITIZE_LEAKS __lsan::ScopedInterceptorDisabler disabler; #endif diff --git a/compiler-rt/lib/hwasan/hwasan_interceptors.cpp b/compiler-rt/lib/hwasan/hwasan_interceptors.cpp --- a/compiler-rt/lib/hwasan/hwasan_interceptors.cpp +++ b/compiler-rt/lib/hwasan/hwasan_interceptors.cpp @@ -215,8 +215,8 @@ return A.callback(A.param); } -INTERCEPTOR(int, pthread_create, void *th, void *attr, void *(*callback)(void*), - void * param) { +INTERCEPTOR_PTHREAD(int, create, void *th, void *attr, + void *(*callback)(void *), void *param) { ScopedTaggingDisabler disabler; ThreadStartArg *A = reinterpret_cast (MmapOrDie( GetPageSizeCached(), "pthread_create")); diff --git a/compiler-rt/lib/interception/interception.h b/compiler-rt/lib/interception/interception.h --- a/compiler-rt/lib/interception/interception.h +++ b/compiler-rt/lib/interception/interception.h @@ -299,6 +299,23 @@ INTERCEPT_FUNCTION_VER_WIN(func, symver) #endif +#if SANITIZER_FREEBSD +// On FreeBSD we also have to intercept the _pthread_* aliases since those are +// used for direct libthr calls from within libc. If we don't intercept both +// pthread_foo and _pthread_foo we see lots of false-positives. +#define INTERCEPTOR_PTHREAD(ret, func, ...) \ + INTERCEPTOR(ret, _pthread_##func, __VA_ARGS__) \ + ALIAS(WRAPPER_NAME(pthread_##func)); \ + INTERCEPTOR(ret, pthread_##func, __VA_ARGS__) +#define INTERCEPT_PTHREAD_FUNCTION(name) \ + INTERCEPT_FUNCTION(pthread_##name); \ + INTERCEPT_FUNCTION(_pthread_##name) +#else +#define INTERCEPTOR_PTHREAD(ret, func, ...) \ + INTERCEPTOR(ret, pthread_##func, __VA_ARGS__) +#define INTERCEPT_PTHREAD_FUNCTION(name) INTERCEPT_FUNCTION(pthread_##name) +#endif + #undef INCLUDED_FROM_INTERCEPTION_LIB #endif // INTERCEPTION_H diff --git a/compiler-rt/lib/lsan/lsan_interceptors.cpp b/compiler-rt/lib/lsan/lsan_interceptors.cpp --- a/compiler-rt/lib/lsan/lsan_interceptors.cpp +++ b/compiler-rt/lib/lsan/lsan_interceptors.cpp @@ -381,8 +381,8 @@ void (*child)()); }; -INTERCEPTOR(int, pthread_atfork, void (*prepare)(), void (*parent)(), - void (*child)()) { +INTERCEPTOR_PTHREAD(int, atfork, void (*prepare)(), void (*parent)(), + void (*child)()) { __lsan::ScopedInterceptorDisabler disabler; // REAL(pthread_atfork) cannot be called due to symbol indirections at least // on NetBSD @@ -432,8 +432,8 @@ return callback(param); } -INTERCEPTOR(int, pthread_create, void *th, void *attr, - void *(*callback)(void *), void *param) { +INTERCEPTOR_PTHREAD(int, create, void *th, void *attr, + void *(*callback)(void *), void *param) { ENSURE_LSAN_INITED; EnsureMainThreadIDIsCorrect(); __sanitizer_pthread_attr_t myattr; @@ -470,7 +470,7 @@ return res; } -INTERCEPTOR(int, pthread_join, void *th, void **ret) { +INTERCEPTOR_PTHREAD(int, join, void *th, void **ret) { ENSURE_LSAN_INITED; int tid = ThreadTid((uptr)th); int res = REAL(pthread_join)(th, ret); @@ -479,7 +479,7 @@ return res; } -INTERCEPTOR(int, pthread_detach, void *th) { +INTERCEPTOR_PTHREAD(int, detach, void *th) { ENSURE_LSAN_INITED; int tid = ThreadTid((uptr)th); int res = REAL(pthread_detach)(th); diff --git a/compiler-rt/lib/memprof/memprof_interceptors.cpp b/compiler-rt/lib/memprof/memprof_interceptors.cpp --- a/compiler-rt/lib/memprof/memprof_interceptors.cpp +++ b/compiler-rt/lib/memprof/memprof_interceptors.cpp @@ -156,8 +156,8 @@ return t->ThreadStart(GetTid(), ¶m->is_registered); } -INTERCEPTOR(int, pthread_create, void *thread, void *attr, - void *(*start_routine)(void *), void *arg) { +INTERCEPTOR_PTHREAD(int, create, void *thread, void *attr, + void *(*start_routine)(void *), void *arg) { EnsureMainThreadIDIsCorrect(); GET_STACK_TRACE_THREAD; int detached = 0; @@ -187,7 +187,7 @@ return result; } -INTERCEPTOR(int, pthread_join, void *t, void **arg) { +INTERCEPTOR_PTHREAD(int, join, void *t, void **arg) { return real_pthread_join(t, arg); } diff --git a/compiler-rt/lib/msan/msan_interceptors.cpp b/compiler-rt/lib/msan/msan_interceptors.cpp --- a/compiler-rt/lib/msan/msan_interceptors.cpp +++ b/compiler-rt/lib/msan/msan_interceptors.cpp @@ -1025,8 +1025,8 @@ return t->ThreadStart(); } -INTERCEPTOR(int, pthread_create, void *th, void *attr, void *(*callback)(void*), - void * param) { +INTERCEPTOR_PTHREAD(int, create, void *th, void *attr, + void *(*callback)(void *), void *param) { ENSURE_MSAN_INITED(); // for GetTlsSize() __sanitizer_pthread_attr_t myattr; if (!attr) { @@ -1048,8 +1048,8 @@ return res; } -INTERCEPTOR(int, pthread_key_create, __sanitizer_pthread_key_t *key, - void (*dtor)(void *value)) { +INTERCEPTOR_PTHREAD(int, key_create, __sanitizer_pthread_key_t *key, + void (*dtor)(void *value)) { if (msan_init_is_running) return REAL(pthread_key_create)(key, dtor); ENSURE_MSAN_INITED(); int res = REAL(pthread_key_create)(key, dtor); @@ -1064,7 +1064,7 @@ ALIAS(WRAPPER_NAME(pthread_key_create)); #endif -INTERCEPTOR(int, pthread_join, void *th, void **retval) { +INTERCEPTOR_PTHREAD(int, join, void *th, void **retval) { ENSURE_MSAN_INITED(); int res = REAL(pthread_join)(th, retval); if (!res && retval) diff --git a/compiler-rt/lib/safestack/safestack.cpp b/compiler-rt/lib/safestack/safestack.cpp --- a/compiler-rt/lib/safestack/safestack.cpp +++ b/compiler-rt/lib/safestack/safestack.cpp @@ -205,9 +205,8 @@ void EnsureInterceptorsInitialized(); /// Intercept thread creation operation to allocate and setup the unsafe stack -INTERCEPTOR(int, pthread_create, pthread_t *thread, - const pthread_attr_t *attr, - void *(*start_routine)(void*), void *arg) { +INTERCEPTOR_PTHREAD(int, create, pthread_t *thread, const pthread_attr_t *attr, + void *(*start_routine)(void *), void *arg) { EnsureInterceptorsInitialized(); size_t size = 0; size_t guard = 0; diff --git a/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc --- a/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc +++ b/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc @@ -2549,7 +2549,7 @@ #endif #if SANITIZER_INTERCEPT_PTHREAD_GETSCHEDPARAM -INTERCEPTOR(int, pthread_getschedparam, uptr thread, int *policy, int *param) { +INTERCEPTOR_PTHREAD(int, getschedparam, uptr thread, int *policy, int *param) { void *ctx; COMMON_INTERCEPTOR_ENTER(ctx, pthread_getschedparam, thread, policy, param); // FIXME: under ASan the call below may write to freed memory and corrupt @@ -2563,7 +2563,7 @@ return res; } #define INIT_PTHREAD_GETSCHEDPARAM \ - COMMON_INTERCEPT_FUNCTION(pthread_getschedparam); + INTERCEPT_PTHREAD_FUNCTION(getschedparam); #else #define INIT_PTHREAD_GETSCHEDPARAM #endif @@ -4158,7 +4158,7 @@ #endif #if SANITIZER_INTERCEPT_PTHREAD_SIGMASK -INTERCEPTOR(int, pthread_sigmask, int how, __sanitizer_sigset_t *set, +INTERCEPTOR_PTHREAD(int, sigmask, int how, __sanitizer_sigset_t *set, __sanitizer_sigset_t *oldset) { void *ctx; COMMON_INTERCEPTOR_ENTER(ctx, pthread_sigmask, how, set, oldset); @@ -4171,7 +4171,7 @@ COMMON_INTERCEPTOR_WRITE_RANGE(ctx, oldset, sizeof(*oldset)); return res; } -#define INIT_PTHREAD_SIGMASK COMMON_INTERCEPT_FUNCTION(pthread_sigmask); +#define INIT_PTHREAD_SIGMASK INTERCEPT_PTHREAD_FUNCTION(sigmask); #else #define INIT_PTHREAD_SIGMASK #endif @@ -4228,7 +4228,7 @@ #endif #if SANITIZER_INTERCEPT_PTHREAD_MUTEX -INTERCEPTOR(int, pthread_mutex_lock, void *m) { +INTERCEPTOR_PTHREAD(int, mutex_lock, void *m) { void *ctx; COMMON_INTERCEPTOR_ENTER(ctx, pthread_mutex_lock, m); COMMON_INTERCEPTOR_MUTEX_PRE_LOCK(ctx, m); @@ -4242,7 +4242,7 @@ return res; } -INTERCEPTOR(int, pthread_mutex_unlock, void *m) { +INTERCEPTOR_PTHREAD(int, mutex_unlock, void *m) { void *ctx; COMMON_INTERCEPTOR_ENTER(ctx, pthread_mutex_unlock, m); COMMON_INTERCEPTOR_MUTEX_UNLOCK(ctx, m); @@ -4252,9 +4252,9 @@ return res; } -#define INIT_PTHREAD_MUTEX_LOCK COMMON_INTERCEPT_FUNCTION(pthread_mutex_lock) +#define INIT_PTHREAD_MUTEX_LOCK INTERCEPT_PTHREAD_FUNCTION(mutex_lock) #define INIT_PTHREAD_MUTEX_UNLOCK \ - COMMON_INTERCEPT_FUNCTION(pthread_mutex_unlock) + INTERCEPT_PTHREAD_FUNCTION(mutex_unlock) #else #define INIT_PTHREAD_MUTEX_LOCK #define INIT_PTHREAD_MUTEX_UNLOCK @@ -4649,24 +4649,25 @@ SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GET || \ SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GET || \ SANITIZER_INTERCEPT_PTHREAD_BARRIERATTR_GET -#define INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(fn, sz) \ - INTERCEPTOR(int, fn, void *attr, void *r) { \ - void *ctx; \ - COMMON_INTERCEPTOR_ENTER(ctx, fn, attr, r); \ - int res = REAL(fn)(attr, r); \ - if (!res && r) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, r, sz); \ - return res; \ +#define INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(fn, sz) \ + INTERCEPTOR_PTHREAD(int, fn, void *attr, void *r) { \ + void *ctx; \ + COMMON_INTERCEPTOR_ENTER(ctx, pthread_##fn, attr, r); \ + int res = REAL(pthread_##fn)(attr, r); \ + if (!res && r) \ + COMMON_INTERCEPTOR_WRITE_RANGE(ctx, r, sz); \ + return res; \ } #define INTERCEPTOR_PTHREAD_ATTR_GET(what, sz) \ - INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_attr_get##what, sz) + INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(attr_get##what, sz) #define INTERCEPTOR_PTHREAD_MUTEXATTR_GET(what, sz) \ - INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_mutexattr_get##what, sz) + INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(mutexattr_get##what, sz) #define INTERCEPTOR_PTHREAD_RWLOCKATTR_GET(what, sz) \ - INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_rwlockattr_get##what, sz) + INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(rwlockattr_get##what, sz) #define INTERCEPTOR_PTHREAD_CONDATTR_GET(what, sz) \ - INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_condattr_get##what, sz) + INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(condattr_get##what, sz) #define INTERCEPTOR_PTHREAD_BARRIERATTR_GET(what, sz) \ - INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(pthread_barrierattr_get##what, sz) + INTERCEPTOR_PTHREAD_OBJECT_ATTR_GET(barrierattr_get##what, sz) #endif #if SANITIZER_INTERCEPT_PTHREAD_ATTR_GET @@ -4674,7 +4675,7 @@ INTERCEPTOR_PTHREAD_ATTR_GET(guardsize, sizeof(SIZE_T)) INTERCEPTOR_PTHREAD_ATTR_GET(scope, sizeof(int)) INTERCEPTOR_PTHREAD_ATTR_GET(stacksize, sizeof(SIZE_T)) -INTERCEPTOR(int, pthread_attr_getstack, void *attr, void **addr, SIZE_T *size) { +INTERCEPTOR_PTHREAD(int, attr_getstack, void *attr, void **addr, SIZE_T *size) { void *ctx; COMMON_INTERCEPTOR_ENTER(ctx, pthread_attr_getstack, attr, addr, size); // FIXME: under ASan the call below may write to freed memory and corrupt @@ -4700,11 +4701,11 @@ } // namespace __sanitizer #define INIT_PTHREAD_ATTR_GET \ - COMMON_INTERCEPT_FUNCTION(pthread_attr_getdetachstate); \ - COMMON_INTERCEPT_FUNCTION(pthread_attr_getguardsize); \ - COMMON_INTERCEPT_FUNCTION(pthread_attr_getscope); \ - COMMON_INTERCEPT_FUNCTION(pthread_attr_getstacksize); \ - COMMON_INTERCEPT_FUNCTION(pthread_attr_getstack); + INTERCEPT_PTHREAD_FUNCTION(attr_getdetachstate); \ + INTERCEPT_PTHREAD_FUNCTION(attr_getguardsize); \ + INTERCEPT_PTHREAD_FUNCTION(attr_getscope); \ + INTERCEPT_PTHREAD_FUNCTION(attr_getstacksize); \ + INTERCEPT_PTHREAD_FUNCTION(attr_getstack); #else #define INIT_PTHREAD_ATTR_GET #endif @@ -4714,8 +4715,8 @@ INTERCEPTOR_PTHREAD_ATTR_GET(schedpolicy, sizeof(int)) #define INIT_PTHREAD_ATTR_GET_SCHED \ - COMMON_INTERCEPT_FUNCTION(pthread_attr_getschedparam); \ - COMMON_INTERCEPT_FUNCTION(pthread_attr_getschedpolicy); + INTERCEPT_PTHREAD_FUNCTION(attr_getschedparam); \ + INTERCEPT_PTHREAD_FUNCTION(attr_getschedpolicy); #else #define INIT_PTHREAD_ATTR_GET_SCHED #endif @@ -4724,13 +4725,13 @@ INTERCEPTOR_PTHREAD_ATTR_GET(inheritsched, sizeof(int)) #define INIT_PTHREAD_ATTR_GETINHERITSCHED \ - COMMON_INTERCEPT_FUNCTION(pthread_attr_getinheritsched); + INTERCEPT_PTHREAD_FUNCTION(attr_getinheritsched); #else #define INIT_PTHREAD_ATTR_GETINHERITSCHED #endif #if SANITIZER_INTERCEPT_PTHREAD_ATTR_GETAFFINITY_NP -INTERCEPTOR(int, pthread_attr_getaffinity_np, void *attr, SIZE_T cpusetsize, +INTERCEPTOR_PTHREAD(int, attr_getaffinity_np, void *attr, SIZE_T cpusetsize, void *cpuset) { void *ctx; COMMON_INTERCEPTOR_ENTER(ctx, pthread_attr_getaffinity_np, attr, cpusetsize, @@ -4745,7 +4746,7 @@ } #define INIT_PTHREAD_ATTR_GETAFFINITY_NP \ - COMMON_INTERCEPT_FUNCTION(pthread_attr_getaffinity_np); + INTERCEPT_PTHREAD_FUNCTION(attr_getaffinity_np); #else #define INIT_PTHREAD_ATTR_GETAFFINITY_NP #endif @@ -4753,7 +4754,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPSHARED INTERCEPTOR_PTHREAD_MUTEXATTR_GET(pshared, sizeof(int)) #define INIT_PTHREAD_MUTEXATTR_GETPSHARED \ - COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getpshared); + INTERCEPT_PTHREAD_FUNCTION(mutexattr_getpshared); #else #define INIT_PTHREAD_MUTEXATTR_GETPSHARED #endif @@ -4761,7 +4762,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETTYPE INTERCEPTOR_PTHREAD_MUTEXATTR_GET(type, sizeof(int)) #define INIT_PTHREAD_MUTEXATTR_GETTYPE \ - COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_gettype); + INTERCEPT_PTHREAD_FUNCTION(mutexattr_gettype); #else #define INIT_PTHREAD_MUTEXATTR_GETTYPE #endif @@ -4769,7 +4770,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPROTOCOL INTERCEPTOR_PTHREAD_MUTEXATTR_GET(protocol, sizeof(int)) #define INIT_PTHREAD_MUTEXATTR_GETPROTOCOL \ - COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getprotocol); + INTERCEPT_PTHREAD_FUNCTION(mutexattr_getprotocol); #else #define INIT_PTHREAD_MUTEXATTR_GETPROTOCOL #endif @@ -4777,7 +4778,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETPRIOCEILING INTERCEPTOR_PTHREAD_MUTEXATTR_GET(prioceiling, sizeof(int)) #define INIT_PTHREAD_MUTEXATTR_GETPRIOCEILING \ - COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getprioceiling); + INTERCEPT_PTHREAD_FUNCTION(mutexattr_getprioceiling); #else #define INIT_PTHREAD_MUTEXATTR_GETPRIOCEILING #endif @@ -4785,7 +4786,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETROBUST INTERCEPTOR_PTHREAD_MUTEXATTR_GET(robust, sizeof(int)) #define INIT_PTHREAD_MUTEXATTR_GETROBUST \ - COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getrobust); + INTERCEPT_PTHREAD_FUNCTION(mutexattr_getrobust); #else #define INIT_PTHREAD_MUTEXATTR_GETROBUST #endif @@ -4793,7 +4794,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_MUTEXATTR_GETROBUST_NP INTERCEPTOR_PTHREAD_MUTEXATTR_GET(robust_np, sizeof(int)) #define INIT_PTHREAD_MUTEXATTR_GETROBUST_NP \ - COMMON_INTERCEPT_FUNCTION(pthread_mutexattr_getrobust_np); + INTERCEPT_PTHREAD_FUNCTION(mutexattr_getrobust_np); #else #define INIT_PTHREAD_MUTEXATTR_GETROBUST_NP #endif @@ -4801,7 +4802,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETPSHARED INTERCEPTOR_PTHREAD_RWLOCKATTR_GET(pshared, sizeof(int)) #define INIT_PTHREAD_RWLOCKATTR_GETPSHARED \ - COMMON_INTERCEPT_FUNCTION(pthread_rwlockattr_getpshared); + INTERCEPT_PTHREAD_FUNCTION(rwlockattr_getpshared); #else #define INIT_PTHREAD_RWLOCKATTR_GETPSHARED #endif @@ -4809,7 +4810,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_RWLOCKATTR_GETKIND_NP INTERCEPTOR_PTHREAD_RWLOCKATTR_GET(kind_np, sizeof(int)) #define INIT_PTHREAD_RWLOCKATTR_GETKIND_NP \ - COMMON_INTERCEPT_FUNCTION(pthread_rwlockattr_getkind_np); + INTERCEPT_PTHREAD_FUNCTION(rwlockattr_getkind_np); #else #define INIT_PTHREAD_RWLOCKATTR_GETKIND_NP #endif @@ -4817,7 +4818,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GETPSHARED INTERCEPTOR_PTHREAD_CONDATTR_GET(pshared, sizeof(int)) #define INIT_PTHREAD_CONDATTR_GETPSHARED \ - COMMON_INTERCEPT_FUNCTION(pthread_condattr_getpshared); + INTERCEPT_PTHREAD_FUNCTION(condattr_getpshared); #else #define INIT_PTHREAD_CONDATTR_GETPSHARED #endif @@ -4825,7 +4826,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_CONDATTR_GETCLOCK INTERCEPTOR_PTHREAD_CONDATTR_GET(clock, sizeof(int)) #define INIT_PTHREAD_CONDATTR_GETCLOCK \ - COMMON_INTERCEPT_FUNCTION(pthread_condattr_getclock); + INTERCEPT_PTHREAD_FUNCTION(condattr_getclock); #else #define INIT_PTHREAD_CONDATTR_GETCLOCK #endif @@ -4833,7 +4834,7 @@ #if SANITIZER_INTERCEPT_PTHREAD_BARRIERATTR_GETPSHARED INTERCEPTOR_PTHREAD_BARRIERATTR_GET(pshared, sizeof(int)) // !mac !android #define INIT_PTHREAD_BARRIERATTR_GETPSHARED \ - COMMON_INTERCEPT_FUNCTION(pthread_barrierattr_getpshared); + INTERCEPT_PTHREAD_FUNCTION(barrierattr_getpshared); #else #define INIT_PTHREAD_BARRIERATTR_GETPSHARED #endif @@ -4946,17 +4947,26 @@ #define INIT_TEMPNAM #endif -#if SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP && !SANITIZER_NETBSD -INTERCEPTOR(int, pthread_setname_np, uptr thread, const char *name) { +#if SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP && SANITIZER_FREEBSD +INTERCEPTOR_PTHREAD(int, set_name_np, uptr thread, const char *name) { + void *ctx; + COMMON_INTERCEPTOR_ENTER(ctx, pthread_set_name_np, thread, name); + COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0); + COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name); + return REAL(pthread_set_name_np)(thread, name); +} +#define INIT_PTHREAD_SETNAME_NP INTERCEPT_PTHREAD_FUNCTION(set_name_np); +#elif SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP && !SANITIZER_NETBSD +INTERCEPTOR_PTHREAD(int, setname_np, uptr thread, const char *name) { void *ctx; COMMON_INTERCEPTOR_ENTER(ctx, pthread_setname_np, thread, name); COMMON_INTERCEPTOR_READ_STRING(ctx, name, 0); COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name); return REAL(pthread_setname_np)(thread, name); } -#define INIT_PTHREAD_SETNAME_NP COMMON_INTERCEPT_FUNCTION(pthread_setname_np); +#define INIT_PTHREAD_SETNAME_NP INTERCEPT_PTHREAD_FUNCTION(setname_np); #elif SANITIZER_INTERCEPT_PTHREAD_SETNAME_NP && SANITIZER_NETBSD -INTERCEPTOR(int, pthread_setname_np, uptr thread, const char *name, void *arg) { +INTERCEPTOR_PTHREAD(int, setname_np, uptr thread, const char *name, void *arg) { void *ctx; char newname[32]; // PTHREAD_MAX_NAMELEN_NP=32 COMMON_INTERCEPTOR_ENTER(ctx, pthread_setname_np, thread, name, arg); @@ -4965,13 +4975,13 @@ COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, newname); return REAL(pthread_setname_np)(thread, name, arg); } -#define INIT_PTHREAD_SETNAME_NP COMMON_INTERCEPT_FUNCTION(pthread_setname_np); +#define INIT_PTHREAD_SETNAME_NP INTERCEPT_PTHREAD_FUNCTION(setname_np); #else #define INIT_PTHREAD_SETNAME_NP #endif #if SANITIZER_INTERCEPT_PTHREAD_GETNAME_NP -INTERCEPTOR(int, pthread_getname_np, uptr thread, char *name, SIZE_T len) { +INTERCEPTOR_PTHREAD(int, getname_np, uptr thread, char *name, SIZE_T len) { void *ctx; COMMON_INTERCEPTOR_ENTER(ctx, pthread_getname_np, thread, name, len); int res = REAL(pthread_getname_np)(thread, name, len); @@ -4979,7 +4989,7 @@ COMMON_INTERCEPTOR_WRITE_RANGE(ctx, name, internal_strnlen(name, len) + 1); return res; } -#define INIT_PTHREAD_GETNAME_NP COMMON_INTERCEPT_FUNCTION(pthread_getname_np); +#define INIT_PTHREAD_GETNAME_NP INTERCEPT_PTHREAD_FUNCTION(getname_np); #else #define INIT_PTHREAD_GETNAME_NP #endif @@ -6493,7 +6503,7 @@ #endif // SANITIZER_INTERCEPT_SEM #if SANITIZER_INTERCEPT_PTHREAD_SETCANCEL -INTERCEPTOR(int, pthread_setcancelstate, int state, int *oldstate) { +INTERCEPTOR_PTHREAD(int, setcancelstate, int state, int *oldstate) { void *ctx; COMMON_INTERCEPTOR_ENTER(ctx, pthread_setcancelstate, state, oldstate); int res = REAL(pthread_setcancelstate)(state, oldstate); @@ -6502,7 +6512,7 @@ return res; } -INTERCEPTOR(int, pthread_setcanceltype, int type, int *oldtype) { +INTERCEPTOR_PTHREAD(int, setcanceltype, int type, int *oldtype) { void *ctx; COMMON_INTERCEPTOR_ENTER(ctx, pthread_setcanceltype, type, oldtype); int res = REAL(pthread_setcanceltype)(type, oldtype); @@ -6511,8 +6521,8 @@ return res; } #define INIT_PTHREAD_SETCANCEL \ - COMMON_INTERCEPT_FUNCTION(pthread_setcancelstate); \ - COMMON_INTERCEPT_FUNCTION(pthread_setcanceltype); + INTERCEPT_PTHREAD_FUNCTION(setcancelstate); \ + INTERCEPT_PTHREAD_FUNCTION(setcanceltype); #else #define INIT_PTHREAD_SETCANCEL #endif diff --git a/compiler-rt/lib/tsan/dd/dd_interceptors.cpp b/compiler-rt/lib/tsan/dd/dd_interceptors.cpp --- a/compiler-rt/lib/tsan/dd/dd_interceptors.cpp +++ b/compiler-rt/lib/tsan/dd/dd_interceptors.cpp @@ -40,13 +40,13 @@ return true; } -INTERCEPTOR(int, pthread_mutex_destroy, pthread_mutex_t *m) { +INTERCEPTOR_PTHREAD(int, mutex_destroy, pthread_mutex_t *m) { InitThread(); MutexDestroy(thr, (uptr)m); return REAL(pthread_mutex_destroy)(m); } -INTERCEPTOR(int, pthread_mutex_lock, pthread_mutex_t *m) { +INTERCEPTOR_PTHREAD(int, mutex_lock, pthread_mutex_t *m) { InitThread(); MutexBeforeLock(thr, (uptr)m, true); int res = REAL(pthread_mutex_lock)(m); @@ -54,7 +54,7 @@ return res; } -INTERCEPTOR(int, pthread_mutex_trylock, pthread_mutex_t *m) { +INTERCEPTOR_PTHREAD(int, mutex_trylock, pthread_mutex_t *m) { InitThread(); int res = REAL(pthread_mutex_trylock)(m); if (res == 0) @@ -62,20 +62,20 @@ return res; } -INTERCEPTOR(int, pthread_mutex_unlock, pthread_mutex_t *m) { +INTERCEPTOR_PTHREAD(int, mutex_unlock, pthread_mutex_t *m) { InitThread(); MutexBeforeUnlock(thr, (uptr)m, true); return REAL(pthread_mutex_unlock)(m); } -INTERCEPTOR(int, pthread_spin_destroy, pthread_spinlock_t *m) { +INTERCEPTOR_PTHREAD(int, spin_destroy, pthread_spinlock_t *m) { InitThread(); int res = REAL(pthread_spin_destroy)(m); MutexDestroy(thr, (uptr)m); return res; } -INTERCEPTOR(int, pthread_spin_lock, pthread_spinlock_t *m) { +INTERCEPTOR_PTHREAD(int, spin_lock, pthread_spinlock_t *m) { InitThread(); MutexBeforeLock(thr, (uptr)m, true); int res = REAL(pthread_spin_lock)(m); @@ -83,7 +83,7 @@ return res; } -INTERCEPTOR(int, pthread_spin_trylock, pthread_spinlock_t *m) { +INTERCEPTOR_PTHREAD(int, spin_trylock, pthread_spinlock_t *m) { InitThread(); int res = REAL(pthread_spin_trylock)(m); if (res == 0) @@ -91,19 +91,19 @@ return res; } -INTERCEPTOR(int, pthread_spin_unlock, pthread_spinlock_t *m) { +INTERCEPTOR_PTHREAD(int, spin_unlock, pthread_spinlock_t *m) { InitThread(); MutexBeforeUnlock(thr, (uptr)m, true); return REAL(pthread_spin_unlock)(m); } -INTERCEPTOR(int, pthread_rwlock_destroy, pthread_rwlock_t *m) { +INTERCEPTOR_PTHREAD(int, rwlock_destroy, pthread_rwlock_t *m) { InitThread(); MutexDestroy(thr, (uptr)m); return REAL(pthread_rwlock_destroy)(m); } -INTERCEPTOR(int, pthread_rwlock_rdlock, pthread_rwlock_t *m) { +INTERCEPTOR_PTHREAD(int, rwlock_rdlock, pthread_rwlock_t *m) { InitThread(); MutexBeforeLock(thr, (uptr)m, false); int res = REAL(pthread_rwlock_rdlock)(m); @@ -111,7 +111,7 @@ return res; } -INTERCEPTOR(int, pthread_rwlock_tryrdlock, pthread_rwlock_t *m) { +INTERCEPTOR_PTHREAD(int, rwlock_tryrdlock, pthread_rwlock_t *m) { InitThread(); int res = REAL(pthread_rwlock_tryrdlock)(m); if (res == 0) @@ -119,8 +119,8 @@ return res; } -INTERCEPTOR(int, pthread_rwlock_timedrdlock, pthread_rwlock_t *m, - const timespec *abstime) { +INTERCEPTOR_PTHREAD(int, rwlock_timedrdlock, pthread_rwlock_t *m, + const timespec *abstime) { InitThread(); int res = REAL(pthread_rwlock_timedrdlock)(m, abstime); if (res == 0) @@ -128,7 +128,7 @@ return res; } -INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *m) { +INTERCEPTOR_PTHREAD(int, rwlock_wrlock, pthread_rwlock_t *m) { InitThread(); MutexBeforeLock(thr, (uptr)m, true); int res = REAL(pthread_rwlock_wrlock)(m); @@ -136,7 +136,7 @@ return res; } -INTERCEPTOR(int, pthread_rwlock_trywrlock, pthread_rwlock_t *m) { +INTERCEPTOR_PTHREAD(int, rwlock_trywrlock, pthread_rwlock_t *m) { InitThread(); int res = REAL(pthread_rwlock_trywrlock)(m); if (res == 0) @@ -144,8 +144,8 @@ return res; } -INTERCEPTOR(int, pthread_rwlock_timedwrlock, pthread_rwlock_t *m, - const timespec *abstime) { +INTERCEPTOR_PTHREAD(int, rwlock_timedwrlock, pthread_rwlock_t *m, + const timespec *abstime) { InitThread(); int res = REAL(pthread_rwlock_timedwrlock)(m, abstime); if (res == 0) @@ -153,7 +153,7 @@ return res; } -INTERCEPTOR(int, pthread_rwlock_unlock, pthread_rwlock_t *m) { +INTERCEPTOR_PTHREAD(int, rwlock_unlock, pthread_rwlock_t *m) { InitThread(); MutexBeforeUnlock(thr, (uptr)m, true); // note: not necessary write unlock return REAL(pthread_rwlock_unlock)(m); @@ -173,14 +173,14 @@ return (pthread_cond_t*)cond; } -INTERCEPTOR(int, pthread_cond_init, pthread_cond_t *c, - const pthread_condattr_t *a) { +INTERCEPTOR_PTHREAD(int, cond_init, pthread_cond_t *c, + const pthread_condattr_t *a) { InitThread(); pthread_cond_t *cond = init_cond(c, true); return REAL(pthread_cond_init)(cond, a); } -INTERCEPTOR(int, pthread_cond_wait, pthread_cond_t *c, pthread_mutex_t *m) { +INTERCEPTOR_PTHREAD(int, cond_wait, pthread_cond_t *c, pthread_mutex_t *m) { InitThread(); pthread_cond_t *cond = init_cond(c); MutexBeforeUnlock(thr, (uptr)m, true); @@ -190,8 +190,8 @@ return res; } -INTERCEPTOR(int, pthread_cond_timedwait, pthread_cond_t *c, pthread_mutex_t *m, - const timespec *abstime) { +INTERCEPTOR_PTHREAD(int, cond_timedwait, pthread_cond_t *c, pthread_mutex_t *m, + const timespec *abstime) { InitThread(); pthread_cond_t *cond = init_cond(c); MutexBeforeUnlock(thr, (uptr)m, true); @@ -201,19 +201,19 @@ return res; } -INTERCEPTOR(int, pthread_cond_signal, pthread_cond_t *c) { +INTERCEPTOR_PTHREAD(int, cond_signal, pthread_cond_t *c) { InitThread(); pthread_cond_t *cond = init_cond(c); return REAL(pthread_cond_signal)(cond); } -INTERCEPTOR(int, pthread_cond_broadcast, pthread_cond_t *c) { +INTERCEPTOR_PTHREAD(int, cond_broadcast, pthread_cond_t *c) { InitThread(); pthread_cond_t *cond = init_cond(c); return REAL(pthread_cond_broadcast)(cond); } -INTERCEPTOR(int, pthread_cond_destroy, pthread_cond_t *c) { +INTERCEPTOR_PTHREAD(int, cond_destroy, pthread_cond_t *c) { InitThread(); pthread_cond_t *cond = init_cond(c); int res = REAL(pthread_cond_destroy)(cond); diff --git a/compiler-rt/lib/tsan/rtl/tsan_interceptors.h b/compiler-rt/lib/tsan/rtl/tsan_interceptors.h --- a/compiler-rt/lib/tsan/rtl/tsan_interceptors.h +++ b/compiler-rt/lib/tsan/rtl/tsan_interceptors.h @@ -56,6 +56,8 @@ si.EnableIgnores(); #define TSAN_INTERCEPTOR(ret, func, ...) INTERCEPTOR(ret, func, __VA_ARGS__) +#define TSAN_INTERCEPTOR_PTHREAD(ret, func, ...) \ + INTERCEPTOR_PTHREAD(ret, func, __VA_ARGS__) #if SANITIZER_NETBSD # define TSAN_INTERCEPTOR_NETBSD_ALIAS(ret, func, ...) \ diff --git a/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp b/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp --- a/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp +++ b/compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp @@ -291,6 +291,7 @@ } #define TSAN_INTERCEPT(func) INTERCEPT_FUNCTION(func) +#define TSAN_INTERCEPT_PTHREAD(func) INTERCEPT_PTHREAD_FUNCTION(func) #if SANITIZER_FREEBSD # define TSAN_INTERCEPT_VER(func, ver) INTERCEPT_FUNCTION(func) # define TSAN_MAYBE_INTERCEPT_NETBSD_ALIAS(func) @@ -960,8 +961,8 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_create, - void *th, void *attr, void *(*callback)(void*), void * param) { +TSAN_INTERCEPTOR_PTHREAD(int, create, void *th, void *attr, + void *(*callback)(void *), void *param) { SCOPED_INTERCEPTOR_RAW(pthread_create, th, attr, callback, param); MaybeSpawnBackgroundThread(); @@ -1017,7 +1018,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_join, void *th, void **ret) { +TSAN_INTERCEPTOR_PTHREAD(int, join, void *th, void **ret) { SCOPED_INTERCEPTOR_RAW(pthread_join, th, ret); int tid = ThreadConsumeTid(thr, pc, (uptr)th); ThreadIgnoreBegin(thr, pc); @@ -1031,7 +1032,7 @@ DEFINE_REAL_PTHREAD_FUNCTIONS -TSAN_INTERCEPTOR(int, pthread_detach, void *th) { +TSAN_INTERCEPTOR_PTHREAD(int, detach, void *th) { SCOPED_INTERCEPTOR_RAW(pthread_detach, th); int tid = ThreadConsumeTid(thr, pc, (uptr)th); int res = REAL(pthread_detach)(th); @@ -1041,7 +1042,7 @@ return res; } -TSAN_INTERCEPTOR(void, pthread_exit, void *retval) { +TSAN_INTERCEPTOR_PTHREAD(void, exit, void *retval) { { SCOPED_INTERCEPTOR_RAW(pthread_exit, retval); #if !SANITIZER_MAC && !SANITIZER_ANDROID @@ -1052,7 +1053,7 @@ } #if SANITIZER_LINUX -TSAN_INTERCEPTOR(int, pthread_tryjoin_np, void *th, void **ret) { +TSAN_INTERCEPTOR_PTHREAD(int, tryjoin_np, void *th, void **ret) { SCOPED_INTERCEPTOR_RAW(pthread_tryjoin_np, th, ret); int tid = ThreadConsumeTid(thr, pc, (uptr)th); ThreadIgnoreBegin(thr, pc); @@ -1065,8 +1066,8 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_timedjoin_np, void *th, void **ret, - const struct timespec *abstime) { +TSAN_INTERCEPTOR_PTHREAD(int, timedjoin_np, void *th, void **ret, + const struct timespec *abstime) { SCOPED_INTERCEPTOR_RAW(pthread_timedjoin_np, th, ret, abstime); int tid = ThreadConsumeTid(thr, pc, (uptr)th); ThreadIgnoreBegin(thr, pc); @@ -1150,7 +1151,7 @@ } } // namespace -INTERCEPTOR(int, pthread_cond_init, void *c, void *a) { +TSAN_INTERCEPTOR_PTHREAD(int, cond_init, void *c, void *a) { void *cond = init_cond(c, true); SCOPED_TSAN_INTERCEPTOR(pthread_cond_init, cond, a); MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), true); @@ -1181,7 +1182,7 @@ return res; } -INTERCEPTOR(int, pthread_cond_wait, void *c, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, cond_wait, void *c, void *m) { void *cond = init_cond(c); SCOPED_TSAN_INTERCEPTOR(pthread_cond_wait, cond, m); return cond_wait( @@ -1189,7 +1190,7 @@ m); } -INTERCEPTOR(int, pthread_cond_timedwait, void *c, void *m, void *abstime) { +TSAN_INTERCEPTOR_PTHREAD(int, cond_timedwait, void *c, void *m, void *abstime) { void *cond = init_cond(c); SCOPED_TSAN_INTERCEPTOR(pthread_cond_timedwait, cond, m, abstime); return cond_wait( @@ -1199,8 +1200,8 @@ } #if SANITIZER_LINUX -INTERCEPTOR(int, pthread_cond_clockwait, void *c, void *m, - __sanitizer_clockid_t clock, void *abstime) { +TSAN_INTERCEPTOR_PTHREAD(int, cond_clockwait, void *c, void *m, + __sanitizer_clockid_t clock, void *abstime) { void *cond = init_cond(c); SCOPED_TSAN_INTERCEPTOR(pthread_cond_clockwait, cond, m, clock, abstime); return cond_wait( @@ -1208,14 +1209,14 @@ [=]() { return REAL(pthread_cond_clockwait)(cond, m, clock, abstime); }, cond, m); } -#define TSAN_MAYBE_PTHREAD_COND_CLOCKWAIT TSAN_INTERCEPT(pthread_cond_clockwait) +#define TSAN_MAYBE_PTHREAD_COND_CLOCKWAIT TSAN_INTERCEPT_PTHREAD(cond_clockwait) #else #define TSAN_MAYBE_PTHREAD_COND_CLOCKWAIT #endif #if SANITIZER_MAC -INTERCEPTOR(int, pthread_cond_timedwait_relative_np, void *c, void *m, - void *reltime) { +TSAN_INTERCEPTOR_PTHREAD(int, cond_timedwait_relative_np, void *c, void *m, + void *reltime) { void *cond = init_cond(c); SCOPED_TSAN_INTERCEPTOR(pthread_cond_timedwait_relative_np, cond, m, reltime); return cond_wait( @@ -1227,21 +1228,21 @@ } #endif -INTERCEPTOR(int, pthread_cond_signal, void *c) { +TSAN_INTERCEPTOR_PTHREAD(int, cond_signal, void *c) { void *cond = init_cond(c); SCOPED_TSAN_INTERCEPTOR(pthread_cond_signal, cond); MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false); return REAL(pthread_cond_signal)(cond); } -INTERCEPTOR(int, pthread_cond_broadcast, void *c) { +TSAN_INTERCEPTOR_PTHREAD(int, cond_broadcast, void *c) { void *cond = init_cond(c); SCOPED_TSAN_INTERCEPTOR(pthread_cond_broadcast, cond); MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), false); return REAL(pthread_cond_broadcast)(cond); } -INTERCEPTOR(int, pthread_cond_destroy, void *c) { +TSAN_INTERCEPTOR_PTHREAD(int, cond_destroy, void *c) { void *cond = init_cond(c); SCOPED_TSAN_INTERCEPTOR(pthread_cond_destroy, cond); MemoryAccessRange(thr, pc, (uptr)c, sizeof(uptr), true); @@ -1254,7 +1255,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_mutex_init, void *m, void *a) { +TSAN_INTERCEPTOR_PTHREAD(int, mutex_init, void *m, void *a) { SCOPED_TSAN_INTERCEPTOR(pthread_mutex_init, m, a); int res = REAL(pthread_mutex_init)(m, a); if (res == 0) { @@ -1271,7 +1272,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_mutex_destroy, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, mutex_destroy, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_mutex_destroy, m); int res = REAL(pthread_mutex_destroy)(m); if (res == 0 || res == errno_EBUSY) { @@ -1280,7 +1281,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_mutex_trylock, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, mutex_trylock, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_mutex_trylock, m); int res = REAL(pthread_mutex_trylock)(m); if (res == errno_EOWNERDEAD) @@ -1291,7 +1292,7 @@ } #if !SANITIZER_MAC -TSAN_INTERCEPTOR(int, pthread_mutex_timedlock, void *m, void *abstime) { +TSAN_INTERCEPTOR_PTHREAD(int, mutex_timedlock, void *m, void *abstime) { SCOPED_TSAN_INTERCEPTOR(pthread_mutex_timedlock, m, abstime); int res = REAL(pthread_mutex_timedlock)(m, abstime); if (res == 0) { @@ -1302,7 +1303,7 @@ #endif #if !SANITIZER_MAC -TSAN_INTERCEPTOR(int, pthread_spin_init, void *m, int pshared) { +TSAN_INTERCEPTOR_PTHREAD(int, spin_init, void *m, int pshared) { SCOPED_TSAN_INTERCEPTOR(pthread_spin_init, m, pshared); int res = REAL(pthread_spin_init)(m, pshared); if (res == 0) { @@ -1311,7 +1312,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_spin_destroy, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, spin_destroy, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_spin_destroy, m); int res = REAL(pthread_spin_destroy)(m); if (res == 0) { @@ -1320,7 +1321,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_spin_lock, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, spin_lock, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_spin_lock, m); MutexPreLock(thr, pc, (uptr)m); int res = REAL(pthread_spin_lock)(m); @@ -1330,7 +1331,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_spin_trylock, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, spin_trylock, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_spin_trylock, m); int res = REAL(pthread_spin_trylock)(m); if (res == 0) { @@ -1339,7 +1340,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_spin_unlock, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, spin_unlock, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_spin_unlock, m); MutexUnlock(thr, pc, (uptr)m); int res = REAL(pthread_spin_unlock)(m); @@ -1347,7 +1348,7 @@ } #endif -TSAN_INTERCEPTOR(int, pthread_rwlock_init, void *m, void *a) { +TSAN_INTERCEPTOR_PTHREAD(int, rwlock_init, void *m, void *a) { SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_init, m, a); int res = REAL(pthread_rwlock_init)(m, a); if (res == 0) { @@ -1356,7 +1357,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_rwlock_destroy, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, rwlock_destroy, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_destroy, m); int res = REAL(pthread_rwlock_destroy)(m); if (res == 0) { @@ -1365,7 +1366,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_rwlock_rdlock, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, rwlock_rdlock, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_rdlock, m); MutexPreReadLock(thr, pc, (uptr)m); int res = REAL(pthread_rwlock_rdlock)(m); @@ -1375,7 +1376,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_rwlock_tryrdlock, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, rwlock_tryrdlock, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_tryrdlock, m); int res = REAL(pthread_rwlock_tryrdlock)(m); if (res == 0) { @@ -1385,7 +1386,7 @@ } #if !SANITIZER_MAC -TSAN_INTERCEPTOR(int, pthread_rwlock_timedrdlock, void *m, void *abstime) { +TSAN_INTERCEPTOR_PTHREAD(int, rwlock_timedrdlock, void *m, void *abstime) { SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_timedrdlock, m, abstime); int res = REAL(pthread_rwlock_timedrdlock)(m, abstime); if (res == 0) { @@ -1395,7 +1396,7 @@ } #endif -TSAN_INTERCEPTOR(int, pthread_rwlock_wrlock, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, rwlock_wrlock, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_wrlock, m); MutexPreLock(thr, pc, (uptr)m); int res = REAL(pthread_rwlock_wrlock)(m); @@ -1405,7 +1406,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_rwlock_trywrlock, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, rwlock_trywrlock, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_trywrlock, m); int res = REAL(pthread_rwlock_trywrlock)(m); if (res == 0) { @@ -1415,7 +1416,7 @@ } #if !SANITIZER_MAC -TSAN_INTERCEPTOR(int, pthread_rwlock_timedwrlock, void *m, void *abstime) { +TSAN_INTERCEPTOR_PTHREAD(int, rwlock_timedwrlock, void *m, void *abstime) { SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_timedwrlock, m, abstime); int res = REAL(pthread_rwlock_timedwrlock)(m, abstime); if (res == 0) { @@ -1425,7 +1426,7 @@ } #endif -TSAN_INTERCEPTOR(int, pthread_rwlock_unlock, void *m) { +TSAN_INTERCEPTOR_PTHREAD(int, rwlock_unlock, void *m) { SCOPED_TSAN_INTERCEPTOR(pthread_rwlock_unlock, m); MutexReadOrWriteUnlock(thr, pc, (uptr)m); int res = REAL(pthread_rwlock_unlock)(m); @@ -1433,21 +1434,21 @@ } #if !SANITIZER_MAC -TSAN_INTERCEPTOR(int, pthread_barrier_init, void *b, void *a, unsigned count) { +TSAN_INTERCEPTOR_PTHREAD(int, barrier_init, void *b, void *a, unsigned count) { SCOPED_TSAN_INTERCEPTOR(pthread_barrier_init, b, a, count); MemoryWrite(thr, pc, (uptr)b, kSizeLog1); int res = REAL(pthread_barrier_init)(b, a, count); return res; } -TSAN_INTERCEPTOR(int, pthread_barrier_destroy, void *b) { +TSAN_INTERCEPTOR_PTHREAD(int, barrier_destroy, void *b) { SCOPED_TSAN_INTERCEPTOR(pthread_barrier_destroy, b); MemoryWrite(thr, pc, (uptr)b, kSizeLog1); int res = REAL(pthread_barrier_destroy)(b); return res; } -TSAN_INTERCEPTOR(int, pthread_barrier_wait, void *b) { +TSAN_INTERCEPTOR_PTHREAD(int, barrier_wait, void *b) { SCOPED_TSAN_INTERCEPTOR(pthread_barrier_wait, b); Release(thr, pc, (uptr)b); MemoryRead(thr, pc, (uptr)b, kSizeLog1); @@ -1460,7 +1461,7 @@ } #endif -TSAN_INTERCEPTOR(int, pthread_once, void *o, void (*f)()) { +TSAN_INTERCEPTOR_PTHREAD(int, once, void *o, void (*f)()) { SCOPED_INTERCEPTOR_RAW(pthread_once, o, f); if (o == 0 || f == 0) return errno_EINVAL; @@ -1913,8 +1914,8 @@ return REAL(sigsetmask)(mask); } -TSAN_INTERCEPTOR(int, pthread_sigmask, int how, const __sanitizer_sigset_t *set, - __sanitizer_sigset_t *oldset) { +TSAN_INTERCEPTOR_PTHREAD(int, sigmask, int how, const __sanitizer_sigset_t *set, + __sanitizer_sigset_t *oldset) { SCOPED_TSAN_INTERCEPTOR(pthread_sigmask, how, set, oldset); return REAL(pthread_sigmask)(how, set, oldset); } @@ -2100,7 +2101,7 @@ return res; } -TSAN_INTERCEPTOR(int, pthread_kill, void *tid, int sig) { +TSAN_INTERCEPTOR_PTHREAD(int, kill, void *tid, int sig) { SCOPED_TSAN_INTERCEPTOR(pthread_kill, tid, sig); ThreadSignalContext *sctx = SigCtx(thr); CHECK_NE(sctx, 0); @@ -2711,14 +2712,14 @@ TSAN_INTERCEPT(strncpy); TSAN_INTERCEPT(strdup); - TSAN_INTERCEPT(pthread_create); - TSAN_INTERCEPT(pthread_join); - TSAN_INTERCEPT(pthread_detach); - TSAN_INTERCEPT(pthread_exit); - #if SANITIZER_LINUX - TSAN_INTERCEPT(pthread_tryjoin_np); - TSAN_INTERCEPT(pthread_timedjoin_np); - #endif + TSAN_INTERCEPT_PTHREAD(create); + TSAN_INTERCEPT_PTHREAD(join); + TSAN_INTERCEPT_PTHREAD(detach); + TSAN_INTERCEPT_PTHREAD(exit); +#if SANITIZER_LINUX + TSAN_INTERCEPT_PTHREAD(tryjoin_np); + TSAN_INTERCEPT_PTHREAD(timedjoin_np); +#endif TSAN_INTERCEPT_VER(pthread_cond_init, PTHREAD_ABI_BASE); TSAN_INTERCEPT_VER(pthread_cond_signal, PTHREAD_ABI_BASE); @@ -2729,32 +2730,32 @@ TSAN_MAYBE_PTHREAD_COND_CLOCKWAIT; - TSAN_INTERCEPT(pthread_mutex_init); - TSAN_INTERCEPT(pthread_mutex_destroy); - TSAN_INTERCEPT(pthread_mutex_trylock); - TSAN_INTERCEPT(pthread_mutex_timedlock); - - TSAN_INTERCEPT(pthread_spin_init); - TSAN_INTERCEPT(pthread_spin_destroy); - TSAN_INTERCEPT(pthread_spin_lock); - TSAN_INTERCEPT(pthread_spin_trylock); - TSAN_INTERCEPT(pthread_spin_unlock); - - TSAN_INTERCEPT(pthread_rwlock_init); - TSAN_INTERCEPT(pthread_rwlock_destroy); - TSAN_INTERCEPT(pthread_rwlock_rdlock); - TSAN_INTERCEPT(pthread_rwlock_tryrdlock); - TSAN_INTERCEPT(pthread_rwlock_timedrdlock); - TSAN_INTERCEPT(pthread_rwlock_wrlock); - TSAN_INTERCEPT(pthread_rwlock_trywrlock); - TSAN_INTERCEPT(pthread_rwlock_timedwrlock); - TSAN_INTERCEPT(pthread_rwlock_unlock); - - TSAN_INTERCEPT(pthread_barrier_init); - TSAN_INTERCEPT(pthread_barrier_destroy); - TSAN_INTERCEPT(pthread_barrier_wait); - - TSAN_INTERCEPT(pthread_once); + TSAN_INTERCEPT_PTHREAD(mutex_init); + TSAN_INTERCEPT_PTHREAD(mutex_destroy); + TSAN_INTERCEPT_PTHREAD(mutex_trylock); + TSAN_INTERCEPT_PTHREAD(mutex_timedlock); + + TSAN_INTERCEPT_PTHREAD(spin_init); + TSAN_INTERCEPT_PTHREAD(spin_destroy); + TSAN_INTERCEPT_PTHREAD(spin_lock); + TSAN_INTERCEPT_PTHREAD(spin_trylock); + TSAN_INTERCEPT_PTHREAD(spin_unlock); + + TSAN_INTERCEPT_PTHREAD(rwlock_init); + TSAN_INTERCEPT_PTHREAD(rwlock_destroy); + TSAN_INTERCEPT_PTHREAD(rwlock_rdlock); + TSAN_INTERCEPT_PTHREAD(rwlock_tryrdlock); + TSAN_INTERCEPT_PTHREAD(rwlock_timedrdlock); + TSAN_INTERCEPT_PTHREAD(rwlock_wrlock); + TSAN_INTERCEPT_PTHREAD(rwlock_trywrlock); + TSAN_INTERCEPT_PTHREAD(rwlock_timedwrlock); + TSAN_INTERCEPT_PTHREAD(rwlock_unlock); + + TSAN_INTERCEPT_PTHREAD(barrier_init); + TSAN_INTERCEPT_PTHREAD(barrier_destroy); + TSAN_INTERCEPT_PTHREAD(barrier_wait); + + TSAN_INTERCEPT_PTHREAD(once); TSAN_INTERCEPT(fstat); TSAN_MAYBE_INTERCEPT___FXSTAT; @@ -2793,10 +2794,10 @@ TSAN_INTERCEPT(sigsuspend); TSAN_INTERCEPT(sigblock); TSAN_INTERCEPT(sigsetmask); - TSAN_INTERCEPT(pthread_sigmask); + TSAN_INTERCEPT_PTHREAD(sigmask); TSAN_INTERCEPT(raise); TSAN_INTERCEPT(kill); - TSAN_INTERCEPT(pthread_kill); + TSAN_INTERCEPT_PTHREAD(kill); TSAN_INTERCEPT(sleep); TSAN_INTERCEPT(usleep); TSAN_INTERCEPT(nanosleep); diff --git a/compiler-rt/test/tsan/freebsd_libc_locks.cpp b/compiler-rt/test/tsan/freebsd_libc_locks.cpp new file mode 100644 --- /dev/null +++ b/compiler-rt/test/tsan/freebsd_libc_locks.cpp @@ -0,0 +1,40 @@ +// RUN: %clangxx_tsan -O1 %s -o %t && %run %t | FileCheck %s +// REQUIRES: freebsd +// FreeBSD libc uses _pthread_* calls (with an extra underscore). Check that +// those are also intercepted and no false-positive race is reported here. +#include "test.h" + +int Global; +pthread_mutex_t mtx; + +extern "C" int _pthread_mutex_lock(pthread_mutex_t *); +extern "C" int _pthread_mutex_unlock(pthread_mutex_t *); + +void *Thread1(void *x) { + pthread_mutex_lock(&mtx); + Global++; + pthread_mutex_unlock(&mtx); + return NULL; +} + +void *Thread2(void *x) { + _pthread_mutex_lock(&mtx); + Global++; + _pthread_mutex_unlock(&mtx); + return NULL; +} + +int main() { + barrier_init(&barrier, 2); + pthread_mutex_init(&mtx, 0); + pthread_t t[2]; + pthread_create(&t[0], NULL, Thread1, NULL); + pthread_create(&t[1], NULL, Thread2, NULL); + pthread_join(t[0], NULL); + pthread_join(t[1], NULL); + pthread_mutex_destroy(&mtx); + printf("DONE\n"); + // CHECK-NOT: WARNING: ThreadSanitizer: + // CHECK: DONE + // CHECK-NOT: WARNING: ThreadSanitizer: +}