 @@ -1,14 +1,14 @@
-/*      $NetBSD: rumpclient.c,v 1.4 2010/11/24 17:03:39 pooka Exp $	*/
+/*      $NetBSD: rumpclient.c,v 1.5 2010/11/25 17:59:03 pooka Exp $	*/
 /*
  * Copyright (c) 2010 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.
+ *
 @@ -22,27 +22,27 @@
  * 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.
  */
 /*
  * Client side routines for rump syscall proxy.
  */
 #include <sys/cdefs.h>
 __RCSID("$NetBSD");
-#include <sys/types.h>
+#include <sys/param.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <pthread.h>
 #include <stdarg.h>
 @@ -74,31 +74,35 @@ syscall_req(struct spclient *spc, int sy
 	rv = dosend(spc, &rhdr, sizeof(rhdr));
 	rv = dosend(spc, data, dlen);
 	if (rv) {
 		unputwait(spc, &rw);
 		return rv;
+	}
 	rv = waitresp(spc, &rw);
 	*resp = rw.rw_data;
 	return rv;
+}
 static int
-send_copyin_resp(struct spclient *spc, uint64_t reqno, void *data, size_t dlen)
+send_copyin_resp(struct spclient *spc, uint64_t reqno, void *data, size_t dlen,
 	int wantstr)
+{
 	struct rsp_hdr rhdr;
 	int rv;
 	if (wantstr)
 		dlen = MIN(dlen, strlen(data)+1);
 	rhdr.rsp_len = sizeof(rhdr) + dlen;
 	rhdr.rsp_reqno = reqno;
 	rhdr.rsp_class = RUMPSP_RESP;
 	rhdr.rsp_type = RUMPSP_COPYIN;
 	rhdr.rsp_sysnum = 0;
 	sendlock(spc);
 	rv = dosend(spc, &rhdr, sizeof(rhdr));
 	rv = dosend(spc, data, dlen);
 	sendunlock(spc);
 	return rv;
+}
 @@ -145,37 +149,41 @@ rumpclient_syscall(int sysnum, const voi
 	memcpy(retval, &resp->rsys_retval, sizeof(resp->rsys_retval));
 	rv = resp->rsys_error;
 	free(rdata);
 	return rv;
+}
 static void
 handlereq(struct spclient *spc)
