int
#if INIT_BEFORE_LIBC
_init(int argc, char *arg0, ...)
{
char **argv = &arg0, **envp = &argv[argc + 1];
#else
_init ()
{
#endif
int init;
const char *name;
#if VERBOSE_INIT_FINI
fprintf (stderr, "preload initialized\n");
#endif /* VERBOSE_INIT_FINI */
#ifdef VMX86_SERVER
vmk_init_lib();
#endif
#if INIT_BEFORE_LIBC
{
int i;
for (i=0; i<argc; i++)
fprintf(stderr, "\targ %d = %s\n", i, argv[i]);
fprintf(stderr, "env 0 is %s\n", envp[0]);
fprintf(stderr, "env 1 is %s\n", envp[1]);
fprintf(stderr, "env 2 is %s\n", envp[2]);
}
#endif
#if START_DYNAMO
pf("ready to start dynamo\n");
name = get_application_short_name();
pf("preload _init: running %s\n", name);
if (!take_over(name))
return 0;
/* FIXME i#287/PR 546544: now load DYNAMORIO_AUTOINJECT DR .so
* and only LD_PRELOAD the preload lib itself
*/
init = dynamorio_app_init();
pf("dynamorio_app_init() returned %d\n", init);
dynamorio_app_take_over();
pf("dynamo started\n");
#endif /* START_DYNAMO */
return 0;
}
int
_fini ()
{
#if VERBOSE_INIT_FINI
fprintf (stderr, "preload finalized\n");
#endif /* VERBOSE_INIT_FINI */
/* since we're using dynamorio_app_take_over we do not need to call dr_app_stop
* or dynamorio_app_exit
*/
return 0;
}
/* auto_setup: called by dynamo_auto_start for non-early follow children.
* This routine itself would be dynamo_auto_start except that we want
* our own go-native path separate from load_dynamo (we could still have
* this by dynamo_auto_start and jump to an asm routine for go-native,
* but keeping the entry in asm is more flexible).
* Assumptions: The saved priv_mcontext_t for the start of the app is on
* the stack, followed by a pointer to a region of memory to free
* (which can be NULL) and its size. If we decide not to take over
* this process, this routine returns; otherwise it does not return.
*/
void
auto_setup(ptr_uint_t appstack)
{
dcontext_t *dcontext;
priv_mcontext_t *mcontext;
byte *pappstack;
byte *addr;
pappstack = (byte *)appstack;
/* Our parameter points at a priv_mcontext_t struct, beyond which are
* two other fields:
pappstack --> +0 priv_mcontext_t struct
+x addr of memory to free (can be NULL)
+y sizeof memory to free
*/
automatic_startup = true;
/* we should control all threads */
control_all_threads = true;
dynamorio_app_init();
if (INTERNAL_OPTION(nullcalls)) {
dynamorio_app_exit();
return;
}
/* For apps injected using follow_children, this is where control should be
* allowed to go native for hotp_only & thin_client.
*/
if (RUNNING_WITHOUT_CODE_CACHE())
return;
/* useful to debug fork-following */
DOLOG(4, LOG_TOP, { SYSLOG_INTERNAL_INFO("dynamo auto start"); });
int
main()
{
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
INIT();
print("initapc main()\n");
import_me(37);
/* ensure still checking ret-after-call after stack bottom issues w/ APC
* use a nop between push and ret to avoid VB push/ret pattern match
*/
__asm {
push offset next_instr
nop
ret
next_instr:
nop
}
print("*** invalid ret allowed!\n");
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int
main(int argc, char *argv[])
{
int i;
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
INIT();
/* set up SEH */
__asm {
push eax
mov eax, offset vcex
mov dword ptr fs:[0], eax
pop eax
}
print("ret-SEH test starting\n");
for (i=0; i<NUM_SCOPE_ENTRIES; i++) {
/* levels start at -1 */
ret_SEH(i-1);
}
print("ret-SEH test stopping\n");
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int main()
{
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
sleeptime.tv_sec = 0;
sleeptime.tv_nsec = 10*1000*1000; /* 10ms */
child_exit = false;
child_done = false;
child = create_thread(run, NULL, &stack);
assert(child > -1);
/* waste some time */
nanosleep(&sleeptime, NULL);
child_exit = true;
/* we want deterministic printf ordering */
while (!child_done)
nanosleep(&sleeptime, NULL);
delete_thread(child, stack);
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
}
int
main()
{
/* get aligned test buffers */
char buffer_stack[BUFFER_SIZE];
char *buf = page_align(buffer);
char *buf_stack = page_align(buffer_stack);
INIT();
#if USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
print("starting up\n");
do_test(buf, 2*PAGE_SIZE);
print("starting stack tests\n");
do_test(buf_stack, 2*PAGE_SIZE);
print("starting overlap tests\n");
test_alloc_overlap();
print("about to exit\n");
#if USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
}
int main(int argc, char *argv[])
{
double res = 0.;
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
#ifdef LINUX
intercept_signal(SIGSEGV, signal_handler);
#else
SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER) our_top_handler);
#endif
print("Segfault about to happen\n");
*((volatile int *)0) = 4;
print("SHOULD NEVER GET HERE\n");
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int
main()
{
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
INIT();
print("calling via IAT-style call\n");
import_me1(57);
print("calling in a thread\n");
join_thread(create_thread((fptr)import_me1));
print("calling in a thread that dies\n");
join_thread(create_thread((fptr)import_me_die));
print("case 5455 regression passed\n");
print("all done\n");
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int
main()
{
INIT();
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
/* make foo code writable */
protect_mem(code_self_mod, 1024, ALLOW_READ|ALLOW_WRITE|ALLOW_EXEC);
// Note that main and the exception handler __except_handler3 are on this page too
foo(0xabcd);
foo(0x1234);
foo(0xef01);
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int main(int argc, char *argv[])
{
pid_t child;
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
if (argc < 2) {
print("ERROR: not enough args\n");
return -1;
}
if (find_dynamo_library())
print("parent is running under DynamoRIO\n");
else
print("parent is running natively\n");
child = fork();
if (child < 0) {
perror("ERROR on fork");
} else if (child > 0) {
pid_t result;
result = waitpid(child, NULL, 0);
assert(result == child);
print("child has exited\n");
} else {
int result;
char *arg[3];
#if NULL_ENV
char **env = NULL;
#else
char *env0 = "LD_LIBRARY_PATH=/bin:.";
char *env[2];
env[0] = env0;
env[1] = NULL;
#endif
arg[0] = argv[1];
arg[1] = "/fake/path/it_worked";
arg[2] = NULL;
if (find_dynamo_library())
print("child is running under DynamoRIO\n");
else
print("child is running natively\n");
result = execve("/bin/bogus_will_fail", arg, env);
result = execve(argv[1], arg, env);
if (result < 0)
perror("ERROR in execve");
}
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
}
int
main(int argc, char **argv)
{
pthread_t thread0, thread1;
void * retval;
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
#if 0
/* Get the number of intervals */
if (argc != 2) {
fprintf(stderr, "Usage: %s <intervals>\n", argv[0]);
exit(0);
}
intervals = atoi(argv[1]);
#else /* for batch mode */
intervals = 10;
#endif
/* Initialize the lock on pi */
pthread_mutex_init(&pi_lock, NULL);
/* Make the two threads */
if (pthread_create(&thread0, NULL, process, "0") ||
pthread_create(&thread1, NULL, process, "1")) {
fprintf(stderr, "%s: cannot make thread\n", argv[0]);
exit(1);
}
/* Join (collapse) the two threads */
if (pthread_join(thread0, &retval) ||
pthread_join(thread1, &retval)) {
fprintf(stderr, "%s: thread join failed\n", argv[0]);
exit(1);
}
/* Print the result */
printf("Estimation of pi is %16.15f\n", pi);
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
}
int main()
{
ptr_int_t myaddr;
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
/* make sure dynamorio can handle this non-call */
myaddr = get_retaddr();
#if VERBOSE
print("my address is something like "PFX"\n", myaddr);
#endif
call_with_retaddr((void*)foo);
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int main()
{
int i;
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
sleeptime.tv_sec = 0;
sleeptime.tv_nsec = 10*1000*1000; /* 10ms */
/* parent remains in own group. creates child who creates a thread group
* and then exits them all
*/
for (i = 0; i < NUM_THREADS; i++) {
child_started[i] = false;
child_exit[i] = false;
}
child[0] = create_thread(run, (void *)(long)0, &stack[0], false);
assert(child[0] > -1);
/* wait for child to start rest of threads */
for (i = 0; i < NUM_THREADS; i++) {
while (!child_started[i]) {
/* waste some time: FIXME: should use futex */
nanosleep(&sleeptime, NULL);
}
}
child_exit[0] = true;
while (!child_done[0])
nanosleep(&sleeptime, NULL);
delete_thread(child[0], stack[0]);
for (i = 1; i < NUM_THREADS; i++)
stack_free(stack[i], THREAD_STACK_SIZE);
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
}
int
main()
{
void *p;
BOOL res;
int size = 0x04000;
#if USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
p = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE);
assert(p);
res = VirtualFree(p, 0, MEM_RELEASE);
assert(res);
printf("Successful\n");
#if USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
}
int main()
{
int i;
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
sleeptime.tv_sec = 0;
sleeptime.tv_nsec = 10*1000*1000; /* 10ms */
for (i = 0; i < NUM_THREADS; i++) {
child_started[i] = false;
child_exit[i] = false;
child[i] = create_thread(run, (void *)(long)i, &stack[i]);
assert(child[i] > -1);
}
for (i = 0; i < NUM_THREADS; i++) {
while (!child_started[i]) {
/* waste some time: FIXME: should use futex */
nanosleep(&sleeptime, NULL);
}
}
/* we have the 1st child exit the whole group to test DR's synchall-at-exit */
child_exit[0] = true;
/* parent doesn't exit on its own */
while (true)
nanosleep(&sleeptime, NULL);
fprintf(stderr, "Should never get here\n");
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
}
int
main()
{
unsigned int tid;
HANDLE hThread;
int res;
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
printf("Before _beginthreadex\n");
fflush(stdout);
hThread = (HANDLE) _beginthreadex(NULL, 0, run_func, NULL, 0, &tid);
while (synch_2) {
SwitchToThread();
}
res = QueueUserAPC(apc_func, hThread, 37);
printf("QueueUserAPC returned %d\n", res);
fflush(stdout);
synch_1 = FALSE;
WaitForSingleObject((HANDLE)hThread, INFINITE);
printf("After _beginthreadex\n");
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int main(int argc, char *argv[])
{
double res = 0.;
int i;
#ifndef X64
int j;
#endif
char *buf;
#ifdef LINUX
stack_t sigstack;
#endif
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
#ifdef LINUX
/* our modrm16 tests clobber esp so we need an alternate stack */
sigstack.ss_sp = (char *) malloc(ALT_STACK_SIZE);
sigstack.ss_size = ALT_STACK_SIZE;
sigstack.ss_flags = SS_ONSTACK;
i = sigaltstack(&sigstack, NULL);
assert(i == 0);
intercept_signal(SIGILL, signal_handler);
intercept_signal(SIGSEGV, signal_handler);
#else
SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER) our_top_handler);
#endif
buf = allocate_mem(7*256+1, ALLOW_READ|ALLOW_WRITE|ALLOW_EXEC);
assert(buf != NULL);
#ifndef X64
print("Jumping to a sequence of every addr16 modrm byte\n");
for (j=0; j<256; j++) {
int mod = ((j >> 6) & 0x3); /* top 2 bits */
int reg = ((j >> 3) & 0x7); /* middle 3 bits */
int rm = (j & 0x7); /* bottom 3 bits */
# if defined(LINUX) || defined(X64)
buf[j*7 + 0] = 0x65; /* gs: */
# else
buf[j*7 + 0] = 0x64; /* fs: */
# endif
buf[j*7 + 1] = 0x67; /* addr16 */
buf[j*7 + 2] = 0x8b; /* load */
# ifdef WINDOWS
/* Windows can't handle stack pointer being off */
if (reg == 4) { /* xsp */
buf[j*7 + 3] = j | 0x8;
} else
buf[j*7 + 3] = j; /* nearly every single modrm byte */
# else
buf[j*7 + 3] = j; /* every single modrm byte */
# endif
if (mod == 1) {
buf[j*7 + 4] = 0x03; /* disp */
buf[j*7 + 5] = 0xc3;
} else if (mod == 2 || (mod == 0 && rm == 6)) {
buf[j*7 + 4] = 0x03; /* disp */
buf[j*7 + 5] = 0x00; /* disp */
} else {
buf[j*7 + 4] = 0xc3; /* ret */
buf[j*7 + 5] = 0xc3;
}
buf[j*7 + 6] = 0xc3;
}
buf[256*7] = 0xcc;
print_access_vio = false;
for (j=0; j<256; j++) {
i = setjmp(mark);
if (i == 0)
test_modrm16(&buf[j*7]);
else
continue;
}
print("Done with modrm test: tested %d\n", j);
count = 0;
print_access_vio = true;
#endif /* !X64 */
/* multi-byte nop tests (case 9862) */
i = setjmp(mark);
if (i == 0) {
print("Testing nops\n");
test_nops();
print("Done with nops\n");
}
/* SSE3 and 3DNow instrs will not run on all processors so we can't have this
* regression test fully test everything: for now its main use is running
* manually on the proper machines, or manually verifying decoding of these,
* but we'll leave as a suite/ regression test.
*/
/* SSE3 tests: mostly w/ modrm of (%edx) */
i = setjmp(mark);
if (i == 0) {
print("Testing SSE3\n");
test_sse3(buf);
print("Should not get here\n");
}
/* 3D-Now tests: mostly w/ modrm of (%ebx) */
i = setjmp(mark);
if (i == 0) {
print("Testing 3D-Now\n");
test_3dnow(buf);
print("Should not get here\n");
}
/* case 6962: far call/jmp tests
* Note that DR currently gets the target address wrong for all of these
* since we skip the segment and only care about the address:
* not going to fix that anytime soon.
*/
print("Testing far call/jmp\n");
test_far_cti();
/* PR 242815: data16 mbr */
print("Testing data16 mbr\n");
test_data16_mbr();
#ifdef LINUX
free(sigstack.ss_sp);
#endif
print("All done\n");
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int
main()
{
uint i;
uint writes = 0;
byte *DR_base;
INIT();
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
#ifdef UNIX
intercept_signal(SIGSEGV, (handler_3_t) signal_handler, false);
#else
SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER) our_top_handler);
#endif
where = setjmp(mark);
if (where == 0) {
DR_base = get_DR_base();
#if VERBOSE
print("DR base is "PFX"\n", DR_base);
#endif
for (i=0; i<DATASEC_NUM; i++) {
byte *start, *end, *pc;
bool found = get_named_section_bounds(DR_base,
/*FIXME use drmarker to find*/
datasec_names[i], &start, &end);
assert(found);
#if VERBOSE
print("data section %s: "PFX"-"PFX"\n", datasec_names[i], start, end);
#endif
print("about to write to every page in %s\n", datasec_names[i]);
for (pc = start; pc < end; pc += PAGE_SIZE) {
/* try to write to every single page */
where = setjmp(mark);
if (where == 0) {
uint old = *((uint *)pc);
*((uint *)pc) = 0x0badbad0;
/* restore in same bb so we don't crash DR */
*((uint *)pc) = old;
/* if the section is protected we shouldn't get here */
writes++;
#if VERBOSE
print("successfully wrote to "PFX" in %s!\n",
pc, datasec_names[i]);
#endif
}
}
#if VERBOSE
print("successfully wrote to %d pages!\n", writes);
#endif
if (writes > 0)
print("successfully wrote to %s\n", datasec_names[i]);
}
} else {
print("no DR or no data sections found: are you running natively?\n");
}
print("all done\n");
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
}
static int
main(int argc, char **argv)
{
STARTUPINFO si = { sizeof(STARTUPINFO) };
PROCESS_INFORMATION pi;
char cmdline[128];
DWORD result = 0;
INIT();
USE_USER32(); /* can't be in runall otherwise! */
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
if (argc == 1) {
/* normal execution */
_snprintf(cmdline, sizeof(cmdline), "%s %d", argv[0], depth);
print("starting chain %d...\n", depth);
}
if (argc == 2) {
depth = atoi(argv[1]);
print("subprocess %d running.\n", depth);
_snprintf(cmdline, sizeof(cmdline), "%s %d", argv[0], depth-1);
}
if (depth != 0) {
if (!CreateProcess(argv[0],
cmdline,
NULL,
NULL,
FALSE,
0,
NULL,
NULL,
&si,
&pi))
print("CreateProcess failure\n");
else {
DWORD exit_code = 0;
print("waiting for child\n");
WaitForSingleObject(pi.hProcess, INFINITE);
if (!GetExitCodeProcess(pi.hProcess, &exit_code)) {
print("GetExitCodeProcess failure %d\n", GetLastError());
} else {
print("process returned %d\n", exit_code);
}
}
}
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return depth * 10;
/* make sure not 259 STILL_ACTIVE which may be returned by GetExitCodeProcess() */
}
int main(int argc, char *argv[])
{
double res = 0.;
int i;
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
#ifdef LINUX
intercept_signal(SIGILL, signal_handler);
intercept_signal(SIGSEGV, signal_handler);
#else
# ifdef X64_DEBUGGER
/* FIXME: the vectored handler works fine in the debugger, but natively
* the app crashes here: yet the SetUnhandled hits infinite fault loops
* in the debugger, and works fine natively!
*/
AddVectoredExceptionHandler(1/*first*/,
(PVECTORED_EXCEPTION_HANDLER) our_top_handler);
# else
SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER) our_top_handler);
# endif
#endif
/* privileged instructions */
print("Privileged instructions about to happen\n");
count = 0;
i = setjmp(mark);
switch (i) {
case 0: test_priv_0();
case 1: test_priv_1();
case 2: test_priv_2();
case 3: test_priv_3();
}
/* prefix tests */
print("OK instr about to happen\n");
/* multiple prefixes */
/* FIXME: actually these prefixes on a jmp are "reserved" but this seems to work */
test_prefix_0();
print("Bad instr about to happen\n");
/* lock prefix, which is illegal instruction if placed on jmp */
count = 0;
invalid_lock = true;
if (setjmp(mark) == 0) {
test_prefix_1();
}
invalid_lock = false;
print("Invalid instructions about to happen\n");
count = 0;
i = setjmp(mark);
switch (i) {
/* note that we decode until a CTI, so for every case the suffix is decoded
* and changes in later cases may fail even the earlier ones.
*/
case 0: test_inval_0();
case 1: test_inval_1();
case 2: test_inval_2();
case 3: test_inval_3();
case 4: test_inval_4();
case 5: test_inval_5();
case 6: test_inval_6();
case 7: test_inval_7();
default: ;
}
print("All done\n");
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int main(int argc, char *argv[])
{
double res = 0.;
int i, j;
#if defined(USE_DYNAMO) || USE_TIMER || USE_SIGSTACK
int rc;
#endif
#if USE_SIGSTACK
stack_t sigstack;
#endif
#if USE_TIMER
struct itimerval t;
#endif
#ifdef USE_DYNAMO
rc = dynamorio_app_init();
ASSERT_NOERR(rc);
dynamorio_app_start();
#endif
#if USE_TIMER
intercept_signal(SIGVTALRM, (handler_t) signal_handler);
t.it_interval.tv_sec = 0;
t.it_interval.tv_usec = 10000;
t.it_value.tv_sec = 0;
t.it_value.tv_usec = 10000;
rc = setitimer(ITIMER_VIRTUAL, &t, NULL);
ASSERT_NOERR(rc);
#endif
#if USE_SIGSTACK
sigstack.ss_sp = (char *) malloc(ALT_STACK_SIZE);
sigstack.ss_size = ALT_STACK_SIZE;
sigstack.ss_flags = SS_ONSTACK;
rc = sigaltstack(&sigstack, NULL);
ASSERT_NOERR(rc);
# if VERBOSE
fprintf(stderr, "Set up sigstack: 0x%08x - 0x%08x\n",
sigstack.ss_sp, sigstack.ss_sp + sigstack.ss_size);
# endif
#endif
intercept_signal(SIGSEGV, (handler_t) signal_handler);
intercept_signal(SIGUSR1, (handler_t) signal_handler);
intercept_signal(SIGUSR2, (handler_t) SIG_IGN);
res = cos(0.56);
fprintf(stderr, "Sending SIGUSR2\n");
kill(getpid(), SIGUSR2);
fprintf(stderr, "Sending SIGUSR1\n");
kill(getpid(), SIGUSR1);
#if USE_SIGSTACK
/* now remove alt stack */
free(sigstack.ss_sp);
sigstack.ss_sp = 0;
sigstack.ss_size = 0;
sigstack.ss_flags = SS_DISABLE;
rc = sigaltstack(&sigstack, NULL);
ASSERT_NOERR(rc);
#endif
fprintf(stderr, "Generating SIGSEGV\n");
#if USE_LONGJMP
res = setjmp(env);
if (res == 0) {
*((int *)0) = 4;
}
#else
kill(getpid(), SIGSEGV);
#endif
for (i=0; i<ITERS; i++) {
if (i % 2 == 0) {
res += cos(1./(double)(i+1));
} else {
res += sin(1./(double)(i+1));
}
j = (i << 4) / (i | 0x38);
a[i] += j;
}
fprintf(stderr, "%f\n", res);
#if USE_TIMER
memset(&t, 0, sizeof(t));
rc = setitimer(ITIMER_VIRTUAL, &t, NULL);
ASSERT_NOERR(rc);
if (timer_hits == 0)
fprintf(stderr, "Got 0 timer hits!\n");
else
fprintf(stderr, "Got some timer hits!\n");
#endif
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int
main()
{
int round;
int t;
GET_NTDLL(NtTerminateProcess, (IN HANDLE ProcessHandle OPTIONAL,
IN NTSTATUS ExitStatus));
INIT();
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
for (round = 0; round < ROUNDS; round++) {
#ifdef VERBOSE
print("round %d\n", round);
#endif
if (round > 0) {
/* clean up first */
NtTerminateProcess(0 /* everyone but me */, 666);
#ifdef VERBOSE
print("all alone again %d\n", round);
#endif VERBOSE
}
global_started = 0;
global_finished = 0;
for (t = 0; t < TOTAL_THREADS; t++) {
thread[t] = (HANDLE)create_thread(executor);
if (thread[t] == NULL)
print("GLE: %d\n", GetLastError());
assert(thread[t] != NULL);
}
#ifdef VERBOSE
print("started %d threads\n", TOTAL_THREADS);
#else
print("started some threads\n");
#endif
/* wait for some to start */
while (global_started < WAIT_TO_START)
YIELD();
/* wait for some work to get done */
while (global_finished < WAIT_TO_FINISH)
YIELD();
#ifdef VERBOSE
print("some %d work, done %d\n", global_started, global_finished);
#endif
}
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
print("done\n");
return 0;
}
int main(int argc, char** argv)
{
HANDLE lib;
HANDLE event;
ULONG_PTR hThread;
int reloaded = 0;
USE_USER32();
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
#ifdef LINUX
/* though win32/ */
intercept_signal(SIGSEGV, signal_handler);
#else
/* note that can't normally if we have a debugger attached this
* will not get this executed */
SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER) our_top_handler);
#endif
event = CreateEvent(NULL, TRUE, FALSE, NULL);
hThread = _beginthreadex(NULL, 0, run_func, event, 0, NULL);
/* need to run as long as necessary to hit the required faults */
while (transitions < NUM_TRANSITIONS) {
lib = LoadLibrary("win32.reload-race.dll.dll");
if (lib == NULL) {
print("error loading library\n");
break;
} else {
reloaded++;
#if VERBOSE
print("reloaded %d times %d\n", reloaded);
#endif
import1 = (funptr)
GetProcAddress(lib, (LPCSTR)"import_me1");
import2 = (funptr)
GetProcAddress(lib, (LPCSTR)"import_me2");
/* may want to explicitly sleep here but that may be slower */
if (reloaded % 2 == 0)
YIELD();
FreeLibrary(lib);
if (reloaded % 3 == 0)
YIELD();
}
}
SetEvent(event);
WaitForSingleObject((HANDLE)hThread, INFINITE);
print("main loop done\n");
check_mem_usage();
#if VERBOSE
print("reloaded %d times %d\n", reloaded);
#endif
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
return 0;
}
int
main()
{
int round;
int b, t;
int res;
INIT();
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
/* this doesn't do much in fact */
res = SetProcessWorkingSetSize(GetCurrentProcess(),
MINSIZE_KB*1024,
MAXSIZE_KB*1024);
// on Win2003 there is a SetProcessWorkingSetSizeEx that sets QUOTA_LIMITS_HARDWS_ENABLE
if (res == 0)
print("SetProcessWorkingSetSize failed GLE: %d\n", GetLastError());
for (round = 0; round < ROUNDS; round++) {
#ifdef VERBOSE
print("round %d\n", round);
#endif
global_started = 0;
global_finished = 0;
/* do in a batch */
for (b = 0; b < TOTAL_THREADS / BATCH_SIZE; b++) {
for (t = 0; t < BATCH_SIZE; t++) {
thread[t] = create_thread(executor);
if (thread[t] == NULL)
print("GLE: %d\n", GetLastError());
assert(thread[t] != NULL);
}
/* now synchronize with all of them - or maybe some? */
#ifdef VERBOSE
print("started %d threads\n", TOTAL_THREADS);
#else
#ifndef SILENT
print("started some threads\n");
#endif
#endif
for (t = 0; t < BATCH_SIZE; t++) {
assert(thread[t] != NULL);
join_thread(thread[t]);
CloseHandle((HANDLE)thread[t]);
thread[t] = NULL; /* in case want to synch with some in a batch, but with all at the end */
if (SWAP_OUT_AFTER_THREAD) {
res = SetProcessWorkingSetSize(GetCurrentProcess(),
-1, -1);
}
}
#ifdef VERBOSE
print("some %d work, done %d\n", global_started, global_finished);
#endif
if (SWAP_OUT_AFTER_BATCH) {
res = SetProcessWorkingSetSize(GetCurrentProcess(),
-1, -1);
}
}
}
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
print("done\n");
return 0;
}
int
main(void)
{
HANDLE ht;
DWORD tid;
CONTEXT tc;
#ifdef USE_DYNAMO
dynamorio_app_init();
dynamorio_app_start();
#endif
control = 0;
start_addr = 0;
ht = CreateThread(NULL, 0, &ThreadProc1, NULL, 0, &tid);
while (start_addr == 0)
; /* wait for thread to set start_addr */
SuspendThread(ht);
memset(&tc, 0, sizeof(tc));
tc.ContextFlags = CONTEXT_CONTROL;
GetThreadContext(ht, &tc);
assert(tc.ContextFlags == CONTEXT_CONTROL);
/* 16 bytes is through je wait4control */
if (tc.CXT_XIP >= start_addr && tc.CXT_XIP <= start_addr + 0x10)
print("eip is valid\n");
else
print("invalid eip: %p\n", (void *)tc.CXT_XIP);
/* test non-CONTROL flags */
memset(&tc, 0, sizeof(tc));
tc.ContextFlags = CONTEXT_INTEGER;
GetThreadContext(ht, &tc);
assert(tc.ContextFlags == CONTEXT_INTEGER);
if (tc.CXT_XAX == 0xdeadbeef)
print("eax is valid\n");
else
print("invalid eax: %p\n", (void *)tc.CXT_XAX);
control = 1; /* stop thread */
ResumeThread(ht);
WaitForSingleObject(ht, INFINITE);
/* try getting own context (technically you're not supposed to do this, msdn says
* result is undefined, but we should handle it reasonably */
tc.ContextFlags = CONTEXT_FULL;
GetThreadContext(GetCurrentThread(), &tc);
/* FIXME - ok we got some result, what can we do to check it? we shouldn't screw up
* the reg state, so ignore that, pc should be the post syscall pc (based on
* observations of native behavior) so either in ntdll.dll or vsyscall page */
print("get context self eip > 0x74000000? %s\n",
tc.CXT_XIP > 0x74000000 ? "yes" : "no");
#ifdef USE_DYNAMO
dynamorio_app_stop();
dynamorio_app_exit();
#endif
print("done\n");
return 0;
}
