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; }