Lines Matching defs:spc
138 LIST_ENTRY(prefork) pf_spcentries; /* linked from forking spc */
148 waitresp(struct spclient *spc, struct respwait *rw)
153 pthread_mutex_lock(&spc->spc_mtx);
154 sendunlockl(spc);
155 while (!rw->rw_done && spc->spc_state != SPCSTATE_DYING) {
156 pthread_cond_wait(&rw->rw_cv, &spc->spc_mtx);
158 TAILQ_REMOVE(&spc->spc_respwait, rw, rw_entries);
159 spcstate = spc->spc_state;
160 pthread_mutex_unlock(&spc->spc_mtx);
195 lwproc_rfork(struct spclient *spc, int flags, const char *comm)
200 rv = rumpuser__hyp.hyp_lwproc_rfork(spc, flags, comm);
276 nextreq(struct spclient *spc)
280 pthread_mutex_lock(&spc->spc_mtx);
281 nw = spc->spc_nextreq++;
282 pthread_mutex_unlock(&spc->spc_mtx);
293 send_error_resp(struct spclient *spc, uint64_t reqno, enum rumpsp_err error)
306 sendlock(spc);
307 (void)SENDIOV(spc, iov);
308 sendunlock(spc);
312 send_handshake_resp(struct spclient *spc, uint64_t reqno, int error)
327 sendlock(spc);
328 rv = SENDIOV(spc, iov);
329 sendunlock(spc);
335 send_syscall_resp(struct spclient *spc, uint64_t reqno, int error,
355 sendlock(spc);
356 rv = SENDIOV(spc, iov);
357 sendunlock(spc);
363 send_prefork_resp(struct spclient *spc, uint64_t reqno, uint32_t *auth)
378 sendlock(spc);
379 rv = SENDIOV(spc, iov);
380 sendunlock(spc);
386 copyin_req(struct spclient *spc, const void *remaddr, size_t *dlen,
411 putwait(spc, &rw, &rhdr);
412 rv = SENDIOV(spc, iov);
414 unputwait(spc, &rw);
418 rv = waitresp(spc, &rw);
431 send_copyout_req(struct spclient *spc, const void *remaddr,
442 rhdr.rsp_reqno = nextreq(spc);
454 sendlock(spc);
455 rv = SENDIOV(spc, iov);
456 sendunlock(spc);
462 anonmmap_req(struct spclient *spc, size_t howmuch, void **resp)
479 putwait(spc, &rw, &rhdr);
480 rv = SENDIOV(spc, iov);
482 unputwait(spc, &rw);
486 rv = waitresp(spc, &rw);
496 send_raise_req(struct spclient *spc, int signo)
509 sendlock(spc);
510 rv = SENDIOV(spc, iov);
511 sendunlock(spc);
517 spcref(struct spclient *spc)
520 pthread_mutex_lock(&spc->spc_mtx);
521 spc->spc_refcnt++;
522 pthread_mutex_unlock(&spc->spc_mtx);
526 spcrelease(struct spclient *spc)
530 pthread_mutex_lock(&spc->spc_mtx);
531 ref = --spc->spc_refcnt;
532 if (__predict_false(spc->spc_inexec && ref <= 2))
533 pthread_cond_broadcast(&spc->spc_cv);
534 pthread_mutex_unlock(&spc->spc_mtx);
539 DPRINTF(("rump_sp: spcrelease: spc %p fd %d\n", spc, spc->spc_fd));
541 _DIAGASSERT(TAILQ_EMPTY(&spc->spc_respwait));
542 _DIAGASSERT(spc->spc_buf == NULL);
544 if (spc->spc_mainlwp) {
545 lwproc_switch(spc->spc_mainlwp);
548 spc->spc_mainlwp = NULL;
550 close(spc->spc_fd);
551 spc->spc_fd = -1;
552 spc->spc_state = SPCSTATE_NEW;
560 struct spclient *spc = &spclist[idx];
567 pthread_mutex_lock(&spc->spc_mtx);
568 spc->spc_state = SPCSTATE_DYING;
569 kickall(spc);
570 sendunlockl(spc);
572 dolwpexit = !spc->spc_inexec;
573 pthread_mutex_unlock(&spc->spc_mtx);
575 if (dolwpexit && spc->spc_mainlwp) {
576 lwproc_switch(spc->spc_mainlwp);
586 memset((char *)spc + SPC_ZEROFF, 0, sizeof(*spc) - SPC_ZEROFF);
588 spcrelease(spc);
594 struct spclient *spc;
598 spc = &spclist[i];
599 if (spc->spc_fd == -1)
602 shutdown(spc->spc_fd, SHUT_RDWR);
605 spcrelease(spc);
675 serv_handlesyscall(struct spclient *spc, struct rsp_hdr *rhdr, uint8_t *data)
682 sysnum, spc->spc_pid));
684 if (__predict_false((rv = lwproc_newlwp(spc->spc_pid)) != 0)) {
686 send_syscall_resp(spc, rhdr->rsp_reqno, rv, retval);
689 spc->spc_syscallreq = rhdr->rsp_reqno;
691 spc->spc_syscallreq = 0;
698 send_syscall_resp(spc, rhdr->rsp_reqno, rv, retval);
702 serv_handleexec(struct spclient *spc, struct rsp_hdr *rhdr, const char *comm)
704 pthread_mutex_lock(&spc->spc_mtx);
706 while (spc->spc_refcnt > 2)
707 pthread_cond_wait(&spc->spc_cv, &spc->spc_mtx);
708 pthread_mutex_unlock(&spc->spc_mtx);
716 lwproc_switch(spc->spc_mainlwp);
720 pthread_mutex_lock(&spc->spc_mtx);
721 spc->spc_inexec = 0;
722 pthread_mutex_unlock(&spc->spc_mtx);
723 send_handshake_resp(spc, rhdr->rsp_reqno, 0);
785 struct spclient *spc = arg;
791 rv = copyin_req(spc, raddr, len, wantstr, &rdata);
826 struct spclient *spc = arg;
830 rv = send_copyout_req(spc, raddr, laddr, dlen);
859 struct spclient *spc = arg;
865 rv = anonmmap_req(spc, howmuch, &rdata);
888 struct spclient *spc = arg;
892 rv = send_raise_req(spc, signo);
900 schedulework(struct spclient *spc, enum sbatype sba_type)
907 reqno = spc->spc_hdr.rsp_reqno;
910 send_error_resp(spc, reqno, RUMPSP_ERR_TRYAGAIN);
911 spcfreebuf(spc);
918 sba->sba_spc = spc;
920 sba->sba_hdr = spc->spc_hdr;
921 sba->sba_data = spc->spc_buf;
922 spcresetbuf(spc);
924 spcref(spc);
958 handlereq(struct spclient *spc)
963 reqno = spc->spc_hdr.rsp_reqno;
964 if (__predict_false(spc->spc_state == SPCSTATE_NEW)) {
965 if (spc->spc_hdr.rsp_type != RUMPSP_HANDSHAKE) {
966 send_error_resp(spc, reqno, RUMPSP_ERR_AUTH);
967 shutdown(spc->spc_fd, SHUT_RDWR);
968 spcfreebuf(spc);
972 if (spc->spc_hdr.rsp_handshake == HANDSHAKE_GUEST) {
976 if ((error = lwproc_rfork(spc, RUMP_RFFD_CLEAR,
977 (const char *)spc->spc_buf)) != 0) {
978 shutdown(spc->spc_fd, SHUT_RDWR);
981 spcfreebuf(spc);
985 spc->spc_mainlwp = lwproc_curlwp();
987 send_handshake_resp(spc, reqno, 0);
988 } else if (spc->spc_hdr.rsp_handshake == HANDSHAKE_FORK) {
994 if (spc->spc_off-HDRSZ != sizeof(*rfp)) {
995 send_error_resp(spc, reqno,
997 shutdown(spc->spc_fd, SHUT_RDWR);
998 spcfreebuf(spc);
1003 rfp = (void *)spc->spc_buf;
1016 spcfreebuf(spc);
1019 send_error_resp(spc, reqno,
1021 shutdown(spc->spc_fd, SHUT_RDWR);
1030 shutdown(spc->spc_fd, SHUT_RDWR);
1039 * the wrong spc pointer. (yea, optimize
1042 if ((error = lwproc_rfork(spc,
1044 send_error_resp(spc, reqno,
1046 shutdown(spc->spc_fd, SHUT_RDWR);
1050 spc->spc_mainlwp = lwproc_curlwp();
1053 lwproc_switch(spc->spc_mainlwp);
1055 send_handshake_resp(spc, reqno, 0);
1057 send_error_resp(spc, reqno, RUMPSP_ERR_AUTH);
1058 shutdown(spc->spc_fd, SHUT_RDWR);
1059 spcfreebuf(spc);
1063 spc->spc_pid = lwproc_getpid();
1066 spc, spc->spc_pid));
1069 spc->spc_state = SPCSTATE_RUNNING;
1073 if (__predict_false(spc->spc_hdr.rsp_type == RUMPSP_PREFORK)) {
1079 DPRINTF(("rump_sp: prefork handler executing for %p\n", spc));
1080 spcfreebuf(spc);
1082 pthread_mutex_lock(&spc->spc_mtx);
1083 inexec = spc->spc_inexec;
1084 pthread_mutex_unlock(&spc->spc_mtx);
1086 send_error_resp(spc, reqno, RUMPSP_ERR_INEXEC);
1087 shutdown(spc->spc_fd, SHUT_RDWR);
1093 send_error_resp(spc, reqno, RUMPSP_ERR_NOMEM);
1102 lwproc_switch(spc->spc_mainlwp);
1103 if ((error = lwproc_rfork(spc, RUMP_RFFD_COPY, NULL)) != 0) {
1104 DPRINTF(("rump_sp: fork failed: %d (%p)\n",error, spc));
1105 send_error_resp(spc, reqno, RUMPSP_ERR_RFORK_FAILED);
1119 LIST_INSERT_HEAD(&spc->spc_pflist, pf, pf_spcentries);
1122 DPRINTF(("rump_sp: prefork handler success %p\n", spc));
1124 send_prefork_resp(spc, reqno, auth);
1128 if (__predict_false(spc->spc_hdr.rsp_type == RUMPSP_HANDSHAKE)) {
1131 if (spc->spc_hdr.rsp_handshake != HANDSHAKE_EXEC) {
1132 send_error_resp(spc, reqno,
1134 shutdown(spc->spc_fd, SHUT_RDWR);
1135 spcfreebuf(spc);
1139 pthread_mutex_lock(&spc->spc_mtx);
1140 inexec = spc->spc_inexec;
1141 pthread_mutex_unlock(&spc->spc_mtx);
1143 send_error_resp(spc, reqno, RUMPSP_ERR_INEXEC);
1144 shutdown(spc->spc_fd, SHUT_RDWR);
1145 spcfreebuf(spc);
1149 pthread_mutex_lock(&spc->spc_mtx);
1150 spc->spc_inexec = 1;
1151 pthread_mutex_unlock(&spc->spc_mtx);
1157 lwproc_switch(spc->spc_mainlwp);
1165 schedulework(spc, SBA_EXEC);
1169 if (__predict_false(spc->spc_hdr.rsp_type != RUMPSP_SYSCALL)) {
1170 send_error_resp(spc, reqno, RUMPSP_ERR_MALFORMED_REQUEST);
1171 spcfreebuf(spc);
1175 schedulework(spc, SBA_SYSCALL);
1182 struct spclient *spc;
1192 spc = &spclist[idx];
1193 pthread_mutex_init(&spc->spc_mtx, NULL);
1194 pthread_cond_init(&spc->spc_cv, NULL);
1195 spc->spc_fd = -1;
1253 spc = &spclist[idx];
1255 switch (readframe(spc)) {
1262 switch (spc->spc_hdr.rsp_class) {
1264 kickwaiter(spc);
1267 handlereq(spc);
1270 send_error_resp(spc,
1271 spc->spc_hdr.rsp_reqno,
1273 spcfreebuf(spc);
1375 struct spclient *spc = arg;
1386 if (spc && spc->spc_syscallreq)
1387 send_syscall_resp(spc, spc->spc_syscallreq, 0, retval);
Indexes created Tue Sep 30 20:09:53 GMT 2025