drcovlib_status_t
drmodtrack_offline_exit(void *handle)
{
module_read_info_t *info = (module_read_info_t *)handle;
if (info == NULL)
return DRCOVLIB_ERROR_INVALID_PARAMETER;
dr_global_free(info->mod, info->num_mods * sizeof(*info->mod));
if (info->map != NULL)
dr_unmap_file((char *)info->map, info->map_size);
dr_global_free(info, sizeof(*info));
return DRCOVLIB_SUCCESS;
}
void
drsym_obj_mod_exit(void *mod_in)
{
pecoff_data_t *mod = (pecoff_data_t *) mod_in;
if (mod->section_base != NULL) {
dr_global_free(mod->section_base,
mod->section_count * sizeof(*mod->section_base));
}
if (mod->sorted_syms != NULL)
dr_global_free(mod->sorted_syms, mod->symbol_count*sizeof(*mod->sorted_syms));
if (mod->sorted_exports != NULL) {
dr_global_free(mod->sorted_exports,
mod->sorted_count*sizeof(*mod->sorted_exports));
}
dr_global_free(mod, sizeof(*mod));
}
static
void decrement(void *tag)
{
elem_t *elem;
elem = find(tag);
if (elem == NULL) {
dr_fprintf(STDERR, "ERROR removing "PFX"\n", tag);
}
else {
elem->count--;
if (elem->count == 0) {
if (head == elem) {
head = elem->next;
}
if (tail == elem) {
tail = elem->prev;
}
if (elem->next) {
elem->next->prev = elem->prev;
}
if (elem->prev) {
elem->prev->next = elem->next;
}
dr_global_free(elem, sizeof(elem_t));
}
}
}
bool
drvector_delete(drvector_t *vec)
{
uint i;
if (vec == NULL)
return false;
if (vec->synch)
dr_mutex_lock(vec->lock);
/* Since we lazily initialize the array, vec->array could be NULL if we
* called drvector_init with capacity 0 and never inserted an element into
* the vec. We check vec->array here and below before access.
* */
if (vec->free_data_func != NULL && vec->array != NULL) {
for (i = 0; i < vec->entries; i++) {
(vec->free_data_func)(vec->array[i]);
}
}
if (vec->array != NULL) {
dr_global_free(vec->array, vec->capacity * sizeof(void *));
vec->array = NULL;
vec->entries = 0;
}
if (vec->synch)
dr_mutex_unlock(vec->lock);
dr_mutex_destroy(vec->lock);
return true;
}
void
terminate_IPC(int idx)
{
ipc_channel_t *channel = &IPC[idx];
if (channel->standalone)
{
dr_raw_mem_free(channel->shared_mem, sizeof(Sigil2DBISharedData));
}
else
{
/* send terminate sequence */
uint finished = SIGIL2_IPC_FINISHED;
uint last_buffer = channel->shmem_buf_idx;
if(dr_write_file(channel->full_fifo, &last_buffer, sizeof(last_buffer)) != sizeof(last_buffer) ||
dr_write_file(channel->full_fifo, &finished, sizeof(finished)) != sizeof(finished))
DR_ABORT_MSG("error writing finish sequence sigil2 fifos");
/* wait for sigil2 to disconnect */
while(dr_read_file(channel->empty_fifo, &finished, sizeof(finished)) > 0);
dr_close_file(channel->empty_fifo);
dr_close_file(channel->full_fifo);
dr_unmap_file(channel->shared_mem, sizeof(Sigil2DBISharedData));
}
dr_global_free((void*)channel->ticket_queue.head, sizeof(ticket_queue_t));
dr_mutex_destroy(channel->queue_lock);
}
void instrace_exit_event()
{
int i;
DEBUG_PRINT("%s - total amount of instructions - %d\n",ins_pass_name, num_refs);
if (client_arg->instrace_mode == OPCODE_TRACE){
dr_printf("opcodes that were covered in this part of the code - \n");
for (i = OP_FIRST; i <= OP_LAST; i++){
if (opcodes_visited[i]){
dr_printf(logfile,"%s - ", decode_opcode_name(i));
}
}
dr_printf("\n");
}
md_delete_list(head, false);
md_delete_list(instrace_head, false);
dr_global_free(client_arg,sizeof(client_arg_t));
code_cache_exit();
drmgr_unregister_tls_field(tls_index);
dr_mutex_destroy(mutex);
if (log_mode){
dr_close_file(logfile);
}
drutil_exit();
drmgr_exit();
}
/** Deletes wrapper context and removes corresponding wrapper. */
static void free_wrap( void* rawWrap ) {
struct wrap* wrap = ( struct wrap* )rawWrap;
if( !drwrap_unwrap( wrap->address, &wrapperPre, NULL ) ) {
dr_printf( "drwrap_unwrap(%p) failed\n", (void*)wrap->address );
exit( 1 );
}
dr_global_free( wrap, sizeof( struct wrap ) );
}
/* if drcontext == NULL uses global memory */
static void
htable_free(void *drcontext, trace_head_entry_t **table)
{
/* assume during process exit so no lock needed */
int i;
/* clean up memory */
for (i = 0; i < HASHTABLE_SIZE(HASH_BITS); i++) {
trace_head_entry_t *e = table[i];
while (e) {
trace_head_entry_t *nexte = e->next;
dr_global_free(e, sizeof(trace_head_entry_t));
e = nexte;
}
table[i] = NULL;
}
dr_global_free(table, TABLE_SIZE);
}
static void
hash_free(void *ptr, size_t size)
{
if (free_func != NULL)
(*free_func)(ptr, size);
else
dr_global_free(ptr, size);
}
void clean_call_mem_information(instr_t * instr, app_pc mem_val, uint write){
void * drcontext = dr_get_current_drcontext();
module_data_t * data = dr_lookup_module(instr_get_app_pc(instr));
uint offset;
app_pc base_pc;
size_t size;
uint prot;
file_t dump_file;
char * dump_filename;
DR_ASSERT(data != NULL);
offset = instr_get_app_pc(instr) - data->start;
dr_mutex_lock(mutex);
//if (!md_lookup_bb_in_module(done_head, data->full_path, offset)){
//md_add_bb_to_module(done_head, data->full_path, offset, MAX_BBS_PER_MODULE, false);
dr_query_memory(mem_val, &base_pc, &size, &prot);
//DEBUG_PRINT("base pc - %x, size - %u, write - %u\n", base_pc, size, write);
if (write){ /* postpone till the end of the function */
if (!is_mem_region_present(write_regions, base_pc, size, write_region_size)){
DEBUG_PRINT("write registered - offset - %x memval %x\n", offset, mem_val);
add_to_mem_region(write_regions, base_pc, size, &write_region_size);
DEBUG_PRINT("base pc %x, size %d\n", base_pc, size);
}
}
else{
if (!is_mem_region_present(read_regions, base_pc, size, read_region_size)){
add_to_mem_region(read_regions, base_pc, size, &read_region_size);
//DEBUG_PRINT("size - %d\n", read_region_size);
//DEBUG_PRINT("present - %d\n", is_mem_region_present(read_regions, base_pc, size, read_region_size));
//dr_abort();
DEBUG_PRINT("read registered - offset - %x memval %x\n", offset, mem_val);
DEBUG_PRINT("base pc %x, size %d\n", base_pc, size);
dump_filename = get_mem_dump_filename(base_pc, size, write,0);
dump_file = dr_open_file(dump_filename, DR_FILE_WRITE_OVERWRITE);
DEBUG_PRINT("%s dumping file\n", dump_filename);
do_mem_dump(dump_file, base_pc, size);
DEBUG_PRINT("file dumped\n");
dr_global_free(dump_filename, sizeof(char) * MAX_STRING_LENGTH);
dr_close_file(dump_file);
}
}
//}
dr_mutex_unlock(mutex);
dr_free_module_data(data);
}
void
drsym_obj_mod_exit(void *mod_in)
{
elf_info_t *mod = (elf_info_t *) mod_in;
if (mod == NULL)
return;
if (mod->elf != NULL)
elf_end(mod->elf);
dr_global_free(mod, sizeof(*mod));
}
static void
drmgr_bb_cb_exit(cb_entry_t *list)
{
cb_entry_t *e, *next_e;
dr_rwlock_write_lock(bb_cb_lock);
for (e = list; e != NULL; e = next_e) {
next_e = e->next;
dr_global_free(e, sizeof(*e));
}
dr_rwlock_write_unlock(bb_cb_lock);
}
static void
drmgr_generic_event_exit(generic_event_entry_t *list, void *rwlock)
{
generic_event_entry_t *e, *next_e;
dr_rwlock_write_lock(rwlock);
for (e = list; e != NULL; e = next_e) {
next_e = e->next;
dr_global_free(e, sizeof(*e));
}
dr_rwlock_write_unlock(rwlock);
}
void delete_table(hash_table_t table)
{
int i;
for (i=0; i<HASH_TABLE_SIZE; i++) {
if (table[i] != NULL) {
delete_list(table[i]);
}
}
dr_global_free(table, sizeof(list_t *) * HASH_TABLE_SIZE);
}
static void
drvector_increase_size(drvector_t *vec, uint newcap)
{
void **newarray = dr_global_alloc(newcap * sizeof(void *));
if (vec->array != NULL) {
memcpy(newarray, vec->array, vec->entries * sizeof(void *));
dr_global_free(vec->array, vec->capacity * sizeof(void *));
}
vec->array = newarray;
vec->capacity = newcap;
}
static void
free_table()
{
/* Free all table entries */
table_entry_t *next;
while (table != NULL) {
next = table->next;
dr_global_free(table, sizeof(table_entry_t));
table = next;
}
}
static
void delete_list(list_t *list)
{
elem_t *iter = list->head;
while (iter != NULL) {
elem_t *next = iter->next;
delete_elem(iter);
iter = next;
}
dr_global_free(list, sizeof(list_t));
}
void <client_name>_exit_event(void)
{
md_delete_list(head, false);
dr_global_free(client_arg, sizeof(client_arg_t));
drmgr_unregister_tls_field(tls_index);
if (log_mode){
dr_close_file(logfile);
}
drmgr_exit();
}
/* Report the history of "analysis mode" changes and clean up local allocations */
static void
event_exit(void)
{
uint i;
context_t *context, *next;
for (context = context_list->head; context != NULL; context = next) {
next = context->next;
for (i = 1; i < context->mode_history_index; i++) {
PRINTF("In context %d at event %d, the mode changed from %d to %d",
context->id, i, context->mode_history[i-1], context->mode_history[i]);
}
PRINTF("Context '%s' terminates in mode %d",
context->label, context->mode);
}
#if !(defined (WINDOWS) && defined (X64))
ASSERT(mem_defines->v1 > MIN_MEM_DEFINES);
ASSERT(mem_defines->v2 > MIN_MEM_DEFINES);
ASSERT(mem_defines->v3 > MIN_MEM_DEFINES);
ASSERT(mem_defines->v4 > MIN_MEM_DEFINES);
#endif
dr_mutex_destroy(context_lock);
dr_mutex_destroy(write_lock);
for (context = context_list->head; context != NULL; context = next) {
next = context->next;
dr_global_free(context->label, (sizeof(char) * strlen(context->label)) + 1);
dr_global_free(context->mode_history, MAX_MODE_HISTORY * sizeof(uint));
dr_global_free(context, sizeof(context_t));
}
dr_global_free(context_list, sizeof(context_list_t));
#if !(defined (WINDOWS) && defined (X64))
dr_global_free(mem_defines, sizeof(mem_defines_t));
#endif
}
/* WARNING i#262: if you use the cmake binary package, ctest is built
* without a GNU_STACK section, which causes the linux kernel to set
* the READ_IMPLIES_EXEC personality flag, which is propagated to
* children and causes all mmaps to be +x, breaking all these tests
* that check for mmapped memory to be +rw or +r!
*/
static
void global_test(void)
{
char *array;
uint prot;
dr_fprintf(STDERR, " testing global memory alloc...");
array = dr_global_alloc(SIZE);
write_array(array);
dr_query_memory((const byte *)array, NULL, NULL, &prot);
if (prot != get_os_mem_prot(DR_MEMPROT_READ|DR_MEMPROT_WRITE))
dr_fprintf(STDERR, "[error: prot %d doesn't match rw] ", prot);
dr_global_free(array, SIZE);
dr_fprintf(STDERR, "success\n");
}
void memtrace_exit_event()
{
md_delete_list(head,false);
code_cache_exit();
drmgr_unregister_tls_field(tls_index);
if (log_mode){
dr_close_file(logfile);
}
dr_mutex_destroy(mutex);
dr_global_free(client_arg, sizeof(client_arg_t));
drutil_exit();
drmgr_exit();
}
static void do_mem_dump(file_t file, uint base_pc,uint size){
uint read;
bool ok;
byte * mem_values = dr_global_alloc(sizeof(byte) * size);
ssize_t written;
ok = dr_safe_read(base_pc, size, mem_values, &read);
DR_ASSERT(ok);
written = dr_write_file(file, mem_values, size);
DEBUG_PRINT("read %d from %x of size %d and written %d\n", read, base_pc, size, written);
dr_global_free(mem_values, sizeof(byte) * size);
}
static void
wrap_post_SSL_read(void *wrapcxt, void *user_data)
{
struct SSL_read_data *sd = (struct SSL_read_data *)user_data;
int actual_read = (int)(ptr_int_t)drwrap_get_retval(wrapcxt);
char filename[MAXIMUM_PATH] = { 0 };
dr_snprintf(filename, BUFFER_SIZE_ELEMENTS(filename), "trace-%x.read", sd->ssl);
NULL_TERMINATE_BUFFER(filename);
FILE *fp = fopen(filename, "ab+");
if (!fp) {
dr_fprintf(STDERR, "Couldn’t open the output file %s\n", filename);
dr_global_free(user_data, sizeof(struct SSL_read_data));
return;
}
if (actual_read > 0) {
fwrite(sd->read_buffer, 1, actual_read, fp);
}
fclose(fp);
dr_global_free(user_data, sizeof(struct SSL_read_data));
}
static void
thread_data_destroy(void *drcontext, per_thread_t *data)
{
/* destroy the bb table */
bb_table_destroy(data->bb_table, data);
dr_close_file(data->log);
/* free thread data */
if (drcontext == NULL) {
ASSERT(!drcov_per_thread, "drcov_per_thread should not be set");
dr_global_free(data, sizeof(*data));
} else {
ASSERT(drcov_per_thread, "drcov_per_thread is not set");
dr_thread_free(drcontext, data, sizeof(*data));
}
}
static bool
drmgr_bb_cb_remove(cb_entry_t **list,
drmgr_xform_cb_t xform_func,
drmgr_analysis_cb_t analysis_func,
/* for quartet */
drmgr_app2app_ex_cb_t app2app_ex_func,
drmgr_ilist_ex_cb_t analysis_ex_func,
drmgr_ilist_ex_cb_t instru2instru_ex_func)
{
bool res = false;
cb_entry_t *e, *prev_e;
ASSERT(list != NULL, "invalid internal params");
ASSERT((xform_func != NULL && analysis_func == NULL) ||
(xform_func == NULL && analysis_func != NULL), "invalid internal params");
dr_rwlock_write_lock(bb_cb_lock);
for (prev_e = NULL, e = *list; e != NULL; prev_e = e, e = e->next) {
if ((xform_func != NULL && xform_func == e->cb.xform_cb) ||
(analysis_func != NULL && analysis_func == e->cb.pair.analysis_cb) ||
(app2app_ex_func != NULL && app2app_ex_func == e->cb.app2app_ex_cb) ||
(analysis_ex_func != NULL &&
analysis_ex_func == e->cb.pair_ex.analysis_ex_cb) ||
(instru2instru_ex_func != NULL &&
instru2instru_ex_func == e->cb.instru2instru_ex_cb))
break;
}
if (e != NULL) {
res = true;
if (prev_e == NULL)
*list = e->next;
else
prev_e->next = e->next;
dr_global_free(e, sizeof(*e));
if (e->has_quartet)
quartet_count--;
else if (xform_func == NULL)
pair_count--;
bb_event_count--;
if (bb_event_count == 0)
dr_unregister_bb_event(drmgr_bb_event);
}
dr_rwlock_write_unlock(bb_cb_lock);
return res;
}
drcovlib_status_t
drmodtrack_dump(file_t log)
{
drcovlib_status_t res;
size_t size = 200 + module_table.vector.entries * (MAXIMUM_PATH + 40);
char *buf;
do {
buf = dr_global_alloc(size);
res = drmodtrack_dump_buf(buf, size);
if (res == DRCOVLIB_SUCCESS)
dr_write_file(log, buf, strlen(buf));
dr_global_free(buf, size);
size *= 2;
} while (res == DRCOVLIB_ERROR_BUF_TOO_SMALL);
return res;
}
static void
read_table()
{
file_t file;
bool read_entry = true;
file = dr_open_file(table_def_file_name, DR_FILE_READ);
if (file == INVALID_FILE) {
DISPLAY_FUNC(NAME" error opening config file \"%s\"\n", table_def_file_name);
return;
}
VVDISPLAY_FUNC(NAME" reading config file: \"%s\"\n", table_def_file_name);
do {
table_entry_t *entry = (table_entry_t *)dr_global_alloc(sizeof(table_entry_t));
if (dr_read_file(file, &entry->value, sizeof(table_value_t)) !=
sizeof(table_value_t)) {
/* end of file */
read_entry = false;
dr_global_free(entry, sizeof(table_entry_t));
} else {
int i;
/* insert NULL termination for module name (including space padding) */
for (i = sizeof(entry->value.module_name) - 1;
i >= 0 && entry->value.module_name[i] == ' '; i--) {
entry->value.module_name[i] = '\0';
}
/* just in case */
entry->value.module_name[sizeof(entry->value.module_name)-1] = '\0';
/* add to the table */
entry->next = table;
table = entry;
VVDISPLAY_FUNC(NAME" read entry for module=\"%s\" to_stack=%s to_heap=%s "
"transfer_to_here=%s\n", entry->value.module_name,
(entry->value.allow_to_stack == 'y' ||
entry->value.allow_to_stack == 'Y') ? "yes" : "no",
(entry->value.allow_to_heap == 'y' ||
entry->value.allow_to_heap == 'Y') ? "yes" : "no",
(entry->value.allow_to_here == 'y' ||
entry->value.allow_to_here == 'Y') ? "yes" : "no");
}
} while (read_entry);
VVDISPLAY_FUNC(NAME" done reading config file.");
}
/* Library offset has to be computed before the probe library is loaded
* into memory. Reading it from the map file is one of the easiest ways to
* do it.
*/
unsigned int get_symbol_offset_from_map(const char *map_file, const char *symbol)
{
const char *pref_addr_str = "Preferred load address is ";
unsigned int pref_base, sym_addr, offset = 0xdeadc0de;
ssize_t file_sz;
file_t fd = INVALID_FILE;
char *buf, *temp;
fd = dr_open_file(map_file, DR_FILE_READ);
if (fd == INVALID_FILE)
goto _get_module_offset_exit;
/* This seems to be the easiest way to get the size of the file. */
if (!dr_file_seek(fd, 0, DR_SEEK_END))
goto _get_module_offset_exit;
file_sz = (ssize_t) dr_file_tell(fd);
if (file_sz <= 0)
goto _get_module_offset_exit;
if (!dr_file_seek(fd, 0, DR_SEEK_SET))
goto _get_module_offset_exit;
/* Read the whole file. */
buf = dr_global_alloc(file_sz + 1);
if (buf == NULL)
goto _get_module_offset_exit;
dr_read_file(fd, buf, file_sz);
buf[file_sz] = '\0';
/* Locate preferred base & symbol address. */
temp = strstr(buf, pref_addr_str);
if (temp != NULL)
{
pref_base = strtoul(temp + strlen(pref_addr_str), NULL, 16);
temp = strstr(buf, symbol);
if (temp != NULL)
sym_addr = strtoul(temp + strlen(symbol), NULL, 16);
offset = sym_addr - pref_base;
}
dr_global_free(buf, file_sz + 1);
_get_module_offset_exit:
if (fd != INVALID_FILE)
dr_close_file(fd);
return offset;
}
static inline void
ordered_lock(ipc_channel_t *channel, uint tid)
{
dr_mutex_lock(channel->queue_lock);
ticket_queue_t *q = &channel->ticket_queue;
if (q->locked)
{
ticket_node_t *node = dr_global_alloc(sizeof(ticket_node_t));
if (node == NULL)
DR_ABORT_MSG("Failed to allocate ticket node\n");
node->next = NULL;
node->dr_event = dr_event_create();
node->waiting = true;
node->thread_id = tid;
DR_ASSERT(q->tail->next == NULL);
q->tail = q->tail->next = node;
SGL_DEBUG("Sleeping Thread :%d\n", tid);
dr_mutex_unlock(channel->queue_lock);
/* MDL20170425 TODO(soonish)
* how likely is it that we'll miss a wakeup here? */
while (node->waiting)
dr_event_wait(node->dr_event);
dr_mutex_lock(channel->queue_lock);
q->head->next = node->next;
if (q->tail == node)
q->tail = q->head;
dr_event_destroy(node->dr_event);
dr_global_free(node, sizeof(ticket_node_t));
SGL_DEBUG("Awakened Thread :%d\n", tid);
}
else
{
q->locked = true;
}
dr_mutex_unlock(channel->queue_lock);
}
/* Lookup an entry by tag and index and delete it.
* Returns false if no such entry exists.
* Caller must hold htable_mutex if drcontext == NULL.
*/
static bool
remove_trace_head_entry(void *drcontext, void *tag)
{
trace_head_entry_t **table = htable;
trace_head_entry_t *e, *prev;
uint hindex;
hindex = (uint) HASH_FUNC_BITS((ptr_uint_t)tag, HASH_BITS);
for (prev = NULL, e = table[hindex]; e; prev = e, e = e->next) {
if (e->tag == tag) {
if (prev)
prev->next = e->next;
else
table[hindex] = e->next;
dr_global_free(e, sizeof(trace_head_entry_t));
return true;
}
}
return false;
}
