static void safe_event_disassemble(void * x) { DisassembleCmdArgs * args = (DisassembleCmdArgs *)x; if (!is_channel_closed(args->c)) { cache_enter(disassemble_cache_client, args->c, args, sizeof(DisassembleCmdArgs)); } channel_unlock(args->c); loc_free(args); }
void cache_notify(AbstractCache * cache) { unsigned i; unsigned cnt = cache->wait_list_cnt; assert(is_dispatch_thread()); if (cnt == 0) return; list_remove(&cache->link); cache->wait_list_cnt = 0; if (wait_list_max < cnt) { wait_list_max = cnt; wait_list_buf = (WaitingCacheClient *)loc_realloc(wait_list_buf, cnt * sizeof(WaitingCacheClient)); } memcpy(wait_list_buf, cache->wait_list_buf, cnt * sizeof(WaitingCacheClient)); for (i = 0; i < cnt; i++) { current_client = wait_list_buf[i]; run_cache_client(); channel_unlock(wait_list_buf[i].channel); } }
static void connect_done(void * args, int error, Channel * c2) { ConnectInfo * info = (ConnectInfo *)args; Channel * c1 = info->c1; if (!is_channel_closed(c1)) { assert(c1->state == ChannelStateRedirectReceived); if (error) { fprintf(stderr, "cannot connect to peer: %s\n", dest_url); channel_close(c1); } else { proxy_create(c1, c2); } } else if (!error) { channel_close(c2); } channel_unlock(c1); peer_server_free(info->ps); loc_free(info); }
static void safe_memory_fill(void * parm) { MemoryCommandArgs * args = (MemoryCommandArgs *)parm; Channel * c = args->c; Context * ctx = args->ctx; if (!is_channel_closed(c)) { Trap trap; if (set_trap(&trap)) { InputStream * inp = &c->inp; OutputStream * out = &c->out; char * token = args->token; ContextAddress addr0 = args->addr; ContextAddress addr = args->addr; unsigned long size = args->size; MemoryErrorInfo err_info; MemoryFillBuffer buf; char * tmp = NULL; int err = 0; memset(&err_info, 0, sizeof(err_info)); if (ctx->exiting || ctx->exited) err = ERR_ALREADY_EXITED; memset(&buf, 0, sizeof(buf)); buf.buf = (char *)tmp_alloc(buf.max = BUF_SIZE); if (err) json_skip_object(inp); else json_read_array(inp, read_memory_fill_array_cb, &buf); json_test_char(inp, MARKER_EOA); json_test_char(inp, MARKER_EOM); while (err == 0 && buf.pos < size && buf.pos <= buf.max / 2) { if (buf.pos == 0) { buf.buf[buf.pos++] = 0; } else { memcpy(buf.buf + buf.pos, buf.buf, buf.pos); buf.pos *= 2; } } while (err == 0 && addr < addr0 + size) { /* Note: context_write_mem() modifies buffer contents */ unsigned wr = (unsigned)(addr0 + size - addr); if (tmp == NULL) tmp = (char *)tmp_alloc(buf.pos); if (wr > buf.pos) wr = buf.pos; /* TODO: word size, mode */ memcpy(tmp, buf.buf, wr); if (context_write_mem(ctx, addr, tmp, wr) < 0) { err = errno; #if ENABLE_ExtendedMemoryErrorReports context_get_mem_error_info(&err_info); #endif } else { addr += wr; } } send_event_memory_changed(ctx, addr0, size); write_stringz(out, "R"); write_stringz(out, token); write_errno(out, err); if (err == 0) { write_stringz(out, "null"); } else { write_ranges(out, addr0, (int)(addr - addr0), BYTE_CANNOT_WRITE, &err_info); } write_stream(out, MARKER_EOM); clear_trap(&trap); } else { trace(LOG_ALWAYS, "Exception in Memory.fill: %s", errno_to_str(trap.error)); channel_close(c); } } channel_unlock(c); context_unlock(ctx); loc_free(args); }
static void safe_memory_get(void * parm) { MemoryCommandArgs * args = (MemoryCommandArgs *)parm; Channel * c = args->c; Context * ctx = args->ctx; if (!is_channel_closed(c)) { Trap trap; if (set_trap(&trap)) { OutputStream * out = &args->c->out; char * token = args->token; ContextAddress addr0 = args->addr; ContextAddress addr = args->addr; unsigned long size = args->size; unsigned long pos = 0; char buf[BUF_SIZE]; int err = 0; MemoryErrorInfo err_info; JsonWriteBinaryState state; memset(&err_info, 0, sizeof(err_info)); if (ctx->exiting || ctx->exited) err = ERR_ALREADY_EXITED; write_stringz(out, "R"); write_stringz(out, token); json_write_binary_start(&state, out, size); while (pos < size) { int rd = size - pos; if (rd > BUF_SIZE) rd = BUF_SIZE; /* TODO: word size, mode */ memset(buf, 0, rd); if (err == 0) { if (context_read_mem(ctx, addr, buf, rd) < 0) { err = errno; #if ENABLE_ExtendedMemoryErrorReports context_get_mem_error_info(&err_info); #endif } else { addr += rd; } } json_write_binary_data(&state, buf, rd); pos += rd; } json_write_binary_end(&state); write_stream(out, 0); write_errno(out, err); if (err == 0) { write_stringz(out, "null"); } else { write_ranges(out, addr0, (int)(addr - addr0), BYTE_CANNOT_READ, &err_info); } write_stream(out, MARKER_EOM); clear_trap(&trap); } else { trace(LOG_ALWAYS, "Exception in Memory.get: %s", errno_to_str(trap.error)); channel_close(c); } } channel_unlock(c); context_unlock(ctx); loc_free(args); }
static void safe_memory_set(void * parm) { MemoryCommandArgs * args = (MemoryCommandArgs *)parm; Channel * c = args->c; Context * ctx = args->ctx; if (!is_channel_closed(c)) { Trap trap; if (set_trap(&trap)) { InputStream * inp = &c->inp; OutputStream * out = &c->out; char * token = args->token; ContextAddress addr0 = args->addr; ContextAddress addr = args->addr; unsigned long size = 0; char buf[BUF_SIZE]; int err = 0; MemoryErrorInfo err_info; JsonReadBinaryState state; memset(&err_info, 0, sizeof(err_info)); if (ctx->exiting || ctx->exited) err = ERR_ALREADY_EXITED; json_read_binary_start(&state, inp); for (;;) { int rd = json_read_binary_data(&state, buf, sizeof(buf)); if (rd == 0) break; if (err == 0) { /* TODO: word size, mode */ if (context_write_mem(ctx, addr, buf, rd) < 0) { err = errno; #if ENABLE_ExtendedMemoryErrorReports context_get_mem_error_info(&err_info); #endif } else { addr += rd; } } size += rd; } json_read_binary_end(&state); json_test_char(inp, MARKER_EOA); json_test_char(inp, MARKER_EOM); send_event_memory_changed(ctx, addr0, size); write_stringz(out, "R"); write_stringz(out, token); write_errno(out, err); if (err == 0) { write_stringz(out, "null"); } else { write_ranges(out, addr0, (int)(addr - addr0), BYTE_CANNOT_WRITE, &err_info); } write_stream(out, MARKER_EOM); clear_trap(&trap); } else { trace(LOG_ALWAYS, "Exception in Memory.set: %s", errno_to_str(trap.error)); channel_close(c); } } channel_unlock(c); context_unlock(ctx); loc_free(args); }