int
main ()
{
pthread_t sigusr1_thread, sigusr2_thread;
/* Protect against running forever. */
alarm (60);
signal (SIGUSR1, sigusr1_handler);
signal (SIGUSR2, sigusr2_handler);
signal (SIGABRT, sigabrt_handler);
/* Don't let any thread advance past initialization. */
ready = 0;
pthread_mutex_init (&thread_count_mutex, NULL);
pthread_cond_init (&thread_count_condvar, NULL);
#define NR_THREADS 2
pthread_create (&sigusr1_thread, NULL, sigusr1_thread_function, NULL);
pthread_create (&sigusr2_thread, NULL, sigusr2_thread_function, NULL);
wait_all_threads_running (NR_THREADS);
all_threads_running ();
pthread_kill (pthread_self (), SIGABRT);
pthread_join (sigusr1_thread, NULL);
pthread_join (sigusr2_thread, NULL);
all_threads_done ();
return 0;
}
void func1_1()
{
dyntid_t (**DYNINST_pthread_self)(void);
int lockres;
int bigTIMEOUT;
int timeout;
/*pthread_attr_t attr;*/
unsigned int i;
void *RTlib;
/* zero out lock registry: */
for (i = 0; i < TEST1_THREADS; ++i) {
current_locks[i] = 0;
}
#if !defined (os_windows) && !defined(os_irix)
RTlib = dlopen("libdyninstAPI_RT.so.1", RTLD_NOW);
if (!RTlib) {
fprintf(stderr, "%s[%d]: could not open dyninst RT lib: %s\n", __FILE__, __LINE__, dlerror());
exit(1);
}
DYNINSTinit_thelock = (void (*)(dyninst_lock_t *))dlsym(RTlib, "dyninst_init_lock");
DYNINSTlock_thelock = (int (*)(dyninst_lock_t *))dlsym(RTlib, "dyninst_lock");
DYNINSTunlock_thelock = (void (*)(dyninst_lock_t *))dlsym(RTlib, "dyninst_unlock");
DYNINST_pthread_self = (dyntid_t (**)(void))dlsym(RTlib, "DYNINST_pthread_self");
if (!DYNINSTinit_thelock) {
fprintf(stderr, "%s[%d]: could not DYNINSTinit_thelock: %s\n", __FILE__, __LINE__, dlerror());
exit(1);
}
if (!DYNINSTlock_thelock) {
fprintf(stderr, "%s[%d]: could not DYNINSTlock_thelock: %s\n", __FILE__, __LINE__, dlerror());
exit(1);
}
if (!DYNINSTunlock_thelock) {
fprintf(stderr, "%s[%d]: could not DYNINSTunlock_thelock:%s\n", __FILE__, __LINE__, dlerror());
exit(1);
}
pthread_mutex_init(&real_lock, NULL);
(*DYNINSTunlock_thelock)(&test1lock);
#if !defined(os_solaris)
/* XXX this is nasty */
/* The way this is supposed to work is that we get a lock, then start a bunch of
threads, which all try to get the same lock, pretty much as soon as they start.
Then, after starting all the threads, we release the lock and let the threads
compete for it, checking to make sure that all threads get the lock at some point
and that no two threads have it at the same time.
The problem is that solaris is having problems with this system when the lock is
obtained before the threads are spawned (pthread_create hangs) -- it is still ok
to just start all the threads and have the system run, its just not quite as clean.
This might be bad asm programming on my behalf, or it might be some idiosyncracy
with solaris libpthreads. This worked, incidentally, when this stuff was all in
the mutator, but that might've been because the asm that was imported to implement
the locks was the gnu asm, not the solaris-cc asm, which is the stuff that gets
compiled, by default into the runtime lib*/
/*
int lockres = (*DYNINSTlock_thelock)(&test1lock);
*/
#endif
lockres = (*DYNINSTlock_thelock)(&test1lock);
createThreads(TEST1_THREADS, thread_main1, test1threads);
assert(test1threads);
sleep_ms(5);
dprintf("%s[%d]: doing initial unlock...\n", __FILE__, __LINE__);
#if !defined(os_solaris)
/* (*DYNINSTunlock_thelock)(&test1lock); */
#endif
(*DYNINSTunlock_thelock)(&test1lock);
/*pthread_mutex_unlock(&real_lock); */
#endif
bigTIMEOUT = 5000;
timeout = 0;
/* wait for all threads to exit */
while (timeout < bigTIMEOUT && ! all_threads_done()) {
timeout += 100;
sleep_ms(100);
}
dlclose(RTlib);
exit(subtest1err);
}
