 @@ -1,14 +1,14 @@
-/*	$NetBSD: svc_run.c,v 1.22 2013/03/11 20:19:29 tron Exp $	*/
+/*	$NetBSD: svc_run.c,v 1.23 2015/11/06 19:34:13 christos Exp $	*/
 /*
  * Copyright (c) 2010, Oracle America, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
+ *
  *     * Redistributions of source code must retain the above copyright
  *       notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  *       copyright notice, this list of conditions and the following
  *       disclaimer in the documentation and/or other materials
 @@ -27,101 +27,113 @@
  *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
 #if 0
 static char *sccsid = "@(#)svc_run.c 1.1 87/10/13 Copyr 1984 Sun Micro";
 static char *sccsid = "@(#)svc_run.c	2.1 88/07/29 4.0 RPCSRC";
 #else
-__RCSID("$NetBSD: svc_run.c,v 1.22 2013/03/11 20:19:29 tron Exp $");
+__RCSID("$NetBSD: svc_run.c,v 1.23 2015/11/06 19:34:13 christos Exp $");
 #endif
 #endif
 /*
  * This is the rpc server side idle loop
  * Wait for input, call server program.
  */
 #include "namespace.h"
 #include "reentrant.h"
 #include <err.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <rpc/rpc.h>
 #include "svc_fdset.h"
 #include "rpc_internal.h"
 #ifdef __weak_alias
 __weak_alias(svc_run,_svc_run)
 __weak_alias(svc_exit,_svc_exit)
 #endif
 void
 svc_run(void)
