/** Called before pthread_rwlock_wrlock() is invoked. If a data structure for
* the client-side object was not yet created, do this now. Also check whether
* an attempt is made to lock recursively a synchronization object that must
* not be locked recursively.
*/
void rwlock_pre_wrlock(const Addr rwlock, const SizeT size)
{
struct rwlock_info* p;
p = rwlock_get(rwlock);
if (s_trace_rwlock)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] pre_rwlock_wrlock 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
rwlock);
}
if (p == 0)
{
p = rwlock_get_or_allocate(rwlock, size);
}
tl_assert(p);
if (rwlock_is_wrlocked_by(p, thread_get_running_tid()))
{
RwlockErrInfo REI = { p->a1 };
VG_(maybe_record_error)(VG_(get_running_tid)(),
RwlockErr,
VG_(get_IP)(VG_(get_running_tid)()),
"Recursive writer locking not allowed",
&REI);
}
}
/** Called before pthread_rwlock_rdlock() is invoked. If a data structure for
* the client-side object was not yet created, do this now. Also check whether
* an attempt is made to lock recursively a synchronization object that must
* not be locked recursively.
*/
void rwlock_pre_rdlock(const Addr rwlock, const SizeT size)
{
struct rwlock_info* p;
p = rwlock_get_or_allocate(rwlock, size);
tl_assert(p);
if (s_trace_rwlock)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] pre_rwlock_rdlock 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
rwlock);
}
if (rwlock_is_wrlocked_by(p, thread_get_running_tid()))
{
VG_(message)(Vg_UserMsg,
"reader-writer lock 0x%lx is already locked for"
" writing by calling thread",
p->a1);
}
}
/**
* Update rwlock_info state when locking the pthread_rwlock_t rwlock.
* Note: this function must be called after pthread_rwlock_wrlock() has been
* called, or a race condition is triggered !
*/
void rwlock_post_wrlock(const Addr rwlock, const Bool took_lock)
{
const DrdThreadId drd_tid = thread_get_running_tid();
struct rwlock_info* p;
struct rwlock_thread_info* q;
p = rwlock_get(rwlock);
if (s_trace_rwlock)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] post_rwlock_wrlock 0x%lx",
VG_(get_running_tid)(),
drd_tid,
rwlock);
}
if (! p || ! took_lock)
return;
q = lookup_or_insert_node(p->thread_info, thread_get_running_tid());
tl_assert(q->writer_nesting_count == 0);
q->writer_nesting_count++;
tl_assert(q->writer_nesting_count == 1);
rwlock_combine_other_vc(p, drd_tid);
thread_new_segment(drd_tid);
}
static void drd_trace_mem_access(const Addr addr, const SizeT size,
const BmAccessTypeT access_type)
{
if (drd_is_any_traced(addr, addr + size))
{
char vc[80];
vc_snprint(vc, sizeof(vc), thread_get_vc(thread_get_running_tid()));
VG_(message)(Vg_UserMsg,
"%s 0x%lx size %ld (vg %d / drd %d / vc %s)",
access_type == eLoad
? "load "
: access_type == eStore
? "store"
: access_type == eStart
? "start"
: access_type == eEnd
? "end "
: "????",
addr,
size,
VG_(get_running_tid)(),
thread_get_running_tid(),
vc);
VG_(get_and_pp_StackTrace)(VG_(get_running_tid)(),
VG_(clo_backtrace_size));
tl_assert(DrdThreadIdToVgThreadId(thread_get_running_tid())
== VG_(get_running_tid)());
}
}
/** Called before pthread_mutex_lock() is invoked. If a data structure for
* the client-side object was not yet created, do this now. Also check whether
* an attempt is made to lock recursively a synchronization object that must
* not be locked recursively.
*/
void mutex_pre_lock(const Addr mutex, const SizeT size, MutexT mutex_type)
{
struct mutex_info* p;
p = mutex_get(mutex);
if (s_trace_mutex)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] pre_mutex_lock %s 0x%lx rc %d owner %d",
VG_(get_running_tid)(),
thread_get_running_tid(),
p ? mutex_get_typename(p) : "(?)",
mutex,
p ? p->recursion_count : 0,
p ? p->owner : VG_INVALID_THREADID);
}
if (mutex_type == mutex_type_invalid_mutex)
{
GenericErrInfo GEI;
VG_(maybe_record_error)(VG_(get_running_tid)(),
GenericErr,
VG_(get_IP)(VG_(get_running_tid)()),
"Not a mutex",
&GEI);
return;
}
if (p == 0)
{
p = mutex_init(mutex, size, mutex_type);
}
tl_assert(p);
if (p->owner == thread_get_running_tid()
&& p->recursion_count >= 1
&& mutex_type != mutex_type_recursive_mutex)
{
MutexErrInfo MEI = { p->a1, p->recursion_count, p->owner };
VG_(maybe_record_error)(VG_(get_running_tid)(),
MutexErr,
VG_(get_IP)(VG_(get_running_tid)()),
"Recursive locking not allowed",
&MEI);
}
}
/* Assumption: stacks grow downward. */
static void drd_stop_using_mem_stack(const Addr a, const SizeT len)
{
thread_set_stack_min(thread_get_running_tid(),
a + len - VG_STACK_REDZONE_SZB);
drd_stop_using_mem(a - VG_STACK_REDZONE_SZB, len + VG_STACK_REDZONE_SZB,
True);
}
/** Called after sem_destroy(). */
void semaphore_destroy(const Addr semaphore)
{
struct semaphore_info* p;
if (s_trace_semaphore)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] semaphore_destroy 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
semaphore);
}
p = semaphore_get(semaphore);
if (p == 0)
{
GenericErrInfo GEI;
VG_(maybe_record_error)(VG_(get_running_tid)(),
GenericErr,
VG_(get_IP)(VG_(get_running_tid)()),
"Not a semaphore",
&GEI);
return;
}
clientobj_remove(semaphore, ClientSemaphore);
}
/* Assumption: stacks grow downward. */
static __inline__
void drd_start_using_mem_stack(const Addr a, const SizeT len)
{
thread_set_stack_min(thread_get_running_tid(), a - VG_STACK_REDZONE_SZB);
drd_start_using_mem(a - VG_STACK_REDZONE_SZB,
len + VG_STACK_REDZONE_SZB);
}
/** Call this function whenever a thread is no longer using the memory
* [ a1, a2 [, e.g. because of a call to free() or a stack pointer
* increase.
*/
void thread_stop_using_mem(const Addr a1, const Addr a2)
{
DrdThreadId other_user;
unsigned i;
/* For all threads, mark the range [ a1, a2 [ as no longer in use. */
other_user = DRD_INVALID_THREADID;
for (i = 0; i < sizeof(s_threadinfo) / sizeof(s_threadinfo[0]); i++)
{
Segment* p;
for (p = s_threadinfo[i].first; p; p = p->next)
{
if (other_user == DRD_INVALID_THREADID
&& i != s_drd_running_tid)
{
if (UNLIKELY(bm_test_and_clear(p->bm, a1, a2)))
{
other_user = i;
}
continue;
}
bm_clear(p->bm, a1, a2);
}
}
/* If any other thread had accessed memory in [ a1, a2 [, update the */
/* danger set. */
if (other_user != DRD_INVALID_THREADID
&& bm_has_any_access(s_danger_set, a1, a2))
{
thread_compute_danger_set(&s_danger_set, thread_get_running_tid());
}
}
/** Deallocate the memory that was allocated by rwlock_initialize(). */
static void rwlock_cleanup(struct rwlock_info* p)
{
struct rwlock_thread_info* q;
tl_assert(p);
if (s_trace_rwlock)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] rwlock_destroy 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
p->a1);
}
if (rwlock_is_locked(p))
{
RwlockErrInfo REI = { p->a1 };
VG_(maybe_record_error)(VG_(get_running_tid)(),
RwlockErr,
VG_(get_IP)(VG_(get_running_tid)()),
"Destroying locked rwlock",
&REI);
}
VG_(OSetGen_ResetIter)(p->thread_info);
for ( ; (q = VG_(OSetGen_Next)(p->thread_info)); q++)
{
vc_cleanup(&q->vc);
}
VG_(OSetGen_Destroy)(p->thread_info);
}
/** Called before pthread_rwlock_init(). */
struct rwlock_info*
rwlock_pre_init(const Addr rwlock, const SizeT size)
{
struct rwlock_info* p;
if (s_trace_rwlock)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] rwlock_init %s 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
rwlock);
}
p = rwlock_get(rwlock);
if (p)
{
const ThreadId vg_tid = VG_(get_running_tid)();
RwlockErrInfo REI
= { p->a1 };
VG_(maybe_record_error)(vg_tid,
RwlockErr,
VG_(get_IP)(vg_tid),
"Reader-writer lock reinitialization",
&REI);
return p;
}
p = rwlock_get_or_allocate(rwlock, size);
return p;
}
/** Called before pthread_cond_init(). */
void cond_pre_init(const Addr cond, const SizeT size)
{
struct cond_info* p;
if (s_trace_cond)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] cond_init 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
cond);
}
tl_assert(size > 0);
p = cond_get(cond);
if (p)
{
CondErrInfo cei = { .cond = cond };
VG_(maybe_record_error)(VG_(get_running_tid)(),
CondErr,
VG_(get_IP)(VG_(get_running_tid)()),
"initialized twice",
&cei);
}
p = cond_get_or_allocate(cond, size);
}
static void drd_report_race(const Addr addr, const SizeT size,
const BmAccessTypeT access_type)
{
DataRaceErrInfo drei;
drei.tid = thread_get_running_tid();
drei.addr = addr;
drei.size = size;
drei.access_type = access_type;
VG_(maybe_record_error)(VG_(get_running_tid)(),
DataRaceErr,
VG_(get_IP)(VG_(get_running_tid)()),
"Conflicting accesses",
&drei);
}
VG_REGPARM(2) void drd_trace_store(Addr addr, SizeT size)
{
#ifdef ENABLE_DRD_CONSISTENCY_CHECKS
/* The assert below has been commented out because of performance reasons.*/
tl_assert(thread_get_running_tid()
== VgThreadIdToDrdThreadId(VG_(get_running_tid())));
#endif
if (running_thread_is_recording()
&& (s_drd_check_stack_accesses || ! thread_address_on_stack(addr))
&& bm_access_store_triggers_conflict(addr, addr + size)
&& ! drd_is_suppressed(addr, addr + size))
{
drd_report_race(addr, size, eStore);
}
}
/**
* Update rwlock_info state when unlocking the pthread_rwlock_t rwlock.
* Note: this function must be called before pthread_rwlock_unlock() is called,
* or a race condition is triggered !
* @return New value of the rwlock recursion count.
* @param rwlock Pointer to pthread_rwlock_t data structure in the client space.
* @param tid ThreadId of the thread calling pthread_rwlock_unlock().
* @param vc Pointer to the current vector clock of thread tid.
*/
void rwlock_pre_unlock(const Addr rwlock)
{
const DrdThreadId drd_tid = thread_get_running_tid();
const ThreadId vg_tid = VG_(get_running_tid)();
const VectorClock* const vc = thread_get_vc(drd_tid);
struct rwlock_info* const p = rwlock_get(rwlock);
struct rwlock_thread_info* q;
if (s_trace_rwlock && p != 0)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] rwlock_unlock 0x%lx",
vg_tid,
drd_tid,
rwlock);
}
if (p == 0 || ! rwlock_is_locked_by(p, drd_tid))
{
RwlockErrInfo REI = { p->a1 };
VG_(maybe_record_error)(vg_tid,
RwlockErr,
VG_(get_IP)(vg_tid),
"Reader-writer lock not locked by calling thread",
&REI);
return;
}
tl_assert(p);
q = lookup_or_insert_node(p->thread_info, drd_tid);
tl_assert(q);
if (q->reader_nesting_count > 0)
q->reader_nesting_count--;
else if (q->writer_nesting_count > 0)
q->writer_nesting_count--;
else
tl_assert(False);
if (q->reader_nesting_count == 0 && q->writer_nesting_count == 0)
{
/* This pthread_rwlock_unlock() call really unlocks the rwlock. Save the */
/* current vector clock of the thread such that it is available when */
/* this rwlock is locked again. */
vc_assign(&q->vc, vc);
thread_new_segment(drd_tid);
}
}
/**
* Update mutex_info state when locking the pthread_mutex_t mutex.
* Note: this function must be called after pthread_mutex_lock() has been
* called, or a race condition is triggered !
*/
void mutex_post_lock(const Addr mutex, const Bool took_lock)
{
const DrdThreadId drd_tid = thread_get_running_tid();
struct mutex_info* p;
p = mutex_get(mutex);
if (s_trace_mutex)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] post_mutex_lock %s 0x%lx rc %d owner %d",
VG_(get_running_tid)(),
drd_tid,
p ? mutex_get_typename(p) : "(?)",
mutex,
p ? p->recursion_count : 0,
p ? p->owner : VG_INVALID_THREADID);
}
if (! p || ! took_lock)
return;
if (p->recursion_count == 0)
{
p->owner = drd_tid;
s_mutex_lock_count++;
}
else if (p->owner != drd_tid)
{
VG_(message)(Vg_UserMsg,
"The impossible happened: mutex 0x%lx is locked"
" simultaneously by two threads (recursion count %d,"
" owners %d and %d) !",
p->a1, p->recursion_count, p->owner, drd_tid);
p->owner = drd_tid;
}
p->recursion_count++;
if (p->recursion_count == 1)
{
const DrdThreadId last_owner = p->owner;
if (last_owner != drd_tid && last_owner != DRD_INVALID_THREADID)
thread_combine_vc2(drd_tid, mutex_get_last_vc(mutex));
thread_new_segment(drd_tid);
}
}
/** Called before sem_wait(). */
void semaphore_pre_wait(const Addr semaphore)
{
struct semaphore_info* p;
p = semaphore_get_or_allocate(semaphore);
if (s_trace_semaphore)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] semaphore_pre_wait 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
semaphore);
}
tl_assert(p);
tl_assert(p->waiters >= 0);
p->waiters++;
tl_assert(p->waiters > 0);
}
/** Called before pthread_mutex_init(). */
struct mutex_info*
mutex_init(const Addr mutex, const SizeT size, const MutexT mutex_type)
{
struct mutex_info* p;
if (s_trace_mutex)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] mutex_init %s 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
mutex_type_name(mutex_type),
mutex);
}
if (mutex_type == mutex_type_invalid_mutex)
{
GenericErrInfo GEI;
VG_(maybe_record_error)(VG_(get_running_tid)(),
GenericErr,
VG_(get_IP)(VG_(get_running_tid)()),
"Not a mutex",
&GEI);
return 0;
}
p = mutex_get(mutex);
if (p)
{
const ThreadId vg_tid = VG_(get_running_tid)();
MutexErrInfo MEI
= { p->a1, p->recursion_count, p->owner };
VG_(maybe_record_error)(vg_tid,
MutexErr,
VG_(get_IP)(vg_tid),
"Mutex reinitialization",
&MEI);
return p;
}
p = mutex_get_or_allocate(mutex, size, mutex_type);
return p;
}
/** Called before sem_post(). */
void semaphore_pre_post(const DrdThreadId tid, const Addr semaphore)
{
struct semaphore_info* p;
if (s_trace_semaphore)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] semaphore_post 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
semaphore);
}
p = semaphore_get_or_allocate(semaphore);
p->value++;
if (p->value == 1)
{
p->last_sem_post_tid = tid;
thread_new_segment(tid);
thread_get_latest_segment(&p->last_sem_post_segment, tid);
}
}
/** Called before sem_init(). */
struct semaphore_info* semaphore_init(const Addr semaphore,
const Word pshared, const UWord value)
{
struct semaphore_info* p;
if (s_trace_semaphore)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] semaphore_init 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
semaphore);
}
if (semaphore_get(semaphore))
{
// To do: print an error message that a semaphore is being reinitialized.
}
p = semaphore_get_or_allocate(semaphore);
p->value = value;
return p;
}
/** Called after sem_wait() finished.
* @note Do not rely on the value of 'waited' -- some glibc versions do
* not set it correctly.
*/
void semaphore_post_wait(const DrdThreadId tid, const Addr semaphore,
const Bool waited)
{
struct semaphore_info* p;
p = semaphore_get(semaphore);
if (s_trace_semaphore)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] semaphore_post_wait 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
semaphore);
}
tl_assert(p->waiters > 0);
p->waiters--;
tl_assert(p->waiters >= 0);
tl_assert(p->value >= 0);
if (p->value == 0)
{
SemaphoreErrInfo sei = { semaphore };
VG_(maybe_record_error)(VG_(get_running_tid)(),
SemaphoreErr,
VG_(get_IP)(VG_(get_running_tid)()),
"Invalid semaphore",
&sei);
return;
}
p->value--;
tl_assert(p->value >= 0);
if (p->last_sem_post_tid != tid
&& p->last_sem_post_tid != DRD_INVALID_THREADID)
{
tl_assert(p->last_sem_post_segment);
thread_combine_vc2(tid, &p->last_sem_post_segment->vc);
}
thread_new_segment(tid);
}
/** Deallocate the memory that was allocated by mutex_initialize(). */
static void mutex_cleanup(struct mutex_info* p)
{
if (s_trace_mutex)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] mutex_destroy %s 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
mutex_get_typename(p),
p->a1);
}
if (mutex_is_locked(p))
{
MutexErrInfo MEI = { p->a1, p->recursion_count, p->owner };
VG_(maybe_record_error)(VG_(get_running_tid)(),
MutexErr,
VG_(get_IP)(VG_(get_running_tid)()),
"Destroying locked mutex",
&MEI);
}
vc_cleanup(&p->vc);
}
VG_REGPARM(2) void drd_trace_store(Addr addr, SizeT size)
{
Segment* sg;
#if 0
/* The assert below has been commented out because of performance reasons.*/
tl_assert(thread_get_running_tid()
== VgThreadIdToDrdThreadId(VG_(get_running_tid())));
#endif
if (! running_thread_is_recording())
return;
if (range_any_is_traced(addr, size))
{
drd_trace_mem_access(addr, size, eStore);
}
sg = running_thread_get_segment();
bm_access_range_store(sg->bm, addr, addr + size);
if (bm_store_has_conflict_with(thread_get_danger_set(), addr, addr + size))
{
drd_report_race(addr, size, eStore);
}
}
/** Called after pthread_cond_destroy(). */
void cond_post_destroy(const Addr cond)
{
struct cond_info* p;
if (s_trace_cond)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] cond_destroy 0x%lx",
VG_(get_running_tid)(),
thread_get_running_tid(),
cond);
}
p = cond_get(cond);
if (p == 0)
{
CondErrInfo cei = { .cond = cond };
VG_(maybe_record_error)(VG_(get_running_tid)(),
CondErr,
VG_(get_IP)(VG_(get_running_tid)()),
"not a condition variable",
&cei);
return;
}
/**
* Update mutex_info state when unlocking the pthread_mutex_t mutex.
* Note: this function must be called before pthread_mutex_unlock() is called,
* or a race condition is triggered !
* @return New value of the mutex recursion count.
* @param mutex Pointer to pthread_mutex_t data structure in the client space.
* @param tid ThreadId of the thread calling pthread_mutex_unlock().
* @param vc Pointer to the current vector clock of thread tid.
*/
void mutex_unlock(const Addr mutex, const MutexT mutex_type)
{
const DrdThreadId drd_tid = thread_get_running_tid();
const ThreadId vg_tid = VG_(get_running_tid)();
const VectorClock* const vc = thread_get_vc(drd_tid);
struct mutex_info* const p = mutex_get(mutex);
if (s_trace_mutex)
{
VG_(message)(Vg_UserMsg,
"[%d/%d] mutex_unlock %s 0x%lx rc %d",
vg_tid,
drd_tid,
p ? mutex_get_typename(p) : "?",
mutex,
p ? p->recursion_count : 0,
p ? p->owner : 0);
}
if (p == 0 || mutex_type == mutex_type_invalid_mutex)
{
GenericErrInfo GEI;
VG_(maybe_record_error)(vg_tid,
GenericErr,
VG_(get_IP)(vg_tid),
"Not a mutex",
&GEI);
return;
}
if (p->owner == DRD_INVALID_THREADID)
{
MutexErrInfo MEI = { p->a1, p->recursion_count, p->owner };
VG_(maybe_record_error)(vg_tid,
MutexErr,
VG_(get_IP)(vg_tid),
"Mutex not locked",
&MEI);
return;
}
tl_assert(p);
if (p->mutex_type != mutex_type)
{
VG_(message)(Vg_UserMsg, "??? mutex %p: type changed from %d into %d",
p->a1, p->mutex_type, mutex_type);
}
tl_assert(p->mutex_type == mutex_type);
tl_assert(p->owner != DRD_INVALID_THREADID);
if (p->owner != drd_tid || p->recursion_count <= 0)
{
MutexErrInfo MEI = { p->a1, p->recursion_count, p->owner };
VG_(maybe_record_error)(vg_tid,
MutexErr,
VG_(get_IP)(vg_tid),
"Mutex not locked by calling thread",
&MEI);
return;
}
tl_assert(p->recursion_count > 0);
p->recursion_count--;
tl_assert(p->recursion_count >= 0);
if (p->recursion_count == 0)
{
/* This pthread_mutex_unlock() call really unlocks the mutex. Save the */
/* current vector clock of the thread such that it is available when */
/* this mutex is locked again. */
vc_assign(&p->vc, vc);
thread_new_segment(drd_tid);
}
}
static Bool drd_handle_client_request(ThreadId vg_tid, UWord* arg, UWord* ret)
{
UWord result = 0;
const DrdThreadId drd_tid = thread_get_running_tid();
tl_assert(vg_tid == VG_(get_running_tid()));
tl_assert(VgThreadIdToDrdThreadId(vg_tid) == drd_tid);
switch (arg[0])
{
case VG_USERREQ__DRD_GET_VALGRIND_THREAD_ID:
result = vg_tid;
break;
case VG_USERREQ__DRD_GET_DRD_THREAD_ID:
result = drd_tid;
break;
case VG_USERREQ__DRD_START_SUPPRESSION:
drd_start_suppression(arg[1], arg[1] + arg[2], "client");
break;
case VG_USERREQ__DRD_FINISH_SUPPRESSION:
drd_finish_suppression(arg[1], arg[1] + arg[2]);
break;
case VG_USERREQ__DRD_SUPPRESS_CURRENT_STACK:
{
const Addr topmost_sp = highest_used_stack_address(vg_tid);
#if 0
UInt nframes;
const UInt n_ips = 20;
Addr ips[n_ips], sps[n_ips], fps[n_ips];
Char desc[128];
unsigned i;
nframes = VG_(get_StackTrace)(vg_tid, ips, n_ips, sps, fps, 0);
VG_(message)(Vg_DebugMsg, "thread %d/%d", vg_tid, drd_tid);
for (i = 0; i < nframes; i++)
{
VG_(describe_IP)(ips[i], desc, sizeof(desc));
VG_(message)(Vg_DebugMsg, "[%2d] sp 0x%09lx fp 0x%09lx ip %s",
i, sps[i], fps[i], desc);
}
#endif
thread_set_stack_startup(drd_tid, VG_(get_SP)(vg_tid));
drd_start_suppression(topmost_sp, VG_(thread_get_stack_max)(vg_tid),
"stack top");
break;
}
case VG_USERREQ__DRD_START_NEW_SEGMENT:
thread_new_segment(PtThreadIdToDrdThreadId(arg[1]));
break;
case VG_USERREQ__DRD_START_TRACE_ADDR:
drd_start_tracing_address_range(arg[1], arg[1] + arg[2]);
break;
case VG_USERREQ__DRD_STOP_TRACE_ADDR:
drd_stop_tracing_address_range(arg[1], arg[1] + arg[2]);
break;
case VG_USERREQ__DRD_STOP_RECORDING:
thread_stop_recording(drd_tid);
break;
case VG_USERREQ__DRD_START_RECORDING:
thread_start_recording(drd_tid);
break;
case VG_USERREQ__SET_PTHREADID:
// pthread_self() returns 0 for programs not linked with libpthread.so.
if (arg[1] != INVALID_POSIX_THREADID)
thread_set_pthreadid(drd_tid, arg[1]);
break;
case VG_USERREQ__SET_JOINABLE:
thread_set_joinable(PtThreadIdToDrdThreadId(arg[1]), (Bool)arg[2]);
break;
case VG_USERREQ__POST_THREAD_JOIN:
tl_assert(arg[1]);
drd_post_thread_join(drd_tid,
PtThreadIdToDrdThreadId(arg[1]));
break;
case VG_USERREQ__PRE_THREAD_CANCEL:
tl_assert(arg[1]);
drd_pre_thread_cancel(drd_tid, PtThreadIdToDrdThreadId(arg[1]));
break;
case VG_USERREQ__POST_THREAD_CANCEL:
tl_assert(arg[1]);
drd_post_thread_cancel(drd_tid, PtThreadIdToDrdThreadId(arg[1]), arg[2]);
break;
case VG_USERREQ__PRE_MUTEX_INIT:
if (thread_enter_synchr(drd_tid) == 0)
drd_pre_mutex_init(arg[1], arg[2]);
break;
case VG_USERREQ__POST_MUTEX_INIT:
thread_leave_synchr(drd_tid);
break;
case VG_USERREQ__PRE_MUTEX_DESTROY:
thread_enter_synchr(drd_tid);
break;
case VG_USERREQ__POST_MUTEX_DESTROY:
if (thread_leave_synchr(drd_tid) == 0)
drd_post_mutex_destroy(arg[1], arg[2]);
break;
case VG_USERREQ__PRE_MUTEX_LOCK:
if (thread_enter_synchr(drd_tid) == 0)
drd_pre_mutex_lock(arg[1], arg[2], arg[3]);
break;
case VG_USERREQ__POST_MUTEX_LOCK:
if (thread_leave_synchr(drd_tid) == 0)
drd_post_mutex_lock(arg[1], arg[2]);
break;
case VG_USERREQ__PRE_MUTEX_UNLOCK:
if (thread_enter_synchr(drd_tid) == 0)
drd_pre_mutex_unlock(arg[1], arg[2]);
break;
case VG_USERREQ__POST_MUTEX_UNLOCK:
thread_leave_synchr(drd_tid);
break;
case VG_USERREQ__PRE_SPIN_INIT_OR_UNLOCK:
if (thread_enter_synchr(drd_tid) == 0)
drd_spin_init_or_unlock(arg[1]);
break;
case VG_USERREQ__POST_SPIN_INIT_OR_UNLOCK:
thread_leave_synchr(drd_tid);
break;
case VG_USERREQ__PRE_COND_INIT:
if (thread_enter_synchr(drd_tid) == 0)
drd_pre_cond_init(arg[1]);
break;
case VG_USERREQ__POST_COND_INIT:
thread_leave_synchr(drd_tid);
break;
case VG_USERREQ__PRE_COND_DESTROY:
thread_enter_synchr(drd_tid);
break;
case VG_USERREQ__POST_COND_DESTROY:
if (thread_leave_synchr(drd_tid) == 0)
drd_post_cond_destroy(arg[1]);
break;
case VG_USERREQ__PRE_COND_WAIT:
if (thread_enter_synchr(drd_tid) == 0)
drd_pre_cond_wait(arg[1], arg[2], arg[3]);
break;
case VG_USERREQ__POST_COND_WAIT:
if (thread_leave_synchr(drd_tid) == 0)
drd_post_cond_wait(arg[1], arg[2], arg[3]);
break;
case VG_USERREQ__PRE_COND_SIGNAL:
if (thread_enter_synchr(drd_tid) == 0)
drd_pre_cond_signal(arg[1]);
break;
case VG_USERREQ__POST_COND_SIGNAL:
thread_leave_synchr(drd_tid);
break;
case VG_USERREQ__PRE_COND_BROADCAST:
if (thread_enter_synchr(drd_tid) == 0)
drd_pre_cond_broadcast(arg[1]);
break;
case VG_USERREQ__POST_COND_BROADCAST:
thread_leave_synchr(drd_tid);
break;
case VG_USERREQ__PRE_SEM_INIT:
if (thread_enter_synchr(drd_tid) == 0)
drd_semaphore_init(arg[1], arg[2], arg[3]);
break;
case VG_USERREQ__POST_SEM_INIT:
thread_leave_synchr(drd_tid);
break;
case VG_USERREQ__PRE_SEM_DESTROY:
thread_enter_synchr(drd_tid);
break;
case VG_USERREQ__POST_SEM_DESTROY:
if (thread_leave_synchr(drd_tid) == 0)
drd_semaphore_destroy(arg[1]);
break;
case VG_USERREQ__PRE_SEM_WAIT:
if (thread_enter_synchr(drd_tid) == 0)
drd_semaphore_pre_wait(drd_tid, arg[1]);
break;
case VG_USERREQ__POST_SEM_WAIT:
if (thread_leave_synchr(drd_tid) == 0)
drd_semaphore_post_wait(drd_tid, arg[1], arg[2]);
break;
case VG_USERREQ__PRE_SEM_POST:
if (thread_enter_synchr(drd_tid) == 0)
drd_semaphore_pre_post(drd_tid, arg[1]);
break;
case VG_USERREQ__POST_SEM_POST:
if (thread_leave_synchr(drd_tid) == 0)
drd_semaphore_post_post(drd_tid, arg[1], arg[2]);
break;
case VG_USERREQ__PRE_BARRIER_INIT:
if (thread_enter_synchr(drd_tid) == 0)
drd_barrier_init(arg[1], arg[2], arg[3], arg[4]);
break;
case VG_USERREQ__POST_BARRIER_INIT:
thread_leave_synchr(drd_tid);
break;
case VG_USERREQ__PRE_BARRIER_DESTROY:
thread_enter_synchr(drd_tid);
break;
case VG_USERREQ__POST_BARRIER_DESTROY:
if (thread_leave_synchr(drd_tid) == 0)
drd_barrier_destroy(arg[1], arg[2]);
break;
case VG_USERREQ__PRE_BARRIER_WAIT:
if (thread_enter_synchr(drd_tid) == 0)
drd_barrier_pre_wait(drd_tid, arg[1], arg[2]);
break;
case VG_USERREQ__POST_BARRIER_WAIT:
if (thread_leave_synchr(drd_tid) == 0)
drd_barrier_post_wait(drd_tid, arg[1], arg[2], arg[3]);
break;
case VG_USERREQ__PRE_RWLOCK_INIT:
rwlock_pre_init(arg[1]);
break;
case VG_USERREQ__POST_RWLOCK_DESTROY:
rwlock_post_destroy(arg[1]);
break;
case VG_USERREQ__PRE_RWLOCK_RDLOCK:
if (thread_enter_synchr(drd_tid) == 0)
rwlock_pre_rdlock(arg[1]);
break;
case VG_USERREQ__POST_RWLOCK_RDLOCK:
if (thread_leave_synchr(drd_tid) == 0)
rwlock_post_rdlock(arg[1], arg[2]);
break;
case VG_USERREQ__PRE_RWLOCK_WRLOCK:
if (thread_enter_synchr(drd_tid) == 0)
rwlock_pre_wrlock(arg[1]);
break;
case VG_USERREQ__POST_RWLOCK_WRLOCK:
if (thread_leave_synchr(drd_tid) == 0)
rwlock_post_wrlock(arg[1], arg[2]);
break;
case VG_USERREQ__PRE_RWLOCK_UNLOCK:
if (thread_enter_synchr(drd_tid) == 0)
rwlock_pre_unlock(arg[1]);
break;
case VG_USERREQ__POST_RWLOCK_UNLOCK:
thread_leave_synchr(drd_tid);
break;
default:
VG_(message)(Vg_DebugMsg, "Unrecognized client request 0x%lx 0x%lx",
arg[0], arg[1]);
tl_assert(0);
return False;
}
*ret = result;
return True;
}
static Bool drd_handle_client_request(ThreadId tid, UWord* arg, UWord* ret)
{
UWord result = 0;
switch (arg[0])
{
case VG_USERREQ__GET_THREAD_SELF:
result = tid;
break;
case VG_USERREQ__SET_THREAD_NAME:
thread_set_name_fmt(VgThreadIdToDrdThreadId(VG_(get_running_tid)()),
(char*)arg[1], arg[2]);
break;
case VG_USERREQ__DRD_START_SUPPRESSION:
drd_start_suppression(arg[1], arg[1] + arg[2], "client");
break;
case VG_USERREQ__DRD_FINISH_SUPPRESSION:
drd_finish_suppression(arg[1], arg[1] + arg[2]);
break;
case VG_USERREQ__DRD_SUPPRESS_CURRENT_STACK:
thread_set_stack_startup(thread_get_running_tid(),
VG_(get_SP)(VG_(get_running_tid)()));
break;
case VG_USERREQ__DRD_START_NEW_SEGMENT:
thread_new_segment(PtThreadIdToDrdThreadId(arg[1]));
break;
case VG_USERREQ__DRD_START_RECORDING:
thread_start_recording(PtThreadIdToDrdThreadId(arg[1]));
break;
case VG_USERREQ__DRD_STOP_RECORDING:
thread_stop_recording(PtThreadIdToDrdThreadId(arg[1]));
break;
case VG_USERREQ__SET_PTHREADID:
thread_set_pthreadid(thread_get_running_tid(), arg[1]);
break;
case VG_USERREQ__SET_JOINABLE:
thread_set_joinable(PtThreadIdToDrdThreadId(arg[1]), (Bool)arg[2]);
break;
case VG_USERREQ__POST_THREAD_JOIN:
tl_assert(arg[1]);
drd_post_thread_join(thread_get_running_tid(),
PtThreadIdToDrdThreadId(arg[1]));
break;
case VG_USERREQ__PRE_MUTEX_INIT:
drd_pre_mutex_init(arg[1], arg[2], arg[3]);
break;
case VG_USERREQ__POST_MUTEX_DESTROY:
drd_post_mutex_destroy(arg[1], arg[2]);
break;
case VG_USERREQ__PRE_PTHREAD_MUTEX_LOCK:
drd_pre_mutex_lock(thread_get_running_tid(), arg[1], arg[2], arg[3]);
break;
case VG_USERREQ__POST_PTHREAD_MUTEX_LOCK:
drd_post_mutex_lock(thread_get_running_tid(), arg[1], arg[2], arg[3]);
break;
case VG_USERREQ__PRE_PTHREAD_MUTEX_UNLOCK:
drd_pre_mutex_unlock(thread_get_running_tid(), arg[1], arg[3]);
break;
case VG_USERREQ__SPIN_INIT_OR_UNLOCK:
drd_spin_init_or_unlock(arg[1], arg[2]);
break;
case VG_USERREQ__POST_PTHREAD_COND_INIT:
drd_post_cond_init(arg[1], arg[2]);
break;
case VG_USERREQ__PRE_PTHREAD_COND_DESTROY:
drd_pre_cond_destroy(arg[1]);
break;
case VG_USERREQ__PRE_PTHREAD_COND_WAIT:
drd_pre_cond_wait(arg[1]/*cond*/, arg[2]/*cond_size*/, arg[3]/*mutex*/);
break;
case VG_USERREQ__POST_PTHREAD_COND_WAIT:
drd_post_cond_wait(arg[1]/*cond*/, arg[3]/*mutex*/,
arg[4]/*mutex_size*/);
break;
case VG_USERREQ__PRE_PTHREAD_COND_SIGNAL:
drd_pre_cond_signal(arg[1]);
break;
case VG_USERREQ__PRE_PTHREAD_COND_BROADCAST:
drd_pre_cond_broadcast(arg[1]);
break;
default:
VG_(message)(Vg_DebugMsg, "Unrecognized client request 0x%lx 0x%lx",
arg[0], arg[1]);
tl_assert(0);
return False;
}
*ret = result;
return True;
}
