void cache_wait(AbstractCache * cache) {
#else
void cache_wait_dbg(const char * file, int line, AbstractCache * cache) {
#endif
assert(is_dispatch_thread());
assert(client_exited == 0);
if (current_client.client != NULL && cache_miss_cnt == 0) {
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;
}
#ifndef NDEBUG
current_client.file = file;
current_client.line = line;
#endif
if (cache->wait_list_cnt == 0) list_add_last(&cache->link, &cache_list);
cache->wait_list_buf[cache->wait_list_cnt++] = current_client;
channel_lock(current_client.channel);
}
#ifndef NDEBUG
else if (current_client.client == NULL) {
trace(LOG_ALWAYS, "cache_wait(): illegal cache access at %s:%d", file, line);
}
#endif
cache_miss_cnt++;
exception(ERR_CACHE_MISS);
}
static void command_disassemble(char * token, Channel * c) {
int error = 0;
Context * ctx = NULL;
DisassembleCmdArgs * args = (DisassembleCmdArgs *)loc_alloc_zero(sizeof(DisassembleCmdArgs));
json_read_string(&c->inp, args->id, sizeof(args->id));
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
args->addr = (ContextAddress)json_read_uint64(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
args->size = (ContextAddress)json_read_uint64(&c->inp);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
json_read_struct(&c->inp, read_disassembly_params, args);
if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);
ctx = id2ctx(args->id);
if (ctx == NULL) error = ERR_INV_CONTEXT;
else if (ctx->exited) error = ERR_ALREADY_EXITED;
else if (context_get_group(ctx, CONTEXT_GROUP_PROCESS)->mem_access == 0) error = ERR_INV_CONTEXT;
if (error != 0) {
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
write_errno(&c->out, error);
write_stringz(&c->out, "null");
write_stream(&c->out, MARKER_EOM);
loc_free(args);
}
else {
channel_lock(args->c = c);
strlcpy(args->token, token, sizeof(args->token));
post_safe_event(ctx, safe_event_disassemble, args);
}
}
/**
* locking_reset - reset the channel
* @rchan: the channel
* @init: 1 if this is a first-time channel initialization
*/
void locking_reset(struct rchan *rchan, int init)
{
if (init)
channel_lock(rchan) = RAW_SPIN_LOCK_UNLOCKED;
write_buf(rchan) = rchan->buf;
write_buf_end(rchan) = write_buf(rchan) + rchan->buf_size;
cur_write_pos(rchan) = write_buf(rchan);
write_limit(rchan) = write_buf_end(rchan) - rchan->end_reserve;
in_progress_event_pos(rchan) = NULL;
in_progress_event_size(rchan) = 0;
interrupted_pos(rchan) = NULL;
interrupting_size(rchan) = 0;
}
static MemoryCommandArgs * read_command_args(char * token, Channel * c, int cmd) {
int err = 0;
char id[256];
MemoryCommandArgs buf;
memset(&buf, 0, sizeof(buf));
json_read_string(&c->inp, id, sizeof(id));
json_test_char(&c->inp, MARKER_EOA);
buf.addr = (ContextAddress)json_read_uint64(&c->inp);
json_test_char(&c->inp, MARKER_EOA);
buf.word_size = (int)json_read_long(&c->inp);
json_test_char(&c->inp, MARKER_EOA);
buf.size = (int)json_read_long(&c->inp);
json_test_char(&c->inp, MARKER_EOA);
buf.mode = (int)json_read_long(&c->inp);
json_test_char(&c->inp, MARKER_EOA);
if (cmd == CMD_GET) json_test_char(&c->inp, MARKER_EOM);
buf.ctx = id2ctx(id);
if (buf.ctx == NULL) err = ERR_INV_CONTEXT;
else if (buf.ctx->exited) err = ERR_ALREADY_EXITED;
else if (buf.ctx->mem_access == 0) err = ERR_INV_CONTEXT;
if (err != 0) {
if (cmd != CMD_GET) {
int ch;
do ch = read_stream(&c->inp);
while (ch != MARKER_EOM && ch != MARKER_EOS);
}
write_stringz(&c->out, "R");
write_stringz(&c->out, token);
if (cmd == CMD_GET) write_stringz(&c->out, "null");
write_errno(&c->out, err);
write_stringz(&c->out, "null");
write_stream(&c->out, MARKER_EOM);
return NULL;
}
else {
MemoryCommandArgs * args = (MemoryCommandArgs *)loc_alloc(sizeof(MemoryCommandArgs));
*args = buf;
args->c = c;
strlcpy(args->token, token, sizeof(args->token));
channel_lock(c);
context_lock(buf.ctx);
return args;
}
}
static void connect_dest(void * x) {
Channel * c1 = (Channel *)x;
PeerServer * ps;
ConnectInfo * info;
ps = channel_peer_from_url(dest_url);
if (ps == NULL) {
trace(LOG_ALWAYS, "cannot parse peer url: %s", dest_url);
channel_close(c1);
return;
}
channel_lock(c1);
c1->state = ChannelStateRedirectReceived;
info = (ConnectInfo *)loc_alloc_zero(sizeof(ConnectInfo));
info->ps = ps;
info->c1 = c1;
channel_connect(ps, connect_done, info);
}
