static void
parse_mcinfo_list(cfg_t *cfg, shash_t *ht)
{
mc_t *mc;
lisp_addr_t *laddr;
char *name;
int i, count;
count = 0;
for (i = 0; i < cfg_size(cfg, "multicast-info"); i++) {
cfg_t *mcnode = cfg_getnsec(cfg, "multicast-info", i);
name = cfg_getstr(mcnode, "mc-info-name");
laddr = lisp_addr_new_lafi(LM_AFI_LCAF);
lisp_addr_lcaf_set_type(laddr, LCAF_MCAST_INFO);
mc = mc_type_new();
lisp_addr_ip_from_char(cfg_getstr(mcnode, "source"), mc->src);
mc->src_plen = cfg_getint(mcnode, "source-mask-length");
lisp_addr_ip_from_char(cfg_getstr(mcnode, "group"), mc->grp);
mc->src_plen = cfg_getint(mcnode, "group-mask-length");
mc->iid = cfg_getint(mcnode, "iid");
lisp_addr_lcaf_set_addr(laddr, mc);
OOR_LOG(LDBG_1, "Configuration file: parsed multicast-info: %s",
lisp_addr_to_char(laddr));
shash_insert(ht, strdup(name), laddr);
count ++;
}
if (count != 0) {
OOR_LOG(LINF, "Parsed configured multicast addresses");
}
}
/* 发起远程调用, 消息类型type, 请求超时timeout_ms, 重试次数retry_times, 请求request, 请求长度size, 结果回调cb, 回调参数arg */
void sio_rpc_call(struct sio_rpc_client *client, uint32_t type, uint64_t timeout_ms, uint32_t retry_times,
const char *request, uint32_t size, sio_rpc_upstream_callback_t cb, void *arg)
{
struct sio_rpc_upstream *upstream = _sio_rpc_choose_upstream(client);
struct sio_rpc_request *req = malloc(sizeof(*req));
req->timeout = timeout_ms;
req->retry_times = retry_times;
req->retry_count = 0;
req->type = type;
req->body = malloc(size);
req->bodylen = size;
memcpy(req->body, request, size);
req->cb = cb;
req->arg = arg;
req->client = client;
req->upstream = upstream;
sio_start_timer(client->rpc->sio, &req->timer, timeout_ms, _sio_rpc_call_timer, req);
assert(shash_insert(client->req_record, (const char *)&req, sizeof(req), NULL) == 0);
if (!req->upstream)
return; /* 无可用连接, 等待请求超时 */
if (_sio_rpc_call(upstream, req) == -1)
req->upstream = NULL; /* call失败, 等待请求超时 */
}
static int _sio_rpc_call(struct sio_rpc_upstream *upstream, struct sio_rpc_request *req)
{
struct sio *sio = upstream->client->rpc->sio;
struct sio_stream *stream = upstream->stream;
req->id = upstream->req_id++;
struct shead shead;
shead.id = req->id;
shead.type = req->type;
shead.reserved = 0;
shead.body_len = req->bodylen;
char head[SHEAD_ENCODE_SIZE];
assert(shead_encode(&shead, head, sizeof(head)) == 0);
int sent_head = sio_stream_write(sio, stream, head, sizeof(head));
int sent_body = sio_stream_write(sio, stream, req->body, req->bodylen);
if (sent_head == 0 && sent_body == 0) { /* call成功发出, 记录状态, 等待应答或者超时 */
assert(shash_insert(upstream->req_status, (const char *)&req->id, sizeof(req->id), req) == 0);
return 0;
}
/* call发送失败, 重置upstream, 等待超时 */
_sio_rpc_reset_upstream(upstream);
return -1;
}
void sio_rpc_server_add_method(struct sio_rpc_server *server, uint32_t type, sio_rpc_dstream_callback_t cb, void *arg)
{
if (shash_find(server->methods, (const char *)&type, sizeof(type), NULL) == 0)
return;
struct sio_rpc_method *method = malloc(sizeof(*method));
method->cb = cb;
method->arg = arg;
assert(shash_insert(server->methods, (const char *)&type, sizeof(type), method) == 0);
}
static void _sio_rpc_dstream_accept(struct sio_rpc_server *server, struct sio *sio, struct sio_stream *stream)
{
struct sio_rpc_dstream *dstream = malloc(sizeof(*dstream));
dstream->id = server->conn_id++;
dstream->server = server;
dstream->stream = stream;
assert(shash_insert(server->dstreams, (const char *)&dstream->id, sizeof(dstream->id), dstream) == 0);
sio_stream_set(sio, stream, _sio_rpc_dstream_callback, dstream);
sio_start_timer(sio, &dstream->timer, 1000, _sio_rpc_dstream_timer, dstream);
}
/* Create a sync structure */
int syscall_sync_create(void *ptr, int type)
{
struct sync *sn;
process_t p = current->proc;
sn = kmem_cache_alloc(sync_cache, 0);
if(!sn)
return -ENOMEM;
sn->sync_type = type;
sn->owner = p->pid;
sn->sync_id = p->sync.id++;
list_init(&sn->wq);
sn->next = NULL;
shash_insert(sn);
list_add(&p->sync.syncs, sn, syncs, struct sync *);
return sn->sync_id;
}
static void
parse_elp_list(cfg_t *cfg, shash_t *ht)
{
elp_node_t *enode;
elp_t *elp;
lisp_addr_t *laddr;
char *name;
int i, j;
for(i = 0; i < cfg_size(cfg, "explicit-locator-path"); i++) {
cfg_t *selp = cfg_getnsec(cfg, "explicit-locator-path", i);
name = cfg_getstr(selp, "elp-name");
elp = elp_type_new();
for (j = 0; j < cfg_size(selp, "elp-node");j++) {
cfg_t *senode = cfg_getnsec(selp, "elp-node", j);
enode = xzalloc(sizeof(elp_node_t));
enode->addr = lisp_addr_new();
if (lisp_addr_ip_from_char(cfg_getstr(senode, "address"),
enode->addr) != GOOD) {
elp_node_del(enode);
OOR_LOG(LDBG_1, "parse_elp_list: Couldn't parse ELP node %s",
cfg_getstr(senode, "address"));
continue;
}
enode->L = cfg_getbool(senode, "lookup") ? 1 : 0;
enode->P = cfg_getbool(senode, "probe") ? 1 : 0;
enode->S = cfg_getbool(senode, "strict") ? 1: 0;
glist_add_tail(enode, elp->nodes);
}
laddr = lisp_addr_new_lafi(LM_AFI_LCAF);
lisp_addr_lcaf_set_type(laddr, LCAF_EXPL_LOC_PATH);
lisp_addr_lcaf_set_addr(laddr, elp);
OOR_LOG(LDBG_1, "Configuration file: parsed explicit-locator-path: %s",
lisp_addr_to_char(laddr));
shash_insert(ht, strdup(name), laddr);
}
}
static void
parse_rle_list(cfg_t *cfg, shash_t *ht)
{
rle_node_t *rnode;
rle_t *rle;
lisp_addr_t *laddr;
char *name;
int i, j;
for (i = 0; i < cfg_size(cfg, "replication-list"); i++) {
cfg_t *selp = cfg_getnsec(cfg, "replication-list", i);
name = cfg_getstr(selp, "rle-name");
laddr = lisp_addr_new_lafi(LM_AFI_LCAF);
lisp_addr_lcaf_set_type(laddr, LCAF_RLE);
rle = rle_type_new();
for (j = 0; j < cfg_size(selp, "rle-node"); j++) {
cfg_t *rlenode = cfg_getnsec(selp, "rle-node", j);
rnode = rle_node_new();
if (lisp_addr_ip_from_char(cfg_getstr(rlenode, "address"),
rnode->addr) != GOOD) {
rle_node_del(rnode);
OOR_LOG(LDBG_1, "parse_rle_list: Couldn't parse RLE node %s",
cfg_getstr(rlenode, "address"));
}
rnode->level = cfg_getint(rlenode, "level");
glist_add_tail(rnode, rle->nodes);
}
lisp_addr_lcaf_set_addr(laddr, (void *)rle);
OOR_LOG(LDBG_1, "Configuration file: parsed replication-list: %s",
lisp_addr_to_char(laddr));
shash_insert(ht, strdup(name), laddr);
}
}
