Home | History | Annotate | Line # | Download | only in librumpuser
      1 /*      $NetBSD: rumpuser_sp.c,v 1.77 2020/05/06 12:44:36 christos Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2010, 2011 Antti Kantee.  All Rights Reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
     16  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     18  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
     21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     25  * SUCH DAMAGE.
     26  */
     27 
     28 /*
     29  * Sysproxy routines.  This provides system RPC support over host sockets.
     30  * The most notable limitation is that the client and server must share
     31  * the same ABI.  This does not mean that they have to be the same
     32  * machine or that they need to run the same version of the host OS,
     33  * just that they must agree on the data structures.  This even *might*
     34  * work correctly from one hardware architecture to another.
     35  */
     36 
     37 #include "rumpuser_port.h"
     38 
     39 #if !defined(lint)
     40 __RCSID("$NetBSD: rumpuser_sp.c,v 1.77 2020/05/06 12:44:36 christos Exp $");
     41 #endif /* !lint */
     42 
     43 #include <sys/types.h>
     44 #include <sys/mman.h>
     45 #include <sys/socket.h>
     46 
     47 #include <arpa/inet.h>
     48 #include <netinet/in.h>
     49 #include <netinet/tcp.h>
     50 
     51 #include <assert.h>
     52 #include <errno.h>
     53 #include <fcntl.h>
     54 #include <poll.h>
     55 #include <pthread.h>
     56 #include <stdarg.h>
     57 #include <stdio.h>
     58 #include <stdlib.h>
     59 #include <string.h>
     60 #include <unistd.h>
     61 
     62 #include <rump/rump.h> /* XXX: for rfork flags */
     63 #include <rump/rumpuser.h>
     64 
     65 #include "rumpuser_int.h"
     66 
     67 #include "sp_common.c"
     68 
     69 #ifndef MAXCLI
     70 #define MAXCLI 256
     71 #endif
     72 #ifndef MAXWORKER
     73 #define MAXWORKER 128
     74 #endif
     75 #ifndef IDLEWORKER
     76 #define IDLEWORKER 16
     77 #endif
     78 int rumpsp_maxworker = MAXWORKER;
     79 int rumpsp_idleworker = IDLEWORKER;
     80 
     81 static struct pollfd pfdlist[MAXCLI];
     82 static struct spclient spclist[MAXCLI];
     83 static unsigned int disco;
     84 static volatile int spfini;
     85 
     86 static char banner[MAXBANNER];
     87 
     88 #define PROTOMAJOR 0
     89 #define PROTOMINOR 4
     90 
     91 
     92 /* either no atomic ops, or we haven't figured out how to use them */
     93 #if defined(__linux__) || defined(__APPLE__) || defined(__CYGWIN__) || defined(__OpenBSD__) || defined(__GNU__) || defined(__GLIBC__)
     94 static pthread_mutex_t discomtx = PTHREAD_MUTEX_INITIALIZER;
     95 
     96 static void
     97 signaldisco(void)
     98 {
     99 
    100 	pthread_mutex_lock(&discomtx);
    101 	disco++;
    102 	pthread_mutex_unlock(&discomtx);
    103 }
    104 
    105 static unsigned int
    106 getdisco(void)
    107 {
    108 	unsigned int discocnt;
    109 
    110 	pthread_mutex_lock(&discomtx);
    111 	discocnt = disco;
    112 	disco = 0;
    113 	pthread_mutex_unlock(&discomtx);
    114 
    115 	return discocnt;
    116 }
    117 
    118 #elif defined(__FreeBSD__) || defined(__DragonFly__)
    119 
    120 #include <machine/atomic.h>
    121 #define signaldisco()	atomic_add_int(&disco, 1)
    122 #define getdisco()	atomic_readandclear_int(&disco)
    123 
    124 #else /* NetBSD */
    125 
    126 #include <sys/atomic.h>
    127 #define signaldisco() atomic_inc_uint(&disco)
    128 #define getdisco() atomic_swap_uint(&disco, 0)
    129 
    130 #endif
    131 
    132 
    133 struct prefork {
    134 	uint32_t pf_auth[AUTHLEN];
    135 	struct lwp *pf_lwp;
    136 
    137 	LIST_ENTRY(prefork) pf_entries;		/* global list */
    138 	LIST_ENTRY(prefork) pf_spcentries;	/* linked from forking spc */
    139 };
    140 static LIST_HEAD(, prefork) preforks = LIST_HEAD_INITIALIZER(preforks);
    141 static pthread_mutex_t pfmtx;
    142 
    143 /*
    144  * This version is for the server.  It's optimized for multiple threads
    145  * and is *NOT* reentrant wrt to signals.
    146  */
    147 static int
    148 waitresp(struct spclient *spc, struct respwait *rw)
    149 {
    150 	int spcstate;
    151 	int rv = 0;
    152 
    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);
    157 	}
    158 	TAILQ_REMOVE(&spc->spc_respwait, rw, rw_entries);
    159 	spcstate = spc->spc_state;
    160 	pthread_mutex_unlock(&spc->spc_mtx);
    161 
    162 	pthread_cond_destroy(&rw->rw_cv);
    163 
    164 	if (rv)
    165 		return rv;
    166 	if (spcstate == SPCSTATE_DYING)
    167 		return ENOTCONN;
    168 	return rw->rw_error;
    169 }
    170 
    171 /*
    172  * Manual wrappers, since librump does not have access to the
    173  * user namespace wrapped interfaces.
    174  */
    175 
    176 static void
    177 lwproc_switch(struct lwp *l)
    178 {
    179 
    180 	rumpuser__hyp.hyp_schedule();
    181 	rumpuser__hyp.hyp_lwproc_switch(l);
    182 	rumpuser__hyp.hyp_unschedule();
    183 }
    184 
    185 static void
    186 lwproc_release(void)
    187 {
    188 
    189 	rumpuser__hyp.hyp_schedule();
    190 	rumpuser__hyp.hyp_lwproc_release();
    191 	rumpuser__hyp.hyp_unschedule();
    192 }
    193 
    194 static int
    195 lwproc_rfork(struct spclient *spc, int flags, const char *comm)
    196 {
    197 	int rv;
    198 
    199 	rumpuser__hyp.hyp_schedule();
    200 	rv = rumpuser__hyp.hyp_lwproc_rfork(spc, flags, comm);
    201 	rumpuser__hyp.hyp_unschedule();
    202 
    203 	return rv;
    204 }
    205 
    206 static int
    207 lwproc_newlwp(pid_t pid)
    208 {
    209 	int rv;
    210 
    211 	rumpuser__hyp.hyp_schedule();
    212 	rv = rumpuser__hyp.hyp_lwproc_newlwp(pid);
    213 	rumpuser__hyp.hyp_unschedule();
    214 
    215 	return rv;
    216 }
    217 
    218 static struct lwp *
    219 lwproc_curlwp(void)
    220 {
    221 	struct lwp *l;
    222 
    223 	rumpuser__hyp.hyp_schedule();
    224 	l = rumpuser__hyp.hyp_lwproc_curlwp();
    225 	rumpuser__hyp.hyp_unschedule();
    226 
    227 	return l;
    228 }
    229 
    230 static pid_t
    231 lwproc_getpid(void)
    232 {
    233 	pid_t p;
    234 
    235 	rumpuser__hyp.hyp_schedule();
    236 	p = rumpuser__hyp.hyp_getpid();
    237 	rumpuser__hyp.hyp_unschedule();
    238 
    239 	return p;
    240 }
    241 
    242 static void
    243 lwproc_execnotify(const char *comm)
    244 {
    245 
    246 	rumpuser__hyp.hyp_schedule();
    247 	rumpuser__hyp.hyp_execnotify(comm);
    248 	rumpuser__hyp.hyp_unschedule();
    249 }
    250 
    251 static void
    252 lwproc_lwpexit(void)
    253 {
    254 
    255 	rumpuser__hyp.hyp_schedule();
    256 	rumpuser__hyp.hyp_lwpexit();
    257 	rumpuser__hyp.hyp_unschedule();
    258 }
    259 
    260 static int
    261 rumpsyscall(int sysnum, void *data, register_t *regrv)
    262 {
    263 	long retval[2] = {0, 0};
    264 	int rv;
    265 
    266 	rumpuser__hyp.hyp_schedule();
    267 	rv = rumpuser__hyp.hyp_syscall(sysnum, data, retval);
    268 	rumpuser__hyp.hyp_unschedule();
    269 
    270 	regrv[0] = retval[0];
    271 	regrv[1] = retval[1];
    272 	return rv;
    273 }
    274 
    275 static uint64_t
    276 nextreq(struct spclient *spc)
    277 {
    278 	uint64_t nw;
    279 
    280 	pthread_mutex_lock(&spc->spc_mtx);
    281 	nw = spc->spc_nextreq++;
    282 	pthread_mutex_unlock(&spc->spc_mtx);
    283 
    284 	return nw;
    285 }
    286 
    287 /*
    288  * XXX: we send responses with "blocking" I/O.  This is not
    289  * ok for the main thread.  XXXFIXME
    290  */
    291 
    292 static void
    293 send_error_resp(struct spclient *spc, uint64_t reqno, enum rumpsp_err error)
    294 {
    295 	struct rsp_hdr rhdr;
    296 	struct iovec iov[1];
    297 
    298 	rhdr.rsp_len = sizeof(rhdr);
    299 	rhdr.rsp_reqno = reqno;
    300 	rhdr.rsp_class = RUMPSP_ERROR;
    301 	rhdr.rsp_type = 0;
    302 	rhdr.rsp_error = error;
    303 
    304 	IOVPUT(iov[0], rhdr);
    305 
    306 	sendlock(spc);
    307 	(void)SENDIOV(spc, iov);
    308 	sendunlock(spc);
    309 }
    310 
    311 static int
    312 send_handshake_resp(struct spclient *spc, uint64_t reqno, int error)
    313 {
    314 	struct rsp_hdr rhdr;
    315 	struct iovec iov[2];
    316 	int rv;
    317 
    318 	rhdr.rsp_len = sizeof(rhdr) + sizeof(error);
    319 	rhdr.rsp_reqno = reqno;
    320 	rhdr.rsp_class = RUMPSP_RESP;
    321 	rhdr.rsp_type = RUMPSP_HANDSHAKE;
    322 	rhdr.rsp_error = 0;
    323 
    324 	IOVPUT(iov[0], rhdr);
    325 	IOVPUT(iov[1], error);
    326 
    327 	sendlock(spc);
    328 	rv = SENDIOV(spc, iov);
    329 	sendunlock(spc);
    330 
    331 	return rv;
    332 }
    333 
    334 static int
    335 send_syscall_resp(struct spclient *spc, uint64_t reqno, int error,
    336 	register_t *retval)
    337 {
    338 	struct rsp_hdr rhdr;
    339 	struct rsp_sysresp sysresp;
    340 	struct iovec iov[2];
    341 	int rv;
    342 
    343 	rhdr.rsp_len = sizeof(rhdr) + sizeof(sysresp);
    344 	rhdr.rsp_reqno = reqno;
    345 	rhdr.rsp_class = RUMPSP_RESP;
    346 	rhdr.rsp_type = RUMPSP_SYSCALL;
    347 	rhdr.rsp_sysnum = 0;
    348 
    349 	sysresp.rsys_error = error;
    350 	memcpy(sysresp.rsys_retval, retval, sizeof(sysresp.rsys_retval));
    351 
    352 	IOVPUT(iov[0], rhdr);
    353 	IOVPUT(iov[1], sysresp);
    354 
    355 	sendlock(spc);
    356 	rv = SENDIOV(spc, iov);
    357 	sendunlock(spc);
    358 
    359 	return rv;
    360 }
    361 
    362 static int
    363 send_prefork_resp(struct spclient *spc, uint64_t reqno, uint32_t *auth)
    364 {
    365 	struct rsp_hdr rhdr;
    366 	struct iovec iov[2];
    367 	int rv;
    368 
    369 	rhdr.rsp_len = sizeof(rhdr) + AUTHLEN*sizeof(*auth);
    370 	rhdr.rsp_reqno = reqno;
    371 	rhdr.rsp_class = RUMPSP_RESP;
    372 	rhdr.rsp_type = RUMPSP_PREFORK;
    373 	rhdr.rsp_sysnum = 0;
    374 
    375 	IOVPUT(iov[0], rhdr);
    376 	IOVPUT_WITHSIZE(iov[1], auth, AUTHLEN*sizeof(*auth));
    377 
    378 	sendlock(spc);
    379 	rv = SENDIOV(spc, iov);
    380 	sendunlock(spc);
    381 
    382 	return rv;
    383 }
    384 
    385 static int
    386 copyin_req(struct spclient *spc, const void *remaddr, size_t *dlen,
    387 	int wantstr, void **resp)
    388 {
    389 	struct rsp_hdr rhdr;
    390 	struct rsp_copydata copydata;
    391 	struct respwait rw;
    392 	struct iovec iov[2];
    393 	int rv;
    394 
    395 	DPRINTF(("copyin_req: %zu bytes from %p\n", *dlen, remaddr));
    396 
    397 	rhdr.rsp_len = sizeof(rhdr) + sizeof(copydata);
    398 	rhdr.rsp_class = RUMPSP_REQ;
    399 	if (wantstr)
    400 		rhdr.rsp_type = RUMPSP_COPYINSTR;
    401 	else
    402 		rhdr.rsp_type = RUMPSP_COPYIN;
    403 	rhdr.rsp_sysnum = 0;
    404 
    405 	copydata.rcp_addr = __UNCONST(remaddr);
    406 	copydata.rcp_len = *dlen;
    407 
    408 	IOVPUT(iov[0], rhdr);
    409 	IOVPUT(iov[1], copydata);
    410 
    411 	putwait(spc, &rw, &rhdr);
    412 	rv = SENDIOV(spc, iov);
    413 	if (rv) {
    414 		unputwait(spc, &rw);
    415 		return rv;
    416 	}
    417 
    418 	rv = waitresp(spc, &rw);
    419 
    420 	DPRINTF(("copyin: response %d\n", rv));
    421 
    422 	*resp = rw.rw_data;
    423 	if (wantstr)
    424 		*dlen = rw.rw_dlen;
    425 
    426 	return rv;
    427 
    428 }
    429 
    430 static int
    431 send_copyout_req(struct spclient *spc, const void *remaddr,
    432 	const void *data, size_t dlen)
    433 {
    434 	struct rsp_hdr rhdr;
    435 	struct rsp_copydata copydata;
    436 	struct iovec iov[3];
    437 	int rv;
    438 
    439 	DPRINTF(("copyout_req (async): %zu bytes to %p\n", dlen, remaddr));
    440 
    441 	rhdr.rsp_len = sizeof(rhdr) + sizeof(copydata) + dlen;
    442 	rhdr.rsp_reqno = nextreq(spc);
    443 	rhdr.rsp_class = RUMPSP_REQ;
    444 	rhdr.rsp_type = RUMPSP_COPYOUT;
    445 	rhdr.rsp_sysnum = 0;
    446 
    447 	copydata.rcp_addr = __UNCONST(remaddr);
    448 	copydata.rcp_len = dlen;
    449 
    450 	IOVPUT(iov[0], rhdr);
    451 	IOVPUT(iov[1], copydata);
    452 	IOVPUT_WITHSIZE(iov[2], __UNCONST(data), dlen);
    453 
    454 	sendlock(spc);
    455 	rv = SENDIOV(spc, iov);
    456 	sendunlock(spc);
    457 
    458 	return rv;
    459 }
    460 
    461 static int
    462 anonmmap_req(struct spclient *spc, size_t howmuch, void **resp)
    463 {
    464 	struct rsp_hdr rhdr;
    465 	struct respwait rw;
    466 	struct iovec iov[2];
    467 	int rv;
    468 
    469 	DPRINTF(("anonmmap_req: %zu bytes\n", howmuch));
    470 
    471 	rhdr.rsp_len = sizeof(rhdr) + sizeof(howmuch);
    472 	rhdr.rsp_class = RUMPSP_REQ;
    473 	rhdr.rsp_type = RUMPSP_ANONMMAP;
    474 	rhdr.rsp_sysnum = 0;
    475 
    476 	IOVPUT(iov[0], rhdr);
    477 	IOVPUT(iov[1], howmuch);
    478 
    479 	putwait(spc, &rw, &rhdr);
    480 	rv = SENDIOV(spc, iov);
    481 	if (rv) {
    482 		unputwait(spc, &rw);
    483 		return rv;
    484 	}
    485 
    486 	rv = waitresp(spc, &rw);
    487 
    488 	*resp = rw.rw_data;
    489 
    490 	DPRINTF(("anonmmap: mapped at %p\n", **(void ***)resp));
    491 
    492 	return rv;
    493 }
    494 
    495 static int
    496 send_raise_req(struct spclient *spc, int signo)
    497 {
    498 	struct rsp_hdr rhdr;
    499 	struct iovec iov[1];
    500 	int rv;
    501 
    502 	rhdr.rsp_len = sizeof(rhdr);
    503 	rhdr.rsp_class = RUMPSP_REQ;
    504 	rhdr.rsp_type = RUMPSP_RAISE;
    505 	rhdr.rsp_signo = signo;
    506 
    507 	IOVPUT(iov[0], rhdr);
    508 
    509 	sendlock(spc);
    510 	rv = SENDIOV(spc, iov);
    511 	sendunlock(spc);
    512 
    513 	return rv;
    514 }
    515 
    516 static void
    517 spcref(struct spclient *spc)
    518 {
    519 
    520 	pthread_mutex_lock(&spc->spc_mtx);
    521 	spc->spc_refcnt++;
    522 	pthread_mutex_unlock(&spc->spc_mtx);
    523 }
    524 
    525 static void
    526 spcrelease(struct spclient *spc)
    527 {
    528 	int ref;
    529 
    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);
    535 
    536 	if (ref > 0)
    537 		return;
    538 
    539 	DPRINTF(("rump_sp: spcrelease: spc %p fd %d\n", spc, spc->spc_fd));
    540 
    541 	_DIAGASSERT(TAILQ_EMPTY(&spc->spc_respwait));
    542 	_DIAGASSERT(spc->spc_buf == NULL);
    543 
    544 	if (spc->spc_mainlwp) {
    545 		lwproc_switch(spc->spc_mainlwp);
    546 		lwproc_release();
    547 	}
    548 	spc->spc_mainlwp = NULL;
    549 
    550 	close(spc->spc_fd);
    551 	spc->spc_fd = -1;
    552 	spc->spc_state = SPCSTATE_NEW;
    553 
    554 	signaldisco();
    555 }
    556 
    557 static void
    558 serv_handledisco(unsigned int idx)
    559 {
    560 	struct spclient *spc = &spclist[idx];
    561 	int dolwpexit;
    562 
    563 	DPRINTF(("rump_sp: disconnecting [%u]\n", idx));
    564 
    565 	pfdlist[idx].fd = -1;
    566 	pfdlist[idx].revents = 0;
    567 	pthread_mutex_lock(&spc->spc_mtx);
    568 	spc->spc_state = SPCSTATE_DYING;
    569 	kickall(spc);
    570 	sendunlockl(spc);
    571 	/* exec uses mainlwp in another thread, but also nuked all lwps */
    572 	dolwpexit = !spc->spc_inexec;
    573 	pthread_mutex_unlock(&spc->spc_mtx);
    574 
    575 	if (dolwpexit && spc->spc_mainlwp) {
    576 		lwproc_switch(spc->spc_mainlwp);
    577 		lwproc_lwpexit();
    578 		lwproc_switch(NULL);
    579 	}
    580 
    581 	/*
    582 	 * Nobody's going to attempt to send/receive anymore,
    583 	 * so reinit info relevant to that.
    584 	 */
    585 	/*LINTED:pointer casts may be ok*/
    586 	memset((char *)spc + SPC_ZEROFF, 0, sizeof(*spc) - SPC_ZEROFF);
    587 
    588 	spcrelease(spc);
    589 }
    590 
    591 static void
    592 serv_shutdown(void)
    593 {
    594 	struct spclient *spc;
    595 	unsigned int i;
    596 
    597 	for (i = 1; i < MAXCLI; i++) {
    598 		spc = &spclist[i];
    599 		if (spc->spc_fd == -1)
    600 			continue;
    601 
    602 		shutdown(spc->spc_fd, SHUT_RDWR);
    603 		serv_handledisco(i);
    604 
    605 		spcrelease(spc);
    606 	}
    607 }
    608 
    609 static unsigned
    610 serv_handleconn(int fd, connecthook_fn connhook, int busy)
    611 {
    612 	struct sockaddr_storage ss;
    613 	socklen_t sl = sizeof(ss);
    614 	int newfd, flags;
    615 	unsigned i;
    616 
    617 	/*LINTED: cast ok */
    618 	newfd = accept(fd, (struct sockaddr *)&ss, &sl);
    619 	if (newfd == -1)
    620 		return 0;
    621 
    622 	if (busy) {
    623 		close(newfd); /* EBUSY */
    624 		return 0;
    625 	}
    626 
    627 	flags = fcntl(newfd, F_GETFL, 0);
    628 	if (fcntl(newfd, F_SETFL, flags | O_NONBLOCK) == -1) {
    629 		close(newfd);
    630 		return 0;
    631 	}
    632 
    633 	if (connhook(newfd) != 0) {
    634 		close(newfd);
    635 		return 0;
    636 	}
    637 
    638 	/* write out a banner for the client */
    639 	if (send(newfd, banner, strlen(banner), MSG_NOSIGNAL)
    640 	    != (ssize_t)strlen(banner)) {
    641 		close(newfd);
    642 		return 0;
    643 	}
    644 
    645 	/* find empty slot the simple way */
    646 	for (i = 0; i < MAXCLI; i++) {
    647 		if (pfdlist[i].fd == -1 && spclist[i].spc_state == SPCSTATE_NEW)
    648 			break;
    649 	}
    650 
    651 	/*
    652 	 * Although not finding a slot is impossible (cf. how this routine
    653 	 * is called), the compiler can still think that i == MAXCLI
    654 	 * if this code is either compiled with NDEBUG or the platform
    655 	 * does not use __dead for assert().  Therefore, add an explicit
    656 	 * check to avoid an array-bounds error.
    657 	 */
    658 	/* assert(i < MAXCLI); */
    659 	if (i == MAXCLI)
    660 		abort();
    661 
    662 	pfdlist[i].fd = newfd;
    663 	spclist[i].spc_fd = newfd;
    664 	spclist[i].spc_istatus = SPCSTATUS_BUSY; /* dedicated receiver */
    665 	spclist[i].spc_refcnt = 1;
    666 
    667 	TAILQ_INIT(&spclist[i].spc_respwait);
    668 
    669 	DPRINTF(("rump_sp: added new connection fd %d at idx %u\n", newfd, i));
    670 
    671 	return i;
    672 }
    673 
    674 static void
    675 serv_handlesyscall(struct spclient *spc, struct rsp_hdr *rhdr, uint8_t *data)
    676 {
    677 	register_t retval[2] = {0, 0};
    678 	int rv, sysnum;
    679 
    680 	sysnum = (int)rhdr->rsp_sysnum;
    681 	DPRINTF(("rump_sp: handling syscall %d from client %d\n",
    682 	    sysnum, spc->spc_pid));
    683 
    684 	if (__predict_false((rv = lwproc_newlwp(spc->spc_pid)) != 0)) {
    685 		retval[0] = -1;
    686 		send_syscall_resp(spc, rhdr->rsp_reqno, rv, retval);
    687 		return;
    688 	}
    689 	spc->spc_syscallreq = rhdr->rsp_reqno;
    690 	rv = rumpsyscall(sysnum, data, retval);
    691 	spc->spc_syscallreq = 0;
    692 	lwproc_release();
    693 
    694 	DPRINTF(("rump_sp: got return value %d & %"PRIxREGISTER
    695 	    "/%"PRIxREGISTER"\n",
    696 	    rv, retval[0], retval[1]));
    697 
    698 	send_syscall_resp(spc, rhdr->rsp_reqno, rv, retval);
    699 }
    700 
    701 static void
    702 serv_handleexec(struct spclient *spc, struct rsp_hdr *rhdr, const char *comm)
    703 {
    704 	pthread_mutex_lock(&spc->spc_mtx);
    705 	/* one for the connection and one for us */
    706 	while (spc->spc_refcnt > 2)
    707 		pthread_cond_wait(&spc->spc_cv, &spc->spc_mtx);
    708 	pthread_mutex_unlock(&spc->spc_mtx);
    709 
    710 	/*
    711 	 * ok, all the threads are dead (or one is still alive and
    712 	 * the connection is dead, in which case this doesn't matter
    713 	 * very much).  proceed with exec.
    714 	 */
    715 
    716 	lwproc_switch(spc->spc_mainlwp);
    717 	lwproc_execnotify(comm);
    718 	lwproc_switch(NULL);
    719 
    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);
    724 }
    725 
    726 enum sbatype { SBA_SYSCALL, SBA_EXEC };
    727 
    728 struct servbouncearg {
    729 	struct spclient *sba_spc;
    730 	struct rsp_hdr sba_hdr;
    731 	enum sbatype sba_type;
    732 	uint8_t *sba_data;
    733 
    734 	TAILQ_ENTRY(servbouncearg) sba_entries;
    735 };
    736 static pthread_mutex_t sbamtx;
    737 static pthread_cond_t sbacv;
    738 static int nworker, idleworker, nwork;
    739 static TAILQ_HEAD(, servbouncearg) wrklist = TAILQ_HEAD_INITIALIZER(wrklist);
    740 
    741 /*ARGSUSED*/
    742 static void *
    743 serv_workbouncer(void *arg)
    744 {
    745 	struct servbouncearg *sba;
    746 
    747 	for (;;) {
    748 		pthread_mutex_lock(&sbamtx);
    749 		if (__predict_false(idleworker - nwork >= rumpsp_idleworker)) {
    750 			nworker--;
    751 			pthread_mutex_unlock(&sbamtx);
    752 			break;
    753 		}
    754 		idleworker++;
    755 		while (TAILQ_EMPTY(&wrklist)) {
    756 			_DIAGASSERT(nwork == 0);
    757 			pthread_cond_wait(&sbacv, &sbamtx);
    758 		}
    759 		idleworker--;
    760 
    761 		sba = TAILQ_FIRST(&wrklist);
    762 		TAILQ_REMOVE(&wrklist, sba, sba_entries);
    763 		nwork--;
    764 		pthread_mutex_unlock(&sbamtx);
    765 
    766 		if (__predict_true(sba->sba_type == SBA_SYSCALL)) {
    767 			serv_handlesyscall(sba->sba_spc,
    768 			    &sba->sba_hdr, sba->sba_data);
    769 		} else {
    770 			_DIAGASSERT(sba->sba_type == SBA_EXEC);
    771 			serv_handleexec(sba->sba_spc, &sba->sba_hdr,
    772 			    (char *)sba->sba_data);
    773 		}
    774 		spcrelease(sba->sba_spc);
    775 		free(sba->sba_data);
    776 		free(sba);
    777 	}
    778 
    779 	return NULL;
    780 }
    781 
    782 static int
    783 sp_copyin(void *arg, const void *raddr, void *laddr, size_t *len, int wantstr)
    784 {
    785 	struct spclient *spc = arg;
    786 	void *rdata = NULL; /* XXXuninit */
    787 	int rv, nlocks;
    788 
    789 	rumpkern_unsched(&nlocks, NULL);
    790 
    791 	rv = copyin_req(spc, raddr, len, wantstr, &rdata);
    792 	if (rv)
    793 		goto out;
    794 
    795 	memcpy(laddr, rdata, *len);
    796 	free(rdata);
    797 
    798  out:
    799 	rumpkern_sched(nlocks, NULL);
    800 	if (rv)
    801 		rv = EFAULT;
    802 	ET(rv);
    803 }
    804 
    805 int
    806 rumpuser_sp_copyin(void *arg, const void *raddr, void *laddr, size_t len)
    807 {
    808 	int rv;
    809 
    810 	rv = sp_copyin(arg, raddr, laddr, &len, 0);
    811 	ET(rv);
    812 }
    813 
    814 int
    815 rumpuser_sp_copyinstr(void *arg, const void *raddr, void *laddr, size_t *len)
    816 {
    817 	int rv;
    818 
    819 	rv = sp_copyin(arg, raddr, laddr, len, 1);
    820 	ET(rv);
    821 }
    822 
    823 static int
    824 sp_copyout(void *arg, const void *laddr, void *raddr, size_t dlen)
    825 {
    826 	struct spclient *spc = arg;
    827 	int nlocks, rv;
    828 
    829 	rumpkern_unsched(&nlocks, NULL);
    830 	rv = send_copyout_req(spc, raddr, laddr, dlen);
    831 	rumpkern_sched(nlocks, NULL);
    832 
    833 	if (rv)
    834 		rv = EFAULT;
    835 	ET(rv);
    836 }
    837 
    838 int
    839 rumpuser_sp_copyout(void *arg, const void *laddr, void *raddr, size_t dlen)
    840 {
    841 	int rv;
    842 
    843 	rv = sp_copyout(arg, laddr, raddr, dlen);
    844 	ET(rv);
    845 }
    846 
    847 int
    848 rumpuser_sp_copyoutstr(void *arg, const void *laddr, void *raddr, size_t *dlen)
    849 {
    850 	int rv;
    851 
    852 	rv = sp_copyout(arg, laddr, raddr, *dlen);
    853 	ET(rv);
    854 }
    855 
    856 int
    857 rumpuser_sp_anonmmap(void *arg, size_t howmuch, void **addr)
    858 {
    859 	struct spclient *spc = arg;
    860 	void *resp, *rdata = NULL; /* XXXuninit */
    861 	int nlocks, rv;
    862 
    863 	rumpkern_unsched(&nlocks, NULL);
    864 
    865 	rv = anonmmap_req(spc, howmuch, &rdata);
    866 	if (rv) {
    867 		rv = EFAULT;
    868 		goto out;
    869 	}
    870 
    871 	resp = *(void **)rdata;
    872 	free(rdata);
    873 
    874 	if (resp == NULL) {
    875 		rv = ENOMEM;
    876 	}
    877 
    878 	*addr = resp;
    879 
    880  out:
    881 	rumpkern_sched(nlocks, NULL);
    882 	ET(rv);
    883 }
    884 
    885 int
    886 rumpuser_sp_raise(void *arg, int signo)
    887 {
    888 	struct spclient *spc = arg;
    889 	int rv, nlocks;
    890 
    891 	rumpkern_unsched(&nlocks, NULL);
    892 	rv = send_raise_req(spc, signo);
    893 	rumpkern_sched(nlocks, NULL);
    894 
    895 	return rv;
    896 }
    897 
    898 static pthread_attr_t pattr_detached;
    899 static void
    900 schedulework(struct spclient *spc, enum sbatype sba_type)
    901 {
    902 	struct servbouncearg *sba;
    903 	pthread_t pt;
    904 	uint64_t reqno;
    905 	int retries = 0;
    906 
    907 	reqno = spc->spc_hdr.rsp_reqno;
    908 	while ((sba = malloc(sizeof(*sba))) == NULL) {
    909 		if (nworker == 0 || retries++ > 10) {
    910 			send_error_resp(spc, reqno, RUMPSP_ERR_TRYAGAIN);
    911 			spcfreebuf(spc);
    912 			return;
    913 		}
    914 		/* slim chance of more memory? */
    915 		usleep(10000);
    916 	}
    917 
    918 	sba->sba_spc = spc;
    919 	sba->sba_type = sba_type;
    920 	sba->sba_hdr = spc->spc_hdr;
    921 	sba->sba_data = spc->spc_buf;
    922 	spcresetbuf(spc);
    923 
    924 	spcref(spc);
    925 
    926 	pthread_mutex_lock(&sbamtx);
    927 	TAILQ_INSERT_TAIL(&wrklist, sba, sba_entries);
    928 	nwork++;
    929 	if (nwork <= idleworker) {
    930 		/* do we have a daemon's tool (i.e. idle threads)? */
    931 		pthread_cond_signal(&sbacv);
    932 	} else if (nworker < rumpsp_maxworker) {
    933 		/*
    934 		 * Else, need to create one
    935 		 * (if we can, otherwise just expect another
    936 		 * worker to pick up the syscall)
    937 		 */
    938 		if (pthread_create(&pt, &pattr_detached,
    939 		    serv_workbouncer, NULL) == 0) {
    940 			nworker++;
    941 		}
    942 	}
    943 	pthread_mutex_unlock(&sbamtx);
    944 }
    945 
    946 /*
    947  *
    948  * Startup routines and mainloop for server.
    949  *
    950  */
    951 
    952 struct spservarg {
    953 	int sps_sock;
    954 	connecthook_fn sps_connhook;
    955 };
    956 
    957 static void
    958 handlereq(struct spclient *spc)
    959 {
    960 	uint64_t reqno;
    961 	int error;
    962 
    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);
    969 			return;
    970 		}
    971 
    972 		if (spc->spc_hdr.rsp_handshake == HANDSHAKE_GUEST) {
    973 			/* make sure we fork off of proc1 */
    974 			_DIAGASSERT(lwproc_curlwp() == NULL);
    975 
    976 			if ((error = lwproc_rfork(spc, RUMP_RFFD_CLEAR,
    977 			    (const char *)spc->spc_buf)) != 0) {
    978 				shutdown(spc->spc_fd, SHUT_RDWR);
    979 			}
    980 
    981 			spcfreebuf(spc);
    982 			if (error)
    983 				return;
    984 
    985 			spc->spc_mainlwp = lwproc_curlwp();
    986 
    987 			send_handshake_resp(spc, reqno, 0);
    988 		} else if (spc->spc_hdr.rsp_handshake == HANDSHAKE_FORK) {
    989 			struct lwp *tmpmain;
    990 			struct prefork *pf;
    991 			struct handshake_fork *rfp;
    992 			int cancel;
    993 
    994 			if (spc->spc_off-HDRSZ != sizeof(*rfp)) {
    995 				send_error_resp(spc, reqno,
    996 				    RUMPSP_ERR_MALFORMED_REQUEST);
    997 				shutdown(spc->spc_fd, SHUT_RDWR);
    998 				spcfreebuf(spc);
    999 				return;
   1000 			}
   1001 
   1002 			/*LINTED*/
   1003 			rfp = (void *)spc->spc_buf;
   1004 			cancel = rfp->rf_cancel;
   1005 
   1006 			pthread_mutex_lock(&pfmtx);
   1007 			LIST_FOREACH(pf, &preforks, pf_entries) {
   1008 				if (memcmp(rfp->rf_auth, pf->pf_auth,
   1009 				    sizeof(rfp->rf_auth)) == 0) {
   1010 					LIST_REMOVE(pf, pf_entries);
   1011 					LIST_REMOVE(pf, pf_spcentries);
   1012 					break;
   1013 				}
   1014 			}
   1015 			pthread_mutex_unlock(&pfmtx);
   1016 			spcfreebuf(spc);
   1017 
   1018 			if (!pf) {
   1019 				send_error_resp(spc, reqno,
   1020 				    RUMPSP_ERR_INVALID_PREFORK);
   1021 				shutdown(spc->spc_fd, SHUT_RDWR);
   1022 				return;
   1023 			}
   1024 
   1025 			tmpmain = pf->pf_lwp;
   1026 			free(pf);
   1027 			lwproc_switch(tmpmain);
   1028 			if (cancel) {
   1029 				lwproc_release();
   1030 				shutdown(spc->spc_fd, SHUT_RDWR);
   1031 				return;
   1032 			}
   1033 
   1034 			/*
   1035 			 * So, we forked already during "prefork" to save
   1036 			 * the file descriptors from a parent exit
   1037 			 * race condition.  But now we need to fork
   1038 			 * a second time since the initial fork has
   1039 			 * the wrong spc pointer.  (yea, optimize
   1040 			 * interfaces some day if anyone cares)
   1041 			 */
   1042 			if ((error = lwproc_rfork(spc,
   1043 			    RUMP_RFFD_SHARE, NULL)) != 0) {
   1044 				send_error_resp(spc, reqno,
   1045 				    RUMPSP_ERR_RFORK_FAILED);
   1046 				shutdown(spc->spc_fd, SHUT_RDWR);
   1047 				lwproc_release();
   1048 				return;
   1049 			}
   1050 			spc->spc_mainlwp = lwproc_curlwp();
   1051 			lwproc_switch(tmpmain);
   1052 			lwproc_release();
   1053 			lwproc_switch(spc->spc_mainlwp);
   1054 
   1055 			send_handshake_resp(spc, reqno, 0);
   1056 		} else {
   1057 			send_error_resp(spc, reqno, RUMPSP_ERR_AUTH);
   1058 			shutdown(spc->spc_fd, SHUT_RDWR);
   1059 			spcfreebuf(spc);
   1060 			return;
   1061 		}
   1062 
   1063 		spc->spc_pid = lwproc_getpid();
   1064 
   1065 		DPRINTF(("rump_sp: handshake for client %p complete, pid %d\n",
   1066 		    spc, spc->spc_pid));
   1067 
   1068 		lwproc_switch(NULL);
   1069 		spc->spc_state = SPCSTATE_RUNNING;
   1070 		return;
   1071 	}
   1072 
   1073 	if (__predict_false(spc->spc_hdr.rsp_type == RUMPSP_PREFORK)) {
   1074 		struct prefork *pf;
   1075 		uint32_t auth[AUTHLEN];
   1076 		size_t randlen;
   1077 		int inexec;
   1078 
   1079 		DPRINTF(("rump_sp: prefork handler executing for %p\n", spc));
   1080 		spcfreebuf(spc);
   1081 
   1082 		pthread_mutex_lock(&spc->spc_mtx);
   1083 		inexec = spc->spc_inexec;
   1084 		pthread_mutex_unlock(&spc->spc_mtx);
   1085 		if (inexec) {
   1086 			send_error_resp(spc, reqno, RUMPSP_ERR_INEXEC);
   1087 			shutdown(spc->spc_fd, SHUT_RDWR);
   1088 			return;
   1089 		}
   1090 
   1091 		pf = malloc(sizeof(*pf));
   1092 		if (pf == NULL) {
   1093 			send_error_resp(spc, reqno, RUMPSP_ERR_NOMEM);
   1094 			return;
   1095 		}
   1096 
   1097 		/*
   1098 		 * Use client main lwp to fork.  this is never used by
   1099 		 * worker threads (except in exec, but we checked for that
   1100 		 * above) so we can safely use it here.
   1101 		 */
   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);
   1106 			lwproc_switch(NULL);
   1107 			free(pf);
   1108 			return;
   1109 		}
   1110 
   1111 		/* Ok, we have a new process context and a new curlwp */
   1112 		rumpuser_getrandom(auth, sizeof(auth), 0, &randlen);
   1113 		memcpy(pf->pf_auth, auth, sizeof(pf->pf_auth));
   1114 		pf->pf_lwp = lwproc_curlwp();
   1115 		lwproc_switch(NULL);
   1116 
   1117 		pthread_mutex_lock(&pfmtx);
   1118 		LIST_INSERT_HEAD(&preforks, pf, pf_entries);
   1119 		LIST_INSERT_HEAD(&spc->spc_pflist, pf, pf_spcentries);
   1120 		pthread_mutex_unlock(&pfmtx);
   1121 
   1122 		DPRINTF(("rump_sp: prefork handler success %p\n", spc));
   1123 
   1124 		send_prefork_resp(spc, reqno, auth);
   1125 		return;
   1126 	}
   1127 
   1128 	if (__predict_false(spc->spc_hdr.rsp_type == RUMPSP_HANDSHAKE)) {
   1129 		int inexec;
   1130 
   1131 		if (spc->spc_hdr.rsp_handshake != HANDSHAKE_EXEC) {
   1132 			send_error_resp(spc, reqno,
   1133 			    RUMPSP_ERR_MALFORMED_REQUEST);
   1134 			shutdown(spc->spc_fd, SHUT_RDWR);
   1135 			spcfreebuf(spc);
   1136 			return;
   1137 		}
   1138 
   1139 		pthread_mutex_lock(&spc->spc_mtx);
   1140 		inexec = spc->spc_inexec;
   1141 		pthread_mutex_unlock(&spc->spc_mtx);
   1142 		if (inexec) {
   1143 			send_error_resp(spc, reqno, RUMPSP_ERR_INEXEC);
   1144 			shutdown(spc->spc_fd, SHUT_RDWR);
   1145 			spcfreebuf(spc);
   1146 			return;
   1147 		}
   1148 
   1149 		pthread_mutex_lock(&spc->spc_mtx);
   1150 		spc->spc_inexec = 1;
   1151 		pthread_mutex_unlock(&spc->spc_mtx);
   1152 
   1153 		/*
   1154 		 * start to drain lwps.  we will wait for it to finish
   1155 		 * in another thread
   1156 		 */
   1157 		lwproc_switch(spc->spc_mainlwp);
   1158 		lwproc_lwpexit();
   1159 		lwproc_switch(NULL);
   1160 
   1161 		/*
   1162 		 * exec has to wait for lwps to drain, so finish it off
   1163 		 * in another thread
   1164 		 */
   1165 		schedulework(spc, SBA_EXEC);
   1166 		return;
   1167 	}
   1168 
   1169 	if (__predict_false(spc->spc_hdr.rsp_type != RUMPSP_SYSCALL)) {
   1170 		send_error_resp(spc, reqno, RUMPSP_ERR_MALFORMED_REQUEST);
   1171 		spcfreebuf(spc);
   1172 		return;
   1173 	}
   1174 
   1175 	schedulework(spc, SBA_SYSCALL);
   1176 }
   1177 
   1178 static void *
   1179 spserver(void *arg)
   1180 {
   1181 	struct spservarg *sarg = arg;
   1182 	struct spclient *spc;
   1183 	unsigned idx;
   1184 	int seen;
   1185 	int rv;
   1186 	unsigned int nfds, maxidx;
   1187 
   1188 	for (idx = 0; idx < MAXCLI; idx++) {
   1189 		pfdlist[idx].fd = -1;
   1190 		pfdlist[idx].events = POLLIN;
   1191 
   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;
   1196 	}
   1197 	pfdlist[0].fd = spclist[0].spc_fd = sarg->sps_sock;
   1198 	pfdlist[0].events = POLLIN;
   1199 	nfds = 1;
   1200 	maxidx = 0;
   1201 
   1202 	pthread_attr_init(&pattr_detached);
   1203 	pthread_attr_setdetachstate(&pattr_detached, PTHREAD_CREATE_DETACHED);
   1204 #if NOTYET
   1205 	pthread_attr_setstacksize(&pattr_detached, 32*1024);
   1206 #endif
   1207 
   1208 	pthread_mutex_init(&sbamtx, NULL);
   1209 	pthread_cond_init(&sbacv, NULL);
   1210 
   1211 	DPRINTF(("rump_sp: server mainloop\n"));
   1212 
   1213 	for (;;) {
   1214 		int discoed;
   1215 
   1216 		/* g/c hangarounds (eventually) */
   1217 		discoed = getdisco();
   1218 		while (discoed--) {
   1219 			nfds--;
   1220 			idx = maxidx;
   1221 			while (idx) {
   1222 				if (pfdlist[idx].fd != -1) {
   1223 					maxidx = idx;
   1224 					break;
   1225 				}
   1226 				idx--;
   1227 			}
   1228 			DPRINTF(("rump_sp: set maxidx to [%u]\n",
   1229 			    maxidx));
   1230 		}
   1231 
   1232 		DPRINTF(("rump_sp: loop nfd %d\n", maxidx+1));
   1233 		seen = 0;
   1234 		rv = poll(pfdlist, maxidx+1, INFTIM);
   1235 		assert(maxidx+1 <= MAXCLI);
   1236 		assert(rv != 0);
   1237 		if (rv == -1) {
   1238 			if (errno == EINTR)
   1239 				continue;
   1240 			fprintf(stderr, "rump_spserver: poll returned %d\n",
   1241 			    errno);
   1242 			break;
   1243 		}
   1244 
   1245 		for (idx = 0; seen < rv && idx < MAXCLI; idx++) {
   1246 			if ((pfdlist[idx].revents & POLLIN) == 0)
   1247 				continue;
   1248 
   1249 			seen++;
   1250 			DPRINTF(("rump_sp: activity at [%u] %d/%d\n",
   1251 			    idx, seen, rv));
   1252 			if (idx > 0) {
   1253 				spc = &spclist[idx];
   1254 				DPRINTF(("rump_sp: mainloop read [%u]\n", idx));
   1255 				switch (readframe(spc)) {
   1256 				case 0:
   1257 					break;
   1258 				case -1:
   1259 					serv_handledisco(idx);
   1260 					break;
   1261 				default:
   1262 					switch (spc->spc_hdr.rsp_class) {
   1263 					case RUMPSP_RESP:
   1264 						kickwaiter(spc);
   1265 						break;
   1266 					case RUMPSP_REQ:
   1267 						handlereq(spc);
   1268 						break;
   1269 					default:
   1270 						send_error_resp(spc,
   1271 						  spc->spc_hdr.rsp_reqno,
   1272 						  RUMPSP_ERR_MALFORMED_REQUEST);
   1273 						spcfreebuf(spc);
   1274 						break;
   1275 					}
   1276 					break;
   1277 				}
   1278 
   1279 			} else {
   1280 				DPRINTF(("rump_sp: mainloop new connection\n"));
   1281 
   1282 				if (__predict_false(spfini)) {
   1283 					close(spclist[0].spc_fd);
   1284 					serv_shutdown();
   1285 					goto out;
   1286 				}
   1287 
   1288 				idx = serv_handleconn(pfdlist[0].fd,
   1289 				    sarg->sps_connhook, nfds == MAXCLI);
   1290 				if (idx)
   1291 					nfds++;
   1292 				if (idx > maxidx)
   1293 					maxidx = idx;
   1294 				DPRINTF(("rump_sp: maxid now %d\n", maxidx));
   1295 			}
   1296 		}
   1297 	}
   1298 
   1299  out:
   1300 	return NULL;
   1301 }
   1302 
   1303 static unsigned cleanupidx;
   1304 static struct sockaddr *cleanupsa;
   1305 int
   1306 rumpuser_sp_init(const char *url,
   1307 	const char *ostype, const char *osrelease, const char *machine)
   1308 {
   1309 	pthread_t pt;
   1310 	struct spservarg *sarg;
   1311 	struct sockaddr *sap;
   1312 	char *p;
   1313 	unsigned idx = 0; /* XXXgcc */
   1314 	int error, s;
   1315 
   1316 	p = strdup(url);
   1317 	if (p == NULL) {
   1318 		error = ENOMEM;
   1319 		goto out;
   1320 	}
   1321 	error = parseurl(p, &sap, &idx, 1);
   1322 	free(p);
   1323 	if (error)
   1324 		goto out;
   1325 
   1326 	snprintf(banner, sizeof(banner), "RUMPSP-%d.%d-%s-%s/%s\n",
   1327 	    PROTOMAJOR, PROTOMINOR, ostype, osrelease, machine);
   1328 
   1329 	s = socket(parsetab[idx].domain, SOCK_STREAM, 0);
   1330 	if (s == -1) {
   1331 		error = errno;
   1332 		goto out;
   1333 	}
   1334 
   1335 	sarg = malloc(sizeof(*sarg));
   1336 	if (sarg == NULL) {
   1337 		close(s);
   1338 		error = ENOMEM;
   1339 		goto out;
   1340 	}
   1341 
   1342 	sarg->sps_sock = s;
   1343 	sarg->sps_connhook = parsetab[idx].connhook;
   1344 
   1345 	cleanupidx = idx;
   1346 	cleanupsa = sap;
   1347 
   1348 	/* sloppy error recovery */
   1349 
   1350 	/*LINTED*/
   1351 	if (bind(s, sap, parsetab[idx].slen) == -1) {
   1352 		error = errno;
   1353 		fprintf(stderr, "rump_sp: failed to bind to URL %s\n", url);
   1354 		goto out;
   1355 	}
   1356 	if (listen(s, MAXCLI) == -1) {
   1357 		error = errno;
   1358 		fprintf(stderr, "rump_sp: server listen failed\n");
   1359 		goto out;
   1360 	}
   1361 
   1362 	if ((error = pthread_create(&pt, NULL, spserver, sarg)) != 0) {
   1363 		fprintf(stderr, "rump_sp: cannot create wrkr thread\n");
   1364 		goto out;
   1365 	}
   1366 	pthread_detach(pt);
   1367 
   1368  out:
   1369 	ET(error);
   1370 }
   1371 
   1372 void
   1373 rumpuser_sp_fini(void *arg)
   1374 {
   1375 	struct spclient *spc = arg;
   1376 	register_t retval[2] = {0, 0};
   1377 
   1378 	if (spclist[0].spc_fd) {
   1379 		parsetab[cleanupidx].cleanup(cleanupsa);
   1380 	}
   1381 
   1382 	/*
   1383 	 * stuff response into the socket, since the rump kernel container
   1384 	 * is just about to exit
   1385 	 */
   1386 	if (spc && spc->spc_syscallreq)
   1387 		send_syscall_resp(spc, spc->spc_syscallreq, 0, retval);
   1388 
   1389 	if (spclist[0].spc_fd) {
   1390 		shutdown(spclist[0].spc_fd, SHUT_RDWR);
   1391 		spfini = 1;
   1392 	}
   1393 
   1394 	/*
   1395 	 * could release thread, but don't bother, since the container
   1396 	 * will be stone dead in a moment.
   1397 	 */
   1398 }
   1399