// pthread_mutex_unlock
PTH_FUNC(int, pthreadZumutexZuunlock, // pthread_mutex_unlock
pthread_mutex_t *mutex)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
if (TRACE_PTH_FNS) {
fprintf(stderr, "<< pthread_mxunlk %p", mutex); fflush(stderr);
}
DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
pthread_mutex_t*,mutex);
CALL_FN_W_W(ret, fn, mutex);
if (ret == 0 /*success*/) {
DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST,
pthread_mutex_t*,mutex);
} else {
DO_PthAPIerror( "pthread_mutex_unlock", ret );
}
if (TRACE_PTH_FNS) {
fprintf(stderr, " mxunlk -> %d >>\n", ret);
}
return ret;
}
// pthread_cond_broadcast
// Note, this is pretty much identical, from a dependency-graph
// point of view, with cond_signal, so the code is duplicated.
// Maybe it should be commoned up.
PTH_FUNC(int, pthreadZucondZubroadcastZAZa, // pthread_cond_broadcast@*
pthread_cond_t* cond)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
if (TRACE_PTH_FNS) {
fprintf(stderr, "<< pthread_broadcast_signal %p", cond);
fflush(stderr);
}
DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_COND_BROADCAST_PRE,
pthread_cond_t*,cond);
CALL_FN_W_W(ret, fn, cond);
if (ret != 0) {
DO_PthAPIerror( "pthread_cond_broadcast", ret );
}
if (TRACE_PTH_FNS) {
fprintf(stderr, " cobro -> %d >>\n", ret);
}
return ret;
}
// pthread_mutex_trylock. The handling needed here is very similar
// to that for pthread_mutex_lock, except that we need to tell
// the pre-lock creq that this is a trylock-style operation, and
// therefore not to complain if the lock is nonrecursive and
// already locked by this thread -- because then it'll just fail
// immediately with EBUSY.
PTH_FUNC(int, pthreadZumutexZutrylock, // pthread_mutex_trylock
pthread_mutex_t *mutex)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
if (TRACE_PTH_FNS) {
fprintf(stderr, "<< pthread_mxtrylock %p", mutex); fflush(stderr);
}
DO_CREQ_v_WW(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_PRE,
pthread_mutex_t*,mutex, long,1/*isTryLock*/);
CALL_FN_W_W(ret, fn, mutex);
/* There's a hole here: libpthread now knows the lock is locked,
but the tool doesn't, so some other thread could run and detect
that the lock has been acquired by someone (this thread). Does
this matter? Not sure, but I don't think so. */
if (ret == 0 /*success*/) {
DO_CREQ_v_W(_VG_USERREQ__HG_PTHREAD_MUTEX_LOCK_POST,
pthread_mutex_t*,mutex);
} else {
if (ret != EBUSY)
DO_PthAPIerror( "pthread_mutex_trylock", ret );
}
if (TRACE_PTH_FNS) {
fprintf(stderr, " :: mxtrylock -> %d >>\n", ret);
}
return ret;
}
int I_WRAP_SONAME_FNNAME_ZU(NONE,fact) ( int n )
{
int r;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
printf("in wrapper1-pre: fact(%d)\n", n);
CALL_FN_W_W(r, fn, n);
printf("in wrapper1-post: fact(%d) = %d\n", n, r);
return r;
}
static __always_inline
int pthread_rwlock_destroy_intercept(pthread_rwlock_t* rwlock)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
CALL_FN_W_W(ret, fn, rwlock);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_RWLOCK_DESTROY,
rwlock, 0, 0, 0, 0);
return ret;
}
static __always_inline
void __cxa_guard_abort_release_intercept(void *guard)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_UNLOCK,
guard, mutex_type_cxa_guard, 0, 0, 0);
CALL_FN_W_W(ret, fn, guard);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_UNLOCK,
guard, 0, 0, 0, 0);
}
// 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__SPIN_INIT_OR_UNLOCK,
spinlock, mutex_type_spinlock, 0, 0, 0);
CALL_FN_W_W(ret, fn, spinlock);
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);
return ret;
}
UInt I_WRAP_SONAME_FNNAME_ZU(NONE,fn_1) ( UInt a1 )
{
UInt r;
void* fn;
VALGRIND_GET_ORIG_FN(fn);
printf("fn_1 wrapper pre ( %d )\n", (int)a1);
CALL_FN_W_W(r, fn, a1);
printf("fn_1 wrapper post1 = %d\n", (int)r);
CALL_FN_v_W(fn, a1);
printf("fn_1 wrapper post2 = %d\n", (int)r);
return r;
}
// 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);
return ret;
}
// QMutex::unlock() -- _ZN6QMutex6unlockEv
QT4CORE_FUNC(void, _ZN6QMutex6unlockEv,
void* mutex)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_UNLOCK,
mutex, mutex_type(mutex), 0, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_UNLOCK,
mutex, 0, 0, 0, 0);
}
// 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);
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;
}
int VG_WRAP_FUNCTION_ZU(VG_Z_LIBC_SONAME, unsetenv) (const char* name)
{
OrigFn fn;
Word result;
const char* p = name;
VALGRIND_GET_ORIG_FN(fn);
if (p)
while (*p++)
__asm__ __volatile__("" ::: "memory");
CALL_FN_W_W(result, fn, name);
return result;
}
static __always_inline int sem_post_intercept(sem_t *sem)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_SEM_POST,
sem, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, sem);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_SEM_POST,
sem, ret == 0, 0, 0, 0);
return ret;
}
int I_WRAP_SONAME_FNNAME_ZU(NONE,fact2) ( int n )
{
int r;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
printf("in wrapper2-pre: fact(%d)\n", n); fflush(stdout);
addMoreLard();
CALL_FN_W_W(r, fn, n);
addMoreLard();
printf("in wrapper2-post: fact(%d) = %d\n", n, r); fflush(stdout);
return r;
}
static __always_inline
int pthread_detach_intercept(pthread_t pt_thread)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
CALL_FN_W_W(ret, fn, pt_thread);
DRD_(set_joinable)(pt_thread, 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);
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_cancel*
PTH_FUNC(int, pthreadZucancelZa, 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;
}
// QMutex::tryLock() -- _ZN6QMutex7tryLockEv
QT4CORE_FUNC(int, _ZN6QMutex7tryLockEv,
void* mutex)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_LOCK,
mutex, mutex_type(mutex), 1, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_LOCK,
mutex, ret, 0, 0, 0);
return ret;
}
static __always_inline
int pthread_cond_broadcast_intercept(pthread_cond_t* cond)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_BROADCAST,
cond, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, cond);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_BROADCAST,
cond, 0, 0, 0, 0);
return ret;
}
static __always_inline
int pthread_cond_destroy_intercept(pthread_cond_t* cond)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_COND_DESTROY,
cond, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, cond);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_COND_DESTROY,
cond, ret==0, 0, 0, 0);
return ret;
}
static __always_inline
int pthread_mutex_unlock_intercept(pthread_mutex_t *mutex)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_UNLOCK,
mutex, DRD_(mutex_type)(mutex), 0, 0, 0);
CALL_FN_W_W(ret, fn, mutex);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_UNLOCK,
mutex, 0, 0, 0, 0);
return ret;
}
static __always_inline
int pthread_cancel_intercept(pthread_t pt_thread)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_THREAD_CANCEL,
pt_thread, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, pt_thread);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_THREAD_CANCEL,
pt_thread, ret==0, 0, 0, 0);
return ret;
}
int I_WRAP_SONAME_FNNAME_ZU(NONE,fact1) ( int n )
{
int r;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
printf("in wrapper1-pre: fact(%d)\n", n);
addMoreLard();
CALL_FN_W_W(r, fn, n);
addMoreLard();
printf("in wrapper1-post: fact(%d) = %d\n", n, r);
if (n >= 3) r += fact2(2);
return r;
}
// QMutex::~QMutex() -- _ZN6QMutexD2Ev
QT4CORE_FUNC(void, _ZN6QMutexD2Ev,
void** 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, mutex_type(mutex), 0, 0, 0);
}
// pthread_mutex_lock
PTH_FUNC(int, pthreadZumutexZulock, // pthread_mutex_lock
pthread_mutex_t *mutex)
{
int ret;
void* fn;
VALGRIND_GET_ORIG_FN(fn);
fprintf(stderr, "<< pthread_mxlock %p", mutex); fflush(stderr);
CALL_FN_W_W(ret, fn, mutex);
fprintf(stderr, " -> %d >>\n", ret);
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;
}
static __always_inline
int pthread_spin_unlock_intercept(pthread_spinlock_t *spinlock)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(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_STMT(VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK,
spinlock, 0, 0, 0, 0);
return ret;
}
static __always_inline
int pthread_spin_destroy_intercept(pthread_spinlock_t *spinlock)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_MUTEX_DESTROY,
spinlock, 0, 0, 0, 0);
CALL_FN_W_W(ret, fn, spinlock);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_MUTEX_DESTROY,
spinlock, mutex_type_spinlock, 0, 0, 0);
return ret;
}
static __always_inline
int pthread_barrier_destroy_intercept(pthread_barrier_t* barrier)
{
int ret;
OrigFn fn;
VALGRIND_GET_ORIG_FN(fn);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__PRE_BARRIER_DESTROY,
barrier, pthread_barrier, 0, 0, 0);
CALL_FN_W_W(ret, fn, barrier);
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__POST_BARRIER_DESTROY,
barrier, pthread_barrier, 0, 0, 0);
return ret;
}
