void init_traps(void) { /* * Fill the exception area with branch instructions so * if we get something we don't expect, the kernel will hardcrash. */ set_trap(SH_EXC_GENERAL, __exc_unexpected, 0x00); set_trap(SH_EXC_TLBMISS, __exc_unexpected, 0x00); set_trap(SH_EXC_INTR, __exc_unexpected, 0x00); install_traps(); }
static void handle_channel_msg(void * x) { Trap trap; ChannelNP * c = (ChannelNP *)x; int has_msg; assert(is_dispatch_thread()); assert(c->magic == CHANNEL_MAGIC); assert(c->ibuf.handling_msg == HandleMsgTriggered); assert(c->ibuf.message_count); has_msg = ibuf_start_message(&c->ibuf); if (has_msg <= 0) { if (has_msg < 0 && c->chan.state != ChannelStateDisconnected) { trace(LOG_PROTOCOL, "Socket is shutdown by remote peer, channel %#lx %s", c, c->chan.peer_name); channel_close(&c->chan); } } else if (set_trap(&trap)) { if (c->chan.receive) { c->chan.receive(&c->chan); } else { handle_protocol_message(&c->chan); assert(c->out_bin_block == NULL); } clear_trap(&trap); } else { trace(LOG_ALWAYS, "Exception in message handler: %s", errno_to_str(trap.error)); send_eof_and_close(&c->chan, trap.error); } }
void virtual_stream_create(const char * type, const char * context_id, size_t buf_len, unsigned access, VirtualStreamCallBack * callback, void * callback_args, VirtualStream ** res) { LINK * l; VirtualStream * stream = loc_alloc_zero(sizeof(VirtualStream)); buf_len++; list_init(&stream->clients); strncpy(stream->type, type, sizeof(stream->type) - 1); stream->magic = STREAM_MAGIC; stream->id = id_cnt++; stream->access = access; stream->callback = callback; stream->callback_args = callback_args; stream->ref_cnt = 1; stream->buf = loc_alloc(buf_len); stream->buf_len = buf_len; for (l = subscriptions.next; l != &subscriptions; l = l->next) { Subscription * h = all2subscription(l); if (strcmp(type, h->type) == 0) { Trap trap; create_client(stream, h->channel); if (set_trap(&trap)) { send_event_stream_created(&h->channel->out, stream, context_id); clear_trap(&trap); } else { trace(LOG_ALWAYS, "Exception sending stream created event: %d %s", trap.error, errno_to_str(trap.error)); } } } list_add_first(&stream->link_all, &streams); *res = stream; }
DWARFCache * get_dwarf_cache(ELF_File * File) { DWARFCache * Cache = (DWARFCache *)File->dwarf_dt_cache; if (Cache == NULL) { Trap trap; if (!sCloseListenerOK) { elf_add_close_listener(free_dwarf_cache); sCloseListenerOK = 1; } sCache = Cache = (DWARFCache *)(File->dwarf_dt_cache = loc_alloc_zero(sizeof(DWARFCache))); sCache->magic = SYM_CACHE_MAGIC; sCache->mFile = File; sCache->mObjectHash = loc_alloc_zero(sizeof(ObjectInfo *) * OBJ_HASH_SIZE); if (set_trap(&trap)) { dio_LoadAbbrevTable(File); load_symbol_tables(); load_debug_sections(); clear_trap(&trap); } else { sCache->mErrorCode = trap.error; strncpy(sCache->mErrorMsg, trap.msg, sizeof(sCache->mErrorMsg) - 1); } sCache = NULL; } if (Cache->mErrorCode) str_exception(Cache->mErrorCode, Cache->mErrorMsg); return Cache; }
static void subscribe_cb(Channel * c, void * x, int error) { Trap trap; PortConnection * conn = (PortConnection *)x; PortAttribute * attr = conn->server->redir_info->attrs; OutputStream * out = &conn->server->channel->out; if (set_trap(&trap)) { if (!error) { error = read_errno(&c->inp); json_test_char(&c->inp, MARKER_EOM); } clear_trap(&trap); } else { error = trap.error; } /* Ignore error for subscribe since we may already have subscribed for this channel */ conn->pending = protocol_send_command(conn->server->channel, "PortForward", "create", portcreate_cb, conn); write_stream(out, '{'); json_write_string(out, "ID"); write_stream(out, ':'); json_write_string(out, conn->id); write_stream(out, ','); while (attr != NULL) { json_write_string(out, attr->name); write_stream(out, ':'); write_string(out, attr->value); attr = attr->next; } write_stream(out, '}'); write_stream(out, MARKER_EOA); write_stream(out, MARKER_EOM); }
int ini_server(const char * url, Protocol * p, TCFBroadcastGroup * b) { ChannelServer * serv = NULL; PeerServer * ps = NULL; Trap trap; if (!set_trap(&trap)) { bcg = NULL; proto = NULL; if (ps != NULL) peer_server_free(ps); errno = trap.error; return -1; } bcg = b; proto = p; ps = channel_peer_from_url(url); if (ps == NULL) str_exception(ERR_OTHER, "Invalid server URL"); peer_server_addprop(ps, loc_strdup("Name"), loc_strdup(PROXY_NAME)); peer_server_addprop(ps, loc_strdup("Proxy"), loc_strdup("")); SERVER_ADDPROP_HOOK; serv = channel_server(ps); if (serv == NULL) exception(errno); serv->new_conn = channel_new_connection; clear_trap(&trap); add_channel_redirection_listener(channel_redirection_listener); return 0; }
static void delete_config_done(Channel *c, void *client_data, int error) { PortConnection * conn = (PortConnection *) client_data; Trap trap; if (set_trap(&trap)) { if (!error) { error = read_errno(&c->inp); json_test_char(&c->inp, MARKER_EOM); } clear_trap(&trap); } else { error = trap.error; } if (!conn->auto_connect_stream) { protocol_send_command(conn->server->channel, "Streams", "disconnect", disconnect_stream_done, conn); json_write_string(&conn->server->channel->out, conn->out_stream_id); write_stream(&conn->server->channel->out, MARKER_EOA); write_stream(&conn->server->channel->out, MARKER_EOM); } else { loc_free(conn->out_stream_id); conn->out_stream_id = NULL; loc_free(conn->in_stream_id); conn->in_stream_id = NULL; port_unlock(conn); port_connection_close(conn); } }
static void command_get_context_cache_client(void * x) { GetContextArgs * args = (GetContextArgs *)x; Channel * c = cache_channel(); Context * ctx = NULL; int frame = STACK_NO_FRAME; RegisterDefinition * reg_def = NULL; Trap trap; if (set_trap(&trap)) { if (id2register(args->id, &ctx, &frame, ®_def) < 0) exception(errno); clear_trap(&trap); } cache_exit(); write_stringz(&c->out, "R"); write_stringz(&c->out, args->token); write_errno(&c->out, trap.error); if (reg_def != NULL) { write_context(&c->out, args->id, ctx, frame, reg_def); } else { write_stringz(&c->out, "null"); } write_stream(&c->out, MARKER_EOM); }
static void load_debug_sections(void) { Trap trap; unsigned idx; ELF_File * File = sCache->mFile; memset(&trap, 0, sizeof(trap)); sSymbolTableLen = sCache->mSymbolTableLen; sObjectList = NULL; sObjectListTail = NULL; sCompUnitsMax = 0; for (idx = 1; idx < File->section_cnt; idx++) { ELF_Section * sec = File->sections + idx; if (sec->size == 0) continue; if (sec->name == NULL) continue; if (strcmp(sec->name, ".debug") == 0 || strcmp(sec->name, ".debug_info") == 0) { sDebugSection = sec; sParentObject = NULL; sPrevSibling = NULL; dio_EnterDebugSection(NULL, sec, 0); if (set_trap(&trap)) { while (dio_GetPos() < sec->size) { dio_ReadUnit(&sUnitDesc, entry_callback); sCompUnit->mDesc = sUnitDesc; } clear_trap(&trap); } dio_ExitSection(); sParentObject = NULL; sPrevSibling = NULL; sCompUnit = NULL; sDebugSection = NULL; if (trap.error) break; } else if (strcmp(sec->name, ".debug_ranges") == 0) { sCache->mDebugRanges = sec; } else if (strcmp(sec->name, ".debug_aranges") == 0) { sCache->mDebugARanges = sec; } else if (strcmp(sec->name, ".debug_line") == 0) { sCache->mDebugLine = sec; } else if (strcmp(sec->name, ".debug_loc") == 0) { sCache->mDebugLoc = sec; } } if (sObjectList == NULL) { loc_free(sCache->mObjectHash); sCache->mObjectHash = NULL; } sCache->mObjectList = sObjectList; sSymbolTableLen = 0; sObjectList = NULL; sObjectListTail = NULL; sCompUnitsMax = 0; if (trap.error) str_exception(trap.error, trap.msg); }
static void getcapabilities_cb(Channel * c, void * x, int error) { Trap trap; PortConnection * conn = (PortConnection *)x; PortAttribute * attr = conn->server->redir_info->attrs; OutputStream * out = &conn->server->channel->out; if (set_trap(&trap)) { if (!error) { error = read_errno(&c->inp); json_read_struct(&c->inp, read_getcapabilities_struct, (void *)conn); json_test_char(&c->inp, MARKER_EOA); json_test_char(&c->inp, MARKER_EOM); } clear_trap(&trap); } else { error = trap.error; } if (error) { connect_port_callback(conn, error); } else { if (conn->auto_connect_stream) { conn->pending = protocol_send_command(conn->server->channel, "PortForward", "create", portcreate_cb, conn); write_stream(out, '{'); json_write_string(out, "ID"); write_stream(out, ':'); json_write_string(out, conn->id); while (attr != NULL) { write_stream(out, ','); if (strcmp(attr->name, "RemotePort") == 0) { json_write_string(out, "Port"); } else { json_write_string(out, attr->name); } write_stream(out, ':'); write_string(out, attr->value); attr = attr->next; } if (conn->auto_connect_stream) { write_stream(out, ','); json_write_string(out, "AutoConnect"); write_stream(out, ':'); json_write_boolean(out, 1); } write_stream(out, '}'); write_stream(out, MARKER_EOA); write_stream(out, MARKER_EOM); } else { conn->pending = protocol_send_command(conn->server->channel, "Streams", "subscribe", subscribe_cb, conn); json_write_string(out, "PortForward"); write_stream(out, MARKER_EOA); write_stream(out, MARKER_EOM); } } }
submap::submap() : ter(), frn(), trp(), rad(), active_item_count(0), field_count(0), turn_last_touched(0), temperature(0) { for (int x = 0; x < SEEX; x++) { for (int y = 0; y < SEEY; y++) { ter[x][y] = t_null; set_furn(x, y, f_null); set_trap(x, y, tr_null); set_radiation(x, y, 0); } } }
static void run_cache_client(int retry) { Trap trap; unsigned i; unsigned id = current_client.id; void * args_copy = NULL; assert(id != 0); current_cache = NULL; cache_miss_cnt = 0; def_channel = NULL; if (current_client.args_copy) args_copy = current_client.args; for (i = 0; i < listeners_cnt; i++) listeners[i](retry ? CTLE_RETRY : CTLE_START); if (set_trap(&trap)) { current_client.client(current_client.args); clear_trap(&trap); assert(current_client.id == 0); assert(cache_miss_cnt == 0); } else if (id != current_client.id) { trace(LOG_ALWAYS, "Unhandled exception in data cache client: %s", errno_to_str(trap.error)); assert(current_client.id == 0); assert(cache_miss_cnt == 0); } else { if (get_error_code(trap.error) != ERR_CACHE_MISS || cache_miss_cnt == 0 || current_cache == NULL) { trace(LOG_ALWAYS, "Unhandled exception in data cache client: %s", errno_to_str(trap.error)); for (i = 0; i < listeners_cnt; i++) listeners[i](CTLE_COMMIT); } else { AbstractCache * cache = current_cache; if (cache->wait_list_cnt >= cache->wait_list_max) { cache->wait_list_max += 8; cache->wait_list_buf = (WaitingCacheClient *)loc_realloc(cache->wait_list_buf, cache->wait_list_max * sizeof(WaitingCacheClient)); } if (current_client.args != NULL && !current_client.args_copy) { void * mem = loc_alloc(current_client.args_size); memcpy(mem, current_client.args, current_client.args_size); current_client.args = mem; current_client.args_copy = 1; } if (cache->wait_list_cnt == 0) list_add_last(&cache->link, &cache_list); if (current_client.channel != NULL) channel_lock_with_msg(current_client.channel, channel_lock_msg); cache->wait_list_buf[cache->wait_list_cnt++] = current_client; for (i = 0; i < listeners_cnt; i++) listeners[i](CTLE_ABORT); args_copy = NULL; } memset(¤t_client, 0, sizeof(current_client)); current_cache = NULL; cache_miss_cnt = 0; def_channel = NULL; } if (args_copy != NULL) loc_free(args_copy); }
static LocationExpressionState * evaluate_location(Context * ctx, int frame, LocationInfo * loc_info) { Trap trap; StackFrame * frame_info = NULL; LocationExpressionState * state = NULL; static uint64_t args[] = { 0, 0 }; if (frame != STACK_NO_FRAME && get_frame_info(ctx, frame, &frame_info) < 0) return NULL; if (!set_trap(&trap)) return NULL; state = evaluate_location_expression(ctx, frame_info, loc_info->value_cmds.cmds, loc_info->value_cmds.cnt, args, loc_info->args_cnt); clear_trap(&trap); return state; }
static void command_get_children_cache_client(void * x) { GetChildrenArgs * args = (GetChildrenArgs *)x; Channel * c = cache_channel(); Context * ctx = NULL; int frame = STACK_NO_FRAME; StackFrame * frame_info = NULL; RegisterDefinition * defs = NULL; RegisterDefinition * parent = NULL; Trap trap; if (set_trap(&trap)) { if (id2register(args->id, &ctx, &frame, &parent) == 0) { if (frame != STACK_TOP_FRAME && get_frame_info(ctx, frame, &frame_info) < 0) exception(errno); } else if (id2frame(args->id, &ctx, &frame) == 0) { if (get_frame_info(ctx, frame, &frame_info) < 0) exception(errno); } else { ctx = id2ctx(args->id); frame = STACK_TOP_FRAME; } if (ctx != NULL) defs = get_reg_definitions(ctx); clear_trap(&trap); } cache_exit(); write_stringz(&c->out, "R"); write_stringz(&c->out, args->token); write_errno(&c->out, trap.error); write_stream(&c->out, '['); if (defs != NULL) { int cnt = 0; RegisterDefinition * reg_def; for (reg_def = defs; reg_def->name != NULL; reg_def++) { if (reg_def->parent != parent) continue; if (frame < 0 || frame_info->is_top_frame || reg_def->size == 0 || read_reg_value(frame_info, reg_def, NULL) == 0) { if (cnt > 0) write_stream(&c->out, ','); json_write_string(&c->out, register2id(ctx, frame, reg_def)); cnt++; } } } write_stream(&c->out, ']'); write_stream(&c->out, 0); write_stream(&c->out, MARKER_EOM); }
static void command_get_cache_client(void * x) { GetArgs * args = (GetArgs *)x; Channel * c = cache_channel(); Trap trap; bbf_pos = 0; if (set_trap(&trap)) { int frame = 0; Context * ctx = NULL; RegisterDefinition * reg_def = NULL; if (id2register(args->id, &ctx, &frame, ®_def) < 0) exception(errno); if (ctx->exited) exception(ERR_ALREADY_EXITED); if ((ctx->reg_access & REG_ACCESS_RD_STOP) != 0) { check_all_stopped(ctx); } if ((ctx->reg_access & REG_ACCESS_RD_RUNNING) == 0) { if (!ctx->stopped && context_has_state(ctx)) str_exception(ERR_IS_RUNNING, "Cannot read register if not stopped"); } if (reg_def->size > bbf_len) { bbf_len += 0x100 + reg_def->size; bbf = (uint8_t *)loc_realloc(bbf, bbf_len); } bbf_pos = reg_def->size; memset(bbf, 0, reg_def->size); if (frame < 0 || is_top_frame(ctx, frame)) { if (context_read_reg(ctx, reg_def, 0, reg_def->size, bbf) < 0) exception(errno); } else { StackFrame * info = NULL; if (get_frame_info(ctx, frame, &info) < 0) exception(errno); if (read_reg_bytes(info, reg_def, 0, reg_def->size, bbf) < 0) exception(errno); } clear_trap(&trap); } cache_exit(); write_stringz(&c->out, "R"); write_stringz(&c->out, args->token); write_errno(&c->out, trap.error); json_write_binary(&c->out, bbf, bbf_pos); write_stream(&c->out, 0); write_stream(&c->out, MARKER_EOM); }
/*H:230 While we're here, dealing with delivering traps and interrupts to the * Guest, we might as well complete the picture: how the Guest tells us where * it wants them to go. This would be simple, except making traps fast * requires some tricks. * * We saw the Guest setting Interrupt Descriptor Table (IDT) entries with the * LHCALL_LOAD_IDT_ENTRY hypercall before: that comes here. */ void load_guest_idt_entry(struct lg_cpu *cpu, unsigned int num, u32 lo, u32 hi) { /* Guest never handles: NMI, doublefault, spurious interrupt or * hypercall. We ignore when it tries to set them. */ if (num == 2 || num == 8 || num == 15 || num == LGUEST_TRAP_ENTRY) return; /* Mark the IDT as changed: next time the Guest runs we'll know we have * to copy this again. */ cpu->changed |= CHANGED_IDT; /* Check that the Guest doesn't try to step outside the bounds. */ if (num >= ARRAY_SIZE(cpu->arch.idt)) kill_guest(cpu, "Setting idt entry %u", num); else set_trap(cpu, &cpu->arch.idt[num], num, lo, hi); }
static void terminal_exited(void * args) { Terminal * term = (Terminal *)args; Trap trap; if (set_trap(&trap)) { send_event_terminal_exited(&term->bcg->out, term); clear_trap(&trap); } else { trace(LOG_ALWAYS, "Exception sending terminal exited event: %d %s", trap.error, errno_to_str(trap.error)); } list_remove(&term->link); channel_unlock_with_msg(term->channel, TERMINALS); loc_free(term); }
static void getconfig_cb(Channel * c, void * x, int error) { Trap trap; PortConnection * conn = (PortConnection *)x; if (set_trap(&trap)) { if (!error) { error = read_errno(&c->inp); json_read_struct(&c->inp, read_getconfig_struct, (void *)conn); json_test_char(&c->inp, MARKER_EOA); json_test_char(&c->inp, MARKER_EOM); } clear_trap(&trap); } else { error = trap.error; } connect_port_callback(conn, error); }
static void run_cache_client(void) { Trap trap; cache_miss_cnt = 0; client_exited = 0; if (set_trap(&trap)) { current_client.client(current_client.args); clear_trap(&trap); assert(cache_miss_cnt == 0); assert(client_exited); } else if (get_error_code(trap.error) != ERR_CACHE_MISS || client_exited || cache_miss_cnt == 0) { trace(LOG_ALWAYS, "Unhandled exception in data cache client: %d %s", trap.error, errno_to_str(trap.error)); } if (cache_miss_cnt == 0 && current_client.args_copy) loc_free(current_client.args); memset(¤t_client, 0, sizeof(current_client)); cache_miss_cnt = 0; client_exited = 0; }
static void delete_write_request(WriteRequest * r, int error) { Channel * c = r->client->channel; Trap trap; if (set_trap(&trap)) { write_stringz(&c->out, "R"); write_stringz(&c->out, r->token); write_errno(&c->out, error); write_stream(&c->out, MARKER_EOM); clear_trap(&trap); } else { trace(LOG_ALWAYS, "Exception handling pending stream write command: %d %s", trap.error, errno_to_str(trap.error)); } list_remove(&r->link_client); loc_free(r->data); loc_free(r); }
static void append_format_parameter(char * type, char * style, char * param) { /* Note: 'param' is UTF-8 encoded JSON text */ char str[64]; if (param != NULL && (*param == '"' || strcmp(type, "number") == 0)) { Trap trap; ByteArrayInputStream buf; InputStream * inp = create_byte_array_input_stream(&buf, param, strlen(param)); if (set_trap(&trap)) { if (*param == '"') { char * x = json_read_alloc_string(inp); if (x != NULL) { char * s = x; while (*s) { realloc_msg_buf(); msg_buf[msg_buf_len++] = *s++; } loc_free(x); } param = NULL; } else { double x = json_read_double(inp); if (strcmp(style, "percent") == 0) { snprintf(str, sizeof(str), "%ld%%", (long)(x * 100)); } else if (strcmp(style, "integer") == 0) { snprintf(str, sizeof(str), "%ld", (long)x); } else { snprintf(str, sizeof(str), "%g", x); } param = str; } clear_trap(&trap); } } if (param != NULL) { while (*param) { realloc_msg_buf(); msg_buf[msg_buf_len++] = *param++; } } }
static void write_stream_done(Channel *c, void *client_data, int error) { Trap trap; PortConnection * conn = (PortConnection *) client_data;; if (set_trap(&trap)) { if (!error) { error = read_errno(&c->inp); json_test_char(&c->inp, MARKER_EOM); } clear_trap(&trap); } else { error = trap.error; } assert (conn->pending_write_request <= MAX_STREAM_WRITE && conn->pending_write_request > 0); if (conn->pending_write_request == MAX_STREAM_WRITE) { send_packet_callback(conn, error); } conn->pending_write_request--; }
static void command_setm_cache_client(void * x) { SetmArgs * args = (SetmArgs *)x; Channel * c = cache_channel(); int notify = 0; Trap trap; if (set_trap(&trap)) { unsigned locs_pos = 0; unsigned data_pos = 0; check_location_list(args->locs, args->locs_cnt, 1); while (locs_pos < args->locs_cnt) { Location * l = args->locs + locs_pos++; assert(l->frame_info == NULL); if (l->size > 0) { if (context_write_reg(l->ctx, l->reg_def, l->offs, l->size, args->data + data_pos) < 0) exception(errno); data_pos += l->size; l->notify = 1; notify = 1; } } clear_trap(&trap); } cache_exit(); if (notify) { unsigned locs_pos = 0; while (locs_pos < args->locs_cnt) { Location * l = args->locs + locs_pos++; if (l->notify) send_event_register_changed(l->id); } } write_stringz(&c->out, "R"); write_stringz(&c->out, args->token); write_errno(&c->out, trap.error); write_stream(&c->out, MARKER_EOM); loc_free(args->locs); loc_free(args->data); }
static void delete_config_done(Channel *c, void *client_data, int error) { PortConnection * conn = (PortConnection *) client_data; Trap trap; if (set_trap(&trap)) { if (!error) { error = read_errno(&c->inp); json_test_char(&c->inp, MARKER_EOM); } clear_trap(&trap); } else { error = trap.error; } loc_free(conn->out_stream_id); conn->out_stream_id = NULL; loc_free(conn->in_stream_id); conn->in_stream_id = NULL; port_unlock(conn); port_connection_close(conn); }
static void command_set_cache_client(void * x) { SetArgs * args = (SetArgs *)x; Channel * c = cache_channel(); int notify = 0; Trap trap; if (set_trap(&trap)) { int frame = 0; Context * ctx = NULL; RegisterDefinition * reg_def = NULL; if (id2register(args->id, &ctx, &frame, ®_def) < 0) exception(errno); if (frame >= 0 && !is_top_frame(ctx, frame)) exception(ERR_INV_CONTEXT); if (ctx->exited) exception(ERR_ALREADY_EXITED); if ((ctx->reg_access & REG_ACCESS_WR_STOP) != 0) { check_all_stopped(ctx); } if ((ctx->reg_access & REG_ACCESS_WR_RUNNING) == 0) { if (!ctx->stopped && context_has_state(ctx)) str_exception(ERR_IS_RUNNING, "Cannot write register if not stopped"); } if ((size_t)args->data_len > reg_def->size) exception(ERR_INV_DATA_SIZE); if (args->data_len > 0) { if (context_write_reg(ctx, reg_def, 0, args->data_len, args->data) < 0) exception(errno); notify = 1; } clear_trap(&trap); } cache_exit(); if (notify) send_event_register_changed(args->id); write_stringz(&c->out, "R"); write_stringz(&c->out, args->token); write_errno(&c->out, trap.error); write_stream(&c->out, MARKER_EOM); loc_free(args->data); }
static void command_getm_cache_client(void * x) { GetmArgs * args = (GetmArgs *)x; Channel * c = cache_channel(); Trap trap; bbf_pos = 0; if (bbf == NULL) bbf = (uint8_t *)loc_alloc(bbf_len = 0x100); if (set_trap(&trap)) { unsigned locs_pos = 0; check_location_list(args->locs, args->locs_cnt, 0); while (locs_pos < args->locs_cnt) { Location * l = args->locs + locs_pos++; if (bbf_pos + l->size > bbf_len) { bbf_len += 0x100 + l->size; bbf = (uint8_t *)loc_realloc(bbf, bbf_len); } memset(bbf + bbf_pos, 0, l->size); if (l->frame_info == NULL) { if (context_read_reg(l->ctx, l->reg_def, l->offs, l->size, bbf + bbf_pos) < 0) exception(errno); } else { if (read_reg_bytes(l->frame_info, l->reg_def, l->offs, l->size, bbf + bbf_pos) < 0) exception(errno); } bbf_pos += l->size; } clear_trap(&trap); } cache_exit(); write_stringz(&c->out, "R"); write_stringz(&c->out, args->token); write_errno(&c->out, trap.error); json_write_binary(&c->out, bbf, bbf_pos); write_stream(&c->out, 0); write_stream(&c->out, MARKER_EOM); loc_free(args->locs); }
static void delete_read_request(ReadRequest * r) { Channel * c = r->client->channel; Trap trap; if (set_trap(&trap)) { write_stringz(&c->out, "R"); write_stringz(&c->out, r->token); write_stringz(&c->out, "null"); write_errno(&c->out, ERR_COMMAND_CANCELLED); json_write_long(&c->out, 0); write_stream(&c->out, 0); json_write_boolean(&c->out, 1); write_stream(&c->out, 0); write_stream(&c->out, MARKER_EOM); clear_trap(&trap); } else { trace(LOG_ALWAYS, "Exception handling pending stream read command: %d %s", trap.error, errno_to_str(trap.error)); } list_remove(&r->link_client); loc_free(r); }
static ContextAddress get_module_id(Context * ctx, ELF_File * module) { ELF_File * exe_file = NULL; ContextAddress addr = elf_get_debug_structure_address(ctx, &exe_file); size_t word_size = exe_file && exe_file->elf64 ? 8 : 4; Trap trap; if (addr == 0 || exe_file == NULL) str_exception(ERR_OTHER, "Cannot find loader debug data"); if (set_trap(&trap)) { ContextAddress r_map = 0; ContextAddress r_brk = 0; ContextAddress mod_id = 0; if (elf_read_memory_word(ctx, exe_file, addr + word_size * 1, &r_map) < 0) exception(errno); if (elf_read_memory_word(ctx, exe_file, addr + word_size * 2, &r_brk) < 0) exception(errno); if (r_map != 0 && r_brk != 0) mod_id = find_module(ctx, exe_file, module, r_map, r_brk); clear_trap(&trap); if (mod_id) return mod_id; } else { str_exception(trap.error, "Cannot access target ELF loader data"); } str_exception(ERR_OTHER, "Cannot get TLS module ID"); return 0; }
static void delete_client(StreamClient * client) { VirtualStream * stream = client->stream; Trap trap; LINK * n; assert(stream->ref_cnt > 0); if (set_trap(&trap)) { send_event_stream_disposed(&client->channel->out, stream); clear_trap(&trap); } else { trace(LOG_ALWAYS, "Exception sending stream deleted event: %d %s", trap.error, errno_to_str(trap.error)); } list_remove(&client->link_hash); list_remove(&client->link_stream); list_remove(&client->link_all); for (n = client->read_requests.next; n != &client->read_requests;) { ReadRequest * r = client2read_request(n); n = n->next; delete_read_request(r); } for (n = client->write_requests.next; n != &client->write_requests;) { WriteRequest * r = client2write_request(n); n = n->next; delete_write_request(r, ERR_COMMAND_CANCELLED); } loc_free(client); if (--stream->ref_cnt == 0) { assert(list_is_empty(&stream->clients)); assert(stream->deleted); post_event(delete_stream, stream); } else if (stream->access & VS_ENABLE_REMOTE_READ) { advance_stream_buffer(stream); } }
static void portcreate_cb(Channel * c, void * x, int error) { Trap trap; PortConnection * conn = (PortConnection *)x; if (set_trap(&trap)) { if (!error) { error = read_errno(&c->inp); json_test_char(&c->inp, MARKER_EOM); } clear_trap(&trap); } else { error = trap.error; } if (error) { connect_port_callback(conn, error); } else { conn->pending = protocol_send_command(conn->server->channel, "PortForward", "getConfig", getconfig_cb, conn); json_write_string(&conn->server->channel->out, conn->id); write_stream(&conn->server->channel->out, MARKER_EOA); write_stream(&conn->server->channel->out, MARKER_EOM); } }