| /* -*- mode: C; c-basic-offset: 3; -*- */ |
| |
| /*--------------------------------------------------------------------*/ |
| /*--- Client-space code for DRD. drd_pthread_intercepts.c ---*/ |
| /*--------------------------------------------------------------------*/ |
| |
| /* |
| This file is part of DRD, a thread error detector. |
| |
| Copyright (C) 2006-2009 Bart Van Assche <bart.vanassche@gmail.com>. |
| |
| This program is free software; you can redistribute it and/or |
| modify it under the terms of the GNU General Public License as |
| published by the Free Software Foundation; either version 2 of the |
| License, or (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
| 02111-1307, USA. |
| |
| The GNU General Public License is contained in the file COPYING. |
| */ |
| |
| /* --------------------------------------------------------------------- |
| ALL THE CODE IN THIS FILE RUNS ON THE SIMULATED CPU. |
| |
| These functions are not called directly - they're the targets of code |
| redirection or load notifications (see pub_core_redir.h for info). |
| They're named weirdly so that the intercept code can find them when the |
| shared object is initially loaded. |
| |
| Note that this filename has the "drd_" prefix because it can appear |
| in stack traces, and the "drd_" makes it a little clearer that it |
| originates from Valgrind. |
| ------------------------------------------------------------------ */ |
| |
| /* |
| * Define _GNU_SOURCE to make sure that pthread_spinlock_t is available when |
| * compiling with older glibc versions (2.3 or before). |
| */ |
| #ifndef _GNU_SOURCE |
| #define _GNU_SOURCE |
| #endif |
| |
| #include <assert.h> /* assert() */ |
| #include <pthread.h> /* pthread_mutex_t */ |
| #include <semaphore.h> /* sem_t */ |
| #include <stdio.h> /* fprintf() */ |
| #include <stdlib.h> /* malloc(), free() */ |
| #include <unistd.h> /* confstr() */ |
| #include "config.h" /* HAVE_PTHREAD_MUTEX_ADAPTIVE_NP etc. */ |
| #include "drd_basics.h" /* DRD_() */ |
| #include "drd_clientreq.h" |
| #include "pub_tool_redir.h" /* VG_WRAP_FUNCTION_ZZ() */ |
| |
| |
| /* Defines. */ |
| |
| /* |
| * Do not undefine the two macro's below, or the following two subtle race |
| * conditions will be introduced in the data race detection algorithm: |
| * - sg_init() runs on the context of the created thread and copies the |
| * vector clock of the creator thread. This only works reliably if |
| * the creator thread waits until this copy has been performed. |
| * - Since DRD_(thread_compute_minimum_vc)() does not take the vector |
| * clocks into account that are involved in thread creation but |
| * for which the corresponding thread has not yet been created, by |
| * undefining the macro below it becomes possible that segments get |
| * discarded that should not yet be discarded. Or: some data races |
| * are not detected. |
| */ |
| #define WAIT_UNTIL_CREATED_THREAD_STARTED |
| #define ALLOCATE_THREAD_ARGS_ON_THE_STACK |
| |
| #define PTH_FUNC(ret_ty, f, args...) \ |
| ret_ty VG_WRAP_FUNCTION_ZZ(libpthreadZdsoZd0,f)(args); \ |
| ret_ty VG_WRAP_FUNCTION_ZZ(libpthreadZdsoZd0,f)(args) |
| |
| |
| /* Local data structures. */ |
| |
| typedef struct |
| { |
| void* (*start)(void*); |
| void* arg; |
| int detachstate; |
| #if defined(WAIT_UNTIL_CREATED_THREAD_STARTED) |
| int wrapper_started; |
| #endif |
| } DrdPosixThreadArgs; |
| |
| |
| /* Local function declarations. */ |
| |
| static void DRD_(init)(void) __attribute__((constructor)); |
| static void DRD_(check_threading_library)(void); |
| static void DRD_(set_main_thread_state)(void); |
| |
| |
| /* Function definitions. */ |
| |
| /** |
| * Shared library initialization function. The function init() is called after |
| * dlopen() has loaded the shared library with DRD client intercepts because |
| * the constructor attribute was specified in the declaration of this function. |
| * Note: do specify the -nostdlib option to gcc when linking this code into a |
| * shared library because doing so would cancel the effect of the constructor |
| * attribute ! Using the gcc option -nodefaultlibs is fine because this last |
| * option preserves the shared library initialization code that calls |
| * constructor and destructor functions. |
| */ |
| static void DRD_(init)(void) |
| { |
| DRD_(check_threading_library)(); |
| DRD_(set_main_thread_state)(); |
| } |
| |
| /** |
| * POSIX threads and DRD each have their own mutex type identification. |
| * Convert POSIX threads' mutex type to DRD's mutex type. In the code below |
| * if-statements are used to test the value of 'kind' instead of a switch |
| * statement because some of the PTHREAD_MUTEX_ macro's may have the same |
| * value. |
| */ |
| static MutexT DRD_(pthread_to_drd_mutex_type)(const int kind) |
| { |
| if (kind == PTHREAD_MUTEX_RECURSIVE) |
| return mutex_type_recursive_mutex; |
| else if (kind == PTHREAD_MUTEX_ERRORCHECK) |
| return mutex_type_errorcheck_mutex; |
| else if (kind == PTHREAD_MUTEX_NORMAL) |
| return mutex_type_default_mutex; |
| else if (kind == PTHREAD_MUTEX_DEFAULT) |
| return mutex_type_default_mutex; |
| #if defined(HAVE_PTHREAD_MUTEX_ADAPTIVE_NP) |
| else if (kind == PTHREAD_MUTEX_ADAPTIVE_NP) |
| return mutex_type_default_mutex; |
| #endif |
| else |
| { |
| return mutex_type_invalid_mutex; |
| } |
| } |
| |
| /** |
| * Read the mutex type stored in the client memory used for the mutex |
| * implementation. |
| * |
| * @note This function depends on the implementation of the POSIX threads |
| * library -- the POSIX standard does not define the name of the member in |
| * which the mutex type is stored. |
| * @note The function mutex_type() has been declared inline in order |
| * to avoid that it shows up in call stacks (drd/tests/...exp* files). |
| * @note glibc stores the mutex type in the lowest two bits, and uses the |
| * higher bits for flags like PTHREAD_MUTEXATTR_FLAG_ROBUST and |
| * PTHREAD_MUTEXATTR_FLAG_PSHARED. |
| */ |
| static __inline__ MutexT DRD_(mutex_type)(pthread_mutex_t* mutex) |
| { |
| #if defined(HAVE_PTHREAD_MUTEX_T__M_KIND) |
| /* glibc + LinuxThreads. */ |
| const int kind = mutex->__m_kind & 3; |
| #elif defined(HAVE_PTHREAD_MUTEX_T__DATA__KIND) |
| /* glibc + NPTL. */ |
| const int kind = mutex->__data.__kind & 3; |
| #else |
| /* Another POSIX threads implementation. Regression tests will fail. */ |
| const int kind = PTHREAD_MUTEX_DEFAULT; |
| fprintf(stderr, |
| "Did not recognize your POSIX threads implementation. Giving up.\n"); |
| assert(0); |
| #endif |
| return DRD_(pthread_to_drd_mutex_type)(kind); |
| } |
| |
| /** |
| * Tell DRD whether 'tid' is a joinable thread or a detached thread. |
| */ |
| static void DRD_(set_joinable)(const pthread_t tid, const int joinable) |
| { |
| int res; |
| assert(joinable == 0 || joinable == 1); |
| VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__SET_JOINABLE, |
| tid, joinable, 0, 0, 0); |
| } |
| |
| /** |
| * The function called from the thread created by pthread_create(). |
| */ |
| static void* DRD_(thread_wrapper)(void* arg) |
| { |
| int res; |
| DrdPosixThreadArgs* arg_ptr; |
| DrdPosixThreadArgs arg_copy; |
| |
| VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__DRD_SUPPRESS_CURRENT_STACK, |
| 0, 0, 0, 0, 0); |
| |
| arg_ptr = (DrdPosixThreadArgs*)arg; |
| arg_copy = *arg_ptr; |
| #if defined(WAIT_UNTIL_CREATED_THREAD_STARTED) |
| arg_ptr->wrapper_started = 1; |
| #else |
| #if defined(ALLOCATE_THREAD_ARGS_ON_THE_STACK) |
| #error Defining ALLOCATE_THREAD_ARGS_ON_THE_STACK but not \ |
| WAIT_UNTIL_CREATED_THREAD_STARTED is not supported. |
| #else |
| free(arg_ptr); |
| #endif |
| #endif |
| |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__SET_PTHREADID, |
| pthread_self(), 0, 0, 0, 0); |
| |
| DRD_(set_joinable)(pthread_self(), |
| arg_copy.detachstate == PTHREAD_CREATE_JOINABLE); |
| |
| return (arg_copy.start)(arg_copy.arg); |
| } |
| |
| /** |
| * Return 1 if the LinuxThreads implementation of POSIX Threads has been |
| * detected, and 0 otherwise. |
| * |
| * @see For more information about the confstr() function, see also |
| * http://www.opengroup.org/onlinepubs/009695399/functions/confstr.html |
| */ |
| static int DRD_(detected_linuxthreads)(void) |
| { |
| #if defined(linux) |
| #if defined(_CS_GNU_LIBPTHREAD_VERSION) |
| /* Linux with a recent glibc. */ |
| char buffer[256]; |
| unsigned len; |
| len = confstr(_CS_GNU_LIBPTHREAD_VERSION, buffer, sizeof(buffer)); |
| assert(len <= sizeof(buffer)); |
| return len > 0 && buffer[0] == 'l'; |
| #else |
| /* Linux without _CS_GNU_LIBPTHREAD_VERSION: most likely LinuxThreads. */ |
| return 1; |
| #endif |
| #else |
| /* Another OS than Linux, hence no LinuxThreads. */ |
| return 0; |
| #endif |
| } |
| |
| /** |
| * Stop and print an error message in case a non-supported threading |
| * library implementation (LinuxThreads) has been detected. |
| */ |
| static void DRD_(check_threading_library)(void) |
| { |
| if (DRD_(detected_linuxthreads)()) |
| { |
| if (getenv("LD_ASSUME_KERNEL")) |
| { |
| fprintf(stderr, |
| "Detected the LinuxThreads threading library. Sorry, but DRD only supports\n" |
| "the newer NPTL (Native POSIX Threads Library). Please try to rerun DRD\n" |
| "after having unset the environment variable LD_ASSUME_KERNEL. Giving up.\n" |
| ); |
| } |
| else |
| { |
| fprintf(stderr, |
| "Detected the LinuxThreads threading library. Sorry, but DRD only supports\n" |
| "the newer NPTL (Native POSIX Threads Library). Please try to rerun DRD\n" |
| "after having upgraded to a newer version of your Linux distribution.\n" |
| "Giving up.\n" |
| ); |
| } |
| abort(); |
| } |
| } |
| |
| /** |
| * The main thread is the only thread not created by pthread_create(). |
| * Update DRD's state information about the main thread. |
| */ |
| static void DRD_(set_main_thread_state)(void) |
| { |
| int res; |
| |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__DRD_SUPPRESS_CURRENT_STACK, |
| 0, 0, 0, 0, 0); |
| |
| // Make sure that DRD knows about the main thread's POSIX thread ID. |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__SET_PTHREADID, |
| pthread_self(), 0, 0, 0, 0); |
| |
| } |
| |
| // pthread_create |
| PTH_FUNC(int, pthreadZucreateZa, // pthread_create* |
| pthread_t *thread, const pthread_attr_t *attr, |
| void *(*start) (void *), void *arg) |
| { |
| int res; |
| int ret; |
| OrigFn fn; |
| #if defined(ALLOCATE_THREAD_ARGS_ON_THE_STACK) |
| DrdPosixThreadArgs thread_args; |
| #endif |
| DrdPosixThreadArgs* thread_args_p; |
| |
| VALGRIND_GET_ORIG_FN(fn); |
| |
| #if defined(ALLOCATE_THREAD_ARGS_ON_THE_STACK) |
| thread_args_p = &thread_args; |
| #else |
| thread_args_p = malloc(sizeof(*thread_args_p)); |
| #endif |
| assert(thread_args_p); |
| |
| thread_args_p->start = start; |
| thread_args_p->arg = arg; |
| #if defined(WAIT_UNTIL_CREATED_THREAD_STARTED) |
| DRD_IGNORE_VAR(thread_args_p->wrapper_started); |
| thread_args_p->wrapper_started = 0; |
| #endif |
| /* |
| * Find out whether the thread will be started as a joinable thread |
| * or as a detached thread. If no thread attributes have been specified, |
| * this means that the new thread will be started as a joinable thread. |
| */ |
| thread_args_p->detachstate = PTHREAD_CREATE_JOINABLE; |
| if (attr) |
| { |
| if (pthread_attr_getdetachstate(attr, &thread_args_p->detachstate) != 0) |
| { |
| assert(0); |
| } |
| } |
| assert(thread_args_p->detachstate == PTHREAD_CREATE_JOINABLE |
| || thread_args_p->detachstate == PTHREAD_CREATE_DETACHED); |
| |
| /* Suppress NPTL-specific conflicts between creator and created thread. */ |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__DRD_STOP_RECORDING, |
| 0, 0, 0, 0, 0); |
| |
| CALL_FN_W_WWWW(ret, fn, thread, attr, DRD_(thread_wrapper), thread_args_p); |
| |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__DRD_START_RECORDING, |
| 0, 0, 0, 0, 0); |
| |
| #if defined(WAIT_UNTIL_CREATED_THREAD_STARTED) |
| if (ret == 0) |
| { |
| /* |
| * Wait until the thread wrapper started. |
| * @todo Find out why some regression tests fail if thread arguments are |
| * passed via dynamically allocated memory and if the loop below is |
| * removed. |
| */ |
| while (! thread_args_p->wrapper_started) |
| { |
| sched_yield(); |
| } |
| } |
| |
| #if defined(ALLOCATE_THREAD_ARGS_DYNAMICALLY) |
| free(thread_args_p); |
| #endif |
| |
| #endif |
| |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__DRD_START_NEW_SEGMENT, |
| pthread_self(), 0, 0, 0, 0); |
| |
| return ret; |
| } |
| |
| // pthread_join |
| PTH_FUNC(int, pthreadZujoin, // pthread_join |
| pthread_t pt_joinee, void **thread_return) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| |
| VALGRIND_GET_ORIG_FN(fn); |
| CALL_FN_W_WW(ret, fn, pt_joinee, thread_return); |
| if (ret == 0) |
| { |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_THREAD_JOIN, |
| pt_joinee, 0, 0, 0, 0); |
| } |
| return ret; |
| } |
| |
| // pthread_detach |
| PTH_FUNC(int, pthreadZudetach, pthread_t pt_thread) |
| { |
| int ret; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| { |
| CALL_FN_W_W(ret, fn, pt_thread); |
| if (ret == 0) |
| { |
| DRD_(set_joinable)(pt_thread, 0); |
| } |
| } |
| return ret; |
| } |
| |
| // pthread_cancel |
| PTH_FUNC(int, pthreadZucancel, pthread_t pt_thread) |
| { |
| int res; |
| int ret; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_THREAD_CANCEL, |
| pt_thread, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, pt_thread); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_THREAD_CANCEL, |
| pt_thread, ret==0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_mutex_init |
| PTH_FUNC(int, pthreadZumutexZuinit, |
| pthread_mutex_t *mutex, |
| const pthread_mutexattr_t* attr) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| int mt; |
| VALGRIND_GET_ORIG_FN(fn); |
| mt = PTHREAD_MUTEX_DEFAULT; |
| if (attr) |
| pthread_mutexattr_gettype(attr, &mt); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_INIT, |
| mutex, DRD_(pthread_to_drd_mutex_type)(mt), |
| 0, 0, 0); |
| CALL_FN_W_WW(ret, fn, mutex, attr); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_INIT, |
| mutex, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_mutex_destroy |
| PTH_FUNC(int, pthreadZumutexZudestroy, |
| pthread_mutex_t *mutex) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_DESTROY, |
| mutex, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, mutex); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_DESTROY, |
| mutex, DRD_(mutex_type)(mutex), 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_mutex_lock |
| PTH_FUNC(int, pthreadZumutexZulock, // pthread_mutex_lock |
| pthread_mutex_t *mutex) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, |
| mutex, DRD_(mutex_type)(mutex), 0, 0, 0); |
| CALL_FN_W_W(ret, fn, mutex); |
| VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__POST_MUTEX_LOCK, |
| mutex, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_mutex_trylock |
| PTH_FUNC(int, pthreadZumutexZutrylock, // pthread_mutex_trylock |
| pthread_mutex_t *mutex) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, |
| mutex, DRD_(mutex_type)(mutex), 1, 0, 0); |
| CALL_FN_W_W(ret, fn, mutex); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_LOCK, |
| mutex, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_mutex_timedlock |
| PTH_FUNC(int, pthreadZumutexZutimedlock, // pthread_mutex_timedlock |
| pthread_mutex_t *mutex, |
| const struct timespec *abs_timeout) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, |
| mutex, DRD_(mutex_type)(mutex), 0, 0, 0); |
| CALL_FN_W_WW(ret, fn, mutex, abs_timeout); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_LOCK, |
| mutex, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_mutex_unlock |
| PTH_FUNC(int, pthreadZumutexZuunlock, // pthread_mutex_unlock |
| pthread_mutex_t *mutex) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, |
| VG_USERREQ__PRE_MUTEX_UNLOCK, |
| mutex, DRD_(mutex_type)(mutex), 0, 0, 0); |
| CALL_FN_W_W(ret, fn, mutex); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, |
| VG_USERREQ__POST_MUTEX_UNLOCK, |
| mutex, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_cond_init |
| PTH_FUNC(int, pthreadZucondZuinitZa, // pthread_cond_init* |
| pthread_cond_t* cond, |
| const pthread_condattr_t* attr) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_INIT, |
| cond, 0, 0, 0, 0); |
| CALL_FN_W_WW(ret, fn, cond, attr); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_COND_INIT, |
| cond, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_cond_destroy |
| PTH_FUNC(int, pthreadZucondZudestroyZa, // pthread_cond_destroy* |
| pthread_cond_t* cond) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_DESTROY, |
| cond, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, cond); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_COND_DESTROY, |
| cond, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_cond_wait |
| PTH_FUNC(int, pthreadZucondZuwaitZa, // pthread_cond_wait* |
| pthread_cond_t *cond, |
| pthread_mutex_t *mutex) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_WAIT, |
| cond, mutex, DRD_(mutex_type)(mutex), 0, 0); |
| CALL_FN_W_WW(ret, fn, cond, mutex); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_COND_WAIT, |
| cond, mutex, 1, 0, 0); |
| return ret; |
| } |
| |
| // pthread_cond_timedwait |
| PTH_FUNC(int, pthreadZucondZutimedwaitZa, // pthread_cond_timedwait* |
| pthread_cond_t *cond, |
| pthread_mutex_t *mutex, |
| const struct timespec* abstime) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_WAIT, |
| cond, mutex, DRD_(mutex_type)(mutex), 0, 0); |
| CALL_FN_W_WWW(ret, fn, cond, mutex, abstime); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_COND_WAIT, |
| cond, mutex, 1, 0, 0); |
| return ret; |
| } |
| |
| // pthread_cond_signal |
| PTH_FUNC(int, pthreadZucondZusignalZa, // pthread_cond_signal* |
| pthread_cond_t* cond) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_SIGNAL, |
| cond, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, cond); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_COND_SIGNAL, |
| cond, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_cond_broadcast |
| PTH_FUNC(int, pthreadZucondZubroadcastZa, // pthread_cond_broadcast* |
| pthread_cond_t* cond) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_COND_BROADCAST, |
| cond, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, cond); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_COND_BROADCAST, |
| cond, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| |
| // pthread_spin_init |
| PTH_FUNC(int, pthreadZuspinZuinit, // pthread_spin_init |
| pthread_spinlock_t *spinlock, |
| int pshared) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK, |
| spinlock, 0, 0, 0, 0); |
| CALL_FN_W_WW(ret, fn, spinlock, pshared); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK, |
| spinlock, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_spin_destroy |
| PTH_FUNC(int, pthreadZuspinZudestroy, // pthread_spin_destroy |
| pthread_spinlock_t *spinlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_MUTEX_DESTROY, |
| spinlock, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, spinlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_DESTROY, |
| spinlock, mutex_type_spinlock, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_spin_lock |
| PTH_FUNC(int, pthreadZuspinZulock, // pthread_spin_lock |
| pthread_spinlock_t *spinlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, |
| spinlock, mutex_type_spinlock, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, spinlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_LOCK, |
| spinlock, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_spin_trylock |
| PTH_FUNC(int, pthreadZuspinZutrylock, // pthread_spin_trylock |
| pthread_spinlock_t *spinlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__PRE_MUTEX_LOCK, |
| spinlock, mutex_type_spinlock, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, spinlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_MUTEX_LOCK, |
| spinlock, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_spin_unlock |
| PTH_FUNC(int, pthreadZuspinZuunlock, // pthread_spin_unlock |
| pthread_spinlock_t *spinlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK, |
| spinlock, mutex_type_spinlock, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, spinlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK, |
| spinlock, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_barrier_init |
| PTH_FUNC(int, pthreadZubarrierZuinit, // pthread_barrier_init |
| pthread_barrier_t* barrier, |
| const pthread_barrierattr_t* attr, |
| unsigned count) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_BARRIER_INIT, |
| barrier, pthread_barrier, count, 0, 0); |
| CALL_FN_W_WWW(ret, fn, barrier, attr, count); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_BARRIER_INIT, |
| barrier, pthread_barrier, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_barrier_destroy |
| PTH_FUNC(int, pthreadZubarrierZudestroy, // pthread_barrier_destroy |
| pthread_barrier_t* barrier) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_BARRIER_DESTROY, |
| barrier, pthread_barrier, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, barrier); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_BARRIER_DESTROY, |
| barrier, pthread_barrier, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_barrier_wait |
| PTH_FUNC(int, pthreadZubarrierZuwait, // pthread_barrier_wait |
| pthread_barrier_t* barrier) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_BARRIER_WAIT, |
| barrier, pthread_barrier, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, barrier); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_BARRIER_WAIT, |
| barrier, pthread_barrier, |
| ret == 0 || ret == PTHREAD_BARRIER_SERIAL_THREAD, |
| ret == PTHREAD_BARRIER_SERIAL_THREAD, 0); |
| return ret; |
| } |
| |
| |
| // sem_init |
| PTH_FUNC(int, semZuinitZa, // sem_init* |
| sem_t *sem, |
| int pshared, |
| unsigned int value) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_INIT, |
| sem, pshared, value, 0, 0); |
| CALL_FN_W_WWW(ret, fn, sem, pshared, value); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_INIT, |
| sem, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // sem_destroy |
| PTH_FUNC(int, semZudestroyZa, // sem_destroy* |
| sem_t *sem) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_DESTROY, |
| sem, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, sem); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_DESTROY, |
| sem, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // sem_wait |
| PTH_FUNC(int, semZuwaitZa, // sem_wait* |
| sem_t *sem) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_WAIT, |
| sem, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, sem); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_WAIT, |
| sem, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // sem_trywait |
| PTH_FUNC(int, semZutrywaitZa, // sem_trywait* |
| sem_t *sem) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_WAIT, |
| sem, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, sem); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_WAIT, |
| sem, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // sem_timedwait |
| PTH_FUNC(int, semZutimedwait, // sem_timedwait |
| sem_t *sem, const struct timespec *abs_timeout) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_WAIT, |
| sem, 0, 0, 0, 0); |
| CALL_FN_W_WW(ret, fn, sem, abs_timeout); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_WAIT, |
| sem, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // sem_post |
| PTH_FUNC(int, semZupostZa, // sem_post* |
| sem_t *sem) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_SEM_POST, |
| sem, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, sem); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_SEM_POST, |
| sem, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_rwlock_init |
| PTH_FUNC(int, |
| pthreadZurwlockZuinitZa, // pthread_rwlock_init* |
| pthread_rwlock_t* rwlock, |
| const pthread_rwlockattr_t* attr) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_INIT, |
| rwlock, 0, 0, 0, 0); |
| CALL_FN_W_WW(ret, fn, rwlock, attr); |
| return ret; |
| } |
| |
| // pthread_rwlock_destroy |
| PTH_FUNC(int, |
| pthreadZurwlockZudestroyZa, // pthread_rwlock_destroy* |
| pthread_rwlock_t* rwlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| CALL_FN_W_W(ret, fn, rwlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_DESTROY, |
| rwlock, 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_rwlock_rdlock |
| PTH_FUNC(int, |
| pthreadZurwlockZurdlockZa, // pthread_rwlock_rdlock* |
| pthread_rwlock_t* rwlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_RDLOCK, |
| rwlock, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, rwlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_RDLOCK, |
| rwlock, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_rwlock_wrlock |
| PTH_FUNC(int, |
| pthreadZurwlockZuwrlockZa, // pthread_rwlock_wrlock* |
| pthread_rwlock_t* rwlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_WRLOCK, |
| rwlock, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, rwlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_WRLOCK, |
| rwlock, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_rwlock_timedrdlock |
| PTH_FUNC(int, |
| pthreadZurwlockZutimedrdlockZa, // pthread_rwlock_timedrdlock* |
| pthread_rwlock_t* rwlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_RDLOCK, |
| rwlock, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, rwlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_RDLOCK, |
| rwlock, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_rwlock_timedwrlock |
| PTH_FUNC(int, |
| pthreadZurwlockZutimedwrlockZa, // pthread_rwlock_timedwrlock* |
| pthread_rwlock_t* rwlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_WRLOCK, |
| rwlock, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, rwlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_WRLOCK, |
| rwlock, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_rwlock_tryrdlock |
| PTH_FUNC(int, |
| pthreadZurwlockZutryrdlockZa, // pthread_rwlock_tryrdlock* |
| pthread_rwlock_t* rwlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_RDLOCK, |
| rwlock, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, rwlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_RDLOCK, |
| rwlock, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_rwlock_trywrlock |
| PTH_FUNC(int, |
| pthreadZurwlockZutrywrlockZa, // pthread_rwlock_trywrlock* |
| pthread_rwlock_t* rwlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_WRLOCK, |
| rwlock, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, rwlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_WRLOCK, |
| rwlock, ret == 0, 0, 0, 0); |
| return ret; |
| } |
| |
| // pthread_rwlock_unlock |
| PTH_FUNC(int, |
| pthreadZurwlockZuunlockZa, // pthread_rwlock_unlock* |
| pthread_rwlock_t* rwlock) |
| { |
| int ret; |
| int res; |
| OrigFn fn; |
| VALGRIND_GET_ORIG_FN(fn); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__PRE_RWLOCK_UNLOCK, |
| rwlock, 0, 0, 0, 0); |
| CALL_FN_W_W(ret, fn, rwlock); |
| VALGRIND_DO_CLIENT_REQUEST(res, -1, VG_USERREQ__POST_RWLOCK_UNLOCK, |
| rwlock, ret == 0, 0, 0, 0); |
| return ret; |
| } |