// Copyright (c) 2024 Epic Games Tools // Licensed under the MIT license (https://opensource.org/license/mit/) //////////////////////////////// //~ rjf: Main Layer Initialization internal void ctrl_init(CTRL_WakeupFunctionType *wakeup_hook) { Arena *arena = arena_alloc(); ctrl_state = push_array(arena, CTRL_State, 1); ctrl_state->arena = arena; ctrl_state->wakeup_hook = wakeup_hook; for(Architecture arch = (Architecture)0; arch < Architecture_COUNT; arch = (Architecture)(arch+1)) { String8 *reg_names = regs_reg_code_string_table_from_architecture(arch); U64 reg_count = regs_reg_code_count_from_architecture(arch); String8 *alias_names = regs_alias_code_string_table_from_architecture(arch); U64 alias_count = regs_alias_code_count_from_architecture(arch); ctrl_state->arch_string2reg_tables[arch] = eval_string2num_map_make(ctrl_state->arena, 256); ctrl_state->arch_string2alias_tables[arch] = eval_string2num_map_make(ctrl_state->arena, 256); for(U64 idx = 1; idx < reg_count; idx += 1) { eval_string2num_map_insert(ctrl_state->arena, &ctrl_state->arch_string2reg_tables[arch], reg_names[idx], idx); } for(U64 idx = 1; idx < alias_count; idx += 1) { eval_string2num_map_insert(ctrl_state->arena, &ctrl_state->arch_string2alias_tables[arch], alias_names[idx], idx); } } ctrl_state->process_memory_cache.slots_count = 256; ctrl_state->process_memory_cache.slots = push_array(arena, CTRL_ProcessMemoryCacheSlot, ctrl_state->process_memory_cache.slots_count); ctrl_state->process_memory_cache.stripes_count = 8; ctrl_state->process_memory_cache.stripes = push_array(arena, CTRL_ProcessMemoryCacheStripe, ctrl_state->process_memory_cache.stripes_count); for(U64 idx = 0; idx < ctrl_state->process_memory_cache.stripes_count; idx += 1) { ctrl_state->process_memory_cache.stripes[idx].rw_mutex = os_rw_mutex_alloc(); } ctrl_state->u2c_ring_size = KB(64); ctrl_state->u2c_ring_base = push_array_no_zero(arena, U8, ctrl_state->u2c_ring_size); ctrl_state->u2c_ring_mutex = os_mutex_alloc(); ctrl_state->u2c_ring_cv = os_condition_variable_alloc(); ctrl_state->c2u_ring_size = KB(64); ctrl_state->c2u_ring_base = push_array_no_zero(arena, U8, ctrl_state->c2u_ring_size); ctrl_state->c2u_ring_mutex = os_mutex_alloc(); ctrl_state->c2u_ring_cv = os_condition_variable_alloc(); ctrl_state->demon_event_arena = arena_alloc(); ctrl_state->user_entry_point_arena = arena_alloc(); for(CTRL_ExceptionCodeKind k = (CTRL_ExceptionCodeKind)0; k < CTRL_ExceptionCodeKind_COUNT; k = (CTRL_ExceptionCodeKind)(k+1)) { if(ctrl_exception_code_kind_default_enable_table[k]) { ctrl_state->exception_code_filters[k/64] |= 1ull<<(k%64); } } ctrl_state->u2ms_ring_size = KB(64); ctrl_state->u2ms_ring_base = push_array(arena, U8, ctrl_state->u2ms_ring_size); ctrl_state->u2ms_ring_mutex = os_mutex_alloc(); ctrl_state->u2ms_ring_cv = os_condition_variable_alloc(); ctrl_state->ctrl_thread = os_launch_thread(ctrl_thread__entry_point, 0, 0); ctrl_state->ms_thread_count = Min(4, os_logical_core_count()-1); ctrl_state->ms_threads = push_array(arena, OS_Handle, ctrl_state->ms_thread_count); for(U64 idx = 0; idx < ctrl_state->ms_thread_count; idx += 1) { ctrl_state->ms_threads[idx] = os_launch_thread(ctrl_mem_stream_thread__entry_point, (void *)idx, 0); } } //////////////////////////////// //~ rjf: Basic Type Functions internal U64 ctrl_hash_from_string(String8 string) { U64 result = 5381; for(U64 i = 0; i < string.size; i += 1) { result = ((result << 5) + result) + string.str[i]; } return result; } internal CTRL_EventCause ctrl_event_cause_from_demon_event_kind(DEMON_EventKind event_kind) { CTRL_EventCause cause = CTRL_EventCause_Null; switch(event_kind) { default:{}break; case DEMON_EventKind_Error: {cause = CTRL_EventCause_Error;}break; case DEMON_EventKind_Exception:{cause = CTRL_EventCause_InterruptedByException;}break; case DEMON_EventKind_Trap: {cause = CTRL_EventCause_InterruptedByTrap;}break; case DEMON_EventKind_Halt: {cause = CTRL_EventCause_InterruptedByHalt;}break; } return cause; } internal B32 ctrl_handle_match(CTRL_Handle a, CTRL_Handle b) { return MemoryMatchStruct(&a, &b); } //////////////////////////////// //~ rjf: Ctrl <-> Demon Handle Translation Functions internal DEMON_Handle ctrl_demon_handle_from_ctrl(CTRL_Handle h) { DEMON_Handle result = h.u64[0]; return result; } internal CTRL_Handle ctrl_handle_from_demon(DEMON_Handle h) { CTRL_Handle result = {h}; return result; } //////////////////////////////// //~ rjf: Machine/Handle Pair Type Functions internal void ctrl_machine_id_handle_pair_list_push(Arena *arena, CTRL_MachineIDHandlePairList *list, CTRL_MachineIDHandlePair *pair) { CTRL_MachineIDHandlePairNode *n = push_array(arena, CTRL_MachineIDHandlePairNode, 1); MemoryCopyStruct(&n->v, pair); SLLQueuePush(list->first, list->last, n); list->count += 1; } internal CTRL_MachineIDHandlePairList ctrl_machine_id_handle_pair_list_copy(Arena *arena, CTRL_MachineIDHandlePairList *src) { CTRL_MachineIDHandlePairList dst = {0}; for(CTRL_MachineIDHandlePairNode *n = src->first; n != 0; n = n->next) { ctrl_machine_id_handle_pair_list_push(arena, &dst, &n->v); } return dst; } //////////////////////////////// //~ rjf: Trap Type Functions internal void ctrl_trap_list_push(Arena *arena, CTRL_TrapList *list, CTRL_Trap *trap) { CTRL_TrapNode *node = push_array(arena, CTRL_TrapNode, 1); MemoryCopyStruct(&node->v, trap); SLLQueuePush(list->first, list->last, node); list->count += 1; } internal CTRL_TrapList ctrl_trap_list_copy(Arena *arena, CTRL_TrapList *src) { CTRL_TrapList dst = {0}; for(CTRL_TrapNode *src_n = src->first; src_n != 0; src_n = src_n->next) { ctrl_trap_list_push(arena, &dst, &src_n->v); } return dst; } //////////////////////////////// //~ rjf: User Breakpoint Type Functions internal void ctrl_user_breakpoint_list_push(Arena *arena, CTRL_UserBreakpointList *list, CTRL_UserBreakpoint *bp) { CTRL_UserBreakpointNode *n = push_array(arena, CTRL_UserBreakpointNode, 1); MemoryCopyStruct(&n->v, bp); SLLQueuePush(list->first, list->last, n); list->count += 1; } internal CTRL_UserBreakpointList ctrl_user_breakpoint_list_copy(Arena *arena, CTRL_UserBreakpointList *src) { CTRL_UserBreakpointList dst = {0}; for(CTRL_UserBreakpointNode *src_n = src->first; src_n != 0; src_n = src_n->next) { CTRL_UserBreakpoint dst_bp = zero_struct; MemoryCopyStruct(&dst_bp, &src_n->v); dst_bp.string = push_str8_copy(arena, src_n->v.string); dst_bp.condition = push_str8_copy(arena, src_n->v.condition); ctrl_user_breakpoint_list_push(arena, &dst, &dst_bp); } return dst; } internal void ctrl_append_resolved_module_user_bp_traps(Arena *arena, DEMON_Handle process, DEMON_Handle module, CTRL_UserBreakpointList *user_bps, DEMON_TrapChunkList *traps_out) { Temp scratch = scratch_begin(&arena, 1); DBGI_Scope *scope = dbgi_scope_open(); String8 exe_path = demon_full_path_from_module(scratch.arena, module); DBGI_Parse *dbgi = dbgi_parse_from_exe_path(scope, exe_path, max_U64); RADDBG_Parsed *rdbg = &dbgi->rdbg; U64 base_vaddr = demon_base_vaddr_from_module(module); for(CTRL_UserBreakpointNode *n = user_bps->first; n != 0; n = n->next) { CTRL_UserBreakpoint *bp = &n->v; switch(bp->kind) { default:{}break; //- rjf: file:line-based breakpoints case CTRL_UserBreakpointKind_FileNameAndLineColNumber: { // rjf: unpack & normalize TxtPt pt = bp->pt; String8 filename = bp->string; String8 filename_normalized = push_str8_copy(scratch.arena, filename); for(U64 idx = 0; idx < filename_normalized.size; idx += 1) { filename_normalized.str[idx] = char_to_lower(filename_normalized.str[idx]); filename_normalized.str[idx] = char_to_correct_slash(filename_normalized.str[idx]); } // rjf: filename -> src_id U32 src_id = 0; { RADDBG_NameMap *mapptr = raddbg_name_map_from_kind(rdbg, RADDBG_NameMapKind_NormalSourcePaths); if(mapptr != 0) { RADDBG_ParsedNameMap map = {0}; raddbg_name_map_parse(rdbg, mapptr, &map); RADDBG_NameMapNode *node = raddbg_name_map_lookup(rdbg, &map, filename_normalized.str, filename_normalized.size); if(node != 0) { U32 id_count = 0; U32 *ids = raddbg_matches_from_map_node(rdbg, node, &id_count); if(id_count > 0) { src_id = ids[0]; } } } } // rjf: src_id * pt -> push if(0 < src_id && src_id < rdbg->source_file_count) { RADDBG_SourceFile *src = rdbg->source_files + src_id; RADDBG_ParsedLineMap line_map = {0}; raddbg_line_map_from_source_file(rdbg, src, &line_map); U32 voff_count = 0; U64 *voffs = raddbg_line_voffs_from_num(&line_map, pt.line, &voff_count); for(U32 i = 0; i < voff_count; i += 1) { U64 vaddr = voffs[i] + base_vaddr; DEMON_Trap trap = {process, vaddr, (U64)bp}; demon_trap_chunk_list_push(arena, traps_out, 256, &trap); } } }break; //- rjf: symbol:voff-based breakpoints case CTRL_UserBreakpointKind_SymbolNameAndOffset: { String8 symbol_name = bp->string; U64 voff = bp->u64; if(rdbg != 0 && rdbg->procedures != 0) { RADDBG_NameMap *mapptr = raddbg_name_map_from_kind(rdbg, RADDBG_NameMapKind_Procedures); if(mapptr != 0) { RADDBG_ParsedNameMap map = {0}; raddbg_name_map_parse(rdbg, mapptr, &map); RADDBG_NameMapNode *node = raddbg_name_map_lookup(rdbg, &map, symbol_name.str, symbol_name.size); if(node != 0) { U32 id_count = 0; U32 *ids = raddbg_matches_from_map_node(rdbg, node, &id_count); for(U32 match_i = 0; match_i < id_count; match_i += 1) { U64 proc_voff = raddbg_first_voff_from_proc(rdbg, ids[match_i]); U64 proc_vaddr = proc_voff + base_vaddr; DEMON_Trap trap = {process, proc_vaddr + voff, (U64)bp}; demon_trap_chunk_list_push(arena, traps_out, 256, &trap); } } } } }break; } } dbgi_scope_close(scope); scratch_end(scratch); } internal void ctrl_append_resolved_process_user_bp_traps(Arena *arena, DEMON_Handle process, CTRL_UserBreakpointList *user_bps, DEMON_TrapChunkList *traps_out) { for(CTRL_UserBreakpointNode *n = user_bps->first; n != 0; n = n->next) { CTRL_UserBreakpoint *bp = &n->v; if(bp->kind == CTRL_UserBreakpointKind_VirtualAddress) { DEMON_Trap trap = {process, bp->u64, (U64)bp}; demon_trap_chunk_list_push(arena, traps_out, 256, &trap); } } } //////////////////////////////// //~ rjf: Message Type Functions //- rjf: deep copying internal void ctrl_msg_deep_copy(Arena *arena, CTRL_Msg *dst, CTRL_Msg *src) { MemoryCopyStruct(dst, src); dst->path = push_str8_copy(arena, src->path); dst->strings = str8_list_copy(arena, &src->strings); dst->cmd_line_string_list = str8_list_copy(arena, &src->cmd_line_string_list); dst->env_string_list = str8_list_copy(arena, &src->env_string_list); dst->traps = ctrl_trap_list_copy(arena, &src->traps); dst->user_bps = ctrl_user_breakpoint_list_copy(arena, &src->user_bps); dst->freeze_state_threads = ctrl_machine_id_handle_pair_list_copy(arena, &src->freeze_state_threads); } //- rjf: list building internal CTRL_Msg * ctrl_msg_list_push(Arena *arena, CTRL_MsgList *list) { CTRL_MsgNode *n = push_array(arena, CTRL_MsgNode, 1); SLLQueuePush(list->first, list->last, n); list->count += 1; CTRL_Msg *msg = &n->v; return msg; } //- rjf: serialization internal String8 ctrl_serialized_string_from_msg_list(Arena *arena, CTRL_MsgList *msgs) { Temp scratch = scratch_begin(&arena, 1); String8List msgs_srlzed = {0}; str8_serial_begin(scratch.arena, &msgs_srlzed); { // rjf: write message count str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msgs->count); // rjf: write all message data for(CTRL_MsgNode *msg_n = msgs->first; msg_n != 0; msg_n = msg_n->next) { CTRL_Msg *msg = &msg_n->v; // rjf: write flat parts str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->kind); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->msg_id); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->machine_id); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->entity); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->parent); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->entity_id); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->exit_code); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->env_inherit); str8_serial_push_array (scratch.arena, &msgs_srlzed, &msg->exception_code_filters[0], ArrayCount(msg->exception_code_filters)); // rjf: write path string str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->path.size); str8_serial_push_data(scratch.arena, &msgs_srlzed, msg->path.str, msg->path.size); // rjf: write general string list str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->strings.node_count); for(String8Node *n = msg->strings.first; n != 0; n = n->next) { str8_serial_push_struct(scratch.arena, &msgs_srlzed, &n->string.size); str8_serial_push_data(scratch.arena, &msgs_srlzed, n->string.str, n->string.size); } // rjf: write command line string list str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->cmd_line_string_list.node_count); for(String8Node *n = msg->cmd_line_string_list.first; n != 0; n = n->next) { str8_serial_push_struct(scratch.arena, &msgs_srlzed, &n->string.size); str8_serial_push_data(scratch.arena, &msgs_srlzed, n->string.str, n->string.size); } // rjf: write environment string list str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->env_string_list.node_count); for(String8Node *n = msg->env_string_list.first; n != 0; n = n->next) { str8_serial_push_struct(scratch.arena, &msgs_srlzed, &n->string.size); str8_serial_push_data(scratch.arena, &msgs_srlzed, n->string.str, n->string.size); } // rjf: write trap list str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->traps.count); for(CTRL_TrapNode *n = msg->traps.first; n != 0; n = n->next) { CTRL_Trap *trap = &n->v; str8_serial_push_struct(scratch.arena, &msgs_srlzed, &trap->flags); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &trap->vaddr); } // rjf: write user breakpoint list str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->user_bps.count); for(CTRL_UserBreakpointNode *n = msg->user_bps.first; n != 0; n = n->next) { CTRL_UserBreakpoint *bp = &n->v; str8_serial_push_struct(scratch.arena, &msgs_srlzed, &bp->kind); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &bp->string.size); str8_serial_push_data(scratch.arena, &msgs_srlzed, bp->string.str, bp->string.size); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &bp->pt); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &bp->u64); str8_serial_push_struct(scratch.arena, &msgs_srlzed, &bp->condition.size); str8_serial_push_data(scratch.arena, &msgs_srlzed, bp->condition.str, bp->condition.size); } // rjf: write freeze state thread list str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->freeze_state_threads.count); for(CTRL_MachineIDHandlePairNode *n = msg->freeze_state_threads.first; n != 0; n = n->next) { str8_serial_push_struct(scratch.arena, &msgs_srlzed, &n->v); } // rjf: write freeze state str8_serial_push_struct(scratch.arena, &msgs_srlzed, &msg->freeze_state_is_frozen); } } String8 string = str8_serial_end(arena, &msgs_srlzed); scratch_end(scratch); return string; } internal CTRL_MsgList ctrl_msg_list_from_serialized_string(Arena *arena, String8 string) { CTRL_MsgList msgs = {0}; { U64 read_off = 0; // rjf: read message count U64 msg_count = 0; read_off += str8_deserial_read_struct(string, read_off, &msg_count); // rjf: read data for all messages for(U64 msg_idx = 0; msg_idx < msg_count; msg_idx += 1) { // rjf: construct message CTRL_MsgNode *msg_node = push_array(arena, CTRL_MsgNode, 1); SLLQueuePush(msgs.first, msgs.last, msg_node); msgs.count += 1; CTRL_Msg *msg = &msg_node->v; // rjf: read flat data read_off += str8_deserial_read_struct(string, read_off, &msg->kind); read_off += str8_deserial_read_struct(string, read_off, &msg->msg_id); read_off += str8_deserial_read_struct(string, read_off, &msg->machine_id); read_off += str8_deserial_read_struct(string, read_off, &msg->entity); read_off += str8_deserial_read_struct(string, read_off, &msg->parent); read_off += str8_deserial_read_struct(string, read_off, &msg->entity_id); read_off += str8_deserial_read_struct(string, read_off, &msg->exit_code); read_off += str8_deserial_read_struct(string, read_off, &msg->env_inherit); read_off += str8_deserial_read_array (string, read_off, &msg->exception_code_filters[0], ArrayCount(msg->exception_code_filters)); // rjf: read path string read_off += str8_deserial_read_struct(string, read_off, &msg->path.size); msg->path.str = push_array_no_zero(arena, U8, msg->path.size); read_off += str8_deserial_read(string, read_off, msg->path.str, msg->path.size, 1); // rjf: read general string list U64 string_list_string_count = 0; read_off += str8_deserial_read_struct(string, read_off, &string_list_string_count); for(U64 idx = 0; idx < string_list_string_count; idx += 1) { String8 str = {0}; read_off += str8_deserial_read_struct(string, read_off, &str.size); str.str = push_array_no_zero(arena, U8, str.size); read_off += str8_deserial_read(string, read_off, str.str, str.size, 1); str8_list_push(arena, &msg->strings, str); } // rjf: read command line string list U64 cmd_line_string_count = 0; read_off += str8_deserial_read_struct(string, read_off, &cmd_line_string_count); for(U64 idx = 0; idx < cmd_line_string_count; idx += 1) { String8 cmd_line_str = {0}; read_off += str8_deserial_read_struct(string, read_off, &cmd_line_str.size); cmd_line_str.str = push_array_no_zero(arena, U8, cmd_line_str.size); read_off += str8_deserial_read(string, read_off, cmd_line_str.str, cmd_line_str.size, 1); str8_list_push(arena, &msg->cmd_line_string_list, cmd_line_str); } // rjf: read environment string list U64 env_string_count = 0; read_off += str8_deserial_read_struct(string, read_off, &env_string_count); for(U64 idx = 0; idx < env_string_count; idx += 1) { String8 env_str = {0}; read_off += str8_deserial_read_struct(string, read_off, &env_str.size); env_str.str = push_array_no_zero(arena, U8, env_str.size); read_off += str8_deserial_read(string, read_off, env_str.str, env_str.size, 1); str8_list_push(arena, &msg->env_string_list, env_str); } // rjf: read trap list U64 trap_count = 0; read_off += str8_deserial_read_struct(string, read_off, &trap_count); for(U64 idx = 0; idx < trap_count; idx += 1) { CTRL_TrapNode *n = push_array(arena, CTRL_TrapNode, 1); SLLQueuePush(msg->traps.first, msg->traps.last, n); msg->traps.count += 1; CTRL_Trap *trap = &n->v; read_off += str8_deserial_read_struct(string, read_off, &trap->flags); read_off += str8_deserial_read_struct(string, read_off, &trap->vaddr); } // rjf: read user breakpoint list U64 user_bp_count = 0; read_off += str8_deserial_read_struct(string, read_off, &user_bp_count); for(U64 idx = 0; idx < user_bp_count; idx += 1) { CTRL_UserBreakpointNode *n = push_array(arena, CTRL_UserBreakpointNode, 1); SLLQueuePush(msg->user_bps.first, msg->user_bps.last, n); msg->user_bps.count += 1; CTRL_UserBreakpoint *bp = &n->v; read_off += str8_deserial_read_struct(string, read_off, &bp->kind); read_off += str8_deserial_read_struct(string, read_off, &bp->string.size); bp->string.str = push_array_no_zero(arena, U8, bp->string.size); read_off += str8_deserial_read(string, read_off, bp->string.str, bp->string.size, 1); read_off += str8_deserial_read_struct(string, read_off, &bp->pt); read_off += str8_deserial_read_struct(string, read_off, &bp->u64); read_off += str8_deserial_read_struct(string, read_off, &bp->condition.size); bp->condition.str = push_array_no_zero(arena, U8, bp->condition.size); read_off += str8_deserial_read(string, read_off, bp->condition.str, bp->condition.size, 1); } // rjf: read freeze state thread list U64 frozen_thread_count = 0; read_off += str8_deserial_read_struct(string, read_off, &frozen_thread_count); for(U64 idx = 0; idx < frozen_thread_count; idx += 1) { CTRL_MachineIDHandlePair pair = {0}; read_off += str8_deserial_read_struct(string, read_off, &pair); ctrl_machine_id_handle_pair_list_push(arena, &msg->freeze_state_threads, &pair); } // rjf: read freeze state read_off += str8_deserial_read_struct(string, read_off, &msg->freeze_state_is_frozen); } } return msgs; } //////////////////////////////// //~ rjf: Event Type Functions //- rjf: list building internal CTRL_Event * ctrl_event_list_push(Arena *arena, CTRL_EventList *list) { CTRL_EventNode *n = push_array(arena, CTRL_EventNode, 1); SLLQueuePush(list->first, list->last, n); list->count += 1; CTRL_Event *event = &n->v; return event; } internal void ctrl_event_list_concat_in_place(CTRL_EventList *dst, CTRL_EventList *to_push) { if(dst->last == 0) { MemoryCopyStruct(dst, to_push); } else if(to_push->first != 0) { dst->last->next = to_push->first; dst->last = to_push->last; dst->count += to_push->count; } MemoryZeroStruct(to_push); } //- rjf: serialization internal String8 ctrl_serialized_string_from_event(Arena *arena, CTRL_Event *event) { Temp scratch = scratch_begin(&arena, 1); String8List srl = {0}; str8_serial_begin(scratch.arena, &srl);; { str8_serial_push_struct(scratch.arena, &srl, &event->kind); str8_serial_push_struct(scratch.arena, &srl, &event->cause); str8_serial_push_struct(scratch.arena, &srl, &event->exception_kind); str8_serial_push_struct(scratch.arena, &srl, &event->msg_id); str8_serial_push_struct(scratch.arena, &srl, &event->machine_id); str8_serial_push_struct(scratch.arena, &srl, &event->entity); str8_serial_push_struct(scratch.arena, &srl, &event->parent); str8_serial_push_struct(scratch.arena, &srl, &event->arch); str8_serial_push_struct(scratch.arena, &srl, &event->u64_code); str8_serial_push_struct(scratch.arena, &srl, &event->entity_id); str8_serial_push_struct(scratch.arena, &srl, &event->vaddr_rng); str8_serial_push_struct(scratch.arena, &srl, &event->rip_vaddr); str8_serial_push_struct(scratch.arena, &srl, &event->stack_base); str8_serial_push_struct(scratch.arena, &srl, &event->tls_root); str8_serial_push_struct(scratch.arena, &srl, &event->exception_code); str8_serial_push_struct(scratch.arena, &srl, &event->string.size); str8_serial_push_data(scratch.arena, &srl, event->string.str, event->string.size); } String8 string = str8_serial_end(arena, &srl); scratch_end(scratch); return string; } internal CTRL_Event ctrl_event_from_serialized_string(Arena *arena, String8 string) { CTRL_Event event = zero_struct; { U64 read_off = 0; read_off += str8_deserial_read_struct(string, read_off, &event.kind); read_off += str8_deserial_read_struct(string, read_off, &event.cause); read_off += str8_deserial_read_struct(string, read_off, &event.exception_kind); read_off += str8_deserial_read_struct(string, read_off, &event.msg_id); read_off += str8_deserial_read_struct(string, read_off, &event.machine_id); read_off += str8_deserial_read_struct(string, read_off, &event.entity); read_off += str8_deserial_read_struct(string, read_off, &event.parent); read_off += str8_deserial_read_struct(string, read_off, &event.arch); read_off += str8_deserial_read_struct(string, read_off, &event.u64_code); read_off += str8_deserial_read_struct(string, read_off, &event.entity_id); read_off += str8_deserial_read_struct(string, read_off, &event.vaddr_rng); read_off += str8_deserial_read_struct(string, read_off, &event.rip_vaddr); read_off += str8_deserial_read_struct(string, read_off, &event.stack_base); read_off += str8_deserial_read_struct(string, read_off, &event.tls_root); read_off += str8_deserial_read_struct(string, read_off, &event.exception_code); read_off += str8_deserial_read_struct(string, read_off, &event.string.size); event.string.str = push_array_no_zero(arena, U8, event.string.size); read_off += str8_deserial_read(string, read_off, event.string.str, event.string.size, 1); } return event; } //////////////////////////////// //~ rjf: Shared Functions //- rjf: run index internal U64 ctrl_run_idx(void) { U64 result = ins_atomic_u64_eval(&ctrl_state->run_idx); return result; } internal U64 ctrl_memgen_idx(void) { U64 result = ins_atomic_u64_eval(&ctrl_state->memgen_idx); return result; } internal U64 ctrl_reggen_idx(void) { U64 result = ins_atomic_u64_eval(&ctrl_state->reggen_idx); return result; } //- rjf: halt everything internal void ctrl_halt(void) { demon_halt(0, 0); } //- rjf: entity introspection internal U32 ctrl_id_from_machine_entity(CTRL_MachineID id, DEMON_Handle handle) { U32 result = 0; return result; } //- rjf: exe -> dbg path mapping internal String8 ctrl_inferred_og_dbg_path_from_exe_path(Arena *arena, String8 exe_path) { Temp scratch = scratch_begin(&arena, 1); String8 result = {0}; { // TODO(rjf): do preliminary header parse of EXE if possible, look for connected debug info path } scratch_end(scratch); return result; } internal String8 ctrl_forced_og_dbg_path_from_exe_path(Arena *arena, String8 exe_path) { String8 result = {0}; // TODO(rjf) return result; } internal String8 ctrl_natural_og_dbg_path_from_exe_path(Arena *arena, String8 exe_path) { String8 exe_extension = str8_skip_last_dot(exe_path); String8 dbg_extension = {0}; if(str8_match(exe_extension, str8_lit("exe"), 0)) {dbg_extension = str8_lit("pdb");} if(str8_match(exe_extension, str8_lit("elf"), 0)) {dbg_extension = str8_lit("debug");} String8 result = {0}; if(dbg_extension.size != 0) { result = push_str8f(arena, "%S.%S", str8_chop_last_dot(exe_path), dbg_extension); } return result; } internal String8 ctrl_og_dbg_path_from_exe_path(Arena *arena, String8 exe_path) { Temp scratch = scratch_begin(&arena, 1); String8 forced_og_dbg_path = ctrl_forced_og_dbg_path_from_exe_path(scratch.arena, exe_path); String8 inferred_og_dbg_path = ctrl_inferred_og_dbg_path_from_exe_path(scratch.arena, exe_path); String8 natural_og_dbg_path = ctrl_natural_og_dbg_path_from_exe_path(scratch.arena, exe_path); String8 og_dbg_path = forced_og_dbg_path.size?forced_og_dbg_path : inferred_og_dbg_path.size?inferred_og_dbg_path : natural_og_dbg_path; og_dbg_path = push_str8_copy(arena, og_dbg_path); scratch_end(scratch); return og_dbg_path; } //- rjf: handle -> arch internal Architecture ctrl_arch_from_handle(CTRL_MachineID machine, CTRL_Handle handle) { return demon_arch_from_object(ctrl_demon_handle_from_ctrl(handle)); } //- rjf: process memory reading/writing internal U64 ctrl_process_read(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, void *dst) { U64 actual_bytes_read = demon_read_memory(ctrl_demon_handle_from_ctrl(process), dst, range.min, dim_1u64(range)); return actual_bytes_read; } internal B32 ctrl_process_write(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, void *src) { ProfBeginFunction(); U64 size = dim_1u64(range); B32 result = demon_write_memory(ctrl_demon_handle_from_ctrl(process), range.min, src, size); if(result) { ins_atomic_u64_inc_eval(&ctrl_state->memgen_idx); } ProfEnd(); return result; } //- rjf: process memory cache interaction internal U128 ctrl_hash_store_key_from_process_vaddr_range(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, B32 zero_terminated) { U64 key_hash_data[] = { (U64)machine_id, (U64)process.u64[0], range.min, range.max, (U64)zero_terminated, }; U128 key = hs_hash_from_data(str8((U8*)key_hash_data, sizeof(key_hash_data))); return key; } internal U128 ctrl_stored_hash_from_process_vaddr_range(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, B32 zero_terminated) { U128 result = {0}; U64 size = dim_1u64(range); if(size != 0) { CTRL_ProcessMemoryCache *cache = &ctrl_state->process_memory_cache; U64 process_hash = ctrl_hash_from_string(str8_struct(&process)); U64 process_slot_idx = process_hash%cache->slots_count; U64 process_stripe_idx = process_slot_idx%cache->stripes_count; CTRL_ProcessMemoryCacheSlot *process_slot = &cache->slots[process_slot_idx]; CTRL_ProcessMemoryCacheStripe *process_stripe = &cache->stripes[process_stripe_idx]; U64 range_hash = ctrl_hash_from_string(str8_struct(&range)); //- rjf: try to read from cache B32 is_good = 0; B32 is_stale = 0; OS_MutexScopeR(process_stripe->rw_mutex) { for(CTRL_ProcessMemoryCacheNode *n = process_slot->first; n != 0; n = n->next) { if(n->machine_id == machine_id && ctrl_handle_match(n->process, process)) { U64 range_slot_idx = range_hash%n->range_hash_slots_count; CTRL_ProcessMemoryRangeHashSlot *range_slot = &n->range_hash_slots[range_slot_idx]; for(CTRL_ProcessMemoryRangeHashNode *range_n = range_slot->first; range_n != 0; range_n = range_n->next) { if(MemoryMatchStruct(&range_n->vaddr_range, &range) && range_n->zero_terminated == zero_terminated) { result = range_n->hash; is_good = 1; is_stale = range_n->memgen_idx < ctrl_memgen_idx(); goto read_cache__break_all; } } } } read_cache__break_all:; } //- rjf: not good -> create process cache node if necessary if(!is_good) { OS_MutexScopeW(process_stripe->rw_mutex) { B32 process_node_exists = 0; for(CTRL_ProcessMemoryCacheNode *n = process_slot->first; n != 0; n = n->next) { if(n->machine_id == machine_id && ctrl_handle_match(n->process, process)) { process_node_exists = 1; break; } } if(!process_node_exists) { Arena *node_arena = arena_alloc(); CTRL_ProcessMemoryCacheNode *node = push_array(node_arena, CTRL_ProcessMemoryCacheNode, 1); node->arena = node_arena; node->machine_id = machine_id; node->process = process; node->range_hash_slots_count = 1024; node->range_hash_slots = push_array(node_arena, CTRL_ProcessMemoryRangeHashSlot, node->range_hash_slots_count); DLLPushBack(process_slot->first, process_slot->last, node); } } } //- rjf: not good -> create range node if necessary if(!is_good) { OS_MutexScopeW(process_stripe->rw_mutex) { for(CTRL_ProcessMemoryCacheNode *n = process_slot->first; n != 0; n = n->next) { if(n->machine_id == machine_id && ctrl_handle_match(n->process, process)) { U64 range_slot_idx = range_hash%n->range_hash_slots_count; CTRL_ProcessMemoryRangeHashSlot *range_slot = &n->range_hash_slots[range_slot_idx]; B32 range_node_exists = 0; for(CTRL_ProcessMemoryRangeHashNode *range_n = range_slot->first; range_n != 0; range_n = range_n->next) { if(MemoryMatchStruct(&range_n->vaddr_range, &range) && range_n->zero_terminated == zero_terminated) { range_node_exists = 1; break; } } if(!range_node_exists) { CTRL_ProcessMemoryRangeHashNode *range_n = push_array(n->arena, CTRL_ProcessMemoryRangeHashNode, 1); SLLQueuePush(range_slot->first, range_slot->last, range_n); range_n->vaddr_range = range; range_n->zero_terminated = zero_terminated; break; } } } } } //- rjf: not good, or is stale -> submit hash request if(!is_good || is_stale) { ctrl_u2ms_enqueue_req(machine_id, process, range, zero_terminated, 0); } } return result; } //- rjf: process memory cache reading helpers internal CTRL_ProcessMemorySlice ctrl_query_cached_data_from_process_vaddr_range(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range) { CTRL_ProcessMemorySlice result = {0}; result.byte_bad_flags = push_array(arena, U64, (dim_1u64(range)+63)/64); result.byte_changed_flags = push_array(arena, U64, (dim_1u64(range)+63)/64); if(range.max > range.min && dim_1u64(range) <= MB(256) && range.min <= 0x000FFFFFFFFFFFFFull && range.max <= 0x000FFFFFFFFFFFFFull) { Temp scratch = scratch_begin(&arena, 1); HS_Scope *scope = hs_scope_open(); CTRL_ProcessMemoryCache *cache = &ctrl_state->process_memory_cache; //- rjf: unpack address range, prepare per-touched-page info U64 page_size = KB(4); Rng1U64 page_range = r1u64(AlignDownPow2(range.min, page_size), AlignPow2(range.max, page_size)); U64 page_count = dim_1u64(page_range)/page_size; U128 *page_hashes = push_array(scratch.arena, U128, page_count); U128 *page_last_hashes = push_array(scratch.arena, U128, page_count); //- rjf: gather hashes & last-hashes for each page for(U64 page_idx = 0; page_idx < page_count; page_idx += 1) { U64 page_base_vaddr = page_range.min + page_idx*page_size; U128 page_key = ctrl_hash_store_key_from_process_vaddr_range(machine_id, process, r1u64(page_base_vaddr, page_base_vaddr+page_size), 0); U128 page_hash = ctrl_stored_hash_from_process_vaddr_range(machine_id, process, r1u64(page_base_vaddr, page_base_vaddr+page_size), 0); U128 page_last_hash = hs_hash_from_key(page_key, 1); page_hashes[page_idx] = page_hash; page_last_hashes[page_idx] = page_last_hash; } //- rjf: setup output buffers void *read_out = push_array(arena, U8, dim_1u64(range)); U64 *byte_bad_flags = result.byte_bad_flags; U64 *byte_changed_flags = result.byte_changed_flags; //- rjf: iterate pages, fill output { U64 write_off = 0; for(U64 page_idx = 0; page_idx < page_count; page_idx += 1) { // rjf: read data for this page String8 data = hs_data_from_hash(scope, page_hashes[page_idx]); Rng1U64 data_vaddr_range = r1u64(page_range.min + page_idx*page_size, page_range.min + page_idx*page_size+data.size); // rjf: skip/chop bytes which are irrelevant for the actual requested read String8 in_range_data = data; if(page_idx == page_count-1 && data_vaddr_range.max > range.max) { in_range_data = str8_chop(in_range_data, data_vaddr_range.max-range.max); } if(page_idx == 0 && range.min > data_vaddr_range.min) { in_range_data = str8_skip(in_range_data, range.min-data_vaddr_range.min); } // rjf: write this chunk MemoryCopy((U8*)read_out+write_off, in_range_data.str, in_range_data.size); // rjf: if this page's hash & last_hash don't match, diff each byte & // fill out changed flags if(!u128_match(page_hashes[page_idx], page_last_hashes[page_idx])) { String8 last_data = hs_data_from_hash(scope, page_last_hashes[page_idx]); String8 in_range_last_data = last_data; if(page_idx == page_count-1 && data_vaddr_range.max > range.max) { in_range_last_data = str8_chop(in_range_last_data, data_vaddr_range.max-range.max); } if(page_idx == 0 && range.min > data_vaddr_range.min) { in_range_last_data = str8_skip(in_range_last_data, range.min-data_vaddr_range.min); } for(U64 idx = 0; idx < in_range_data.size; idx += 1) { U8 last_byte = idx < in_range_last_data.size ? in_range_last_data.str[idx] : 0; U8 now_byte = idx < in_range_data.size ? in_range_data.str[idx] : 0; if(last_byte != now_byte) { U64 idx_in_read_out = write_off+idx; byte_changed_flags[idx_in_read_out/64] |= (1ull<<(idx_in_read_out%64)); } } } // rjf: increment past this chunk write_off += in_range_data.size; if(data.size < page_size) { U64 missed_byte_count = page_size-data.size; write_off += missed_byte_count; } } } //- rjf: fill result result.data.str = (U8*)read_out; result.data.size = dim_1u64(range); result.byte_bad_flags = byte_bad_flags; result.byte_changed_flags = byte_changed_flags; hs_scope_close(scope); scratch_end(scratch); } return result; } internal CTRL_ProcessMemorySlice ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, U64 limit, U64 endt_us) { CTRL_ProcessMemorySlice result = ctrl_query_cached_data_from_process_vaddr_range(arena, machine_id, process, r1u64(vaddr, vaddr+limit)); for(U64 idx = 0; idx < result.data.size; idx += 1) { if(result.data.str[idx] == 0) { result.data.size = idx; break; } } return result; } //- rjf: register reading/writing internal void * ctrl_reg_block_from_thread(CTRL_MachineID machine_id, CTRL_Handle thread) { void *regs = demon_read_regs(ctrl_demon_handle_from_ctrl(thread)); return regs; } internal B32 ctrl_thread_write_reg_block(CTRL_MachineID machine_id, CTRL_Handle thread, void *block) { B32 good = demon_write_regs(ctrl_demon_handle_from_ctrl(thread), block); ins_atomic_u64_inc_eval(&ctrl_state->reggen_idx); return good; } internal U64 ctrl_rip_from_thread(CTRL_MachineID machine_id, CTRL_Handle thread) { U64 result = 0; void *regs = ctrl_reg_block_from_thread(machine_id, thread); if(regs != 0) { Architecture arch = demon_arch_from_object(ctrl_demon_handle_from_ctrl(thread)); result = regs_rip_from_arch_block(arch, regs); } return result; } internal B32 ctrl_thread_write_rip(CTRL_MachineID machine_id, CTRL_Handle thread, U64 rip) { B32 result = 0; void *regs = ctrl_reg_block_from_thread(machine_id, thread); if(regs != 0) { Architecture arch = demon_arch_from_object(ctrl_demon_handle_from_ctrl(thread)); regs_arch_block_write_rip(arch, regs, rip); ctrl_thread_write_reg_block(machine_id, thread, regs); result = 1; } return result; } internal U64 ctrl_tls_root_vaddr_from_thread(CTRL_MachineID machine_id, CTRL_Handle thread) { U64 result = 0; DEMON_Handle demon_handle = ctrl_demon_handle_from_ctrl(thread); result = demon_tls_root_vaddr_from_thread(demon_handle); return result; } //- rjf: process * vaddr -> module internal CTRL_Handle ctrl_module_from_process_vaddr(CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr) { CTRL_Handle handle = {0}; { Temp scratch = scratch_begin(0, 0); DEMON_HandleArray modules = demon_modules_from_process(scratch.arena, ctrl_demon_handle_from_ctrl(process)); for(U64 idx = 0; idx < modules.count; idx += 1) { DEMON_Handle m = modules.handles[idx]; Rng1U64 m_vaddr_rng = demon_vaddr_range_from_module(m); if(contains_1u64(m_vaddr_rng, vaddr)) { handle = ctrl_handle_from_demon(m); break; } } scratch_end(scratch); } return handle; } //- rjf: unwinding internal CTRL_Unwind ctrl_unwind_from_process_thread(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, CTRL_Handle thread) { ProfBeginFunction(); Temp scratch = scratch_begin(&arena, 1); DBGI_Scope *scope = dbgi_scope_open(); Architecture arch = demon_arch_from_object(ctrl_demon_handle_from_ctrl(thread)); U64 arch_reg_block_size = regs_block_size_from_architecture(arch); CTRL_Unwind unwind = {0}; unwind.error = 1; switch(arch) { default:{}break; case Architecture_x64: { // rjf: grab initial register block void *regs_block = push_array(scratch.arena, U8, arch_reg_block_size); B32 regs_block_good = 0; { void *regs_raw = ctrl_reg_block_from_thread(machine_id, thread); if(regs_raw != 0) { MemoryCopy(regs_block, regs_raw, arch_reg_block_size); regs_block_good = 1; } } // rjf: grab initial memory view B32 stack_memview_good = 0; UNW_MemView stack_memview = {0}; if(regs_block_good) { U64 stack_base_unrounded = demon_stack_base_vaddr_from_thread(ctrl_demon_handle_from_ctrl(thread)); U64 stack_top_unrounded = regs_rsp_from_arch_block(arch, regs_block); U64 stack_base = AlignPow2(stack_base_unrounded, KB(4)); U64 stack_top = AlignDownPow2(stack_top_unrounded, KB(4)); U64 stack_size = stack_base - stack_top; if(stack_base >= stack_top) { String8 stack_memory = {0}; stack_memory.str = push_array_no_zero(scratch.arena, U8, stack_size); stack_memory.size = ctrl_process_read(machine_id, process, r1u64(stack_top, stack_top+stack_size), stack_memory.str); if(stack_memory.size != 0) { stack_memview_good = 1; stack_memview.data = stack_memory.str; stack_memview.addr_first = stack_top; stack_memview.addr_opl = stack_base; } } } // rjf: loop & unwind UNW_MemView memview = stack_memview; if(stack_memview_good) for(;;) { unwind.error = 0; // rjf: regs -> rip*module*binary U64 rip = regs_rip_from_arch_block(arch, regs_block); CTRL_Handle module = ctrl_module_from_process_vaddr(machine_id, process, rip); // rjf: cancel on 0 rip if(rip == 0) { break; } // rjf: binary -> all the binary info String8 binary_full_path = demon_full_path_from_module(scratch.arena, ctrl_demon_handle_from_ctrl(module)); DBGI_Parse *dbgi = dbgi_parse_from_exe_path(scope, binary_full_path, 0); String8 binary_data = str8((U8 *)dbgi->exe_base, dbgi->exe_props.size); // rjf: cancel on bad data if(binary_data.size == 0) { unwind.error = 1; break; } // rjf: valid step -> push frame CTRL_UnwindFrame *frame = push_array(arena, CTRL_UnwindFrame, 1); frame->rip = rip; frame->regs = push_array_no_zero(arena, U8, arch_reg_block_size); MemoryCopy(frame->regs, regs_block, arch_reg_block_size); SLLQueuePush(unwind.first, unwind.last, frame); unwind.count += 1; // rjf: unwind one step UNW_Result unwind_step = unw_pe_x64(binary_data, &dbgi->pe, demon_vaddr_range_from_module(ctrl_demon_handle_from_ctrl(module)).min, &memview, (UNW_X64_Regs *)regs_block); // rjf: cancel on bad step if(unwind_step.dead != 0) { break; } if(unwind_step.missed_read != 0) { unwind.error = 1; break; } if(unwind_step.stack_pointer == 0) { break; } } }break; } dbgi_scope_close(scope); scratch_end(scratch); ProfEnd(); return unwind; } //- rjf: name -> register/alias hash tables, for eval internal EVAL_String2NumMap * ctrl_string2reg_from_arch(Architecture arch) { return &ctrl_state->arch_string2reg_tables[arch]; } internal EVAL_String2NumMap * ctrl_string2alias_from_arch(Architecture arch) { return &ctrl_state->arch_string2alias_tables[arch]; } //////////////////////////////// //~ rjf: User -> Ctrl Communication internal B32 ctrl_u2c_push_msgs(CTRL_MsgList *msgs, U64 endt_us) { Temp scratch = scratch_begin(0, 0); String8 msgs_srlzed_baked = ctrl_serialized_string_from_msg_list(scratch.arena, msgs); B32 good = 0; OS_MutexScope(ctrl_state->u2c_ring_mutex) for(;;) { U64 unconsumed_size = (ctrl_state->u2c_ring_write_pos-ctrl_state->u2c_ring_read_pos); U64 available_size = ctrl_state->u2c_ring_size-unconsumed_size; if(available_size >= sizeof(U64) + msgs_srlzed_baked.size) { ctrl_state->u2c_ring_write_pos += ring_write_struct(ctrl_state->u2c_ring_base, ctrl_state->u2c_ring_size, ctrl_state->u2c_ring_write_pos, &msgs_srlzed_baked.size); ctrl_state->u2c_ring_write_pos += ring_write(ctrl_state->u2c_ring_base, ctrl_state->u2c_ring_size, ctrl_state->u2c_ring_write_pos, msgs_srlzed_baked.str, msgs_srlzed_baked.size); ctrl_state->u2c_ring_write_pos += 7; ctrl_state->u2c_ring_write_pos -= ctrl_state->u2c_ring_write_pos%8; good = 1; break; } if(os_now_microseconds() >= endt_us) { break; } os_condition_variable_wait(ctrl_state->u2c_ring_cv, ctrl_state->u2c_ring_mutex, endt_us); } if(good) { os_condition_variable_broadcast(ctrl_state->u2c_ring_cv); } scratch_end(scratch); return good; } internal CTRL_MsgList ctrl_u2c_pop_msgs(Arena *arena) { Temp scratch = scratch_begin(&arena, 1); String8 msgs_srlzed_baked = {0}; OS_MutexScope(ctrl_state->u2c_ring_mutex) for(;;) { U64 unconsumed_size = (ctrl_state->u2c_ring_write_pos-ctrl_state->u2c_ring_read_pos); if(unconsumed_size >= sizeof(U64)) { U64 size_to_decode = 0; ctrl_state->u2c_ring_read_pos += ring_read_struct(ctrl_state->u2c_ring_base, ctrl_state->u2c_ring_size, ctrl_state->u2c_ring_read_pos, &size_to_decode); msgs_srlzed_baked.size = size_to_decode; msgs_srlzed_baked.str = push_array_no_zero(scratch.arena, U8, msgs_srlzed_baked.size); ctrl_state->u2c_ring_read_pos += ring_read(ctrl_state->u2c_ring_base, ctrl_state->u2c_ring_size, ctrl_state->u2c_ring_read_pos, msgs_srlzed_baked.str, size_to_decode); ctrl_state->u2c_ring_read_pos += 7; ctrl_state->u2c_ring_read_pos -= ctrl_state->u2c_ring_read_pos%8; break; } os_condition_variable_wait(ctrl_state->u2c_ring_cv, ctrl_state->u2c_ring_mutex, max_U64); } os_condition_variable_broadcast(ctrl_state->u2c_ring_cv); CTRL_MsgList msgs = ctrl_msg_list_from_serialized_string(arena, msgs_srlzed_baked); scratch_end(scratch); return msgs; } //////////////////////////////// //~ rjf: Ctrl -> User Communication internal void ctrl_c2u_push_events(CTRL_EventList *events) { if(events->count != 0) ProfScope("ctrl_c2u_push_events") { for(CTRL_EventNode *n = events->first; n != 0; n = n ->next) { Temp scratch = scratch_begin(0, 0); String8 event_srlzed = ctrl_serialized_string_from_event(scratch.arena, &n->v); OS_MutexScope(ctrl_state->c2u_ring_mutex) for(;;) { U64 unconsumed_size = (ctrl_state->c2u_ring_write_pos-ctrl_state->c2u_ring_read_pos); U64 available_size = ctrl_state->c2u_ring_size-unconsumed_size; if(available_size >= sizeof(U64) + event_srlzed.size) { ctrl_state->c2u_ring_write_pos += ring_write_struct(ctrl_state->c2u_ring_base, ctrl_state->c2u_ring_size, ctrl_state->c2u_ring_write_pos, &event_srlzed.size); ctrl_state->c2u_ring_write_pos += ring_write(ctrl_state->c2u_ring_base, ctrl_state->c2u_ring_size, ctrl_state->c2u_ring_write_pos, event_srlzed.str, event_srlzed.size); ctrl_state->c2u_ring_write_pos += 7; ctrl_state->c2u_ring_write_pos -= ctrl_state->c2u_ring_write_pos%8; break; } os_condition_variable_wait(ctrl_state->c2u_ring_cv, ctrl_state->c2u_ring_mutex, os_now_microseconds()+100); } os_condition_variable_broadcast(ctrl_state->c2u_ring_cv); if(ctrl_state->wakeup_hook != 0) { ctrl_state->wakeup_hook(); } scratch_end(scratch); } } } internal CTRL_EventList ctrl_c2u_pop_events(Arena *arena) { ProfBeginFunction(); Temp scratch = scratch_begin(&arena, 1); CTRL_EventList events = {0}; OS_MutexScope(ctrl_state->c2u_ring_mutex) for(;;) { U64 unconsumed_size = (ctrl_state->c2u_ring_write_pos-ctrl_state->c2u_ring_read_pos); if(unconsumed_size >= sizeof(U64)) { U64 size_to_decode = 0; ctrl_state->c2u_ring_read_pos += ring_read_struct(ctrl_state->c2u_ring_base, ctrl_state->c2u_ring_size, ctrl_state->c2u_ring_read_pos, &size_to_decode); String8 event_srlzed = {0}; event_srlzed.size = size_to_decode; event_srlzed.str = push_array_no_zero(scratch.arena, U8, event_srlzed.size); ctrl_state->c2u_ring_read_pos += ring_read(ctrl_state->c2u_ring_base, ctrl_state->c2u_ring_size, ctrl_state->c2u_ring_read_pos, event_srlzed.str, event_srlzed.size); ctrl_state->c2u_ring_read_pos += 7; ctrl_state->c2u_ring_read_pos -= ctrl_state->c2u_ring_read_pos%8; CTRL_Event *new_event = ctrl_event_list_push(arena, &events); *new_event = ctrl_event_from_serialized_string(arena, event_srlzed); } else { break; } } os_condition_variable_broadcast(ctrl_state->c2u_ring_cv); scratch_end(scratch); ProfEnd(); return events; } //////////////////////////////// //~ rjf: User -> Memory Stream Communication internal B32 ctrl_u2ms_enqueue_req(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 vaddr_range, B32 zero_terminated, U64 endt_us) { B32 good = 0; OS_MutexScope(ctrl_state->u2ms_ring_mutex) for(;;) { U64 unconsumed_size = ctrl_state->u2ms_ring_write_pos-ctrl_state->u2ms_ring_read_pos; U64 available_size = ctrl_state->u2ms_ring_size-unconsumed_size; if(available_size >= sizeof(machine_id)+sizeof(process)+sizeof(vaddr_range)) { good = 1; ctrl_state->u2ms_ring_write_pos += ring_write_struct(ctrl_state->u2ms_ring_base, ctrl_state->u2ms_ring_size, ctrl_state->u2ms_ring_write_pos, &machine_id); ctrl_state->u2ms_ring_write_pos += ring_write_struct(ctrl_state->u2ms_ring_base, ctrl_state->u2ms_ring_size, ctrl_state->u2ms_ring_write_pos, &process); ctrl_state->u2ms_ring_write_pos += ring_write_struct(ctrl_state->u2ms_ring_base, ctrl_state->u2ms_ring_size, ctrl_state->u2ms_ring_write_pos, &vaddr_range); ctrl_state->u2ms_ring_write_pos += ring_write_struct(ctrl_state->u2ms_ring_base, ctrl_state->u2ms_ring_size, ctrl_state->u2ms_ring_write_pos, &zero_terminated); break; } if(os_now_microseconds() >= endt_us) {break;} os_condition_variable_wait(ctrl_state->u2ms_ring_cv, ctrl_state->u2ms_ring_mutex, endt_us); } os_condition_variable_broadcast(ctrl_state->u2ms_ring_cv); return good; } internal void ctrl_u2ms_dequeue_req(CTRL_MachineID *out_machine_id, CTRL_Handle *out_process, Rng1U64 *out_vaddr_range, B32 *out_zero_terminated) { OS_MutexScope(ctrl_state->u2ms_ring_mutex) for(;;) { U64 unconsumed_size = ctrl_state->u2ms_ring_write_pos-ctrl_state->u2ms_ring_read_pos; if(unconsumed_size >= sizeof(*out_machine_id)+sizeof(*out_process)+sizeof(*out_vaddr_range)) { ctrl_state->u2ms_ring_read_pos += ring_read_struct(ctrl_state->u2ms_ring_base, ctrl_state->u2ms_ring_size, ctrl_state->u2ms_ring_read_pos, out_machine_id); ctrl_state->u2ms_ring_read_pos += ring_read_struct(ctrl_state->u2ms_ring_base, ctrl_state->u2ms_ring_size, ctrl_state->u2ms_ring_read_pos, out_process); ctrl_state->u2ms_ring_read_pos += ring_read_struct(ctrl_state->u2ms_ring_base, ctrl_state->u2ms_ring_size, ctrl_state->u2ms_ring_read_pos, out_vaddr_range); ctrl_state->u2ms_ring_read_pos += ring_read_struct(ctrl_state->u2ms_ring_base, ctrl_state->u2ms_ring_size, ctrl_state->u2ms_ring_read_pos, out_zero_terminated); break; } os_condition_variable_wait(ctrl_state->u2ms_ring_cv, ctrl_state->u2ms_ring_mutex, max_U64); } os_condition_variable_broadcast(ctrl_state->u2ms_ring_cv); } //////////////////////////////// //~ rjf: Control-Thread-Only Functions //- rjf: entry point internal void ctrl_thread__entry_point(void *p) { TCTX tctx_; tctx_init_and_equip(&tctx_); ThreadName("[ctrl] thread"); ProfBeginFunction(); demon_primary_thread_begin(); Temp scratch = scratch_begin(0, 0); for(;;) { temp_end(scratch); //- rjf: get next messages CTRL_MsgList msgs = ctrl_u2c_pop_msgs(scratch.arena); //- rjf: process messages { demon_exclusive_mode_begin(); B32 done = 0; for(CTRL_MsgNode *msg_n = msgs.first; msg_n != 0 && done == 0; msg_n = msg_n->next) { CTRL_Msg *msg = &msg_n->v; MemoryCopyArray(ctrl_state->exception_code_filters, msg->exception_code_filters); switch(msg->kind) { case CTRL_MsgKind_Null: case CTRL_MsgKind_COUNT:{}break; //- rjf: target operations case CTRL_MsgKind_LaunchAndHandshake:{ctrl_thread__launch_and_handshake(msg);}break; case CTRL_MsgKind_LaunchAndInit: {ctrl_thread__launch_and_init (msg);}break; case CTRL_MsgKind_Attach: {ctrl_thread__attach (msg);}break; case CTRL_MsgKind_Kill: {ctrl_thread__kill (msg);}break; case CTRL_MsgKind_Detach: {ctrl_thread__detach (msg);}break; case CTRL_MsgKind_Run: {ctrl_thread__run (msg); done = 1;}break; case CTRL_MsgKind_SingleStep: {ctrl_thread__single_step (msg); done = 1;}break; //- rjf: configuration case CTRL_MsgKind_SetUserEntryPoints: { arena_clear(ctrl_state->user_entry_point_arena); MemoryZeroStruct(&ctrl_state->user_entry_points); for(String8Node *n = msg->strings.first; n != 0; n = n->next) { str8_list_push(ctrl_state->user_entry_point_arena, &ctrl_state->user_entry_points, n->string); } }break; } } demon_exclusive_mode_end(); } } scratch_end(scratch); ProfEnd(); } //- rjf: attached process running/event gathering internal DEMON_Event * ctrl_thread__next_demon_event(Arena *arena, CTRL_Msg *msg, DEMON_RunCtrls *run_ctrls, CTRL_Spoof *spoof) { ProfBeginFunction(); DEMON_Event *event = push_array(arena, DEMON_Event, 1); Temp scratch = scratch_begin(&arena, 1); //- rjf: loop -> try to get event, run, repeat U64 spoof_old_ip_value = 0; ProfScope("loop -> try to get event, run, repeat") for(B32 got_event = 0; got_event == 0;) { //- rjf: get next event ProfScope("get next event") { // rjf: grab first event DEMON_EventNode *next_event_node = ctrl_state->first_demon_event_node; // rjf: determine if we should filter B32 should_filter_event = 0; if(next_event_node != 0) { DEMON_Event *ev = &next_event_node->v; switch(ev->kind) { default:{}break; case DEMON_EventKind_Exception: { // NOTE(rjf): first chance exceptions -> try ignoring should_filter_event = (ev->exception_repeated == 0 && (spoof == 0 || ev->instruction_pointer != spoof->new_ip_value)); // rjf: exception code -> kind CTRL_ExceptionCodeKind code_kind = CTRL_ExceptionCodeKind_Null; if(should_filter_event) { for(CTRL_ExceptionCodeKind k = (CTRL_ExceptionCodeKind)0; k < CTRL_ExceptionCodeKind_COUNT; k = (CTRL_ExceptionCodeKind)(k+1)) { if(ctrl_exception_code_kind_code_table[k] == ev->code) { code_kind = k; break; } } } // rjf: exception code kind -> shouldn't stop? if so, do not filter if(should_filter_event) { B32 shouldnt_filter = !!(ctrl_state->exception_code_filters[code_kind/64] & (1ull<<(code_kind%64))); if(should_filter_event && shouldnt_filter) { should_filter_event = 0; } } // rjf: special case: be gracious with ASan modules or symbols if // they do their cute little 0xc0000005 exception trick... if(!should_filter_event && ev->code == 0xc0000005 && (spoof == 0 || ev->instruction_pointer != spoof->new_ip_value)) { DBGI_Scope *scope = dbgi_scope_open(); DEMON_HandleArray modules = demon_modules_from_process(scratch.arena, ev->process); if(modules.count != 0) { // rjf: determine base address of asan shadow space U64 asan_shadow_base_vaddr = 0; B32 asan_shadow_variable_exists_but_is_zero = 0; CTRL_Handle module = ctrl_handle_from_demon(modules.handles[0]); String8 module_path = demon_full_path_from_module(scratch.arena, ctrl_demon_handle_from_ctrl(module)); DBGI_Parse *dbgi = dbgi_parse_from_exe_path(scope, module_path, max_U64); RADDBG_Parsed *rdbg = &dbgi->rdbg; RADDBG_NameMap *unparsed_map = raddbg_name_map_from_kind(rdbg, RADDBG_NameMapKind_GlobalVariables); if(rdbg->global_variables != 0 && unparsed_map != 0) { RADDBG_ParsedNameMap map = {0}; raddbg_name_map_parse(rdbg, unparsed_map, &map); String8 name = str8_lit("__asan_shadow_memory_dynamic_address"); RADDBG_NameMapNode *node = raddbg_name_map_lookup(rdbg, &map, name.str, name.size); if(node != 0) { U32 id_count = 0; U32 *ids = raddbg_matches_from_map_node(rdbg, node, &id_count); if(id_count > 0 && 0 < ids[0] && ids[0] < rdbg->global_variable_count) { RADDBG_GlobalVariable *global_var = &rdbg->global_variables[ids[0]]; U64 global_var_voff = global_var->voff; U64 global_var_vaddr = global_var->voff + demon_base_vaddr_from_module(ctrl_demon_handle_from_ctrl(module)); Architecture arch = demon_arch_from_object(ev->thread); U64 addr_size = bit_size_from_arch(arch)/8; ctrl_process_read(CTRL_MachineID_Client, ctrl_handle_from_demon(ev->process), r1u64(global_var_vaddr, global_var_vaddr+addr_size), &asan_shadow_base_vaddr); asan_shadow_variable_exists_but_is_zero = (asan_shadow_base_vaddr == 0); } } } // rjf: determine if this was a read/write to the shadow space B32 violation_in_shadow_space = 0; if(asan_shadow_base_vaddr != 0) { U64 asan_shadow_space_size = TB(128)/8; if(asan_shadow_base_vaddr <= ev->address && ev->address < asan_shadow_base_vaddr+asan_shadow_space_size) { violation_in_shadow_space = 1; } } // rjf: filter event if this violation occurred in asan's shadow space if(violation_in_shadow_space || asan_shadow_variable_exists_but_is_zero) { should_filter_event = 1; } } dbgi_scope_close(scope); } }break; } } // rjf: good event & unfiltered? -> pop from queue & grab as result if(next_event_node != 0 && !should_filter_event) { got_event = 1; SLLQueuePop(ctrl_state->first_demon_event_node, ctrl_state->last_demon_event_node); MemoryCopyStruct(event, &next_event_node->v); event->string = push_str8_copy(arena, event->string); run_ctrls->ignore_previous_exception = 1; } // rjf: good event but filtered? pop from queue if(next_event_node != 0 && should_filter_event) { SLLQueuePop(ctrl_state->first_demon_event_node, ctrl_state->last_demon_event_node); run_ctrls->ignore_previous_exception = 0; } } //- rjf: no event -> demon_run for a new one if(got_event == 0) ProfScope("no event -> demon_run for a new one") { // rjf: prep spoof B32 do_spoof = (spoof != 0 && run_ctrls->single_step_thread == 0); U64 size_of_spoof = 0; if(do_spoof) ProfScope("prep spoof") { Architecture arch = demon_arch_from_object(ctrl_demon_handle_from_ctrl(spoof->process)); demon_read_memory(ctrl_demon_handle_from_ctrl(spoof->process), &spoof_old_ip_value, spoof->vaddr, sizeof(spoof_old_ip_value)); size_of_spoof = bit_size_from_arch(arch)/8; } // rjf: set spoof if(do_spoof) ProfScope("set spoof") { demon_write_memory(ctrl_demon_handle_from_ctrl(spoof->process), spoof->vaddr, &spoof->new_ip_value, size_of_spoof); } // rjf: run for new events ProfScope("run for new events") { DEMON_EventList events = demon_run(scratch.arena, run_ctrls); for(DEMON_EventNode *src_n = events.first; src_n != 0; src_n = src_n->next) { DEMON_EventNode *dst_n = ctrl_state->free_demon_event_node; if(dst_n != 0) { SLLStackPop(ctrl_state->free_demon_event_node); } else { dst_n = push_array(ctrl_state->demon_event_arena, DEMON_EventNode, 1); } MemoryCopyStruct(&dst_n->v, &src_n->v); dst_n->v.string = push_str8_copy(ctrl_state->demon_event_arena, dst_n->v.string); SLLQueuePush(ctrl_state->first_demon_event_node, ctrl_state->last_demon_event_node, dst_n); } } // rjf: unset spoof if(do_spoof) ProfScope("unset spoof") { demon_write_memory(ctrl_demon_handle_from_ctrl(spoof->process), spoof->vaddr, &spoof_old_ip_value, size_of_spoof); } // rjf: inc generation counters { ins_atomic_u64_inc_eval(&ctrl_state->run_idx); ins_atomic_u64_inc_eval(&ctrl_state->memgen_idx); ins_atomic_u64_inc_eval(&ctrl_state->reggen_idx); } } } //- rjf: irrespective of what event came back, we should ALWAYS check the // spoof's thread and see if it hit the spoof address, because we may have // simply been sent other debug events first if(spoof != 0) { U64 spoof_thread_rip = demon_read_ip(ctrl_demon_handle_from_ctrl(spoof->thread)); if(spoof_thread_rip == spoof->new_ip_value) { demon_write_ip(ctrl_demon_handle_from_ctrl(spoof->thread), spoof_old_ip_value); } } //- rjf: push ctrl events associated with this demon event CTRL_EventList evts = {0}; ProfScope("push ctrl events associated with this demon event") switch(event->kind) { default:{}break; case DEMON_EventKind_CreateProcess: { CTRL_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); out_evt->kind = CTRL_EventKind_NewProc; out_evt->msg_id = msg->msg_id; out_evt->machine_id = CTRL_MachineID_Client; out_evt->entity = ctrl_handle_from_demon(event->process); out_evt->arch = demon_arch_from_object(event->process); out_evt->entity_id = event->code; ctrl_state->process_counter += 1; }break; case DEMON_EventKind_CreateThread: { CTRL_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); out_evt->kind = CTRL_EventKind_NewThread; out_evt->msg_id = msg->msg_id; out_evt->machine_id = CTRL_MachineID_Client; out_evt->entity = ctrl_handle_from_demon(event->thread); out_evt->parent = ctrl_handle_from_demon(event->process); out_evt->arch = demon_arch_from_object(event->process); out_evt->entity_id = event->code; out_evt->stack_base = demon_stack_base_vaddr_from_thread(event->thread); out_evt->tls_root = demon_tls_root_vaddr_from_thread(event->thread); out_evt->rip_vaddr = event->instruction_pointer; out_evt->string = event->string; }break; case DEMON_EventKind_LoadModule: { CTRL_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); String8 module_path = event->string; dbgi_binary_open(module_path); out_evt->kind = CTRL_EventKind_NewModule; out_evt->msg_id = msg->msg_id; out_evt->machine_id = CTRL_MachineID_Client; out_evt->entity = ctrl_handle_from_demon(event->module); out_evt->parent = ctrl_handle_from_demon(event->process); out_evt->arch = demon_arch_from_object(event->module); out_evt->entity_id = event->code; out_evt->vaddr_rng = r1u64(event->address, event->address+event->size); out_evt->rip_vaddr = demon_base_vaddr_from_module(event->module); out_evt->string = module_path; }break; case DEMON_EventKind_ExitProcess: { CTRL_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); out_evt->kind = CTRL_EventKind_EndProc; out_evt->msg_id = msg->msg_id; out_evt->machine_id = CTRL_MachineID_Client; out_evt->entity = ctrl_handle_from_demon(event->process); out_evt->u64_code = event->code; ctrl_state->process_counter -= 1; }break; case DEMON_EventKind_ExitThread: { CTRL_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); out_evt->kind = CTRL_EventKind_EndThread; out_evt->msg_id = msg->msg_id; out_evt->machine_id = CTRL_MachineID_Client; out_evt->entity = ctrl_handle_from_demon(event->thread); out_evt->entity_id = event->code; }break; case DEMON_EventKind_UnloadModule: { CTRL_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); String8 module_path = event->string; dbgi_binary_close(module_path); out_evt->kind = CTRL_EventKind_EndModule; out_evt->msg_id = msg->msg_id; out_evt->machine_id = CTRL_MachineID_Client; out_evt->entity = ctrl_handle_from_demon(event->module); }break; case DEMON_EventKind_DebugString: { CTRL_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); out_evt->kind = CTRL_EventKind_DebugString; out_evt->msg_id = msg->msg_id; out_evt->machine_id = CTRL_MachineID_Client; out_evt->entity = ctrl_handle_from_demon(event->thread); out_evt->parent = ctrl_handle_from_demon(event->process); out_evt->string = event->string; }break; case DEMON_EventKind_SetThreadName: { CTRL_Event *out_evt = ctrl_event_list_push(scratch.arena, &evts); out_evt->kind = CTRL_EventKind_ThreadName; out_evt->msg_id = msg->msg_id; out_evt->machine_id = CTRL_MachineID_Client; out_evt->entity = ctrl_handle_from_demon(event->thread); out_evt->parent = ctrl_handle_from_demon(event->process); out_evt->string = event->string; }break; } ctrl_c2u_push_events(&evts); //- rjf: clear process memory cache, if we've just started a lone process if(event->kind == DEMON_EventKind_CreateProcess && ctrl_state->process_counter == 1) { CTRL_ProcessMemoryCache *cache = &ctrl_state->process_memory_cache; for(U64 slot_idx = 0; slot_idx < cache->slots_count; slot_idx += 1) { U64 stripe_idx = slot_idx%cache->stripes_count; CTRL_ProcessMemoryCacheSlot *slot = &cache->slots[slot_idx]; CTRL_ProcessMemoryCacheStripe *stripe = &cache->stripes[stripe_idx]; OS_MutexScopeW(stripe->rw_mutex) { for(CTRL_ProcessMemoryCacheNode *n = slot->first, *next = 0; n != 0; n = next) { next = n->next; arena_clear(n->arena); } } MemoryZeroStruct(slot); } } //- rjf: out of queued up demon events -> clear event arena if(ctrl_state->first_demon_event_node == 0) { ctrl_state->free_demon_event_node = 0; arena_clear(ctrl_state->demon_event_arena); } scratch_end(scratch); ProfEnd(); return(event); } //- rjf: eval helpers internal B32 ctrl_eval_memory_read(void *u, void *out, U64 addr, U64 size) { DEMON_Handle process = (DEMON_Handle)u; U64 read_size = demon_read_memory(process, out, addr, size); B32 result = (read_size == size); return result; } //- rjf: msg kind implementations internal void ctrl_thread__launch_and_handshake(CTRL_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); DBGI_Scope *scope = dbgi_scope_open(); //- rjf: launch OS_LaunchOptions opts = {0}; { opts.cmd_line = msg->cmd_line_string_list; opts.path = msg->path; opts.env = msg->env_string_list; opts.inherit_env = msg->env_inherit; } U32 id = demon_launch_process(&opts); //- rjf: record start { CTRL_EventList evts = {0}; CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts); event->kind = CTRL_EventKind_Started; ctrl_c2u_push_events(&evts); } //- rjf: run to handshake DEMON_Event *stop_event = 0; if(id != 0) { // rjf: prep run controls DEMON_Handle unfrozen_process = 0; DEMON_RunCtrls run_ctrls = {0}; { run_ctrls.run_entities_are_unfrozen = 1; run_ctrls.run_entities_are_processes = 1; run_ctrls.run_entities = &unfrozen_process; run_ctrls.run_entity_count = 0; } // rjf: run until handshake-signifying events for(B32 done = 0; done == 0;) { DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &run_ctrls, 0); switch(event->kind) { default:{}break; case DEMON_EventKind_CreateProcess: { unfrozen_process = event->process; run_ctrls.run_entity_count = 1; }break; case DEMON_EventKind_Error: case DEMON_EventKind_Breakpoint: case DEMON_EventKind_Exception: case DEMON_EventKind_ExitProcess: case DEMON_EventKind_HandshakeComplete: { done = 1; stop_event = event; }break; } } } //- rjf: record bad stop if(stop_event == 0 && id == 0) { CTRL_EventList evts = {0}; CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts); event->kind = CTRL_EventKind_Error; event->cause = CTRL_EventCause_Error; ctrl_c2u_push_events(&evts); } //- rjf: record stop { CTRL_EventList evts = {0}; CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts); event->kind = CTRL_EventKind_Stopped; if(stop_event != 0) { event->cause = ctrl_event_cause_from_demon_event_kind(stop_event->kind); event->machine_id = CTRL_MachineID_Client; event->entity = ctrl_handle_from_demon(stop_event->thread); event->parent = ctrl_handle_from_demon(stop_event->process); event->exception_code = stop_event->code; event->vaddr_rng = r1u64(stop_event->address, stop_event->address); event->rip_vaddr = stop_event->instruction_pointer; } ctrl_c2u_push_events(&evts); } //- rjf: push request resolution event { CTRL_EventList evts = {0}; CTRL_Event *evt = ctrl_event_list_push(scratch.arena, &evts); evt->kind = CTRL_EventKind_LaunchAndHandshakeDone; evt->machine_id= CTRL_MachineID_Client; evt->msg_id = msg->msg_id; evt->entity_id = id; ctrl_c2u_push_events(&evts); } dbgi_scope_close(scope); scratch_end(scratch); ProfEnd(); } internal void ctrl_thread__launch_and_init(CTRL_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); //- rjf: launch OS_LaunchOptions opts = {0}; { opts.cmd_line = msg->cmd_line_string_list; opts.path = msg->path; opts.env = msg->env_string_list; opts.inherit_env = msg->env_inherit; } U32 id = demon_launch_process(&opts); //- rjf: record start { CTRL_EventList evts = {0}; CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts); event->kind = CTRL_EventKind_Started; ctrl_c2u_push_events(&evts); } //- rjf: run to initialization (entry point) DEMON_Event *stop_event = 0; if(id != 0) { DEMON_Handle unfrozen_process[8] = {0}; DEMON_TrapChunkList demon_traps = {0}; U64 entry_vaddr = 0; DEMON_Handle entry_vaddr_proc = 0; DEMON_RunCtrls run_ctrls = {0}; run_ctrls.run_entities_are_unfrozen = 1; run_ctrls.run_entities_are_processes = 1; for(B32 done = 0; done == 0;) { DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &run_ctrls, 0); switch(event->kind) { default:{}break; // rjf: new process -> freeze process case DEMON_EventKind_CreateProcess: if(run_ctrls.run_entity_count < ArrayCount(unfrozen_process)) { unfrozen_process[run_ctrls.run_entity_count] = event->process; run_ctrls.run_entities = &unfrozen_process[0]; run_ctrls.run_entity_count += 1; }break; // rjf: breakpoint -> if it's the entry point, we're done. otherwise, keep going case DEMON_EventKind_Breakpoint: if(event->instruction_pointer == entry_vaddr) { done = 1; stop_event = event; }break; // rjf: exception -> done case DEMON_EventKind_Exception: { done = 1; stop_event = event; }break; // rjf: process ended? -> remove from unfrozen processes. zero processes -> done. case DEMON_EventKind_ExitProcess: { for(U64 idx = 0; idx < run_ctrls.run_entity_count; idx += 1) { if(run_ctrls.run_entities[idx] == event->process && idx+1 < run_ctrls.run_entity_count) { MemoryCopy(run_ctrls.run_entities+idx, run_ctrls.run_entities+idx+1, sizeof(DEMON_Handle)*(run_ctrls.run_entity_count-(idx+1))); break; } } run_ctrls.run_entity_count -= 1; if(run_ctrls.run_entity_count == 0) { done = 1; stop_event = event; } }break; // rjf: done with handshake -> ready to find entry point. search launched processes case DEMON_EventKind_HandshakeComplete: { DBGI_Scope *scope = dbgi_scope_open(); // rjf: find entry point vaddr for(U64 process_idx = 0; process_idx < run_ctrls.run_entity_count; process_idx += 1) { DEMON_HandleArray modules = demon_modules_from_process(scratch.arena, run_ctrls.run_entities[process_idx]); if(modules.count == 0) { continue; } DEMON_Handle module = modules.handles[0]; String8 exe_path = demon_full_path_from_module(scratch.arena, module); DBGI_Parse *dbgi = dbgi_parse_from_exe_path(scope, exe_path, max_U64); RADDBG_Parsed *rdbg = &dbgi->rdbg; RADDBG_NameMap *unparsed_map = raddbg_name_map_from_kind(rdbg, RADDBG_NameMapKind_Procedures); RADDBG_ParsedNameMap map = {0}; raddbg_name_map_parse(rdbg, unparsed_map, &map); String8 default_entry_points[] = { str8_lit("WinMain"), str8_lit("wWinMain"), str8_lit("main"), str8_lit("wmain"), str8_lit("WinMainCRTStartup"), str8_lit("wWinMainCRTStartup"), str8_lit("mainCRTStartup"), str8_lit("wmainCRTStartup"), }; // rjf: default to picking PE header's entry B32 entry_is_user_defined = 0; U64 entry_voff = dbgi->pe.entry_point; if(rdbg->scope_vmap != 0 && rdbg->procedures != 0 && rdbg->unit_vmap != 0 && rdbg->units != 0 && rdbg->file_paths) { U64 scope_idx = raddbg_vmap_idx_from_voff(rdbg->scope_vmap, rdbg->scope_vmap_count, entry_voff); RADDBG_Scope *scope = &rdbg->scopes[scope_idx]; U64 proc_idx = scope->proc_idx; RADDBG_Procedure *procedure = &rdbg->procedures[proc_idx]; U64 name_size = 0; U8 *name_base = raddbg_string_from_idx(rdbg, procedure->name_string_idx, &name_size); String8 name = str8(name_base, name_size); U64 unit_idx = raddbg_vmap_idx_from_voff(rdbg->unit_vmap, rdbg->unit_vmap_count, entry_voff); RADDBG_Unit *unit = &rdbg->units[unit_idx]; RADDBG_ParsedLineInfo unit_line_info = {0}; raddbg_line_info_from_unit(rdbg, unit, &unit_line_info); U64 line_info_idx = raddbg_line_info_idx_from_voff(&unit_line_info, entry_voff); if(name_size != 0 && line_info_idx < unit_line_info.count) { String8 obj_path = {0}; { String8List obj_path_nodes = {0}; for(U32 idx = unit->object_file_path_node; idx != 0; idx = rdbg->file_paths[idx].parent_path_node) { RADDBG_FilePathNode *n = &rdbg->file_paths[idx]; U64 n_name_size = 0; U8 *n_name_base = raddbg_string_from_idx(rdbg, n->name_string_idx, &n_name_size); str8_list_push_front(scratch.arena, &obj_path_nodes, str8(n_name_base, n_name_size)); } StringJoin join = {0}; join.sep = str8_lit("/"); obj_path = str8_list_join(scratch.arena, &obj_path_nodes, &join); } FileProperties props = os_properties_from_file_path(obj_path); if(props.modified) { entry_is_user_defined = 1; } } B32 entry_point_matches_defaults = 0; for(U64 idx = 0; idx < ArrayCount(default_entry_points); idx += 1) { if(str8_match(name, default_entry_points[idx], 0)) { entry_point_matches_defaults = 1; } } if(!entry_point_matches_defaults && name.size != 0) { entry_is_user_defined = 1; } } // rjf: find voff for one of the default entry points if(!entry_is_user_defined) { for(U64 idx = 0; idx < ArrayCount(default_entry_points); idx += 1) { U32 procedure_id = 0; { String8 name = default_entry_points[idx]; RADDBG_NameMapNode *node = raddbg_name_map_lookup(rdbg, &map, name.str, name.size); if(node != 0) { U32 id_count = 0; U32 *ids = raddbg_matches_from_map_node(rdbg, node, &id_count); if(id_count > 0) { procedure_id = ids[0]; } } } if(procedure_id != 0) { U64 new_voff = raddbg_first_voff_from_proc(rdbg, procedure_id); if(new_voff != 0) { entry_voff = new_voff; break; } } } } // rjf: find voff for one of the custom entry points attached to this msg if(rdbg->procedures != 0 && unparsed_map != 0) { for(String8Node *n = msg->strings.first; n != 0; n = n->next) { U32 procedure_id = 0; { String8 name = n->string; RADDBG_NameMapNode *node = raddbg_name_map_lookup(rdbg, &map, name.str, name.size); if(node != 0) { U32 id_count = 0; U32 *ids = raddbg_matches_from_map_node(rdbg, node, &id_count); if(id_count > 0) { procedure_id = ids[0]; } } } if(procedure_id != 0) { U64 new_voff = raddbg_first_voff_from_proc(rdbg, procedure_id); if(new_voff != 0) { entry_voff = new_voff; break; } } } } // rjf: find voff for one of the user's custom entry points if(rdbg->procedures != 0 && unparsed_map != 0) { for(String8Node *n = ctrl_state->user_entry_points.first; n != 0; n = n->next) { U32 procedure_id = 0; { String8 name = n->string; RADDBG_NameMapNode *node = raddbg_name_map_lookup(rdbg, &map, name.str, name.size); if(node != 0) { U32 id_count = 0; U32 *ids = raddbg_matches_from_map_node(rdbg, node, &id_count); if(id_count > 0) { procedure_id = ids[0]; } } } if(procedure_id != 0) { U64 new_voff = raddbg_first_voff_from_proc(rdbg, procedure_id); if(new_voff != 0) { entry_voff = new_voff; break; } } } } // rjf: nonzero voff? => store if(entry_voff != 0) { U64 base_vaddr = demon_base_vaddr_from_module(module); entry_vaddr = base_vaddr + entry_voff; entry_vaddr_proc = run_ctrls.run_entities[process_idx]; } // rjf: found entry point -> insert into trap controls if(entry_vaddr != 0) { DEMON_Trap trap = {entry_vaddr_proc, entry_vaddr}; demon_trap_chunk_list_push(scratch.arena, &demon_traps, 256, &trap); run_ctrls.traps = demon_traps; } // rjf: no entry point found -> done else { done = 1; stop_event = event; } } dbgi_scope_close(scope); }break; } } } //- rjf: record bad stop if(stop_event == 0 && id == 0) { CTRL_EventList evts = {0}; CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts); event->kind = CTRL_EventKind_Error; event->cause = CTRL_EventCause_Error; ctrl_c2u_push_events(&evts); } //- rjf: record stop { CTRL_EventList evts = {0}; CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts); event->kind = CTRL_EventKind_Stopped; event->msg_id = msg->msg_id; if(stop_event != 0) { event->cause = ctrl_event_cause_from_demon_event_kind(stop_event->kind); event->machine_id = CTRL_MachineID_Client; event->entity = ctrl_handle_from_demon(stop_event->thread); event->parent = ctrl_handle_from_demon(stop_event->process); event->exception_code = stop_event->code; event->vaddr_rng = r1u64(stop_event->address, stop_event->address); event->rip_vaddr = stop_event->instruction_pointer; } ctrl_c2u_push_events(&evts); } //- rjf: push request resolution event { CTRL_EventList evts = {0}; CTRL_Event *evt = ctrl_event_list_push(scratch.arena, &evts); evt->kind = CTRL_EventKind_LaunchAndInitDone; evt->machine_id= CTRL_MachineID_Client; evt->msg_id = msg->msg_id; evt->entity_id = id; ctrl_c2u_push_events(&evts); } scratch_end(scratch); ProfEnd(); } internal void ctrl_thread__attach(CTRL_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); DBGI_Scope *scope = dbgi_scope_open(); //- rjf: attach B32 attach_successful = demon_attach_process(msg->entity_id); //- rjf: run to handshake if(attach_successful) { DEMON_Handle unfrozen_process = 0; DEMON_RunCtrls run_ctrls = {0}; run_ctrls.run_entities_are_unfrozen = 1; run_ctrls.run_entities_are_processes = 1; for(B32 done = 0; done == 0;) { DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &run_ctrls, 0); switch(event->kind) { default:{}break; case DEMON_EventKind_CreateProcess: { unfrozen_process = event->process; run_ctrls.run_entities = &unfrozen_process; run_ctrls.run_entity_count = 1; }break; case DEMON_EventKind_HandshakeComplete: { done = 1; }break; } } } //- rjf: push request resolution event { CTRL_EventList evts = {0}; CTRL_Event *evt = ctrl_event_list_push(scratch.arena, &evts); evt->kind = CTRL_EventKind_AttachDone; evt->machine_id= CTRL_MachineID_Client; evt->msg_id = msg->msg_id; evt->entity_id = !!attach_successful * msg->entity_id; ctrl_c2u_push_events(&evts); } dbgi_scope_close(scope); scratch_end(scratch); ProfEnd(); } internal void ctrl_thread__kill(CTRL_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); DBGI_Scope *scope = dbgi_scope_open(); DEMON_Handle process = ctrl_demon_handle_from_ctrl(msg->entity); U32 exit_code = msg->exit_code; //- rjf: send kill B32 kill_worked = demon_kill_process(process, exit_code); //- rjf: wait for process to be dead if(demon_object_exists(process) && kill_worked) { DEMON_RunCtrls run_ctrls = {0}; run_ctrls.run_entities_are_unfrozen = 1; run_ctrls.run_entities_are_processes = 1; run_ctrls.run_entities = &process; run_ctrls.run_entity_count = 1; for(B32 done = 0; done == 0;) { DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &run_ctrls, 0); if(event->kind == DEMON_EventKind_ExitProcess && event->process == process) { done = 1; } } } //- rjf: push request resolution event { CTRL_EventList evts = {0}; CTRL_Event *evt = ctrl_event_list_push(scratch.arena, &evts); evt->kind = CTRL_EventKind_KillDone; evt->machine_id= CTRL_MachineID_Client; evt->msg_id = msg->msg_id; if(kill_worked) { evt->entity = msg->entity; } ctrl_c2u_push_events(&evts); } dbgi_scope_close(scope); scratch_end(scratch); ProfEnd(); } internal void ctrl_thread__detach(CTRL_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); DBGI_Scope *scope = dbgi_scope_open(); DEMON_Handle process = ctrl_demon_handle_from_ctrl(msg->entity); //- rjf: detach B32 detach_worked = demon_detach_process(process); //- rjf: wait for process to be dead if(demon_object_exists(process) && detach_worked) { DEMON_RunCtrls run_ctrls = {0}; run_ctrls.run_entities_are_unfrozen = 1; run_ctrls.run_entities_are_processes = 1; run_ctrls.run_entities = &process; run_ctrls.run_entity_count = 1; for(B32 done = 0; done == 0;) { DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &run_ctrls, 0); if(event->kind == DEMON_EventKind_ExitProcess && event->process == process) { done = 1; } } } //- rjf: push request resolution event { CTRL_EventList evts = {0}; CTRL_Event *evt = ctrl_event_list_push(scratch.arena, &evts); evt->kind = CTRL_EventKind_DetachDone; evt->machine_id= CTRL_MachineID_Client; evt->msg_id = msg->msg_id; if(detach_worked) { evt->entity = msg->entity; } ctrl_c2u_push_events(&evts); } dbgi_scope_close(scope); scratch_end(scratch); ProfEnd(); } internal void ctrl_thread__run(CTRL_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); DBGI_Scope *scope = dbgi_scope_open(); DEMON_Event *stop_event = 0; CTRL_EventCause stop_cause = CTRL_EventCause_Null; DEMON_Handle target_thread = ctrl_demon_handle_from_ctrl(msg->entity); DEMON_Handle target_process = ctrl_demon_handle_from_ctrl(msg->parent); U64 spoof_ip_vaddr = 911; ////////////////////////////// //- rjf: gather processes // DEMON_HandleArray processes = demon_all_processes(scratch.arena); ////////////////////////////// //- rjf: gather all initial breakpoints // DEMON_TrapChunkList user_traps = {0}; { // rjf: resolve module-dependent user bps for(U64 process_idx = 0; process_idx < processes.count; process_idx += 1) { DEMON_Handle process = processes.handles[process_idx]; DEMON_HandleArray modules = demon_modules_from_process(scratch.arena, process); for(U64 module_idx = 0; module_idx < modules.count; module_idx += 1) { DEMON_Handle module = modules.handles[module_idx]; ctrl_append_resolved_module_user_bp_traps(scratch.arena, process, module, &msg->user_bps, &user_traps); } } // rjf: push virtual-address user breakpoints per-process for(U64 process_idx = 0; process_idx < processes.count; process_idx += 1) { ctrl_append_resolved_process_user_bp_traps(scratch.arena, processes.handles[process_idx], &msg->user_bps, &user_traps); } } ////////////////////////////// //- rjf: single step "stuck threads" // // "Stuck threads" are threads that are already on a User BP and would hit // it immediately if resumed with all User BPs enabled. To get them "unstuck" // we just need to single step them to get them off their current instruction. // // This only applies to threads OTHER THAN the target thread. If the target // thread is on a user breakpoint, then we need to let trap net logic run, // which may include features put on a trap net trap at the same address as // the user breakpoint. // B32 target_thread_is_on_user_bp_and_trap_net_trap = 0; if(stop_event == 0) { // rjf: gather stuck threads DEMON_HandleList stuck_threads = {0}; for(U64 i = 0; i < processes.count; i += 1) { DEMON_Handle process = processes.handles[i]; DEMON_HandleArray threads = demon_threads_from_process(scratch.arena, process); for(U64 j = 0; j < threads.count; j += 1) { DEMON_Handle thread = threads.handles[j]; U64 rip = demon_read_ip(thread); // rjf: determine if thread is frozen B32 thread_is_frozen = !msg->freeze_state_is_frozen; for(CTRL_MachineIDHandlePairNode *n = msg->freeze_state_threads.first; n != 0; n = n->next) { if(ctrl_demon_handle_from_ctrl(n->v.handle) == thread) { thread_is_frozen ^= 1; break; } } // rjf: not frozen? -> check if stuck & gather if so if(thread_is_frozen == 0) { for(DEMON_TrapChunkNode *n = user_traps.first; n != 0; n = n->next) { B32 is_on_user_bp = 0; for(DEMON_Trap *trap_ptr = n->v; trap_ptr < n->v+n->count; trap_ptr += 1) { if(trap_ptr->process == process && trap_ptr->address == rip) { is_on_user_bp = 1; } } B32 is_on_net_trap = 0; for(CTRL_TrapNode *n = msg->traps.first; n != 0; n = n->next) { if(n->v.vaddr == rip) { is_on_net_trap = 1; } } if(is_on_user_bp && (!is_on_net_trap || thread != target_thread)) { demon_handle_list_push(scratch.arena, &stuck_threads, thread); } if(is_on_user_bp && is_on_net_trap && thread == target_thread) { target_thread_is_on_user_bp_and_trap_net_trap = 1; } } } } } // rjf: actually step stuck threads for(DEMON_HandleNode *node = stuck_threads.first; node != 0; node = node->next) { DEMON_RunCtrls run_ctrls = {0}; run_ctrls.single_step_thread = node->v; for(B32 done = 0; done == 0;) { DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &run_ctrls, 0); switch(event->kind) { default:{}break; case DEMON_EventKind_Error: stop_cause = CTRL_EventCause_Error; goto stop; case DEMON_EventKind_Exception: stop_cause = CTRL_EventCause_InterruptedByException; goto stop; case DEMON_EventKind_Trap: stop_cause = CTRL_EventCause_InterruptedByTrap; goto stop; case DEMON_EventKind_Halt: stop_cause = CTRL_EventCause_InterruptedByHalt; goto stop; stop:; { stop_event = event; done = 1; }break; case DEMON_EventKind_SingleStep: { done = 1; }break; } } } } ////////////////////////////// //- rjf: resolve trap net // DEMON_TrapChunkList trap_net_traps = {0}; for(CTRL_TrapNode *node = msg->traps.first; node != 0; node = node->next) { DEMON_Trap trap = {target_process, node->v.vaddr}; demon_trap_chunk_list_push(scratch.arena, &trap_net_traps, 256, &trap); } ////////////////////////////// //- rjf: join user breakpoints and trap net traps // DEMON_TrapChunkList joined_traps = {0}; { demon_trap_chunk_list_concat_shallow_copy(scratch.arena, &joined_traps, &user_traps); demon_trap_chunk_list_concat_shallow_copy(scratch.arena, &joined_traps, &trap_net_traps); } ////////////////////////////// //- rjf: record start // if(stop_event == 0) { CTRL_EventList evts = {0}; CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts); event->kind = CTRL_EventKind_Started; ctrl_c2u_push_events(&evts); } ////////////////////////////// //- rjf: run loop // if(stop_event == 0) { U64 sp_check_value = demon_read_sp(target_thread); B32 spoof_mode = 0; CTRL_Spoof spoof = {0}; for(;;) { ////////////////////////// //- rjf: choose low level traps // DEMON_TrapChunkList *trap_list = &joined_traps; if(spoof_mode) { trap_list = &user_traps; } ////////////////////////// //- rjf: choose spoof // CTRL_Spoof *run_spoof = 0; if(spoof_mode) { run_spoof = &spoof; } ////////////////////////// //- rjf: setup run controls // DEMON_RunCtrls run_ctrls = {0}; run_ctrls.ignore_previous_exception = 1; run_ctrls.run_entity_count = msg->freeze_state_threads.count; run_ctrls.run_entities = push_array(scratch.arena, DEMON_Handle, run_ctrls.run_entity_count); run_ctrls.run_entities_are_unfrozen = !msg->freeze_state_is_frozen; { U64 idx = 0; for(CTRL_MachineIDHandlePairNode *n = msg->freeze_state_threads.first; n != 0; n = n->next) { run_ctrls.run_entities[idx] = ctrl_demon_handle_from_ctrl(n->v.handle); idx += 1; } } run_ctrls.traps = *trap_list; ////////////////////////// //- rjf: get next event // DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &run_ctrls, run_spoof); ////////////////////////// //- rjf: determine event handling // B32 hard_stop = 0; CTRL_EventCause hard_stop_cause = ctrl_event_cause_from_demon_event_kind(event->kind); B32 use_stepping_logic = 0; switch(event->kind) { default:{}break; case DEMON_EventKind_Error: case DEMON_EventKind_Halt: case DEMON_EventKind_SingleStep: case DEMON_EventKind_Trap: { hard_stop = 1; }break; case DEMON_EventKind_Exception: case DEMON_EventKind_Breakpoint: { use_stepping_logic = 1; }break; case DEMON_EventKind_CreateProcess: { DEMON_TrapChunkList new_traps = {0}; ctrl_append_resolved_process_user_bp_traps(scratch.arena, event->process, &msg->user_bps, &new_traps); demon_trap_chunk_list_concat_shallow_copy(scratch.arena, &joined_traps, &new_traps); }break; case DEMON_EventKind_LoadModule: { DEMON_TrapChunkList new_traps = {0}; ctrl_append_resolved_module_user_bp_traps(scratch.arena, event->process, event->module, &msg->user_bps, &new_traps); demon_trap_chunk_list_concat_shallow_copy(scratch.arena, &joined_traps, &new_traps); demon_trap_chunk_list_concat_shallow_copy(scratch.arena, &user_traps, &new_traps); }break; } ////////////////////////// //- rjf: unpack info about thread attached to event // Architecture arch = demon_arch_from_object(event->thread); U64 reg_size = regs_block_size_from_architecture(arch); void *thread_regs_block = demon_read_regs(event->thread); U64 thread_rip_vaddr = regs_rip_from_arch_block(arch, thread_regs_block); DEMON_Handle module = 0; U64 thread_rip_voff = 0; { Temp temp = temp_begin(scratch.arena); DEMON_HandleArray modules = demon_modules_from_process(temp.arena, event->process); if(modules.count != 0) { for(U64 idx = 0; idx < modules.count; idx += 1) { Rng1U64 vaddr_range = demon_vaddr_range_from_module(modules.handles[idx]); if(contains_1u64(vaddr_range, thread_rip_vaddr)) { module = modules.handles[idx]; thread_rip_voff = thread_rip_vaddr - vaddr_range.min; break; } } } temp_end(temp); } ////////////////////////// //- rjf: stepping logic // //{ ////////////////////////// //- rjf: handle if hitting a spoof or baked in trap // B32 hit_spoof = 0; B32 exception_stop = 0; if(use_stepping_logic) { if(event->kind == DEMON_EventKind_Exception) { // rjf: spoof check if(spoof_mode && target_process == event->process && target_thread == event->thread && spoof.new_ip_value == event->instruction_pointer) { hit_spoof = 1; } // rjf: other exceptions cause stop if(!hit_spoof) { exception_stop = 1; use_stepping_logic = 0; } } } //- rjf: handle spoof hit if(hit_spoof) { // rjf: clear spoof mode spoof_mode = 0; MemoryZeroStruct(&spoof); // rjf: skip remainder of handling use_stepping_logic = 0; } //- rjf: for breakpoint events, gather bp info B32 hit_user_bp = 0; B32 hit_trap_net_bp = 0; B32 hit_conditional_bp_but_filtered = 0; CTRL_TrapFlags hit_trap_flags = 0; if(use_stepping_logic) { if(event->kind == DEMON_EventKind_Breakpoint) { Temp temp = temp_begin(scratch.arena); String8List conditions = {0}; // rjf: user breakpoints for(DEMON_TrapChunkNode *n = user_traps.first; n != 0; n = n->next) { DEMON_Trap *trap = n->v; DEMON_Trap *opl = n->v + n->count; for(;trap < opl; trap += 1) { if(trap->process == event->process && trap->address == event->instruction_pointer && (event->thread != target_thread || !target_thread_is_on_user_bp_and_trap_net_trap)) { CTRL_UserBreakpoint *user_bp = (CTRL_UserBreakpoint *)trap->id; hit_user_bp = 1; if(user_bp != 0 && user_bp->condition.size != 0) { str8_list_push(temp.arena, &conditions, user_bp->condition); } } } } // rjf: evaluate hit stop conditions if(conditions.node_count != 0) { String8 exe_path = demon_full_path_from_module(temp.arena, module); DBGI_Parse *dbgi = dbgi_parse_from_exe_path(scope, exe_path, max_U64); RADDBG_Parsed *rdbg = &dbgi->rdbg; for(String8Node *condition_n = conditions.first; condition_n != 0; condition_n = condition_n->next) { String8 string = condition_n->string; EVAL_ParseCtx parse_ctx = zero_struct; { parse_ctx.arch = arch; parse_ctx.ip_voff = thread_rip_voff; parse_ctx.rdbg = rdbg; parse_ctx.type_graph = tg_graph_begin(bit_size_from_arch(arch)/8, 256); parse_ctx.regs_map = ctrl_string2reg_from_arch(arch); parse_ctx.reg_alias_map = ctrl_string2alias_from_arch(arch); parse_ctx.locals_map = eval_push_locals_map_from_raddbg_voff(temp.arena, rdbg, thread_rip_voff); parse_ctx.member_map = eval_push_member_map_from_raddbg_voff(temp.arena, rdbg, thread_rip_voff); } EVAL_TokenArray tokens = eval_token_array_from_text(temp.arena, string); EVAL_ParseResult parse = eval_parse_expr_from_text_tokens(temp.arena, &parse_ctx, string, &tokens); EVAL_ErrorList errors = parse.errors; B32 parse_has_expr = (parse.expr != &eval_expr_nil); B32 parse_is_type = (parse_has_expr && parse.expr->kind == EVAL_ExprKind_TypeIdent); EVAL_IRTreeAndType ir_tree_and_type = {&eval_irtree_nil}; if(parse_has_expr && errors.count == 0) { ir_tree_and_type = eval_irtree_and_type_from_expr(temp.arena, parse_ctx.type_graph, rdbg, parse.expr, &errors); } EVAL_OpList op_list = {0}; if(parse_has_expr && ir_tree_and_type.tree != &eval_irtree_nil) { eval_oplist_from_irtree(scratch.arena, ir_tree_and_type.tree, &op_list); } String8 bytecode = {0}; if(parse_has_expr && parse_is_type == 0 && op_list.encoded_size != 0) { bytecode = eval_bytecode_from_oplist(scratch.arena, &op_list); } EVAL_Result eval = {0}; if(bytecode.size != 0) { U64 module_base = demon_base_vaddr_from_module(module); U64 tls_base = 0; // TODO(rjf) EVAL_Machine machine = {0}; machine.u = (void *)event->process; machine.arch = arch; machine.memory_read = ctrl_eval_memory_read; machine.reg_data = thread_regs_block; machine.reg_size = reg_size; machine.module_base = &module_base; machine.tls_base = &tls_base; eval = eval_interpret(&machine, bytecode); } if(eval.bad_eval == 0 && eval.value.u64 == 0) { hit_user_bp = 0; hit_conditional_bp_but_filtered = 1; } else { hit_user_bp = 1; hit_conditional_bp_but_filtered = 0; break; } } } // rjf: gather trap net hits if(!hit_user_bp && event->process == target_process) { for(CTRL_TrapNode *node = msg->traps.first; node != 0; node = node->next) { if(node->v.vaddr == event->instruction_pointer) { hit_trap_net_bp = 1; hit_trap_flags |= node->v.flags; } } } temp_end(temp); } } //- rjf: hit conditional user bp but filtered -> single step B32 cond_bp_single_step_stop = 0; CTRL_EventCause cond_bp_single_step_stop_cause = CTRL_EventCause_Null; if(hit_conditional_bp_but_filtered) { DEMON_RunCtrls single_step_ctrls = {0}; single_step_ctrls.single_step_thread = event->thread; for(B32 single_step_done = 0; single_step_done == 0;) { DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &single_step_ctrls, 0); switch(event->kind) { default:{}break; case DEMON_EventKind_Error: case DEMON_EventKind_Exception: case DEMON_EventKind_Halt: case DEMON_EventKind_Trap: { cond_bp_single_step_stop = 1; single_step_done = 1; use_stepping_logic = 0; cond_bp_single_step_stop_cause = ctrl_event_cause_from_demon_event_kind(event->kind); }break; case DEMON_EventKind_SingleStep: { single_step_done = 1; cond_bp_single_step_stop_cause = ctrl_event_cause_from_demon_event_kind(event->kind); }break; } } } //- rjf: user breakpoints on *any thread* cause a stop B32 user_bp_stop = 0; if(use_stepping_logic && hit_user_bp) { user_bp_stop = 1; use_stepping_logic = 0; } //- rjf: trap net on off-target threads are ignored B32 step_past_trap_net = 0; if(use_stepping_logic && hit_trap_net_bp) { if(event->thread != target_thread) { step_past_trap_net = 1; use_stepping_logic = 0; } } //- rjf: trap net on on-target threads trigger trap net logic B32 use_trap_net_logic = 0; if(use_stepping_logic && hit_trap_net_bp) { if(event->thread == target_thread) { use_trap_net_logic = 1; } } //- rjf: trap net logic: stack pointer check B32 stack_pointer_matches = 0; if(use_trap_net_logic) { U64 sp = demon_read_sp(target_thread); stack_pointer_matches = (sp == sp_check_value); } //- rjf: trap net logic: single step after hit B32 single_step_stop = 0; CTRL_EventCause single_step_stop_cause = CTRL_EventCause_Null; if(use_trap_net_logic) { if(hit_trap_flags & CTRL_TrapFlag_SingleStepAfterHit) { DEMON_RunCtrls single_step_ctrls = {0}; single_step_ctrls.single_step_thread = target_thread; for(B32 single_step_done = 0; single_step_done == 0;) { DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &single_step_ctrls, 0); switch(event->kind) { default:{}break; case DEMON_EventKind_Error: case DEMON_EventKind_Exception: case DEMON_EventKind_Halt: case DEMON_EventKind_Trap: { single_step_stop = 1; single_step_done = 1; use_stepping_logic = 0; use_trap_net_logic = 0; single_step_stop_cause = ctrl_event_cause_from_demon_event_kind(event->kind); }break; case DEMON_EventKind_SingleStep: { single_step_done = 1; single_step_stop_cause = ctrl_event_cause_from_demon_event_kind(event->kind); }break; } } } } //- rjf: trap net logic: begin spoof mode B32 begin_spoof_mode = 0; if(use_trap_net_logic) { if(hit_trap_flags & CTRL_TrapFlag_BeginSpoofMode) { // rjf: setup spoof mode begin_spoof_mode = 1; U64 spoof_sp = demon_read_sp(target_thread); spoof_mode = 1; spoof.process = ctrl_handle_from_demon(target_process); spoof.thread = ctrl_handle_from_demon(target_thread); spoof.vaddr = spoof_sp; spoof.new_ip_value = spoof_ip_vaddr; } } //- rjf: trap net logic: save stack pointer B32 save_stack_pointer = 0; if(use_trap_net_logic) { if(hit_trap_flags & CTRL_TrapFlag_SaveStackPointer) { if(stack_pointer_matches) { save_stack_pointer = 1; sp_check_value = demon_read_sp(target_thread); } } } //- rjf: trap net logic: end stepping B32 trap_net_stop = 0; if(use_trap_net_logic) { if(hit_trap_flags & CTRL_TrapFlag_EndStepping) { if((hit_trap_flags & CTRL_TrapFlag_IgnoreStackPointerCheck) || stack_pointer_matches) { trap_net_stop = 1; use_trap_net_logic = 0; } } } //} // //- rjf: stepping logic //////////////////////////////// //- rjf: handle step past trap net B32 step_past_trap_net_stop = 0; CTRL_EventCause step_past_trap_net_stop_cause = CTRL_EventCause_Null; if(step_past_trap_net) { DEMON_RunCtrls single_step_ctrls = {0}; single_step_ctrls.single_step_thread = event->thread; for(B32 single_step_done = 0; single_step_done == 0;) { DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &single_step_ctrls, 0); switch(event->kind) { default:{}break; case DEMON_EventKind_Error: case DEMON_EventKind_Exception: case DEMON_EventKind_Halt: case DEMON_EventKind_Trap: { step_past_trap_net_stop = 1; single_step_done = 1; step_past_trap_net_stop_cause = ctrl_event_cause_from_demon_event_kind(event->kind); }break; case DEMON_EventKind_SingleStep: { single_step_done = 1; step_past_trap_net_stop_cause = ctrl_event_cause_from_demon_event_kind(event->kind); }break; } } } //- rjf: loop exit condition CTRL_EventCause stage_stop_cause = CTRL_EventCause_Null; if(hard_stop) { stage_stop_cause = hard_stop_cause; } else if(cond_bp_single_step_stop) { stage_stop_cause = cond_bp_single_step_stop_cause; } else if(single_step_stop) { stage_stop_cause = single_step_stop_cause; } else if(step_past_trap_net_stop) { stage_stop_cause = step_past_trap_net_stop_cause; } else if(exception_stop) { stage_stop_cause = CTRL_EventCause_InterruptedByException; } else if(user_bp_stop) { stage_stop_cause = CTRL_EventCause_UserBreakpoint; } else if(trap_net_stop) { stage_stop_cause = CTRL_EventCause_Finished; } if(stage_stop_cause != CTRL_EventCause_Null) { stop_event = event; stop_cause = stage_stop_cause; break; } } } ////////////////////////////// //- rjf: record stop // if(stop_event != 0) { CTRL_EventList evts = {0}; CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts); event->kind = CTRL_EventKind_Stopped; event->cause = stop_cause; event->machine_id = CTRL_MachineID_Client; event->entity = ctrl_handle_from_demon(stop_event->thread); event->parent = ctrl_handle_from_demon(stop_event->process); event->exception_code = stop_event->code; event->vaddr_rng = r1u64(stop_event->address, stop_event->address); event->rip_vaddr = stop_event->instruction_pointer; ctrl_c2u_push_events(&evts); } dbgi_scope_close(scope); scratch_end(scratch); ProfEnd(); } internal void ctrl_thread__single_step(CTRL_Msg *msg) { ProfBeginFunction(); Temp scratch = scratch_begin(0, 0); DBGI_Scope *scope = dbgi_scope_open(); //- rjf: record start { CTRL_EventList evts = {0}; CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts); event->kind = CTRL_EventKind_Started; ctrl_c2u_push_events(&evts); } //- rjf: single step DEMON_Event *stop_event = 0; CTRL_EventCause stop_cause = CTRL_EventCause_Null; { DEMON_RunCtrls run_ctrls = {0}; run_ctrls.single_step_thread = ctrl_demon_handle_from_ctrl(msg->entity); for(B32 done = 0; done == 0;) { DEMON_Event *event = ctrl_thread__next_demon_event(scratch.arena, msg, &run_ctrls, 0); switch(event->kind) { default:{}break; case DEMON_EventKind_Error: {stop_cause = CTRL_EventCause_Error;}goto end_single_step; case DEMON_EventKind_Exception: {stop_cause = CTRL_EventCause_InterruptedByException;}goto end_single_step; case DEMON_EventKind_Halt: {stop_cause = CTRL_EventCause_InterruptedByHalt;}goto end_single_step; case DEMON_EventKind_Trap: {stop_cause = CTRL_EventCause_InterruptedByTrap;}goto end_single_step; case DEMON_EventKind_SingleStep: {stop_cause = CTRL_EventCause_Finished;}goto end_single_step; case DEMON_EventKind_Breakpoint: {stop_cause = CTRL_EventCause_UserBreakpoint;}goto end_single_step; end_single_step: { stop_event = event; done = 1; }break; } } } //- rjf: record stop if(stop_event != 0) { CTRL_EventList evts = {0}; CTRL_Event *event = ctrl_event_list_push(scratch.arena, &evts); event->kind = CTRL_EventKind_Stopped; event->cause = stop_cause; event->machine_id = CTRL_MachineID_Client; event->entity = ctrl_handle_from_demon(stop_event->thread); event->parent = ctrl_handle_from_demon(stop_event->process); event->exception_code = stop_event->code; event->vaddr_rng = r1u64(stop_event->address, stop_event->address); event->rip_vaddr = stop_event->instruction_pointer; ctrl_c2u_push_events(&evts); } dbgi_scope_close(scope); scratch_end(scratch); ProfEnd(); } //////////////////////////////// //~ rjf: Memory-Stream-Thread-Only Functions //- rjf: entry point internal void ctrl_mem_stream_thread__entry_point(void *p) { TCTX tctx_ = {0}; tctx_init_and_equip(&tctx_); CTRL_ProcessMemoryCache *cache = &ctrl_state->process_memory_cache; for(;;) { //- rjf: unpack next request CTRL_MachineID machine_id = 0; CTRL_Handle process = {0}; Rng1U64 vaddr_range = {0}; B32 zero_terminated = 0; ctrl_u2ms_dequeue_req(&machine_id, &process, &vaddr_range, &zero_terminated); U128 key = ctrl_hash_store_key_from_process_vaddr_range(machine_id, process, vaddr_range, zero_terminated); //- rjf: unpack process memory cache key U64 process_hash = ctrl_hash_from_string(str8_struct(&process)); U64 process_slot_idx = process_hash%cache->slots_count; U64 process_stripe_idx = process_slot_idx%cache->stripes_count; CTRL_ProcessMemoryCacheSlot *process_slot = &cache->slots[process_slot_idx]; CTRL_ProcessMemoryCacheStripe *process_stripe = &cache->stripes[process_stripe_idx]; //- rjf: unpack address range hash cache key U64 range_hash = ctrl_hash_from_string(str8_struct(&vaddr_range)); //- rjf: take task B32 got_task = 0; U64 preexisting_memgen_idx = 0; U128 preexisting_hash = {0}; OS_MutexScopeW(process_stripe->rw_mutex) { for(CTRL_ProcessMemoryCacheNode *n = process_slot->first; n != 0; n = n->next) { if(n->machine_id == machine_id && ctrl_handle_match(n->process, process)) { U64 range_slot_idx = range_hash%n->range_hash_slots_count; CTRL_ProcessMemoryRangeHashSlot *range_slot = &n->range_hash_slots[range_slot_idx]; for(CTRL_ProcessMemoryRangeHashNode *range_n = range_slot->first; range_n != 0; range_n = range_n->next) { if(MemoryMatchStruct(&range_n->vaddr_range, &vaddr_range) && range_n->zero_terminated == zero_terminated) { got_task = !ins_atomic_u32_eval_cond_assign(&range_n->is_taken, 1, 0); preexisting_memgen_idx = range_n->memgen_idx; preexisting_hash = range_n->hash; goto take_task__break_all; } } } } take_task__break_all:; } //- rjf: task was taken -> read memory U64 range_size = 0; Arena *range_arena = 0; void *range_base = 0; U64 zero_terminated_size = 0; U64 memgen_idx = ctrl_memgen_idx(); if(got_task && memgen_idx != preexisting_memgen_idx) { range_size = dim_1u64(vaddr_range); U64 arena_size = AlignPow2(range_size + ARENA_HEADER_SIZE, KB(64)); range_arena = arena_alloc__sized(range_size+ARENA_HEADER_SIZE, range_size+ARENA_HEADER_SIZE); range_base = push_array_no_zero(range_arena, U8, range_size); U64 bytes_read = ctrl_process_read(machine_id, process, vaddr_range, range_base); if(bytes_read == 0) { arena_release(range_arena); range_base = 0; range_size = 0; range_arena = 0; } else if(bytes_read < range_size) { MemoryZero((U8 *)range_base + bytes_read, range_size-bytes_read); } zero_terminated_size = range_size; if(zero_terminated) { for(U64 idx = 0; idx < bytes_read; idx += 1) { if(((U8 *)range_base)[idx] == 0) { zero_terminated_size = idx; break; } } } } //- rjf: read successful -> submit to hash store U128 hash = {0}; if(got_task && range_base != 0) { hash = hs_submit_data(key, &range_arena, str8((U8*)range_base, zero_terminated_size)); } //- rjf: commit hash to cache if(got_task) OS_MutexScopeW(process_stripe->rw_mutex) { for(CTRL_ProcessMemoryCacheNode *n = process_slot->first; n != 0; n = n->next) { if(n->machine_id == machine_id && ctrl_handle_match(n->process, process)) { U64 range_slot_idx = range_hash%n->range_hash_slots_count; CTRL_ProcessMemoryRangeHashSlot *range_slot = &n->range_hash_slots[range_slot_idx]; for(CTRL_ProcessMemoryRangeHashNode *range_n = range_slot->first; range_n != 0; range_n = range_n->next) { if(MemoryMatchStruct(&range_n->vaddr_range, &vaddr_range) && range_n->zero_terminated == zero_terminated) { if(!u128_match(u128_zero(), hash)) { range_n->hash = hash; range_n->memgen_idx = memgen_idx; } ins_atomic_u32_eval_assign(&range_n->is_taken, 0); goto commit__break_all; } } } } commit__break_all:; } } }