int main(void)
{
parent_ready = create_cond_var();
int i;
thread_t threads[NUM_PARENT_THREADS];
for (i = 0; i < NUM_PARENT_THREADS; ++i)
threads[i] = create_thread(parent_func, NULL);
/* We setup and start at once to avoid process memory changing much between
* the two.
*/
dr_app_setup_and_start();
wait_cond_var(parent_ready);
thread_sleep(50);
dr_app_stop_and_cleanup();
parent_exit = true;
for (i = 0; i < NUM_PARENT_THREADS; ++i)
join_thread(threads[i]);
destroy_cond_var(parent_ready);
print("all done\n");
return 0;
}
int
main(int argc, const char *argv[])
{
intercept_signal(SIGSEGV, signal_handler, true/*sigstack*/);
print("pre-DR init\n");
dr_app_setup();
assert(!dr_app_running_under_dynamorio());
dr_app_start();
assert(dr_app_running_under_dynamorio());
if (do_some_work() < 0)
print("error in computation\n");
print("pre-DR stop\n");
dr_app_stop_and_cleanup();
assert(!dr_app_running_under_dynamorio());
print("all done\n");
return 0;
}
int
main(int argc, const char *argv[])
{
static int outer_iters = 2048;
/* We trace a 4-iter burst of execution. */
static int iter_start = outer_iters/3;
static int iter_stop = iter_start + 4;
if (!my_setenv("DYNAMORIO_OPTIONS", "-stderr_mask 0xc -client_lib ';;-offline'"))
std::cerr << "failed to set env var!\n";
/* We use an outer loop to test re-attaching (i#2157). */
for (int j = 0; j < 3; ++j) {
std::cerr << "pre-DR init\n";
dr_app_setup();
assert(!dr_app_running_under_dynamorio());
for (int i = 0; i < outer_iters; ++i) {
if (i == iter_start) {
std::cerr << "pre-DR start\n";
dr_app_start();
}
if (i >= iter_start && i <= iter_stop)
assert(dr_app_running_under_dynamorio());
else
assert(!dr_app_running_under_dynamorio());
if (do_some_work(i) < 0)
std::cerr << "error in computation\n";
if (i == iter_stop) {
std::cerr << "pre-DR detach\n";
dr_app_stop_and_cleanup();
}
}
std::cerr << "all done\n";
}
return 0;
}
unsigned int __stdcall
#else
void *
#endif
thread_func(void *arg)
{
unsigned int idx = (unsigned int)(uintptr_t)arg;
static const int reattach_iters = 4;
static const int outer_iters = 2048;
/* We trace a 4-iter burst of execution. */
static const int iter_start = outer_iters / 3;
static const int iter_stop = iter_start + 4;
#ifdef UNIX
/* We test sigaltstack with attach+detach to avoid bugs like i#3116 */
stack_t sigstack;
# define ALT_STACK_SIZE (SIGSTKSZ * 2)
sigstack.ss_sp = (char *)malloc(ALT_STACK_SIZE);
sigstack.ss_size = ALT_STACK_SIZE;
sigstack.ss_flags = SS_ONSTACK;
int res = sigaltstack(&sigstack, NULL);
assert(res == 0);
#endif
/* We use an outer loop to test re-attaching (i#2157). */
for (int j = 0; j < reattach_iters; ++j) {
if (idx == burst_owner) {
std::cerr << "pre-DR init\n";
dr_app_setup();
assert(!dr_app_running_under_dynamorio());
}
for (int i = 0; i < outer_iters; ++i) {
if (idx == burst_owner && i == iter_start) {
std::cerr << "pre-DR start\n";
dr_app_start();
}
if (idx == burst_owner) {
if (i >= iter_start && i <= iter_stop)
assert(dr_app_running_under_dynamorio());
else
assert(!dr_app_running_under_dynamorio());
}
if (do_some_work(i) < 0)
std::cerr << "error in computation\n";
if (idx == burst_owner && i == iter_stop) {
std::cerr << "pre-DR detach\n";
dr_app_stop_and_cleanup();
}
}
}
#ifdef UNIX
stack_t check_stack;
res = sigaltstack(NULL, &check_stack);
assert(res == 0 && check_stack.ss_sp == sigstack.ss_sp &&
check_stack.ss_size == sigstack.ss_size);
sigstack.ss_flags = SS_DISABLE;
res = sigaltstack(&sigstack, NULL);
assert(res == 0);
free(sigstack.ss_sp);
#endif
if (idx == burst_owner) {
signal_cond_var(burst_owner_finished);
} else {
/* Avoid having < 1 thread per core in the output. */
wait_cond_var(burst_owner_finished);
}
finished[idx] = true;
return 0;
}
