DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
uint i;
dr_set_client_name("DynamoRIO Sample Client 'stats'", "http://dynamorio.org/issues");
my_id = id;
/* Make it easy to tell by looking at the log which client executed. */
dr_log(NULL, LOG_ALL, 1, "Client 'stats' initializing\n");
if (!drmgr_init())
DR_ASSERT(false);
drx_init();
stats = shared_memory_init();
memset(stats, 0, sizeof(stats));
stats->num_stats = NUM_STATS;
stats->pid = dr_get_process_id();
for (i=0; i<NUM_STATS; i++) {
strncpy(stats->names[i], stat_names[i], CLIENTSTAT_NAME_MAX_LEN);
stats->names[i][CLIENTSTAT_NAME_MAX_LEN-1] = '\0';
}
dr_register_exit_event(event_exit);
if (!drmgr_register_bb_instrumentation_event(event_analyze_bb,
event_insert_instrumentation, NULL))
DR_ASSERT(false);
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
drreg_options_t ops = {sizeof(ops), 1 /*max slots needed: aflags*/, false};
dr_set_client_name("DynamoRIO Sample Client 'bbcount'",
"http://dynamorio.org/issues");
if (!drmgr_init() || drreg_init(&ops) != DRREG_SUCCESS)
DR_ASSERT(false);
/* register events */
dr_register_exit_event(event_exit);
if (!drmgr_register_bb_instrumentation_event(NULL, event_app_instruction, NULL))
DR_ASSERT(false);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'bbcount' initializing\n");
#ifdef SHOW_RESULTS
/* also give notification to stderr */
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called at init. */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client bbcount is running\n");
}
#endif
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
drreg_options_t ops = { sizeof(ops), 4 /*max slots needed*/, false };
dr_set_client_name("DynamoRIO Sample Client 'memval'", "http://dynamorio.org/issues");
if (!drmgr_init() || !drutil_init() || !drx_init())
DR_ASSERT(false);
if (drreg_init(&ops) != DRREG_SUCCESS)
DR_ASSERT(false);
/* register events */
dr_register_exit_event(event_exit);
if (!drmgr_register_thread_init_event(event_thread_init) ||
!drmgr_register_thread_exit_event(event_thread_exit) ||
!drmgr_register_bb_app2app_event(event_bb_app2app, NULL) ||
!drmgr_register_bb_instrumentation_event(event_app_analysis,
event_app_instruction, NULL))
DR_ASSERT(false);
client_id = id;
tls_idx = drmgr_register_tls_field();
trace_buffer = drx_buf_create_trace_buffer(MEM_BUF_SIZE, trace_fault);
/* We could make this a trace buffer and specially handle faults, but it is not yet
* worth the effort.
*/
write_buffer = drx_buf_create_circular_buffer(WRT_BUF_SIZE);
DR_ASSERT(tls_idx != -1 && trace_buffer != NULL && write_buffer != NULL);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, DR_LOG_ALL, 1, "Client 'memval' initializing\n");
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
module_data_t *appmod;
dr_set_client_name("DynamoRIO Sample Client 'modxfer_app2lib'",
"http://dynamorio.org/issues");
appmod = dr_get_main_module();
DR_ASSERT(appmod != NULL);
app_base = appmod->start;
app_end = appmod->end;
dr_free_module_data(appmod);
if (!drmgr_init())
DR_ASSERT(false);
/* register events */
dr_register_exit_event(event_exit);
if (!drmgr_register_bb_instrumentation_event(event_analyze_bb,
event_insert_instrumentation, NULL))
DR_ASSERT(false);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, DR_LOG_ALL, 1, "Client 'modxfer_app2lib' initializing\n");
#ifdef SHOW_RESULTS
/* also give notification to stderr */
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called at init. */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client modxfer_app2lib is running\n");
}
#endif
}
DR_EXPORT void
dr_init(client_id_t id)
{
drmgr_priority_t priority = {sizeof(priority), "drmgr-test", NULL, NULL, 0};
drmgr_priority_t priority4 = {sizeof(priority), "drmgr-test4", NULL, NULL, 0};
drmgr_priority_t sys_pri_A = {sizeof(priority), "drmgr-test-A",
NULL, NULL, 10};
drmgr_priority_t sys_pri_B = {sizeof(priority), "drmgr-test-B",
"drmgr-test-A", NULL, 5};
bool ok;
drmgr_init();
dr_register_exit_event(event_exit);
drmgr_register_thread_init_event(event_thread_init);
drmgr_register_thread_exit_event(event_thread_exit);
ok = drmgr_register_bb_instrumentation_event(event_bb_analysis,
event_bb_insert,
&priority);
CHECK(ok, "drmgr register bb failed");
/* check register/unregister instrumentation_ex */
ok = drmgr_register_bb_instrumentation_ex_event(event_bb4_app2app,
event_bb4_analysis,
event_bb4_insert2,
event_bb4_instru2instru,
NULL);
CHECK(ok, "drmgr_register_bb_instrumentation_ex_event failed");
ok = drmgr_unregister_bb_instrumentation_ex_event(event_bb4_app2app,
event_bb4_analysis,
event_bb4_insert2,
event_bb4_instru2instru);
CHECK(ok, "drmgr_unregister_bb_instrumentation_ex_event failed");
/* test data passing among all 4 phases */
ok = drmgr_register_bb_instrumentation_ex_event(event_bb4_app2app,
event_bb4_analysis,
event_bb4_insert,
event_bb4_instru2instru,
&priority4);
tls_idx = drmgr_register_tls_field();
CHECK(tls_idx != -1, "drmgr_register_tls_field failed");
cls_idx = drmgr_register_cls_field(event_thread_context_init,
event_thread_context_exit);
CHECK(cls_idx != -1, "drmgr_register_tls_field failed");
dr_register_filter_syscall_event(event_filter_syscall);
ok = drmgr_register_pre_syscall_event_ex(event_pre_sys_A, &sys_pri_A) &&
drmgr_register_pre_syscall_event_ex(event_pre_sys_B, &sys_pri_B);
CHECK(ok, "drmgr register sys failed");
ok = drmgr_register_post_syscall_event_ex(event_post_sys_A, &sys_pri_A) &&
drmgr_register_post_syscall_event_ex(event_post_sys_B, &sys_pri_B);
CHECK(ok, "drmgr register sys failed");
syslock = dr_mutex_create();
ok = drmgr_register_bb_app2app_event(one_time_bb_event, NULL);
CHECK(ok, "drmgr app2app registration failed");
}
DR_EXPORT void
dr_init(client_id_t id)
{
if (!drmgr_init())
CHECK(false, "init failed");
/* init buffer routines */
drx_init();
circular_fast = drx_buf_create_circular_buffer(DRX_BUF_FAST_CIRCULAR_BUFSZ);
circular_slow = drx_buf_create_circular_buffer(CIRCULAR_SLOW_SZ);
trace = drx_buf_create_trace_buffer(TRACE_SZ, verify_trace_buffer);
CHECK(circular_fast != NULL, "circular fast failed");
CHECK(circular_slow != NULL, "circular slow failed");
CHECK(trace != NULL, "trace failed");
CHECK(drmgr_register_thread_init_event(event_thread_init),
"event thread init failed");
/* register events */
dr_register_exit_event(event_exit);
if (!drmgr_register_bb_instrumentation_event(event_app_analysis,
event_app_instruction,
NULL))
CHECK(false, "init failed");
}
DR_EXPORT void
dr_init(client_id_t id)
{
drmgr_priority_t priority = {sizeof(priority), "drmgr-test", NULL, NULL, 0};
drmgr_priority_t priority4 = {sizeof(priority), "drmgr-test4", NULL, NULL, 0};
bool ok;
drmgr_init();
dr_register_exit_event(event_exit);
drmgr_register_thread_init_event(event_thread_init);
drmgr_register_thread_exit_event(event_thread_exit);
ok = drmgr_register_bb_instrumentation_event(event_bb_analysis,
event_bb_insert,
&priority);
CHECK(ok, "drmgr register bb failed");
/* test data passing among all 4 phases */
ok = drmgr_register_bb_instrumentation_ex_event(event_bb4_app2app,
event_bb4_analysis,
event_bb4_insert,
event_bb4_instru2instru,
&priority4);
tls_idx = drmgr_register_tls_field();
CHECK(tls_idx != 1, "drmgr_register_tls_field failed");
cls_idx = drmgr_register_cls_field(event_thread_context_init,
event_thread_context_exit);
CHECK(cls_idx != 1, "drmgr_register_tls_field failed");
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
dr_set_client_name("DynamoRIO Sample Client 'inline'",
"http://dynamorio.org/issues");
if (!drmgr_init())
DR_ASSERT(false);
hashtable_init_ex(&head_table, HASH_BITS, HASH_INTPTR, false/*!strdup*/,
false/*synchronization is external*/,
free_trace_head_entry, NULL, NULL);
dr_register_exit_event(event_exit);
if (!drmgr_register_bb_instrumentation_event(event_analyze_bb, NULL, NULL))
DR_ASSERT(false);
dr_register_delete_event(event_fragment_deleted);
dr_register_end_trace_event(query_end_trace);
/* Make it easy to tell from the log file which client executed. */
dr_log(NULL, DR_LOG_ALL, 1, "Client 'inline' initializing\n");
#ifdef SHOW_RESULTS
/* also give notification to stderr */
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* Ask for best-effort printing to cmd window. Must be called at init. */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client inline is running\n");
}
#endif
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
/* We need 2 reg slots beyond drreg's eflags slots => 3 slots */
drreg_options_t ops = { sizeof(ops), 3, false };
dr_set_client_name("DynamoRIO Sample Client 'memtrace'",
"http://dynamorio.org/issues");
if (!drmgr_init() || drreg_init(&ops) != DRREG_SUCCESS || !drutil_init())
DR_ASSERT(false);
/* register events */
dr_register_exit_event(event_exit);
if (!drmgr_register_thread_init_event(event_thread_init) ||
!drmgr_register_thread_exit_event(event_thread_exit) ||
!drmgr_register_bb_app2app_event(event_bb_app2app, NULL) ||
!drmgr_register_bb_instrumentation_event(NULL /*analysis_func*/,
event_app_instruction, NULL))
DR_ASSERT(false);
client_id = id;
mutex = dr_mutex_create();
tls_idx = drmgr_register_tls_field();
DR_ASSERT(tls_idx != -1);
/* The TLS field provided by DR cannot be directly accessed from the code cache.
* For better performance, we allocate raw TLS so that we can directly
* access and update it with a single instruction.
*/
if (!dr_raw_tls_calloc(&tls_seg, &tls_offs, MEMTRACE_TLS_COUNT, 0))
DR_ASSERT(false);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, DR_LOG_ALL, 1, "Client 'memtrace' initializing\n");
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
dr_set_client_name("DynamoRIO Sample Client 'div'", "http://dynamorio.org/issues");
if (!drmgr_init())
DR_ASSERT(false);
dr_register_exit_event(exit_event);
if (!drmgr_register_bb_instrumentation_event(NULL, event_app_instruction, NULL))
DR_ASSERT(false);
count_mutex = dr_mutex_create();
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
drreg_options_t ops = { sizeof(ops), 1 /*max slots needed*/, false };
if (!drmgr_init())
CHECK(false, "drmgr init failed");
if (drreg_init(&ops) != DRREG_SUCCESS)
CHECK(false, "drreg_init failed");
dr_register_exit_event(event_exit);
if (!drmgr_register_bb_instrumentation_event(NULL, event_app_instruction, NULL))
CHECK(false, "bb reg failed");
}
drcovlib_status_t
drcovlib_init(drcovlib_options_t *ops)
{
int count = dr_atomic_add32_return_sum(&drcovlib_init_count, 1);
if (count > 1)
return DRCOVLIB_SUCCESS;
if (ops->struct_size != sizeof(options))
return DRCOVLIB_ERROR_INVALID_PARAMETER;
if ((ops->flags & (~(DRCOVLIB_DUMP_AS_TEXT|DRCOVLIB_THREAD_PRIVATE))) != 0)
return DRCOVLIB_ERROR_INVALID_PARAMETER;
if (TEST(DRCOVLIB_THREAD_PRIVATE, ops->flags)) {
if (!dr_using_all_private_caches())
return DRCOVLIB_ERROR_INVALID_SETUP;
drcov_per_thread = true;
}
options = *ops;
if (options.logdir != NULL)
dr_snprintf(logdir, BUFFER_SIZE_ELEMENTS(logdir), "%s", ops->logdir);
else /* default */
dr_snprintf(logdir, BUFFER_SIZE_ELEMENTS(logdir), ".");
NULL_TERMINATE_BUFFER(logdir);
options.logdir = logdir;
if (options.native_until_thread > 0)
go_native = true;
drmgr_init();
drx_init();
/* We follow a simple model of the caller requesting the coverage dump,
* either via calling the exit routine, using its own soft_kills nudge, or
* an explicit dump call for unusual cases. This means that drx's
* soft_kills remains inside the outer later, i.e., the drcov client. This
* is the easiest approach for coordinating soft_kills among many libraries.
* Thus, we do *not* register for an exit event here.
*/
drmgr_register_thread_init_event(event_thread_init);
drmgr_register_thread_exit_event(event_thread_exit);
drmgr_register_bb_instrumentation_event(event_basic_block_analysis, NULL, NULL);
dr_register_filter_syscall_event(event_filter_syscall);
drmgr_register_pre_syscall_event(event_pre_syscall);
#ifdef UNIX
dr_register_fork_init_event(event_fork);
#endif
tls_idx = drmgr_register_tls_field();
if (tls_idx == -1)
return DRCOVLIB_ERROR;
return event_init();
}
DR_EXPORT void
dr_init(client_id_t id)
{
drreg_options_t ops = { sizeof(ops), 2 /*max slots needed*/, false };
drreg_status_t res;
bool ok = drmgr_init();
CHECK(ok, "drmgr_init failed");
ok = drx_init();
CHECK(ok, "drx_init failed");
res = drreg_init(&ops);
CHECK(res == DRREG_SUCCESS, "drreg_init failed");
dr_register_exit_event(event_exit);
if (!drmgr_register_bb_instrumentation_event(NULL, event_app_instruction, NULL))
DR_ASSERT(false);
}
static bool
drmgr_cls_init(void)
{
/* For callback init we watch for KiUserCallbackDispatcher.
* For callback exit we watch for NtCallbackReturn or int 0x2b.
*/
static int cls_initialized; /* 0=not tried; >0=success; <0=failure */
module_data_t *data;
module_handle_t ntdll_lib;
app_pc addr_cbret;
drmgr_priority_t priority = {sizeof(priority), "drmgr_cls", NULL, NULL, 0};
if (cls_initialized > 0)
return true;
else if (cls_initialized < 0)
return false;
cls_initialized = -1;
if (!drmgr_register_bb_instrumentation_event(drmgr_event_bb_analysis,
drmgr_event_bb_insert,
&priority))
return false;
dr_register_filter_syscall_event(drmgr_event_filter_syscall);
data = dr_lookup_module_by_name("ntdll.dll");
if (data == NULL) {
/* fatal error: something is really wrong w/ underlying DR */
return false;
}
ntdll_lib = data->handle;
dr_free_module_data(data);
addr_KiCallback = (app_pc) dr_get_proc_address(ntdll_lib, "KiUserCallbackDispatcher");
if (addr_KiCallback == NULL)
return false; /* should not happen */
/* the wrapper is not good enough for two reasons: one, we want to swap
* contexts at the last possible moment, not prior to executing a few
* instrs; second, we'll miss hand-rolled syscalls
*/
addr_cbret = (app_pc) dr_get_proc_address(ntdll_lib, "NtCallbackReturn");
if (addr_cbret == NULL)
return false; /* should not happen */
sysnum_NtCallbackReturn = drmgr_decode_sysnum_from_wrapper(addr_cbret);
if (sysnum_NtCallbackReturn == -1)
return false; /* should not happen */
cls_initialized = 1;
return true;
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
/* We need 2 reg slots beyond drreg's eflags slots => 3 slots */
drreg_options_t ops = {sizeof(ops), 3, false};
/* Specify priority relative to other instrumentation operations: */
drmgr_priority_t priority = {
sizeof(priority), /* size of struct */
"memtrace", /* name of our operation */
NULL, /* optional name of operation we should precede */
NULL, /* optional name of operation we should follow */
0}; /* numeric priority */
dr_set_client_name("DynamoRIO Sample Client 'memtrace'",
"http://dynamorio.org/issues");
page_size = dr_page_size();
drmgr_init();
drutil_init();
client_id = id;
mutex = dr_mutex_create();
dr_register_exit_event(event_exit);
if (!drmgr_register_thread_init_event(event_thread_init) ||
!drmgr_register_thread_exit_event(event_thread_exit) ||
!drmgr_register_bb_app2app_event(event_bb_app2app, &priority) ||
!drmgr_register_bb_instrumentation_event(NULL, event_bb_insert, &priority) ||
drreg_init(&ops) != DRREG_SUCCESS) {
/* something is wrong: can't continue */
DR_ASSERT(false);
return;
}
tls_index = drmgr_register_tls_field();
DR_ASSERT(tls_index != -1);
code_cache_init();
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, DR_LOG_ALL, 1, "Client 'memtrace' initializing\n");
#ifdef SHOW_RESULTS
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called at init. */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client memtrace is running\n");
}
#endif
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
/* We need no drreg slots ourselves, but we initialize drreg as we call
* drreg_restore_app_values(), required since drx_insert_counter_update()
* uses drreg when drmgr is used.
*/
drreg_options_t ops = {sizeof(ops)};
dr_set_client_name("DynamoRIO Sample Client 'modxfer'",
"http://dynamorio.org/issues");
if (!drmgr_init() || drreg_init(&ops) != DRREG_SUCCESS)
DR_ASSERT(false);
drx_init();
/* register events */
dr_register_exit_event(event_exit);
if (!drmgr_register_bb_instrumentation_event(event_analyze_bb,
event_insert_instrumentation, NULL))
DR_ASSERT(false);
drmgr_register_module_load_event(event_module_load);
drmgr_register_module_unload_event(event_module_unload);
mod_lock = dr_mutex_create();
logfile = log_file_open(id, NULL /* drcontext */,
NULL/* path */, "modxfer",
#ifndef WINDOWS
DR_FILE_CLOSE_ON_FORK |
#endif
DR_FILE_ALLOW_LARGE);
DR_ASSERT(logfile != INVALID_FILE);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'modxfer' initializing\n");
#ifdef SHOW_RESULTS
/* also give notification to stderr */
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called at init. */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client modxfer is running\n");
}
#endif
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
drreg_options_t ops = {sizeof(ops), 2 /*max slots needed*/, false};
dr_set_client_name("DynamoRIO Sample Client 'bbbuf'",
"http://dynamorio.org/issues");
if (!drmgr_init() || !drx_init() ||
drreg_init(&ops) != DRREG_SUCCESS)
DR_ASSERT(false);
buf = drx_buf_create_circular_buffer(DRX_BUF_FAST_CIRCULAR_BUFSZ);
DR_ASSERT(buf);
/* register events */
dr_register_exit_event(event_exit);
if (!drmgr_register_thread_init_event(event_thread_init) ||
!drmgr_register_bb_instrumentation_event(NULL, event_app_instruction, NULL))
DR_ASSERT(false);
}
/*
* Main entry point that sets up all the facilities we need.
*/
DR_EXPORT void dr_client_main(client_id_t id, int argc, const char **argv)
{
dr_set_client_name(
"Time-sensitive activity logger for PuTTY crypto testing",
"https://www.chiark.greenend.org.uk/~sgtatham/putty/");
outfile = INVALID_FILE;
bool ok = drmgr_init();
DR_ASSERT(ok);
/*
* Run our main instrumentation pass with lower priority than
* drwrap, so that we don't start logging the inside of a function
* whose drwrap pre-wrapper would have wanted to disable logging.
*/
drmgr_priority_t pri = {sizeof(pri), "sclog", NULL, NULL,
DRMGR_PRIORITY_INSERT_DRWRAP+1};
ok = drmgr_register_bb_instrumentation_event(
NULL, instrument_instr, &pri);
DR_ASSERT(ok);
ok = drutil_init();
DR_ASSERT(ok);
ok = drwrap_init();
DR_ASSERT(ok);
drsym_error_t symstatus = drsym_init(0);
DR_ASSERT(symstatus == DRSYM_SUCCESS);
dr_register_exit_event(exit_event);
drreg_options_t ops = { sizeof(ops), 3, false };
drreg_status_t regstatus = drreg_init(&ops);
DR_ASSERT(regstatus == DRREG_SUCCESS);
drmgr_register_module_load_event(load_module);
ok = drmgr_register_bb_app2app_event(expand_rep_movsb, NULL);
DR_ASSERT(ok);
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
dr_set_client_name("DynamoRIO Sample Client 'inscount'",
"http://dynamorio.org/issues");
/* Options */
if (!droption_parser_t::parse_argv(DROPTION_SCOPE_CLIENT, argc, argv, NULL, NULL))
DR_ASSERT(false);
drmgr_init();
/* Get main module address */
if (only_from_app.get_value()) {
module_data_t *exe = dr_get_main_module();
if (exe != NULL)
exe_start = exe->start;
dr_free_module_data(exe);
}
/* register events */
dr_register_exit_event(event_exit);
drmgr_register_bb_instrumentation_event(event_bb_analysis, event_app_instruction,
NULL);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, DR_LOG_ALL, 1, "Client 'inscount' initializing\n");
#ifdef SHOW_RESULTS
/* also give notification to stderr */
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called at init. */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client inscount is running\n");
}
#endif
}
DR_EXPORT void
dr_init(client_id_t id)
{
int i = 0;
int j = 0;
drmgr_init();
dr_enable_console_printing();
setupInsPasses();
doCommandLineArgProcessing(id);
DEBUG_PRINT("argument length - %d\n", argument_length);
for (i = 0; i < argument_length; i++){
DEBUG_PRINT("\"%s - %s\"\n", arguments[i].name, arguments[i].arguments);
}
dr_register_nudge_event(nudge_event, id);
/*if (log_mode){
populate_conv_filename(global_logfilename, logdir, "global", NULL);
global_logfile = dr_open_file(global_logfilename, DR_FILE_WRITE_OVERWRITE);
DR_ASSERT(global_logfile != INVALID_FILE);
}*/
//dr_messagebox("client id - %d\n", id);
DEBUG_PRINT("%s is starting\n", dr_get_application_name());
/* if you are using it only for photoshop do no instrument other exes */
if (strcmp(exec, "photoshop") == 0){
DEBUG_PRINT("photoshop detected only instrumenting Photoshop.exe\n");
if(strcmp(dr_get_application_name(), "Photoshop.exe") != 0){
return;
}
DEBUG_PRINT("starting to instrument Photoshop.exe\n");
}
for( i=0 ; i<argument_length; i++){
for( j=0; j<pass_length; j++){
if(strcmp(arguments[i].name,ins_pass[j].name) == 0){
//we can now register the call backs
DEBUG_PRINT("%s - registered\n", arguments[i].name);
DEBUG_PRINT("%s - initializing...\n", arguments[i].name);
ins_pass[j].init_func(id,arguments[i].name, arguments[i].arguments);
DEBUG_PRINT("%s - initialized\n", arguments[i].name);
//register thread events
if(ins_pass[j].thread_init != NULL)
drmgr_register_thread_init_event(ins_pass[j].thread_init);
if(ins_pass[j].thread_exit != NULL)
drmgr_register_thread_exit_event(ins_pass[j].thread_exit);
//register bb events
if(ins_pass[j].app2app_bb != NULL)
drmgr_register_bb_app2app_event(ins_pass[j].app2app_bb,
&ins_pass[j].priority);
if(ins_pass[j].instrumentation_bb != NULL || ins_pass[j].analysis_bb != NULL)
drmgr_register_bb_instrumentation_event(ins_pass[j].analysis_bb,
ins_pass[j].instrumentation_bb,
&ins_pass[j].priority);
if (ins_pass[j].module_load != NULL)
drmgr_register_module_load_event_ex(ins_pass[j].module_load, &ins_pass[j].priority);
if (ins_pass[j].module_unload != NULL)
drmgr_register_module_unload_event_ex(ins_pass[j].module_unload, &ins_pass[j].priority);
}
}
}
dr_register_exit_event(process_exit_routine_call);
}