+{
-	fd_set readfds, cleanfds;
+	fd_set *readfds, *cleanfds;
 	struct timeval timeout;
-	int maxfd;
+	int maxfd, fdsize;
 #ifndef RUMP_RPC
 	int probs = 0;
 #endif
 #ifdef _REENTRANT
 	extern rwlock_t svc_fd_lock;
 #endif
 	readfds = NULL;
 	cleanfds = NULL;
 	fdsize = 0;
 	timeout.tv_sec = 30;
 	timeout.tv_usec = 0;
 	for (;;) {
 		rwlock_rdlock(&svc_fd_lock);
-		readfds = *get_fdset();
+		if (fdsize != svc_fdset_getsize(0)) {
-		cleanfds = *get_fdset();
+			fdsize = svc_fdset_getsize(0);
-		maxfd = *get_fdsetmax();
+			free(readfds);
 			readfds = svc_fdset_copy(svc_fdset_get());
 			free(cleanfds);
 			cleanfds = svc_fdset_copy(svc_fdset_get());
+		}
 		maxfd = *svc_fdset_getmax();
 		rwlock_unlock(&svc_fd_lock);
-		switch (select(maxfd + 1, &readfds, NULL, NULL, &timeout)) {
+		switch (select(maxfd + 1, readfds, NULL, NULL, &timeout)) {
 		case -1:
 #ifndef RUMP_RPC
 			if ((errno == EINTR || errno == EBADF) && probs < 100) {
 				probs++;
 				continue;
+			}
 #endif
 			if (errno == EINTR) {
 				continue;
+			}
 			warn("%s: select failed", __func__);
-			return;
+			goto out;
 		case 0:
-			__svc_clean_idle(&cleanfds, 30, FALSE);
+			__svc_clean_idle(cleanfds, 30, FALSE);
 			continue;
 		default:
-			svc_getreqset(&readfds);
+			svc_getreqset2(readfds, fdsize);
 #ifndef RUMP_RPC
 			probs = 0;
 #endif
+		}
+	}
 out:
 	free(readfds);
 	free(cleanfds);
+}
 /*
  *      This function causes svc_run() to exit by telling it that it has no
  *      more work to do.
  */
 void
 svc_exit(void)
+{
 #ifdef _REENTRANT
 	extern rwlock_t svc_fd_lock;
 #endif
 	rwlock_wrlock(&svc_fd_lock);
-	FD_ZERO(get_fdset());
+	svc_fdset_zero();
 	rwlock_unlock(&svc_fd_lock);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: svc.c,v 1.34 2013/03/11 20:19:29 tron Exp $	*/
+/*	$NetBSD: svc.c,v 1.35 2015/11/06 19:34:13 christos Exp $	*/
 /*
  * Copyright (c) 2010, Oracle America, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
+ *
  *     * Redistributions of source code must retain the above copyright
  *       notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  *       copyright notice, this list of conditions and the following
  *       disclaimer in the documentation and/or other materials
 @@ -27,27 +27,27 @@
  *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
 #if 0
 static char *sccsid = "@(#)svc.c 1.44 88/02/08 Copyr 1984 Sun Micro";
 static char *sccsid = "@(#)svc.c	2.4 88/08/11 4.0 RPCSRC";
 #else
-__RCSID("$NetBSD: svc.c,v 1.34 2013/03/11 20:19:29 tron Exp $");
+__RCSID("$NetBSD: svc.c,v 1.35 2015/11/06 19:34:13 christos Exp $");
 #endif
 #endif
 /*
  * svc.c, Server-side remote procedure call interface.
+ *
  * There are two sets of procedures here.  The xprt routines are
  * for handling transport handles.  The svc routines handle the
  * list of service routines.
+ *
  * Copyright (C) 1984, Sun Microsystems, Inc.
  */
 @@ -80,27 +80,29 @@ __weak_alias(svc_sendreply,_svc_sendrepl
 __weak_alias(svc_unregister,_svc_unregister)
 __weak_alias(svcerr_auth,_svcerr_auth)
 __weak_alias(svcerr_decode,_svcerr_decode)
 __weak_alias(svcerr_noproc,_svcerr_noproc)
 __weak_alias(svcerr_noprog,_svcerr_noprog)
 __weak_alias(svcerr_progvers,_svcerr_progvers)
 __weak_alias(svcerr_systemerr,_svcerr_systemerr)
 __weak_alias(svcerr_weakauth,_svcerr_weakauth)
 __weak_alias(xprt_register,_xprt_register)
 __weak_alias(xprt_unregister,_xprt_unregister)
 __weak_alias(rpc_control,_rpc_control)
 #endif
 /* __svc_xports[-1] is reserved for raw */
 SVCXPRT **__svc_xports;
 int __svc_maxxports;
 int __svc_maxrec;
 #define	RQCRED_SIZE	400		/* this size is excessive */
 #define SVC_VERSQUIET 0x0001		/* keep quiet about vers mismatch */
 #define version_keepquiet(xp) ((u_long)(xp)->xp_p3 & SVC_VERSQUIET)
 #define max(a, b) (a > b ? a : b)
 /*
  * The services list
  * Each entry represents a set of procedures (an rpc program).
  * The dispatch routine takes request structs and runs the
 @@ -115,99 +117,130 @@ static struct svc_callout {
 } *svc_head;
 #ifdef _REENTRANT
 extern rwlock_t svc_lock;
 extern rwlock_t svc_fd_lock;
 #endif
 static struct svc_callout *svc_find(rpcprog_t, rpcvers_t,
 					 struct svc_callout **, char *);
 static void __xprt_do_unregister(SVCXPRT *xprt, bool_t dolock);
 /* ***************  SVCXPRT related stuff **************** */
 static bool_t
 xprt_alloc(int sock)
+{
 	int maxset;
 	char *newxports;
 	if (++sock < 0)
 		return FALSE;
 	maxset = svc_fdset_getsize(sock);
 	if (maxset == -1)
 		return FALSE;
 	if (__svc_xports != NULL && maxset <= __svc_maxxports)
 		return TRUE;
 	if (__svc_xports != NULL)
 		--__svc_xports;
 	newxports = realloc(__svc_xports, maxset * sizeof(SVCXPRT *));
 	if (newxports == NULL) {
 		warn("%s: out of memory", __func__);
 		return FALSE;
+	}
 	memset(newxports + __svc_maxxports * sizeof(SVCXPRT *), 0,
 	    (maxset - __svc_maxxports) * sizeof(SVCXPRT *));
 	__svc_xports = (void *)newxports;
 	__svc_xports++;
 	__svc_maxxports = maxset;
 	return TRUE;
+}
 /*
  * Activate a transport handle.
  */
 bool_t
 xprt_register(SVCXPRT *xprt)
+{
 	int sock;
 	_DIAGASSERT(xprt != NULL);
 	rwlock_wrlock(&svc_fd_lock);
 	sock = xprt->xp_fd;
-	rwlock_wrlock(&svc_fd_lock);
+	if (!xprt_alloc(sock))
 	if (__svc_xports == NULL) {
 		__svc_xports = mem_alloc(FD_SETSIZE * sizeof(SVCXPRT *));
 		if (__svc_xports == NULL) {
 			warn("%s: out of memory", __func__);
 			goto out;
 		memset(__svc_xports, '\0', FD_SETSIZE * sizeof(SVCXPRT *));
 	if (sock >= FD_SETSIZE) {
 		warnx("%s: socket descriptor %d too large for setsize %u",
 		    __func__, sock, (unsigned)FD_SETSIZE);
 		goto out;
 	__svc_xports[sock] = xprt;
-	FD_SET(sock, get_fdset());
+	if (sock != -1) {
-	*get_fdsetmax() = max(*get_fdsetmax(), sock);
+		svc_fdset_set(sock);
+	}
 	rwlock_unlock(&svc_fd_lock);
 	return (TRUE);
 out:
 	rwlock_unlock(&svc_fd_lock);
 	return (FALSE);
+}
 void
 xprt_unregister(SVCXPRT *xprt)
+{
 	__xprt_do_unregister(xprt, TRUE);
+}
 void
 __xprt_unregister_unlocked(SVCXPRT *xprt)
+{
 	__xprt_do_unregister(xprt, FALSE);
+}
 /*
  * De-activate a transport handle.
  */
 static void
 __xprt_do_unregister(SVCXPRT *xprt, bool_t dolock)
+{
-	int sock;
+	int sock, *fdmax;
 	_DIAGASSERT(xprt != NULL);
 	sock = xprt->xp_fd;
 	if (dolock)
 		rwlock_wrlock(&svc_fd_lock);
 	if ((sock < FD_SETSIZE) && (__svc_xports[sock] == xprt)) {
-		__svc_xports[sock] = NULL;
+	sock = xprt->xp_fd;
-		FD_CLR(sock, get_fdset());
+	if (sock >= __svc_maxxports || __svc_xports[sock] != xprt)
-		if (sock >= *get_fdsetmax()) {
+		goto out;
 			for ((*get_fdsetmax())--; *get_fdsetmax() >= 0;
-			    (*get_fdsetmax())--)
+	__svc_xports[sock] = NULL;
-				if (__svc_xports[*get_fdsetmax()])
+	if (sock == -1)
-					break;
+		goto out;
 	fdmax = svc_fdset_getmax();
 	if (sock < *fdmax)
 		goto clr;
 	for ((*fdmax)--; *fdmax >= 0; (*fdmax)--)
 		if (__svc_xports[*fdmax])
 			break;
 clr:
 	svc_fdset_clr(sock);
 out:
 	if (dolock)
 		rwlock_unlock(&svc_fd_lock);
+}
 /*
  * Add a service program to the callout list.
  * The dispatch routine will be called when a rpc request for this
  * program number comes in.
  */
 bool_t
 svc_reg(SVCXPRT *xprt, const rpcprog_t prog, const rpcvers_t vers,
 	void (*dispatch)(struct svc_req *, SVCXPRT *),
 	const struct netconfig *nconf)
 @@ -590,53 +623,59 @@ svcerr_progvers(SVCXPRT *xprt, rpcvers_t
  * the "cooked" credentials (rqst->rq_clntcred).
  * However, this function does not know the structure of the cooked
  * credentials, so it make the following assumptions:
  *   a) the structure is contiguous (no pointers), and
  *   b) the cred structure size does not exceed RQCRED_SIZE bytes.
  * In all events, all three parameters are freed upon exit from this routine.
  * The storage is trivially management on the call stack in user land, but
  * is mallocated in kernel land.
  */
 void
 svc_getreq(int rdfds)
+{
-	fd_set readfds;
+	fd_set *readfds = svc_fdset_copy(NULL);
-	FD_ZERO(&readfds);
+	readfds->fds_bits[0] = (unsigned int)rdfds;
-	readfds.fds_bits[0] = (unsigned int)rdfds;
+	svc_getreqset(readfds);
-	svc_getreqset(&readfds);
+	free(readfds);
+}
 void
-svc_getreqset(fd_set *readfds)
+svc_getreqset2(fd_set *readfds, int maxsize)
+{
 	uint32_t mask, *maskp;
 	int sock, bit, fd;
 	_DIAGASSERT(readfds != NULL);
 	maskp = readfds->fds_bits;
-	for (sock = 0; sock < FD_SETSIZE; sock += NFDBITS) {
+	for (sock = 0; sock < maxsize; sock += NFDBITS) {
 	    for (mask = *maskp++; (bit = ffs((int)mask)) != 0;
 		mask ^= (1 << (bit - 1))) {
 		/* sock has input waiting */
 		fd = sock + bit - 1;
 		svc_getreq_common(fd);
+	    }
+	}
+}
 void
 svc_getreqset(fd_set *readfds)
+{
 	svc_getreqset2(readfds, FD_SETSIZE);
+}
 void
 svc_getreq_common(int fd)
+{
 	SVCXPRT *xprt;
 	struct svc_req r;
 	struct rpc_msg msg;
 	int prog_found;
 	rpcvers_t low_vers;
 	rpcvers_t high_vers;
 	enum xprt_stat stat;
 	char cred_area[2*MAX_AUTH_BYTES + RQCRED_SIZE];
 	msg.rm_call.cb_cred.oa_base = cred_area;
 	msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
 @@ -730,27 +769,27 @@ svc_getreq_poll(struct pollfd *pfdp, int
 			/*
 			 *	We assume that this function is only called
 			 *	via someone select()ing from svc_fdset or
 			 *	pollts()ing from svc_pollset[].  Thus it's safe
 			 *	to handle the POLLNVAL event by simply turning
 			 *	the corresponding bit off in svc_fdset.  The
 			 *	svc_pollset[] array is derived from svc_fdset
 			 *	and so will also be updated eventually.
+			 *
 			 *	XXX Should we do an xprt_unregister() instead?
 			 */
 			if (p->revents & POLLNVAL) {
 				rwlock_wrlock(&svc_fd_lock);
-				FD_CLR(p->fd, get_fdset());
+				svc_fdset_clr(p->fd);
 				rwlock_unlock(&svc_fd_lock);
 			} else
 				svc_getreq_common(p->fd);
+		}
+	}
+}
 bool_t
 rpc_control(int what, void *arg)
+{
 	int val;
 	switch (what) {

 @@ -1,63 +1,300 @@
-/*	$NetBSD: svc_fdset.c,v 1.1 2013/03/05 19:55:23 christos Exp $	*/
+/*	$NetBSD: svc_fdset.c,v 1.2 2015/11/06 19:34:13 christos Exp $	*/
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: svc_fdset.c,v 1.1 2013/03/05 19:55:23 christos Exp $");
+__RCSID("$NetBSD: svc_fdset.c,v 1.2 2015/11/06 19:34:13 christos Exp $");
 #include "reentrant.h"
 #include <sys/fd_set.h>
 #include <rpc/rpc.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/select.h>
-#include "svc_fdset.h"
+struct svc_fdset {
 	fd_set *fdset;
 	int	fdmax;
 	int	fdsize;
 };
 /* The single threaded, one global fd_set version */
 static fd_set *__svc_fdset;
 static int svc_fdsize = 0;
 /*
  * Update the old global svc_fdset if needed for binary compatibility
  */
 #define COMPAT_UPDATE(a)				\
 	do						\
 		if ((a) == __svc_fdset)			\
 			svc_fdset = *__svc_fdset;	\
 	while (/*CONSTCOND*/0)
 static thread_key_t fdsetkey = -2;
 #ifdef FDSET_DEBUG
 #include <stdio.h>
 #include <stdarg.h>
 #include <unistd.h>
 #include <lwp.h>
 static void  __printflike(3, 0)
 svc_header(const char *func, size_t line, const char *fmt, va_list ap)
+{
 	fprintf(stderr, "%s[%d.%d]: %s, %zu: ", getprogname(), (int)getpid(),
 	    (int)_lwp_self(), func, line);
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
+}
 static void __printflike(5, 6)
 svc_fdset_print(const char *func, size_t line, const fd_set *fds, int fdmax,
     const char *fmt, ...)
+{
 	va_list ap;
 	const char *did = "";
 	va_start(ap, fmt);
 	svc_header(func, line, fmt, ap);
 	va_end(ap);
 	if (fdmax == 0)
 		fdmax = FD_SETSIZE;
 	fprintf(stderr, "%p[%d] <", fds, fdmax);
 	for (int i = 0; i <= fdmax; i++) {
 		if (!FD_ISSET(i, fds))
 			continue;
 		fprintf(stderr, "%s%d", did, i);
 		did = ", ";
+	}
 	fprintf(stderr, ">\n");
+}
 static void __printflike(3, 4)
 svc_print(const char *func, size_t line, const char *fmt, ...)
+{
 	va_list ap;
 	va_start(ap, fmt);
 	svc_header(func, line, fmt, ap);
 	va_end(ap);
 	fprintf(stderr, "\n");
+}
 #define DPRINTF_FDSET(...)	svc_fdset_print(__func__, __LINE__, __VA_ARGS__)
 #define DPRINTF(...)		svc_print(__func__, __LINE__, __VA_ARGS__)
 #else
 #define DPRINTF_FDSET(...)
 #define DPRINTF(...)
 #endif
 static void
 svc_fdset_free(void *v)
+{
 	struct svc_fdset *rv = v;
 	DPRINTF_FDSET(rv->fdset, 0, "free");
 	free(rv->fdset);
 	free(rv);
+}
 static fd_set *
 svc_fdset_resize(int fd, fd_set **fdset, int *fdsize)
+{
 	if (*fdset && fd < *fdsize) {
 		DPRINTF_FDSET(*fdset, 0, "keeping %d < %d",
 		    fd, *fdsize);
 		return *fdset;
+	}
 	fd += FD_SETSIZE;
 	if (fd == 517)
 		abort();
 	char *newfdset = realloc(*fdset, __NFD_BYTES(fd));
 	if (newfdset == NULL)
 		return NULL;
 	memset(newfdset + __NFD_BYTES(*fdsize), 0,
 	    __NFD_BYTES(fd) - __NFD_BYTES(*fdsize));
 	*fdset = (void *)newfdset;
 	DPRINTF_FDSET(*fdset, 0, "resize %d > %d", fd, *fdsize);
 	*fdsize = fd;
 	COMPAT_UPDATE(*fdset);
 	return *fdset;
+}
 static struct svc_fdset *
 svc_fdset_alloc(int fd)
+{
 	struct svc_fdset *rv;
 	if (fdsetkey == -1)
 		thr_keycreate(&fdsetkey, svc_fdset_free);
 	if ((rv = thr_getspecific(fdsetkey)) == NULL) {
 		rv = calloc(1, sizeof(*rv));
 		if (rv == NULL)
 			return NULL;
 		(void)thr_setspecific(fdsetkey, rv);
 		if (svc_fdsize != 0) {
 			rv->fdset = __svc_fdset;
 			DPRINTF("switching to %p", rv->fdset);
 			rv->fdmax = svc_maxfd;
 			rv->fdsize = svc_fdsize;
 			svc_fdsize = 0;
 		} else {
 			DPRINTF("first thread time %p", rv->fdset);
+		}
 	} else {
 		DPRINTF("again for %p", rv->fdset);
 		if (fd < rv->fdsize)
 			return rv;
+	}
 	if (svc_fdset_resize(fd, &rv->fdset, &rv->fdsize) == NULL)
 		return NULL;
 	return rv;
+}
 static fd_set *
 svc_fdset_get_internal(int fd)
+{
 	struct svc_fdset *rv;
 	if (!__isthreaded || fdsetkey == -2)
 		return svc_fdset_resize(fd, &__svc_fdset, &svc_fdsize);
 	rv = svc_fdset_alloc(fd);
 	if (rv == NULL)
 		return NULL;
 	return rv->fdset;
+}
-static pthread_key_t fdsetkey;
+/* allow each thread to have their own copy */
-static pthread_key_t fdmaxkey;
+void
-static fd_set thefdset;
+svc_fdset_init(int flags)
 static int thefdmax;
 	DPRINTF("%x", flags);
 	if ((flags & SVC_FDSET_MT) && fdsetkey == -2)
 		fdsetkey = -1;
+}
 void
-init_fdsets(void)
+svc_fdset_zero(void)
+{
 	DPRINTF("zero");
 	fd_set *fds = svc_fdset_get_internal(0);
 	int size = svc_fdset_getsize(0);
 	memset(fds, 0, __NFD_BYTES(size));
 	*svc_fdset_getmax() = 0;
 	COMPAT_UPDATE(fds);
 	pthread_key_create(&fdsetkey, NULL);
 	pthread_key_create(&fdmaxkey, NULL);
+}
 void
-alloc_fdset(void)
+svc_fdset_set(int fd)
+{
-	fd_set *fdsetti;
+	fd_set *fds = svc_fdset_get_internal(fd);
-	int *fdmax;
+	int *fdmax = svc_fdset_getmax();
 	FD_SET(fd, fds);
 	if (fd > *fdmax)
 		*fdmax = fd;
 	DPRINTF_FDSET(fds, *fdmax, "%d", fd);
-	fdsetti = malloc(sizeof(*fdsetti));
+	COMPAT_UPDATE(fds);
 	memset(fdsetti, 0, sizeof(*fdsetti));
 	pthread_setspecific(fdsetkey, fdsetti);
 int
-	fdmax = malloc(sizeof(*fdmax));
+svc_fdset_isset(int fd)
 	memset(fdmax, 0, sizeof(*fdmax));
-	pthread_setspecific(fdmaxkey, fdmax);
+	fd_set *fds = svc_fdset_get_internal(fd);
 	DPRINTF_FDSET(fds, 0, "%d", fd);
 	return FD_ISSET(fd, fds);
+}
 void
 svc_fdset_clr(int fd)
+{
 	fd_set *fds = svc_fdset_get_internal(fd);
 	FD_CLR(fd, fds);
 	/* XXX: update fdmax? */
 	DPRINTF_FDSET(fds, 0, "%d", fd);
 	COMPAT_UPDATE(fds);
+}
 fd_set *
-get_fdset(void)
+svc_fdset_copy(const fd_set *orig)
+{
-	fd_set *rv;
+	int len, fdmax;
 	fd_set *fds;
 	len = 0;
 	fds = 0;
 	fdmax = *svc_fdset_getmax();
 	DPRINTF_FDSET(orig, 0, "[orig]");
 	fds = svc_fdset_resize(fdmax, &fds, &len);
 	if (fds == NULL)
 		return NULL;
 	if (orig)
 		memcpy(fds, orig, __NFD_BYTES(fdmax));
 	DPRINTF_FDSET(fds, 0, "[copy]");
 	return fds;
+}
-	rv = pthread_getspecific(fdsetkey);
+fd_set *
-	if (rv)
+svc_fdset_get(void)
 		return rv;
-	else
+	fd_set *fds = svc_fdset_get_internal(0);
-		return &thefdset;
+	DPRINTF_FDSET(fds, 0, "get");
 	return fds;
+}
 int *
-get_fdsetmax(void)
+svc_fdset_getmax(void)
+{
 	struct svc_fdset *rv;
 	if (!__isthreaded || fdsetkey == -2)
 		return &svc_maxfd;
 	rv = svc_fdset_alloc(0);
 	if (rv == NULL)
 		return NULL;
 	return &rv->fdmax;
+}
 int
 svc_fdset_getsize(int fd)
+{
-	int *rv;
+	struct svc_fdset *rv;
-	rv = pthread_getspecific(fdmaxkey);
+	if (!__isthreaded || fdsetkey == -2) {
-	if (rv)
+		if (svc_fdset_resize(fd, &__svc_fdset, &svc_fdsize) == NULL)
-		return rv;
+			return -1;
-	else
+		else
-		return &thefdmax;
+			return svc_fdsize;
+	}
 	rv = svc_fdset_alloc(fd);
 	if (rv == NULL)
 		return -1;
 	return rv->fdsize;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: svc_vc.c,v 1.30 2013/03/11 20:19:29 tron Exp $	*/
+/*	$NetBSD: svc_vc.c,v 1.31 2015/11/06 19:34:13 christos Exp $	*/
 /*
  * Copyright (c) 2010, Oracle America, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
+ *
  *     * Redistributions of source code must retain the above copyright
  *       notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  *       copyright notice, this list of conditions and the following
  *       disclaimer in the documentation and/or other materials
 @@ -27,27 +27,27 @@
  *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
 #if 0
 static char *sccsid = "@(#)svc_tcp.c 1.21 87/08/11 Copyr 1984 Sun Micro";
 static char *sccsid = "@(#)svc_tcp.c	2.2 88/08/01 4.0 RPCSRC";
 #else
-__RCSID("$NetBSD: svc_vc.c,v 1.30 2013/03/11 20:19:29 tron Exp $");
+__RCSID("$NetBSD: svc_vc.c,v 1.31 2015/11/06 19:34:13 christos Exp $");
 #endif
 #endif
 /*
  * svc_vc.c, Server side for Connection Oriented based RPC.
+ *
  * Actually implements two flavors of transporter -
  * a tcp rendezvouser (a listner and connection establisher)
  * and a record/tcp stream.
  */
 #include "namespace.h"
 #include "reentrant.h"
 @@ -302,45 +302,46 @@ out:
+}
 /*ARGSUSED*/
 static bool_t
 rendezvous_request(SVCXPRT *xprt, struct rpc_msg *msg)
+{
 	int sock, flags;
 	struct cf_rendezvous *r;
 	struct cf_conn *cd;
 	struct sockaddr_storage addr;
 	socklen_t len;
 	struct __rpc_sockinfo si;
 	SVCXPRT *newxprt;
 	fd_set cleanfds;
 	_DIAGASSERT(xprt != NULL);
 	_DIAGASSERT(msg != NULL);
 	r = (struct cf_rendezvous *)xprt->xp_p1;
 again:
 	len = sizeof addr;
 	if ((sock = accept(xprt->xp_fd, (struct sockaddr *)(void *)&addr,
 	    &len)) < 0) {
 		if (errno == EINTR)
 			goto again;
 		/*
 		 * Clean out the most idle file descriptor when we're
 		 * running out.
 		 */
 		if (errno == EMFILE || errno == ENFILE) {
-			cleanfds = *get_fdset();
+			fd_set *cleanfds = svc_fdset_copy(svc_fdset_get());
-			if (__svc_clean_idle(&cleanfds, 0, FALSE))
+			int rv = __svc_clean_idle(cleanfds, 0, FALSE);
 			free(cleanfds);
 			if (rv)
 				goto again;
+		}
 		return FALSE;
+	}
 	/*
 	 * make a new transporter (re-uses xprt)
 	 */
 	newxprt = makefd_xprt(sock, r->sendsize, r->recvsize);
 	if (newxprt == NULL)
 		goto out;
 	newxprt->xp_rtaddr.buf = mem_alloc(len);
 	if (newxprt->xp_rtaddr.buf == NULL)
 		goto out;
 @@ -750,54 +751,59 @@ svc_vc_rendezvous_ops(SVCXPRT *xprt)
 	xprt->xp_ops = &ops;
 	xprt->xp_ops2 = &ops2;
 	mutex_unlock(&ops_lock);
+}
 /*
  * Destroy xprts that have not have had any activity in 'timeout' seconds.
  * If 'cleanblock' is true, blocking connections (the default) are also
  * cleaned. If timeout is 0, the least active connection is picked.
  */
 bool_t
 __svc_clean_idle(fd_set *fds, int timeout, bool_t cleanblock)
+{
-	int i, ncleaned;
+	int i, ncleaned, fdmax;
 	SVCXPRT *xprt, *least_active;
 	struct timeval tv, tdiff, tmax;
 	struct cf_conn *cd;
 	gettimeofday(&tv, NULL);
 	tmax.tv_sec = tmax.tv_usec = 0;
 	least_active = NULL;
 	rwlock_wrlock(&svc_fd_lock);
-	for (i = ncleaned = 0; i <= svc_maxfd; i++) {
+	fdmax = *svc_fdset_getmax();
-		if (FD_ISSET(i, fds)) {
+	for (i = ncleaned = 0; i <= fdmax; i++) {
-			xprt = __svc_xports[i];
+		if (!svc_fdset_isset(i))
-			if (xprt == NULL || xprt->xp_ops == NULL ||
+			continue;
 			    xprt->xp_ops->xp_recv != svc_vc_recv)
-				continue;
+		xprt = __svc_xports[i];
-			cd = (struct cf_conn *)xprt->xp_p1;
+		if (xprt == NULL || xprt->xp_ops == NULL ||
-			if (!cleanblock && !cd->nonblock)
+		    xprt->xp_ops->xp_recv != svc_vc_recv)
-				continue;
+			continue;
 			if (timeout == 0) {
-				timersub(&tv, &cd->last_recv_time, &tdiff);
+		cd = (struct cf_conn *)xprt->xp_p1;
-				if (timercmp(&tdiff, &tmax, >)) {
+		if (!cleanblock && !cd->nonblock)
-					tmax = tdiff;
+			continue;
 					least_active = xprt;
 		if (timeout == 0) {
-				continue;
+			timersub(&tv, &cd->last_recv_time, &tdiff);
 			if (timercmp(&tdiff, &tmax, >)) {
-			if (tv.tv_sec - cd->last_recv_time.tv_sec > timeout) {
+				tmax = tdiff;
-				__xprt_unregister_unlocked(xprt);
+				least_active = xprt;
 				__svc_vc_dodestroy(xprt);
 				ncleaned++;
+			}
 			continue;
+		}
 		if (tv.tv_sec - cd->last_recv_time.tv_sec > timeout) {
 			__xprt_unregister_unlocked(xprt);
 			__svc_vc_dodestroy(xprt);
 			ncleaned++;
+		}
+	}
 	if (timeout == 0 && least_active != NULL) {
 		__xprt_unregister_unlocked(least_active);
 		__svc_vc_dodestroy(least_active);
 		ncleaned++;
+	}
 	rwlock_unlock(&svc_fd_lock);
 	return ncleaned > 0 ? TRUE : FALSE;
+}

 @@ -1,28 +1,28 @@
-#	$NetBSD: Makefile.inc,v 1.22 2015/04/15 19:13:47 mrg Exp $
+#	$NetBSD: Makefile.inc,v 1.23 2015/11/06 19:34:13 christos Exp $
 # librpc sources
 .PATH:	${.CURDIR}/rpc
 SRCS+=	auth_none.c auth_unix.c authunix_prot.c bindresvport.c \
 	clnt_bcast.c clnt_dg.c clnt_generic.c clnt_perror.c \
 	clnt_raw.c clnt_simple.c \
 	clnt_vc.c rpc_dtablesize.c \
 	getnetconfig.c getnetpath.c getrpcent.c getrpcport.c \
 	mt_misc.c pmap_clnt.c pmap_getmaps.c pmap_getport.c pmap_prot.c \
 	pmap_prot2.c pmap_rmt.c rpc_prot.c rpc_commondata.c rpc_callmsg.c \
 	rpc_generic.c rpc_soc.c rpcb_clnt.c rpcb_prot.c rpcb_st_xdr.c \
 	svc.c svc_auth.c svc_dg.c svc_auth_unix.c svc_generic.c svc_raw.c \
-	svc_run.c svc_simple.c svc_vc.c \
+	svc_run.c svc_simple.c svc_vc.c svc_fdset.c \
 	xdr.c xdr_array.c xdr_float.c xdr_mem.c xdr_rec.c xdr_reference.c \
 	xdr_stdio.c xdr_sizeof.c __rpc_getxid.c
 CPPFLAGS+=	-DPORTMAP
 MAN+=	bindresvport.3 getnetconfig.3 getnetpath.3 getrpcent.3 getrpcport.3 \
 	rpc.3 rpc_soc.3 rpc_clnt_auth.3 rpc_clnt_calls.3 rpc_clnt_create.3 \
 	rpc_svc_calls.3 rpc_svc_create.3 rpc_svc_err.3 rpc_svc_reg.3 \
 	rpc_xdr.3 rpcbind.3 xdr.3
 MLINKS+=	bindresvport.3 bindresvport_sa.3 \
 		getnetconfig.3 setnetconfig.3 \
 		getnetconfig.3 getnetconfigent.3 \
 		getnetconfig.3 endnetconfig.3 \

 @@ -1,30 +1,18 @@
-/*	$NetBSD: svc_fdset.h,v 1.1 2013/03/05 19:55:23 christos Exp $	*/
+/*	$NetBSD: svc_fdset.h,v 1.2 2015/11/06 19:34:13 christos Exp $	*/
 #ifndef _LIBC
 void init_fdsets(void);
 void alloc_fdset(void);
 fd_set *get_fdset(void);
 int *get_fdsetmax(void);
 # ifdef RUMP_RPC
 #  include <rump/rump.h>
 #  include <rump/rump_syscalls.h>
 #  undef	close
 #  define	close(a)		rump_sys_close(a)
 #  undef	fcntl
 #  define	fcntl(a, b, c)		rump_sys_fcntl(a, b, c)
 #  undef	read
 #  define	read(a, b, c)		rump_sys_read(a, b, c)
 #  undef	write
 #  define	write(a, b, c)		rump_sys_write(a, b, c)
 #  undef	pollts
 #  define	pollts(a, b, c, d)	rump_sys_pollts(a, b, c, d)
 #  undef	select
 #  define	select(a, b, c, d, e)	rump_sys_select(a, b, c, d, e)
 # endif
 #else
 # define	get_fdset()	(&svc_fdset)
 # define	get_fdsetmax()	(&svc_maxfd)
 #endif