+{
 	struct rsp_copydata *copydata;
 	void *mapaddr;
 	size_t maplen;
 	int reqtype = spc->spc_hdr.rsp_type;
-	switch (spc->spc_hdr.rsp_type) {
+	switch (reqtype) {
 	case RUMPSP_COPYIN:
 	case RUMPSP_COPYINSTR:
 		/*LINTED*/
 		copydata = (struct rsp_copydata *)spc->spc_buf;
 		DPRINTF(("rump_sp handlereq: copyin request: %p/%zu\n",
 		    copydata->rcp_addr, copydata->rcp_len));
 		send_copyin_resp(spc, spc->spc_hdr.rsp_reqno,
-		    copydata->rcp_addr, copydata->rcp_len);
+		    copydata->rcp_addr, copydata->rcp_len,
 		    reqtype == RUMPSP_COPYINSTR);
 		break;
 	case RUMPSP_COPYOUT:
 	case RUMPSP_COPYOUTSTR:
 		/*LINTED*/
 		copydata = (struct rsp_copydata *)spc->spc_buf;
 		DPRINTF(("rump_sp handlereq: copyout request: %p/%zu\n",
 		    copydata->rcp_addr, copydata->rcp_len));
 		/*LINTED*/
 		memcpy(copydata->rcp_addr, copydata->rcp_data,
 		    copydata->rcp_len);
 		break;
 	case RUMPSP_ANONMMAP:
 		/*LINTED*/
 		maplen = *(size_t *)spc->spc_buf;
 		mapaddr = mmap(NULL, maplen, PROT_READ|PROT_WRITE,
 		    MAP_ANON, -1, 0);

 @@ -1,14 +1,14 @@
-/*      $NetBSD: rumpuser_sp.c,v 1.14 2010/11/24 20:29:13 pooka Exp $	*/
+/*      $NetBSD: rumpuser_sp.c,v 1.15 2010/11/25 17:59:02 pooka Exp $	*/
 /*
  * Copyright (c) 2010 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.
+ *
 @@ -28,27 +28,27 @@
 /*
  * Sysproxy routines.  This provides system RPC support over host sockets.
  * The most notable limitation is that the client and server must share
  * the same ABI.  This does not mean that they have to be the same
  * machine or that they need to run the same version of the host OS,
  * just that they must agree on the data structures.  This even *might*
  * work correctly from one hardware architecture to another.
+ *
  * Not finished yet, i.e. don't use in production.  Lacks locking plus
  * handling of multiple clients and unexpected connection closes.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: rumpuser_sp.c,v 1.14 2010/11/24 20:29:13 pooka Exp $");
+__RCSID("$NetBSD: rumpuser_sp.c,v 1.15 2010/11/25 17:59:02 pooka Exp $");
 #include <sys/types.h>
 #include <sys/atomic.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 @@ -184,56 +184,63 @@ send_syscall_resp(struct spclient *spc,
 	sysresp.rsys_error = error;
 	memcpy(sysresp.rsys_retval, retval, sizeof(sysresp.rsys_retval));
 	sendlock(spc);
 	rv = dosend(spc, &rhdr, sizeof(rhdr));
 	rv = dosend(spc, &sysresp, sizeof(sysresp));
 	sendunlock(spc);
 	return rv;
+}
 static int
-copyin_req(struct spclient *spc, const void *remaddr, size_t dlen, void **resp)
+copyin_req(struct spclient *spc, const void *remaddr, size_t *dlen,
 	int wantstr, void **resp)
+{
 	struct rsp_hdr rhdr;
 	struct rsp_copydata copydata;
 	struct respwait rw;
 	int rv;
-	DPRINTF(("copyin_req: %zu bytes from %p\n", dlen, remaddr));
+	DPRINTF(("copyin_req: %zu bytes from %p\n", *dlen, remaddr));
 	rhdr.rsp_len = sizeof(rhdr) + sizeof(copydata);
 	rhdr.rsp_class = RUMPSP_REQ;
-	rhdr.rsp_type = RUMPSP_COPYIN;
+	if (wantstr)
 		rhdr.rsp_type = RUMPSP_COPYINSTR;
 	else
 		rhdr.rsp_type = RUMPSP_COPYIN;
 	rhdr.rsp_sysnum = 0;
 	copydata.rcp_addr = __UNCONST(remaddr);
-	copydata.rcp_len = dlen;
+	copydata.rcp_len = *dlen;
 	putwait(spc, &rw, &rhdr);
 	rv = dosend(spc, &rhdr, sizeof(rhdr));
 	rv = dosend(spc, &copydata, sizeof(copydata));
 	if (rv) {
 		unputwait(spc, &rw);
 		return rv;
+	}
 	rv = waitresp(spc, &rw);
 	DPRINTF(("copyin: response %d\n", rv));
 	*resp = rw.rw_data;
 	if (wantstr)
 		*dlen = rw.rw_dlen;
 	return rv;
+}
 static int
 send_copyout_req(struct spclient *spc, const void *remaddr,
 	const void *data, size_t dlen)
+{
 	struct rsp_hdr rhdr;
 	struct rsp_copydata copydata;
 	int rv;
 	DPRINTF(("copyout_req (async): %zu bytes to %p\n", dlen, remaddr));
 @@ -429,65 +436,93 @@ struct sysbouncearg {
 	uint8_t *sba_data;
 };
 static void *
 serv_syscallbouncer(void *arg)
+{
 	struct sysbouncearg *barg = arg;
 	serv_handlesyscall(barg->sba_spc, &barg->sba_hdr, barg->sba_data);
 	spcrelease(barg->sba_spc);
 	free(arg);
 	return NULL;
+}
-int
+static int
-rumpuser_sp_copyin(void *arg, const void *uaddr, void *kaddr, size_t len)
+sp_copyin(void *arg, const void *raddr, void *laddr, size_t *len, int wantstr)
+{
 	struct spclient *spc = arg;
 	void *rdata = NULL; /* XXXuninit */
 	int rv, nlocks;
 	rumpuser__kunlock(0, &nlocks, NULL);
-	rv = copyin_req(spc, uaddr, len, &rdata);
+	rv = copyin_req(spc, raddr, len, wantstr, &rdata);
 	if (rv)
 		goto out;
-	memcpy(kaddr, rdata, len);
+	memcpy(laddr, rdata, *len);
 	free(rdata);
  out:
 	rumpuser__klock(nlocks, NULL);
 	if (rv)
 		return EFAULT;
 	return 0;
+}
 int
-rumpuser_sp_copyout(void *arg, const void *kaddr, void *uaddr, size_t dlen)
+rumpuser_sp_copyin(void *arg, const void *raddr, void *laddr, size_t len)
+{
 	return sp_copyin(arg, raddr, laddr, &len, 0);
+}
 int
 rumpuser_sp_copyinstr(void *arg, const void *raddr, void *laddr, size_t *len)
+{
 	return sp_copyin(arg, raddr, laddr, len, 1);
+}
 static int
 sp_copyout(void *arg, const void *laddr, void *raddr, size_t dlen)
+{
 	struct spclient *spc = arg;
 	int nlocks, rv;
 	rumpuser__kunlock(0, &nlocks, NULL);
-	rv = send_copyout_req(spc, uaddr, kaddr, dlen);
+	rv = send_copyout_req(spc, raddr, laddr, dlen);
 	rumpuser__klock(nlocks, NULL);
 	if (rv)
 		return EFAULT;
 	return 0;
+}
 int
 rumpuser_sp_copyout(void *arg, const void *laddr, void *raddr, size_t dlen)
+{
 	return sp_copyout(arg, laddr, raddr, dlen);
+}
 int
 rumpuser_sp_copyoutstr(void *arg, const void *laddr, void *raddr, size_t *dlen)
+{
 	return sp_copyout(arg, laddr, raddr, *dlen);
+}
 int
 rumpuser_sp_anonmmap(void *arg, size_t howmuch, void **addr)
+{
 	struct spclient *spc = arg;
 	void *resp, *rdata;
 	int nlocks, rv;
 	rumpuser__kunlock(0, &nlocks, NULL);
 	rv = anonmmap_req(spc, howmuch, &rdata);
 	if (rv) {
 		rv = EFAULT;
 		goto out;
+	}

 @@ -1,14 +1,14 @@
-/*      $NetBSD: sp_common.c,v 1.9 2010/11/24 17:20:24 pooka Exp $	*/
+/*      $NetBSD: sp_common.c,v 1.10 2010/11/25 17:59:02 pooka Exp $	*/
 /*
  * Copyright (c) 2010 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.
+ *
 @@ -63,27 +63,30 @@ mydprintf(const char *fmt, ...)
 	va_start(ap, fmt);
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
+}
 #else
 #define DPRINTF(x)
 #endif
 /*
  * Bah, I hate writing on-off-wire conversions in C
  */
 enum { RUMPSP_REQ, RUMPSP_RESP };
-enum { RUMPSP_SYSCALL, RUMPSP_COPYIN, RUMPSP_COPYOUT, RUMPSP_ANONMMAP };
+enum {	RUMPSP_SYSCALL,
 	RUMPSP_COPYIN, RUMPSP_COPYINSTR,
 	RUMPSP_COPYOUT, RUMPSP_COPYOUTSTR,
 	RUMPSP_ANONMMAP };
 struct rsp_hdr {
 	uint64_t rsp_len;
 	uint64_t rsp_reqno;
 	uint16_t rsp_class;
 	uint16_t rsp_type;
 	/*
 	 * We want this structure 64bit-aligned for typecast fun,
 	 * so might as well use the following for something.
 	 */
 	uint32_t rsp_sysnum;
 };
 #define HDRSZ sizeof(struct rsp_hdr)
 @@ -186,28 +189,30 @@ dosend(struct spclient *spc, const void
 	for (sent = 0, n = 0; sent < dlen; ) {
 		if (n) {
 			if (poll(&pfd, 1, INFTIM) == -1) {
 				if (errno == EINTR)
 					continue;
 				return errno;
+			}
+		}
 		n = send(fd, sdata + sent, dlen - sent, MSG_NOSIGNAL);
 		if (n == 0) {
 			return EFAULT;
+		}
-		if (n == -1 && errno != EAGAIN) {
+		if (n == -1)  {
-			return EFAULT;
+			if (errno != EAGAIN)
 				return EFAULT;
 			continue;
+		}
 		sent += n;
+	}
 	return 0;
+}
 static void
 putwait(struct spclient *spc, struct respwait *rw, struct rsp_hdr *rhdr)
+{
 	rw->rw_data = NULL;
 	rw->rw_dlen = 0;
 @@ -232,27 +237,29 @@ kickwaiter(struct spclient *spc)
+{
 	struct respwait *rw;
 	pthread_mutex_lock(&spc->spc_mtx);
 	TAILQ_FOREACH(rw, &spc->spc_respwait, rw_entries) {
 		if (rw->rw_reqno == spc->spc_hdr.rsp_reqno)
 			break;
+	}
 	if (rw == NULL) {
 		printf("PANIC: no waiter\n");
 		abort();
 		return;
+	}
 	DPRINTF(("rump_sp: client %p woke up waiter at %p\n", spc, rw));
 	rw->rw_data = spc->spc_buf;
 	rw->rw_dlen = (size_t)spc->spc_off;
 	pthread_cond_signal(&rw->rw_cv);
 	pthread_mutex_unlock(&spc->spc_mtx);
 	spc->spc_buf = NULL;
 	spc->spc_off = 0;
+}
 static void
 kickall(struct spclient *spc)
+{
 	struct respwait *rw;
 	/* DIAGASSERT(mutex_owned(spc_lock)) */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rumpuser.h,v 1.52 2010/11/22 20:42:19 pooka Exp $	*/
+/*	$NetBSD: rumpuser.h,v 1.53 2010/11/25 17:59:02 pooka Exp $	*/
 /*
  * Copyright (c) 2007 Antti Kantee.  All Rights Reserved.
+ *
  * Development of this software was supported by Google Summer of Code.
+ *
  * 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
 @@ -26,27 +26,27 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef _RUMP_RUMPUSER_H_
 #define _RUMP_RUMPUSER_H_
 #ifdef _KERNEL
 #include <sys/stdint.h>
 #else
 #include <stdint.h>
 #endif
-#define RUMPUSER_VERSION 5
+#define RUMPUSER_VERSION 6
 int rumpuser_getversion(void);
 struct msghdr;
 struct pollfd;
 struct sockaddr;
 typedef void (*kernel_lockfn)(int, void *);
 typedef void (*kernel_unlockfn)(int, int *, void *);
 int rumpuser_getfileinfo(const char *, uint64_t *, int *, int *);
 #define RUMPUSER_FT_OTHER 0
 #define RUMPUSER_FT_DIR 1
 #define RUMPUSER_FT_REG 2
 @@ -209,17 +209,19 @@ struct rumpuser_sp_ops {
 	void (*spop_unschedule)(void);
 	void (*spop_lwproc_switch)(struct lwp *);
 	void (*spop_lwproc_release)(void);
 	int (*spop_lwproc_newproc)(void *);
 	int (*spop_lwproc_newlwp)(pid_t);
 	struct lwp * (*spop_lwproc_curlwp)(void);
 	int (*spop_syscall)(int, void *, register_t *);
 	pid_t (*spop_getpid)(void);
 };
 int	rumpuser_sp_init(const struct rumpuser_sp_ops *, const char *);
 int	rumpuser_sp_copyin(void *, const void *, void *, size_t);
 int	rumpuser_sp_copyinstr(void *, const void *, void *, size_t *);
 int	rumpuser_sp_copyout(void *, const void *, void *, size_t);
 int	rumpuser_sp_copyoutstr(void *, const void *, void *, size_t *);
 int	rumpuser_sp_anonmmap(void *, size_t, void **);
 #endif /* _RUMP_RUMPUSER_H_ */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rumpcopy.c,v 1.12 2010/11/22 21:46:04 pooka Exp $	*/
+/*	$NetBSD: rumpcopy.c,v 1.13 2010/11/25 17:59:03 pooka Exp $	*/
 /*
  * Copyright (c) 2009 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,27 +16,27 @@
  * 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>
-__KERNEL_RCSID(0, "$NetBSD: rumpcopy.c,v 1.12 2010/11/22 21:46:04 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rumpcopy.c,v 1.13 2010/11/25 17:59:03 pooka Exp $");
 #include <sys/param.h>
 #include <sys/lwp.h>
 #include <sys/systm.h>
 #include <sys/uio.h>
 #include <rump/rumpuser.h>
 #include "rump_private.h"
 int
 copyin(const void *uaddr, void *kaddr, size_t len)
+{
 @@ -108,28 +108,28 @@ copystr(const void *kfaddr, void *kdaddr
 int
 copyinstr(const void *uaddr, void *kaddr, size_t len, size_t *done)
+{
 	uint8_t *to;
 	int rv;
 	if (len == 0)
 		return 0;
 	if (curproc->p_vmspace == vmspace_kernel())
 		return copystr(uaddr, kaddr, len, done);
-	if ((rv = rumpuser_sp_copyin(curproc->p_vmspace->vm_map.pmap,
+	if ((rv = rumpuser_sp_copyinstr(curproc->p_vmspace->vm_map.pmap,
-	    uaddr, kaddr, len)) != 0)
+	    uaddr, kaddr, &len)) != 0)
 		return rv;
 	/* figure out if we got a terminated string or not */
 	to = (uint8_t *)kaddr + (len-1);
 	while (to != kaddr) {
 		if (*to == 0)
 			goto found;
 		to--;
+	}
 	return ENAMETOOLONG;
  found:
 	if (done)
 @@ -141,28 +141,28 @@ copyinstr(const void *uaddr, void *kaddr
 int
 copyoutstr(const void *kaddr, void *uaddr, size_t len, size_t *done)
+{
 	size_t slen;
 	int error;
 	if (curproc->p_vmspace == vmspace_kernel())
 		return copystr(kaddr, uaddr, len, done);
 	slen = strlen(kaddr)+1;
 	if (slen > len)
 		return ENAMETOOLONG;
-	error = rumpuser_sp_copyout(curproc->p_vmspace->vm_map.pmap,
+	error = rumpuser_sp_copyoutstr(curproc->p_vmspace->vm_map.pmap,
-	    kaddr, uaddr, slen);
+	    kaddr, uaddr, &slen);
 	if (done)
 		*done = slen;
 	return error;
+}
 int
 kcopy(const void *src, void *dst, size_t len)
+{
 	memcpy(dst, src, len);
 	return 0;
+}