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_init(client_id_t id)
{
client_id = id;
dr_fprintf(STDERR, "thank you for testing the client interface\n");
drmgr_init();
cls_idx = drmgr_register_cls_field(event_thread_context_init,
event_thread_context_exit);
ASSERT(cls_idx != -1);
dr_register_nudge_event(event_nudge, id);
dr_register_filter_syscall_event(event_filter_syscall);
drmgr_register_pre_syscall_event(event_pre_syscall);
drmgr_register_post_syscall_event(event_post_syscall);
dr_register_exit_event(event_exit);
#ifdef WINDOWS
sysnum_CreateProcess = get_sysnum("NtCreateProcess");
ASSERT(sysnum_CreateProcess != -1);
/* not asserting on these since added later */
sysnum_CreateProcessEx = get_sysnum("NtCreateProcessEx");
sysnum_CreateUserProcess = get_sysnum("NtCreateUserProcess");
sysnum_ResumeThread = get_sysnum("NtResumeThread");
ASSERT(sysnum_ResumeThread != -1);
#endif
}
DR_EXPORT
void dr_init(client_id_t id)
{
table = new_table();
dr_register_bb_event(bb_event);
dr_register_exit_event(dr_exit);
}
DR_EXPORT
void dr_init(client_id_t id)
{
drsys_options_t ops = { sizeof(ops), 0, };
drmgr_init();
if (drsys_init(id, &ops) != DRMF_SUCCESS)
ASSERT(false, "drsys failed to init");
dr_register_exit_event(exit_event);
dr_register_filter_syscall_event(event_filter_syscall);
drmgr_register_pre_syscall_event(event_pre_syscall);
drmgr_register_post_syscall_event(event_post_syscall);
if (drsys_filter_all_syscalls() != DRMF_SUCCESS)
ASSERT(false, "drsys_filter_all_syscalls should never fail");
test_static_queries();
test_static_iterator();
/* XXX: it would be nice to do deeper tests:
* + drsys_filter_syscall() and have an app that makes both filtered
* and unfiltered syscalls
* + have app make specific syscall w/ specific args and ensure
* they match up
*/
}
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_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)
{
dr_register_exit_event(exit_event);
dr_register_bb_event(bb_event);
count_mutex = dr_mutex_create();
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
/* empty client */
dr_set_client_name("DynamoRIO Sample Client 'empty'", "http://dynamorio.org/issues");
dr_register_exit_event(event_exit);
}
DR_EXPORT void dr_init(client_id_t id) {
dr_fprintf(STDERR, "info: starting dtrace, &dr_init=%p..\n", &dr_init);
trace_file = dr_open_file(TRACE_FILE_NAME,
DR_FILE_ALLOW_LARGE | DR_FILE_WRITE_OVERWRITE);
if(trace_file == INVALID_FILE) {
dr_fprintf(STDERR, "fatal: dr_open_file() failed\n");
dr_exit_process(1);
}
trace_file_lock = dr_mutex_create();
trace_buffer = tb_create(-1);
trace_buffer_lock = dr_mutex_create();
hashtable_init_ex(&tags,
16,
HASH_INTPTR,
false,
false,
&tag_info_free_raw,
NULL,
NULL);
tags_lock = dr_mutex_create();
dr_register_exit_event(&dr_exit);
dr_register_thread_init_event(&handle_thread_init);
dr_register_thread_exit_event(&handle_thread_exit);
dr_register_bb_event(&handle_bb);
dr_register_trace_event(&handle_trace);
dr_register_delete_event(&handle_delete);
dr_register_signal_event(&handle_signal);
dr_register_restore_state_event(&handle_restore_state);
}
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[])
{
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_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)
{
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[])
{
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)
{
module_data_t *appmod = dr_get_main_module();
DR_ASSERT(appmod != NULL);
app_base = appmod->start;
app_end = appmod->end;
dr_free_module_data(appmod);
/* register events */
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, 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 in dr_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)
{
dr_set_client_name("DynamoRIO Sample Client 'instrcalls'",
"http://dynamorio.org/issues");
my_id = id;
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'instrcalls' initializing\n");
/* also give notification to stderr */
#ifdef SHOW_RESULTS
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called in dr_init(). */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client instrcalls is running\n");
}
#endif
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
dr_register_thread_init_event(event_thread_init);
dr_register_thread_exit_event(event_thread_exit);
#ifdef SHOW_SYMBOLS
if (drsym_init(0) != DRSYM_SUCCESS) {
dr_log(NULL, LOG_ALL, 1, "WARNING: unable to initialize symbol translation\n");
}
#endif
}
DR_EXPORT void
dr_init(client_id_t id)
{
dr_register_exit_event(event_exit);
dr_register_trace_event(event_trace);
/* this optimization is only worthwhile on the Pentium 4, where
* an add of 1 is faster than an inc
*/
enable = (proc_get_family() == FAMILY_PENTIUM_4);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'inc2add' 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 in dr_init(). */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client inc2add is running\n");
}
#endif
/* initialize our global variables */
num_examined = 0;
num_converted = 0;
}
/* Parse CL options and register DR event handlers and annotation handlers */
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
context_lock = dr_mutex_create();
write_lock = dr_mutex_create();
# ifdef WINDOWS
dr_enable_console_printing();
# endif
client_id = id;
/* XXX: should use droption */
if (argc > 1 && strcmp(argv[1], "full-decode") == 0) {
PRINTF("Init annotation test client with full decoding");
dr_register_bb_event(empty_bb_event);
} else if (argc > 1 && strlen(argv[1]) >= 8 && strncmp(argv[1], "truncate", 8) == 0) {
bb_truncation_length = (argv[1][9] - '0'); /* format is "truncate@n" (0<n<10) */
ASSERT(bb_truncation_length < 10 && bb_truncation_length > 0);
PRINTF("Init annotation test client with bb truncation");
dr_register_bb_event(bb_event_truncate);
} else {
PRINTF("Init annotation test client with fast decoding");
}
context_list = dr_global_alloc(sizeof(context_list_t));
memset(context_list, 0, sizeof(context_list_t));
#if !(defined (WINDOWS) && defined (X64))
mem_defines = dr_global_alloc(sizeof(mem_defines_t));
memset(mem_defines, 0, sizeof(mem_defines_t));
#endif
dr_register_exit_event(event_exit);
register_call("test_annotation_init_mode", (void *) init_mode, 1);
register_call("test_annotation_init_context", (void *) init_context, 3);
register_call("test_annotation_get_mode", (void *) get_mode, 1);
register_call("test_annotation_set_mode", (void *) set_mode, 2);
#if !(defined (WINDOWS) && defined (X64))
register_call("test_annotation_rotate_valgrind_handler",
(void *) rotate_valgrind_handler, 1);
#endif
register_call("test_annotation_eight_args", (void *) test_eight_args_v1, 8);
register_call("test_annotation_eight_args", (void *) test_eight_args_v2, 8);
/* Test removing the last handler */
dr_annotation_unregister_call("test_annotation_eight_args", test_eight_args_v1);
register_call("test_annotation_nine_args", (void *) test_nine_args_v1, 9);
register_call("test_annotation_nine_args", (void *) test_nine_args_v2, 9);
/* Test removing the first handler */
dr_annotation_unregister_call("test_annotation_nine_args", test_nine_args_v2);
/* Test multiple handlers */
register_call("test_annotation_ten_args", (void *) test_ten_args_v1, 10);
register_call("test_annotation_ten_args", (void *) test_ten_args_v2, 10);
dr_annotation_register_return("test_annotation_get_client_version", (void *) "2.2.8");
}
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_init(client_id_t id)
{
/* register events */
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
print("in dr_client_main\n");
dr_register_bb_event(event_bb);
dr_register_signal_event(event_signal);
dr_register_exit_event(event_exit);
}
DR_EXPORT void dr_init(client_id_t id)
{
/* Register Events */
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
/* Initalize lock */
as_built_lock = dr_mutex_create();
}
DR_EXPORT void
dr_init(client_id_t id)
{
dr_register_exit_event(exit_event);
#if defined(UNIX)
dr_register_signal_event(signal_event);
#elif defined(WINDOWS)
dr_register_exception_event(exception_event);
#endif
}
DR_EXPORT void
dr_init(client_id_t id)
{
drmgr_init();
drwrap_init();
dr_register_exit_event(event_exit);
drmgr_register_module_load_event(module_load_event);
drmgr_register_module_unload_event(module_unload_event);
tls_idx = drmgr_register_tls_field();
CHECK(tls_idx > -1, "unable to reserve TLS field");
}
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_init(client_id_t id)
{
#ifdef LINUX
dr_register_signal_event(event_signal);
#endif
dr_register_exit_event(event_exit);
#ifdef SHOW_RESULTS
if (dr_is_notify_on())
dr_fprintf(STDERR, "Client signal 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), 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");
}
DR_EXPORT void
dr_init(client_id_t id)
{
/* register events */
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'memtrace' initializing\n");
if (dr_is_notify_on()) {
dr_fprintf(STDERR, "Client is running\n");
}
}
DR_EXPORT void
dr_init(client_id_t id)
{
num_bb = 0;
ave_size = 0.;
max_size = 0;
stats_mutex = dr_mutex_create();
dr_register_bb_event(event_basic_block);
dr_register_exit_event(event_exit);
#ifdef SHOW_RESULTS
if (dr_is_notify_on())
dr_fprintf(STDERR, "Client bbsize is running\n");
#endif
}
DR_EXPORT void dr_init(client_id_t id)
{
insn_count = 0;
read_count = 0;
writ_count = 0;
read_size = 0;
writ_size = 0;
dr_register_post_syscall_event(event_post_syscall);
dr_register_bb_event(event_bb);
dr_register_thread_init_event(event_thread_init);
dr_register_thread_exit_event(event_thread_exit);
dr_register_exit_event(event_exit);
}
