 @@ -1,14 +1,14 @@
-/*      $NetBSD: hijack.c,v 1.2 2011/01/08 14:19:27 pooka Exp $	*/
+/*      $NetBSD: hijack.c,v 1.3 2011/01/08 18:11:46 pooka Exp $	*/
 /*-
  * Copyright (c) 2011 Antti Kantee.  All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. 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 provided with the distribution.
+ *
 @@ -16,107 +16,105 @@
  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 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>
-__RCSID("$NetBSD: hijack.c,v 1.2 2011/01/08 14:19:27 pooka Exp $");
+__RCSID("$NetBSD: hijack.c,v 1.3 2011/01/08 18:11:46 pooka Exp $");
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/poll.h>
 #include <rump/rump.h>
 #include <rump/rumpclient.h>
 #include <rump/rump_syscalls.h>
 #include <assert.h>
 #include <dlfcn.h>
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <pthread.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <unistd.h>
 enum {	RUMPCALL_SOCKET, RUMPCALL_ACCEPT, RUMPCALL_BIND, RUMPCALL_CONNECT,
 	RUMPCALL_GETPEERNAME, RUMPCALL_GETSOCKNAME, RUMPCALL_LISTEN,
 	RUMPCALL_RECVFROM, RUMPCALL_RECVMSG,
 	RUMPCALL_SENDTO, RUMPCALL_SENDMSG,
 	RUMPCALL_GETSOCKOPT, RUMPCALL_SETSOCKOPT,
 	RUMPCALL_SHUTDOWN,
 	RUMPCALL_READ, RUMPCALL_READV,
 	RUMPCALL_WRITE, RUMPCALL_WRITEV,
 	RUMPCALL_IOCTL, RUMPCALL_FCNTL,
 	RUMPCALL_CLOSE,
-	RUMPCALL_SELECT, RUMPCALL_POLL, RUMPCALL_POLLTS,
+	RUMPCALL_SELECT, RUMPCALL_POLLTS,
 	RUMPCALL__NUM
 };
 const char *sysnames[] = {
 	"__socket30",
 	"accept",
 	"bind",
 	"connect",
 	"getpeername",
 	"getsockname",
 	"listen",
 	"recvfrom",
 	"recvmsg",
 	"sendto",
 	"sendmsg",
 	"getsockopt",
 	"setsockopt",
 	"shutdown",
 	"read",
 	"readv",
 	"write",
 	"writev",
 	"ioctl",
 	"fcntl",
 	"close",
 	"__select50",
 	"poll",
 	"__pollts50",
 };
 static ssize_t	(*host_read)(int, void *, size_t);
 static ssize_t	(*host_readv)(int, const struct iovec *, int);
 static ssize_t	(*host_write)(int, const void *, size_t);
 static ssize_t	(*host_writev)(int, const struct iovec *, int);
 static int	(*host_ioctl)(int, unsigned long, ...);
 static int	(*host_fcntl)(int, int, ...);
 static int	(*host_close)(int);
 static int	(*host_select)(int, fd_set *, fd_set *, fd_set *,
 			       struct timeval *);
 static int	(*host_poll)(struct pollfd *, nfds_t, int);
 static pid_t	(*host_fork)(void);
 static int	(*host_dup2)(int, int);
 #if 0
 static int	(*host_pollts)(struct pollfd *, nfds_t,
 			       const struct timespec *, const sigset_t *);
-#endif
+static pid_t	(*host_fork)(void);
 static int	(*host_dup2)(int, int);
 static void *rumpcalls[RUMPCALL__NUM];
 /*
  * This is called from librumpclient in case of LD_PRELOAD.
  * It ensures correct RTLD_NEXT.
  */
 static void *
 hijackdlsym(void *handle, const char *symbol)
+{
 	return dlsym(handle, symbol);
+}
 @@ -136,37 +134,37 @@ rcinit(void)
 	_DIAGASSERT(rumpcinit);
 	rumpcdlsym = dlsym(hand, "rumpclient_dlsym");
 	*rumpcdlsym = hijackdlsym;
 	host_read = dlsym(RTLD_NEXT, "read");
 	host_readv = dlsym(RTLD_NEXT, "readv");
 	host_write = dlsym(RTLD_NEXT, "write");
 	host_writev = dlsym(RTLD_NEXT, "writev");
 	host_ioctl = dlsym(RTLD_NEXT, "ioctl");
 	host_fcntl = dlsym(RTLD_NEXT, "fcntl");
 	host_close = dlsym(RTLD_NEXT, "close");
 	host_select = dlsym(RTLD_NEXT, "select");
