version 1.26.2.9, 2015/06/29 22:39:33
|
version 1.27.2.6, 2015/07/22 15:07:10
|
Line 82 static sched_task_func_t cbProto[SOCK_MAX_SUPPORT][4]
|
Line 82 static sched_task_func_t cbProto[SOCK_MAX_SUPPORT][4]
|
|
|
static volatile uintptr_t _glSigArg = 0; |
static volatile uintptr_t _glSigArg = 0; |
|
|
|
|
void |
void |
rpc_freeCli(rpc_cli_t * __restrict c) |
rpc_freeCli(rpc_cli_t * __restrict c) |
{ |
{ |
Line 197 txPacket(sched_task_t *task)
|
Line 196 txPacket(sched_task_t *task)
|
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) { |
} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) { |
rpc_SetErr(EMSGSIZE, "Message too long"); |
rpc_SetErr(EMSGSIZE, "Message too long"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else { |
} else { |
rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c)); |
rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c)); |
/* Go Encapsulate variables */ |
/* Go Encapsulate variables */ |
Line 214 txPacket(sched_task_t *task)
|
Line 213 txPacket(sched_task_t *task)
|
rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); |
rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else |
} else |
wlen += ret; |
wlen += ret; |
} |
} |
Line 263 execCall(sched_task_t *task)
|
Line 262 execCall(sched_task_t *task)
|
rpc_SetErr(ERPCMISMATCH, "#%d - %s", elwix_GetErrno(), elwix_GetError()); |
rpc_SetErr(ERPCMISMATCH, "#%d - %s", elwix_GetErrno(), elwix_GetError()); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
taskExit(task, NULL); |
taskExit(task, NULL); |
} |
} |
} else |
} else |
Line 274 execCall(sched_task_t *task)
|
Line 273 execCall(sched_task_t *task)
|
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else { |
} else { |
/* if client doesn't want reply */ |
/* if client doesn't want reply */ |
rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(c, rpc, f->func_name, arr)); | RPC_SET_RETURN(rpc, rpc_srv_execCall(c, rpc, f->func_name, arr)); |
if (rpc->call_rep.ret == htonl(-1)) { |
if (rpc->call_rep.ret == htonl(-1)) { |
if (!rpc->call_rep.eno) { |
if (!rpc->call_rep.eno) { |
LOGERR; |
LOGERR; |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} |
} |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
ait_freeVars(&c->cli_vars); |
ait_freeVars(&c->cli_vars); |
Line 313 rxPacket(sched_task_t *task)
|
Line 312 rxPacket(sched_task_t *task)
|
u_short crc; |
u_short crc; |
#endif |
#endif |
u_char *buf = AIT_GET_BUF(&c->cli_buf); |
u_char *buf = AIT_GET_BUF(&c->cli_buf); |
|
u_char b[sizeof(struct tagRPCCall)]; |
struct tagRPCCall *rpc = (struct tagRPCCall*) buf; |
struct tagRPCCall *rpc = (struct tagRPCCall*) buf; |
#ifdef TCP_SESSION_TIMEOUT |
#ifdef TCP_SESSION_TIMEOUT |
struct timespec ts = { DEF_RPC_TIMEOUT, 0 }; |
struct timespec ts = { DEF_RPC_TIMEOUT, 0 }; |
Line 322 rxPacket(sched_task_t *task)
|
Line 322 rxPacket(sched_task_t *task)
|
TASK_ARG(task), ts, TASK_ARG(task), 0); |
TASK_ARG(task), ts, TASK_ARG(task), 0); |
#endif |
#endif |
|
|
|
/* prepare rx */ |
|
len = recv(TASK_FD(task), b, sizeof b, MSG_PEEK); |
|
if (len == sizeof b) |
|
rlen = ntohl(((struct tagRPCCall*) b)->call_len); |
|
|
rlen = recv(TASK_FD(task), buf, rlen, 0); |
rlen = recv(TASK_FD(task), buf, rlen, 0); |
if (rlen == -1) { |
if (rlen == -1) { |
/* close connection */ |
/* close connection */ |
Line 333 rxPacket(sched_task_t *task)
|
Line 338 rxPacket(sched_task_t *task)
|
rpc_SetErr(ERPCMISMATCH, "Short RPC packet"); |
rpc_SetErr(ERPCMISMATCH, "Short RPC packet"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
goto err; |
goto err; |
} else |
} else |
len = ntohl(rpc->call_len); |
len = ntohl(rpc->call_len); |
Line 342 rxPacket(sched_task_t *task)
|
Line 347 rxPacket(sched_task_t *task)
|
rpc_SetErr(ERPCMISMATCH, "Short RPC packet"); |
rpc_SetErr(ERPCMISMATCH, "Short RPC packet"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
goto err; |
goto err; |
} |
} |
|
|
Line 361 rxPacket(sched_task_t *task)
|
Line 366 rxPacket(sched_task_t *task)
|
rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet"); |
rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
goto err; |
goto err; |
} |
} |
#endif |
#endif |
Line 372 rxPacket(sched_task_t *task)
|
Line 377 rxPacket(sched_task_t *task)
|
rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session"); |
rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
goto err; |
goto err; |
} |
} |
|
|
Line 458 txUDPPacket(sched_task_t *task)
|
Line 463 txUDPPacket(sched_task_t *task)
|
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) { |
} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) { |
rpc_SetErr(EMSGSIZE, "Message too long"); |
rpc_SetErr(EMSGSIZE, "Message too long"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else { |
} else { |
rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c)); |
rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c)); |
/* Go Encapsulate variables */ |
/* Go Encapsulate variables */ |
Line 475 txUDPPacket(sched_task_t *task)
|
Line 480 txUDPPacket(sched_task_t *task)
|
rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); |
rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else |
} else |
wlen += ret; |
wlen += ret; |
} |
} |
Line 519 rxUDPPacket(sched_task_t *task)
|
Line 524 rxUDPPacket(sched_task_t *task)
|
|
|
/* receive connect packet */ |
/* receive connect packet */ |
AIT_SET_BUF(&b, NULL, srv->srv_netbuf); |
AIT_SET_BUF(&b, NULL, srv->srv_netbuf); |
salen = sa.ss.ss_len = sizeof(sockaddr_t); | salen = sa.ss.ss_len = (u_char) MIN(sizeof(sockaddr_t), 0xff); |
rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen); |
rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen); |
rpc = (struct tagRPCCall*) AIT_GET_BUF(&b); |
rpc = (struct tagRPCCall*) AIT_GET_BUF(&b); |
if (rlen < sizeof(struct tagRPCCall)) |
if (rlen < sizeof(struct tagRPCCall)) |
Line 598 txRAWPacket(sched_task_t *task)
|
Line 603 txRAWPacket(sched_task_t *task)
|
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) { |
} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) { |
rpc_SetErr(EMSGSIZE, "Message too long"); |
rpc_SetErr(EMSGSIZE, "Message too long"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else { |
} else { |
rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c)); |
rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c)); |
/* Go Encapsulate variables */ |
/* Go Encapsulate variables */ |
Line 613 txRAWPacket(sched_task_t *task)
|
Line 618 txRAWPacket(sched_task_t *task)
|
RPC_RETVARS(c)); |
RPC_RETVARS(c)); |
if (ret == -1) { |
if (ret == -1) { |
rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); |
rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else |
} else |
wlen += ret; |
wlen += ret; |
} |
} |
Line 658 rxRAWPacket(sched_task_t *task)
|
Line 664 rxRAWPacket(sched_task_t *task)
|
|
|
/* receive connect packet */ |
/* receive connect packet */ |
AIT_SET_BUF(&b, NULL, srv->srv_netbuf); |
AIT_SET_BUF(&b, NULL, srv->srv_netbuf); |
salen = sa.ss.ss_len = sizeof(sockaddr_t); | salen = sa.ss.ss_len = (u_char) MIN(sizeof(sockaddr_t), 0xff); |
rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen); |
rlen = recvfrom(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b), 0, &sa.sa, &salen); |
if (sa.sa.sa_family == AF_INET) { |
if (sa.sa.sa_family == AF_INET) { |
struct ip *h; |
struct ip *h; |
Line 758 txBPFPacket(sched_task_t *task)
|
Line 764 txBPFPacket(sched_task_t *task)
|
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) { |
} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) { |
rpc_SetErr(EMSGSIZE, "Message too long"); |
rpc_SetErr(EMSGSIZE, "Message too long"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else { |
} else { |
rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c)); |
rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c)); |
/* Go Encapsulate variables */ |
/* Go Encapsulate variables */ |
Line 775 txBPFPacket(sched_task_t *task)
|
Line 781 txBPFPacket(sched_task_t *task)
|
rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); |
rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else |
} else |
wlen += ret; |
wlen += ret; |
} |
} |
Line 921 txEXTPacket(sched_task_t *task)
|
Line 927 txEXTPacket(sched_task_t *task)
|
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) { |
} else if (rpc_pktFreeSpace(c) > s->srv_netbuf) { |
rpc_SetErr(EMSGSIZE, "Message too long"); |
rpc_SetErr(EMSGSIZE, "Message too long"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else { |
} else { |
rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c)); |
rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c)); |
/* Go Encapsulate variables */ |
/* Go Encapsulate variables */ |
Line 938 txEXTPacket(sched_task_t *task)
|
Line 944 txEXTPacket(sched_task_t *task)
|
rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); |
rpc_SetErr(EBADRPC, "Prepare RPC packet failed"); |
|
|
rpc->call_argc ^= rpc->call_argc; |
rpc->call_argc ^= rpc->call_argc; |
rpc->call_rep.ret = RPC_ERROR(-1); | RPC_SET_RETURN(rpc, -1); |
rpc->call_rep.eno = RPC_ERROR(rpc_Errno); | RPC_SET_ERRNO(rpc, rpc_Errno); |
} else |
} else |
wlen += ret; |
wlen += ret; |
} |
} |
Line 1111 rxBLOB(sched_task_t *task)
|
Line 1117 rxBLOB(sched_task_t *task)
|
if (!(b = rpc_srv_getBLOB(s, ntohl(blob.hdr_var)))) { |
if (!(b = rpc_srv_getBLOB(s, ntohl(blob.hdr_var)))) { |
rpc_SetErr(EINVAL, "Var=%x not found", ntohl(blob.hdr_var)); |
rpc_SetErr(EINVAL, "Var=%x not found", ntohl(blob.hdr_var)); |
blob.hdr_cmd = no; |
blob.hdr_cmd = no; |
blob.hdr_ret = RPC_ERROR(-1); | RPC_SET_BLOB_RET(&blob, -1); |
break; |
break; |
} else |
} else |
blob.hdr_len = htonl(b->blob_len); |
blob.hdr_len = htonl(b->blob_len); |
Line 1122 rxBLOB(sched_task_t *task)
|
Line 1128 rxBLOB(sched_task_t *task)
|
rpc_srv_blobUnmap(b); |
rpc_srv_blobUnmap(b); |
} else { |
} else { |
blob.hdr_cmd = error; |
blob.hdr_cmd = error; |
blob.hdr_ret = RPC_ERROR(-1); | RPC_SET_BLOB_RET(&blob, -1); |
} |
} |
break; |
break; |
case set: |
case set: |
Line 1136 rxBLOB(sched_task_t *task)
|
Line 1142 rxBLOB(sched_task_t *task)
|
rpc_srv_blobUnmap(b); |
rpc_srv_blobUnmap(b); |
} else { |
} else { |
blob.hdr_cmd = error; |
blob.hdr_cmd = error; |
blob.hdr_ret = RPC_ERROR(-1); | RPC_SET_BLOB_RET(&blob, -1); |
} |
} |
break; |
break; |
case unset: |
case unset: |
if (rpc_srv_unregisterBLOB(s, ntohl(blob.hdr_var)) == -1) { |
if (rpc_srv_unregisterBLOB(s, ntohl(blob.hdr_var)) == -1) { |
blob.hdr_cmd = error; |
blob.hdr_cmd = error; |
blob.hdr_ret = RPC_ERROR(-1); | RPC_SET_BLOB_RET(&blob, -1); |
} |
} |
break; |
break; |
default: |
default: |
rpc_SetErr(EPROCUNAVAIL, "Unsupported BLOB command %d", blob.hdr_cmd); |
rpc_SetErr(EPROCUNAVAIL, "Unsupported BLOB command %d", blob.hdr_cmd); |
blob.hdr_cmd = error; |
blob.hdr_cmd = error; |
blob.hdr_ret = RPC_ERROR(-1); | RPC_SET_BLOB_RET(&blob, -1); |
} |
} |
|
|
end: |
end: |
Line 1161 end:
|
Line 1167 end:
|
static void * |
static void * |
flushBLOB(sched_task_t *task) |
flushBLOB(sched_task_t *task) |
{ |
{ |
|
#ifdef atomic_load_acq_ptr |
uintptr_t sigArg = atomic_load_acq_ptr(&_glSigArg); |
uintptr_t sigArg = atomic_load_acq_ptr(&_glSigArg); |
|
#else |
|
uintptr_t sigArg = *((volatile uintptr_t*) &_glSigArg); |
|
#endif |
rpc_srv_t *srv = sigArg ? (void*) sigArg : TASK_ARG(task); |
rpc_srv_t *srv = sigArg ? (void*) sigArg : TASK_ARG(task); |
rpc_blob_t *b, *tmp; |
rpc_blob_t *b, *tmp; |
|
|
Line 1369 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
Line 1379 rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
|
|
|
srv->srv_blob.kill = 1; |
srv->srv_blob.kill = 1; |
|
|
schedEnd(&srv->srv_blob.root); |
|
|
|
if (srv->srv_blob.server.cli_sa.sa.sa_family == AF_LOCAL) |
if (srv->srv_blob.server.cli_sa.sa.sa_family == AF_LOCAL) |
unlink(srv->srv_blob.server.cli_sa.sun.sun_path); |
unlink(srv->srv_blob.server.cli_sa.sun.sun_path); |
|
|
|
schedEnd(&srv->srv_blob.root); |
} |
} |
|
|
/* |
/* |
Line 1403 rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
|
Line 1413 rpc_srv_loopBLOBServer(rpc_srv_t * __restrict srv)
|
/* disabled kqueue support in libaitsched */ |
/* disabled kqueue support in libaitsched */ |
struct sigaction sa; |
struct sigaction sa; |
|
|
|
#ifdef atomic_store_rel_ptr |
atomic_store_rel_ptr(&_glSigArg, (uintptr_t) srv); |
atomic_store_rel_ptr(&_glSigArg, (uintptr_t) srv); |
|
#else |
|
*((volatile uintptr_t*) &_glSigArg) = (uintptr_t) srv; |
|
#endif |
|
|
memset(&sa, 0, sizeof sa); |
memset(&sa, 0, sizeof sa); |
sigemptyset(&sa.sa_mask); |
sigemptyset(&sa.sa_mask); |
Line 1592 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
Line 1606 rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
|
|
|
/* if send kill to blob server */ |
/* if send kill to blob server */ |
rpc_srv_endBLOBServer(*psrv); |
rpc_srv_endBLOBServer(*psrv); |
|
/* wait for BLOB server done */ |
|
while (*(&(*psrv)->srv_blob.root)) |
|
usleep(1000); |
|
|
(*psrv)->srv_kill = 1; |
(*psrv)->srv_kill = 1; |
sleep(RPC_SCHED_POLLING); |
sleep(RPC_SCHED_POLLING); |
|
|
schedEnd(&(*psrv)->srv_root); |
|
|
|
if ((*psrv)->srv_server.cli_sa.sa.sa_family == AF_LOCAL) |
if ((*psrv)->srv_server.cli_sa.sa.sa_family == AF_LOCAL) |
unlink((*psrv)->srv_server.cli_sa.sun.sun_path); |
unlink((*psrv)->srv_server.cli_sa.sun.sun_path); |
|
|
|
schedEnd(&(*psrv)->srv_root); |
|
|
pthread_mutex_destroy(&(*psrv)->srv_funcs.mtx); |
pthread_mutex_destroy(&(*psrv)->srv_funcs.mtx); |
e_free(*psrv); |
e_free(*psrv); |