-	host_poll = dlsym(RTLD_NEXT, "poll");
+	host_pollts = dlsym(RTLD_NEXT, "pollts");
 	host_fork = dlsym(RTLD_NEXT, "fork");
 	host_dup2 = dlsym(RTLD_NEXT, "dup2");
 	for (i = 0; i < RUMPCALL__NUM; i++) {
 		char sysname[128];
 		snprintf(sysname, sizeof(sysname), "rump_sys_%s", sysnames[i]);
 		rumpcalls[i] = dlsym(hand, sysname);
 		if (!rumpcalls[i]) {
-			fprintf(stderr, "%s\n", sysname);
+			fprintf(stderr, "cannot find symbol: %s\n", sysname);
 			exit(1);
+		}
+	}
 	if (rumpcinit() == -1)
 		err(1, "rumpclient init");
+}
 //#define DEBUGJACK
 #ifdef DEBUGJACK
 #define DPRINTF(x) printf x
 #else
 #define DPRINTF(x)
 @@ -677,61 +675,79 @@ checkpoll(struct pollfd *fds, nfds_t nfd
+	}
+}
 static void
 adjustpoll(struct pollfd *fds, nfds_t nfds, int (*fdadj)(int))
+{
 	nfds_t i;
 	for (i = 0; i < nfds; i++) {
 		fds[i].fd = fdadj(fds[i].fd);
+	}
+}
 struct mytimespec {
 	uint64_t tv_sec;
 	long tv_nsec;
 };
 /*
  * poll is easy as long as the call comes in the fds only in one
  * kernel.  otherwise its quite tricky...
  */
 struct pollarg {
 	struct pollfd *pfds;
 	nfds_t nfds;
-	int timeout;
+	const struct timespec *ts;
 	const sigset_t *sigmask;
 	int pipefd;
 	int errnum;
 };
 static void *
 hostpoll(void *arg)
+{
 	struct pollarg *parg = arg;
 	intptr_t rv;
-	rv = poll(parg->pfds, parg->nfds, parg->timeout);
+	rv = host_pollts(parg->pfds, parg->nfds, parg->ts, parg->sigmask);
 	if (rv == -1)
 		parg->errnum = errno;
 	rump_sys_write(parg->pipefd, &rv, sizeof(rv));
 	return (void *)(intptr_t)rv;
+}
 int
-poll(struct pollfd *fds, nfds_t nfds, int timeout)
+pollts(struct pollfd *fds, nfds_t nfds, const struct timespec *ts,
 	const sigset_t *sigmask)
+{
-	int (*op_poll)(struct pollfd *, nfds_t, int);
+	int (*op_pollts)(struct pollfd *, nfds_t, const struct timespec *,
 			 const sigset_t *);
 	int hostcall = 0, rumpcall = 0;
 	pthread_t pt;
 	nfds_t i;
 	int rv;
 #if 0
 	/* XXX: quick 5.0 kludge.  do syscall compat in rumpclient properly */
 	struct mytimespec mts;
 	if (ts) {
 		mts.tv_sec = ts->tv_sec;
 		mts.tv_nsec = ts->tv_nsec;
 		ts = (struct timespec *)&mts;
+	}
 #endif
 	DPRINTF(("poll\n"));
 	checkpoll(fds, nfds, &hostcall, &rumpcall);
 	if (hostcall && rumpcall) {
 		struct pollfd *pfd_host = NULL, *pfd_rump = NULL;
 		int rpipe[2] = {-1,-1}, hpipe[2] = {-1,-1};
 		struct pollarg parg;
 		uintptr_t lrv;
 		int sverrno = 0, trv;
 		/*
 		 * ok, this is where it gets tricky.  We must support
 		 * this since it's a very common operation in certain
 @@ -743,27 +759,30 @@ poll(struct pollfd *fds, nfds_t nfds, in
 		rv = -1;
 		/* allocate full vector for O(n) joining after call */
 		pfd_host = malloc(sizeof(*pfd_host)*(nfds+1));
 		if (!pfd_host)
 			goto out;
 		pfd_rump = malloc(sizeof(*pfd_rump)*(nfds+1));
 		if (!pfd_rump) {
 			goto out;
+		}
 		/* split vectors */
 		for (i = 0; i < nfds; i++) {
-			if (fd_isrump(fds[i].fd)) {
+			if (fds[i].fd == -1) {
 				pfd_host[i].fd = -1;
 				pfd_rump[i].fd = -1;
 			} else if (fd_isrump(fds[i].fd)) {
 				pfd_host[i].fd = -1;
 				pfd_rump[i].fd = fd_host2rump(fds[i].fd);
 				pfd_rump[i].events = fds[i].events;
 			} else {
 				pfd_rump[i].fd = -1;
 				pfd_host[i].fd = fds[i].fd;
 				pfd_host[i].events = fds[i].events;
+			}
+		}
 		/*
 		 * then, open two pipes, one for notifications
 		 * to each kernel.
 @@ -775,78 +794,87 @@ poll(struct pollfd *fds, nfds_t nfds, in
 		pfd_host[nfds].fd = hpipe[0];
 		pfd_host[nfds].events = POLLIN;
 		pfd_rump[nfds].fd = rpipe[0];
 		pfd_rump[nfds].events = POLLIN;
 		/*
 		 * then, create a thread to do host part and meanwhile
 		 * do rump kernel part right here
 		 */
 		parg.pfds = pfd_host;
 		parg.nfds = nfds+1;
-		parg.timeout = timeout;
+		parg.ts = ts;
 		parg.sigmask = sigmask;
 		parg.pipefd = rpipe[1];
 		pthread_create(&pt, NULL, hostpoll, &parg);
-		lrv = rump_sys_poll(pfd_rump, nfds+1, timeout);
+		op_pollts = rumpcalls[RUMPCALL_POLLTS];
 		lrv = op_pollts(pfd_rump, nfds+1, ts, NULL);
 		sverrno = errno;
 		write(hpipe[1], &rv, sizeof(rv));
 		pthread_join(pt, (void *)&trv);
 		/* check who "won" and merge results */
 		if (lrv != 0 && pfd_host[nfds].revents & POLLIN) {
 			rv = trv;
 			for (i = 0; i < nfds; i++) {
 				if (pfd_rump[i].fd != -1)
 					fds[i].revents = pfd_rump[i].revents;
+			}
 			sverrno = parg.errnum;
 		} else if (trv != 0 && pfd_rump[nfds].revents & POLLIN) {
 			rv = trv;
 			for (i = 0; i < nfds; i++) {
 				if (pfd_host[i].fd != -1)
 					fds[i].revents = pfd_host[i].revents;
+			}
 		} else {
 			rv = 0;
 			assert(timeout != -1);
+		}
  out:
 		if (rpipe[0] != -1)
 			rump_sys_close(rpipe[0]);
 		if (rpipe[1] != -1)
 			rump_sys_close(rpipe[1]);
 		if (hpipe[0] != -1)
 			close(hpipe[0]);
 		if (hpipe[1] != -1)
 			close(hpipe[1]);
 		free(pfd_host);
 		free(pfd_rump);
 		errno = sverrno;
 	} else {
 		if (hostcall) {
-			op_poll = host_poll;
+			op_pollts = host_pollts;
 		} else {
-			op_poll = rumpcalls[RUMPCALL_POLL];
+			op_pollts = rumpcalls[RUMPCALL_POLLTS];
 			adjustpoll(fds, nfds, fd_host2rump);
+		}
-		rv = op_poll(fds, nfds, timeout);
+		rv = op_pollts(fds, nfds, ts, sigmask);
 		if (rumpcall)
 			adjustpoll(fds, nfds, fd_rump2host);
+	}
 	return rv;
+}
 int
-pollts(struct pollfd *fds, nfds_t nfds, const struct timespec *ts,
+poll(struct pollfd *fds, nfds_t nfds, int timeout)
 	const sigset_t *sigmask)
+{
 	struct timespec ts;
 	struct timespec *tsp = NULL;
 	if (timeout != INFTIM) {
 		ts.tv_sec = timeout / 1000;
 		ts.tv_nsec = (timeout % 1000) * 1000;
 		tsp = &ts;
+	}
-	abort();
+	return pollts(fds, nfds, tsp, NULL);
+}