 @@ -1,172 +1,177 @@
-/*	$NetBSD: rumpuser.h,v 1.19 2009/02/28 15:49:12 pooka Exp $	*/
+/*	$NetBSD: rumpuser.h,v 1.20 2009/03/18 15:32:27 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
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  * 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.
  */
 #ifndef _RUMP_RUMPUSER_H_
 #define _RUMP_RUMPUSER_H_
 #include <sys/stdint.h>
 struct msghdr;
 struct pollfd;
 struct sockaddr;
 typedef void (*kernel_lockfn)(int);
 typedef void (*kernel_unlockfn)(int, int *);
 int rumpuser_getfileinfo(const char *, uint64_t *, int *, int *);
 #define RUMPUSER_FT_DIR 1
 #define RUMPUSER_FT_REG 2
 #define RUMPUSER_FT_BLK 3
 #define RUMPUSER_FT_OTHER 4
 int rumpuser_nanosleep(uint64_t *, uint64_t *, int *);
 #define rumpuser_malloc(a,b) rumpuser__malloc(a,b,__func__,__LINE__);
 #define rumpuser_realloc(a,b,c) rumpuser__realloc(a,b,c,__func__,__LINE__);
 void *rumpuser__malloc(size_t, int, const char *, int);
 void *rumpuser__realloc(void *, size_t, int, const char *, int);
 void rumpuser_free(void *);
 void *rumpuser_anonmmap(size_t, int, int, int *);
-void *rumpuser_filemmap(int fd, off_t, size_t, int, int, int *);
+#define RUMPUSER_FILEMMAP_READ		0x01
 #define RUMPUSER_FILEMMAP_WRITE		0x02
 #define RUMPUSER_FILEMMAP_TRUNCATE	0x04
 #define RUMPUSER_FILEMMAP_SHARED	0x08
 void *rumpuser_filemmap(int fd, off_t, size_t, int, int *);
 void  rumpuser_unmap(void *, size_t);
 int   rumpuser_memsync(void *, size_t, int *);
 int rumpuser_open(const char *, int, int *);
 int rumpuser_ioctl(int, u_long, void *, int *);
 int rumpuser_close(int, int *);
 int rumpuser_fsync(int, int *);
 typedef void (*rump_biodone_fn)(void *, size_t, int);
 ssize_t rumpuser_read(int, void *, size_t, int *);
 ssize_t rumpuser_pread(int, void *, size_t, off_t, int *);
 ssize_t rumpuser_write(int, const void *, size_t, int *);
 ssize_t rumpuser_pwrite(int, const void *, size_t, off_t, int *);
 void rumpuser_read_bio(int, void *, size_t, off_t, rump_biodone_fn, void *);
 void rumpuser_write_bio(int, const void *, size_t, off_t,rump_biodone_fn,void*);
 struct rumpuser_iovec {
 	void *iov_base;
 	uint64_t iov_len;
 };
 ssize_t rumpuser_readv(int, const struct rumpuser_iovec *, int, int *);
 ssize_t rumpuser_writev(int, const struct rumpuser_iovec *, int, int *);
 int rumpuser_gettime(uint64_t *, uint64_t *, int *);
 int rumpuser_getenv(const char *, char *, size_t, int *);
 int rumpuser_gethostname(char *, size_t, int *);
 char *rumpuser_realpath(const char *, char *, int *);
 int rumpuser_poll(struct pollfd *, int, int, int *);
 int rumpuser_putchar(int, int *);
 void rumpuser_panic(void);
 void rumpuser_seterrno(int);
 int rumpuser_writewatchfile_setup(int, int, intptr_t, int *);
 int rumpuser_writewatchfile_wait(int, intptr_t *, int *);
 /* rumpuser_pth */
 void rumpuser_thrinit(kernel_lockfn, kernel_unlockfn, int);
 int  rumpuser_bioinit(rump_biodone_fn);
 int  rumpuser_thread_create(void *(*f)(void *), void *, const char *);
 void rumpuser_thread_exit(void);
 struct rumpuser_mtx;
 void rumpuser_mutex_init(struct rumpuser_mtx **);
 void rumpuser_mutex_recursive_init(struct rumpuser_mtx **);
 void rumpuser_mutex_enter(struct rumpuser_mtx *);
 int  rumpuser_mutex_tryenter(struct rumpuser_mtx *);
 void rumpuser_mutex_exit(struct rumpuser_mtx *);
 void rumpuser_mutex_destroy(struct rumpuser_mtx *);
 int  rumpuser_mutex_held(struct rumpuser_mtx *);
 struct rumpuser_rw;
 void rumpuser_rw_init(struct rumpuser_rw **);
 void rumpuser_rw_enter(struct rumpuser_rw *, int);
 int  rumpuser_rw_tryenter(struct rumpuser_rw *, int);
 void rumpuser_rw_exit(struct rumpuser_rw *);
 void rumpuser_rw_destroy(struct rumpuser_rw *);
 int  rumpuser_rw_held(struct rumpuser_rw *);
 int  rumpuser_rw_rdheld(struct rumpuser_rw *);
 int  rumpuser_rw_wrheld(struct rumpuser_rw *);
 struct rumpuser_cv;
 void rumpuser_cv_init(struct rumpuser_cv **);
 void rumpuser_cv_destroy(struct rumpuser_cv *);
 void rumpuser_cv_wait(struct rumpuser_cv *, struct rumpuser_mtx *);
 int  rumpuser_cv_timedwait(struct rumpuser_cv *, struct rumpuser_mtx *,
 			   struct timespec *);
 void rumpuser_cv_signal(struct rumpuser_cv *);
 void rumpuser_cv_broadcast(struct rumpuser_cv *);
 int  rumpuser_cv_has_waiters(struct rumpuser_cv *);
 struct lwp;
 void rumpuser_set_curlwp(struct lwp *);
 struct lwp *rumpuser_get_curlwp(void);
 /* "aio" stuff for being able to fire of a B_ASYNC I/O and continue */
 struct rumpuser_aio {
 	int	rua_fd;
 	uint8_t	*rua_data;
 	size_t	rua_dlen;
 	off_t	rua_off;
 	void	*rua_bp;
 	int	rua_op;
 };
 #define N_AIOS 128
 extern struct rumpuser_mtx rumpuser_aio_mtx;
 extern struct rumpuser_cv rumpuser_aio_cv;
 extern struct rumpuser_aio rumpuser_aios[N_AIOS];
 extern int rumpuser_aio_head, rumpuser_aio_tail;
 /* rumpuser_net */
 int  rumpuser_net_socket(int, int, int, int *);
 int  rumpuser_net_sendmsg(int, const struct msghdr *, int, int *);
 int  rumpuser_net_recvmsg(int, struct msghdr *, int, int *);
 int  rumpuser_net_connect(int, const struct sockaddr *, int, int *);
 int  rumpuser_net_bind(int, const struct sockaddr *, int, int *);
 int  rumpuser_net_accept(int, struct sockaddr *, int *, int *);
 int  rumpuser_net_listen(int, int, int *);
 enum rumpuser_getnametype { RUMPUSER_SOCKNAME, RUMPUSER_PEERNAME };
 int  rumpuser_net_getname(int, struct sockaddr *, int *,
 			      enum rumpuser_getnametype, int *);
 #endif /* _RUMP_RUMPUSER_H_ */

 @@ -1,484 +1,496 @@
-/*	$NetBSD: rumpuser.c,v 1.36 2009/03/18 10:22:45 cegger Exp $	*/
+/*	$NetBSD: rumpuser.c,v 1.37 2009/03/18 15:32:27 pooka Exp $	*/
 /*
  * Copyright (c) 2007 Antti Kantee.  All Rights Reserved.
+ *
  * Development of this software was supported by Google Summer of Code
  * and the Finnish Cultural Foundation.
+ *
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  * 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>
 #if !defined(lint)
-__RCSID("$NetBSD: rumpuser.c,v 1.36 2009/03/18 10:22:45 cegger Exp $");
+__RCSID("$NetBSD: rumpuser.c,v 1.37 2009/03/18 15:32:27 pooka Exp $");
 #endif /* !lint */
 /* thank the maker for this */
 #ifdef __linux__
 #define _XOPEN_SOURCE 500
 #define _BSD_SOURCE
 #define _FILE_OFFSET_BITS 64
 #include <features.h>
 #endif
 #include <sys/param.h>
 #include <sys/event.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <sys/uio.h>
 #include <assert.h>
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 #include <rump/rumpuser.h>
 #include "rumpuser_int.h"
 int
 rumpuser_getfileinfo(const char *path, uint64_t *size, int *ft, int *error)
+{
 	struct stat sb;
 	int rv;
 	rv = stat(path, &sb);
 	if (rv == -1) {
 		*error = errno;
 		return rv;
+	}
 	*size = sb.st_size;
 	switch (sb.st_mode & S_IFMT) {
 	case S_IFDIR:
 		*ft = RUMPUSER_FT_DIR;
 		break;
 	case S_IFREG:
 		*ft = RUMPUSER_FT_REG;
 		break;
 	case S_IFBLK:
 		*ft = RUMPUSER_FT_BLK;
 		break;
 	default:
 		*ft = RUMPUSER_FT_OTHER;
 		break;
+	}
 	return rv;
+}
 int
 rumpuser_nanosleep(uint64_t *sec, uint64_t *nsec, int *error)
+{
 	struct timespec rqt, rmt;
 	int rv;
 	/*LINTED*/
 	rqt.tv_sec = *sec;
 	/*LINTED*/
 	rqt.tv_nsec = *nsec;
 	KLOCK_WRAP(rv = nanosleep(&rqt, &rmt));
 	if (rv == -1)
 		*error = errno;
 	*sec = rmt.tv_sec;
 	*nsec = rmt.tv_nsec;
 	return rv;
+}
 void *
 rumpuser__malloc(size_t howmuch, int canfail, const char *func, int line)
+{
 	void *rv;
 	rv = malloc(howmuch);
 	if (rv == NULL && canfail == 0) {
 		warn("malloc failed %s (%d)", func, line);
 		abort();
+	}
 	if (rv)
 		memset(rv, 0, howmuch);
 	return rv;
+}
 void *
 rumpuser__realloc(void *ptr, size_t howmuch, int canfail,
 	const char *func, int line)
+{
 	void *rv;
 	rv = realloc(ptr, howmuch);
 	if (rv == NULL && canfail == 0) {
 		warn("realloc failed %s (%d)", func, line);
 		abort();
+	}
 	return rv;
+}
 void
 rumpuser_free(void *ptr)
+{
 	free(ptr);
+}
 void *
 rumpuser_anonmmap(size_t size, int alignbit, int exec, int *error)
+{
 	void *rv;
 	int prot;
 	prot = PROT_READ|PROT_WRITE;
 	if (exec)
 		prot |= PROT_EXEC;
 	/* XXX: MAP_ALIGNED() is not portable */
 	rv = mmap(NULL, size, prot, MAP_ANON | MAP_ALIGNED(alignbit), -1, 0);
 	if (rv == MAP_FAILED) {
 		*error = errno;
 		return NULL;
+	}
 	return rv;
+}
 void
 rumpuser_unmap(void *addr, size_t len)
+{
 	int rv;
 	rv = munmap(addr, len);
 	assert(rv == 0);
+}
 void *
-rumpuser_filemmap(int fd, off_t offset, size_t len, int shared,
+rumpuser_filemmap(int fd, off_t offset, size_t len, int flags, int *error)
 	int dotruncate, int *error)
+{
 	void *rv;
-	int flags;
+	int mmflags, prot;
-	if (dotruncate)
+	if (flags & RUMPUSER_FILEMMAP_TRUNCATE)
 		ftruncate(fd, offset + len);
-	flags = MAP_FILE;
+	mmflags = MAP_FILE;
-	if (shared)
+	if (flags & RUMPUSER_FILEMMAP_SHARED)
-		flags |= MAP_SHARED;
+		mmflags |= MAP_SHARED;
 	else
-		flags |= MAP_PRIVATE;
+		mmflags |= MAP_PRIVATE;
-	rv = mmap(NULL, len, PROT_READ|PROT_WRITE, flags, fd, offset);
+	prot = 0;
 	if (flags & RUMPUSER_FILEMMAP_READ)
 		prot |= PROT_READ;
 	if (flags & RUMPUSER_FILEMMAP_WRITE)
 		prot |= PROT_WRITE;
 	rv = mmap(NULL, len, PROT_READ|PROT_WRITE, mmflags, fd, offset);
 	if (rv == MAP_FAILED) {
 		*error = errno;
 		return NULL;
+	}
 	*error = 0;
 	return rv;
+}
 int
 rumpuser_memsync(void *addr, size_t len, int *error)
+{
 	DOCALL_KLOCK(int, (msync(addr, len, MS_SYNC)));
+}
 int
 rumpuser_open(const char *path, int flags, int *error)
+{
 	DOCALL(int, (open(path, flags, 0644)));
+}
 int
 rumpuser_ioctl(int fd, u_long cmd, void *data, int *error)
+{
 	DOCALL_KLOCK(int, (ioctl(fd, cmd, data)));
+}
 int
 rumpuser_close(int fd, int *error)
+{
 	DOCALL(int, close(fd));
+}
 int
 rumpuser_fsync(int fd, int *error)
+{
 	DOCALL_KLOCK(int, fsync(fd));
+}
 ssize_t
 rumpuser_read(int fd, void *data, size_t size, int *error)
+{
 	ssize_t rv;
 	KLOCK_WRAP(rv = read(fd, data, size));
 	if (rv == -1)
 		*error = errno;
 	return rv;
+}
 ssize_t
 rumpuser_pread(int fd, void *data, size_t size, off_t offset, int *error)
+{
 	ssize_t rv;
 	KLOCK_WRAP(rv = pread(fd, data, size, offset));
 	if (rv == -1)
 		*error = errno;
 	return rv;
+}
 void
 rumpuser_read_bio(int fd, void *data, size_t size, off_t offset,
 	rump_biodone_fn biodone, void *biodonecookie)
+{
 	ssize_t rv;
 	int error = 0;
 	KLOCK_WRAP(rv = rumpuser_pread(fd, data, size, offset, &error));
 	/* check against <0 instead of ==-1 to get typing below right */
 	if (rv < 0)
 		rv = 0;
 	/* LINTED: see above */
 	biodone(biodonecookie, rv, error);
+}
 ssize_t
 rumpuser_write(int fd, const void *data, size_t size, int *error)
+{
 	ssize_t rv;
 	KLOCK_WRAP(rv = write(fd, data, size));
 	if (rv == -1)
 		*error = errno;
 	return rv;
+}
 ssize_t
 rumpuser_pwrite(int fd, const void *data, size_t size, off_t offset, int *error)
+{
 	ssize_t rv;
 	KLOCK_WRAP(rv = pwrite(fd, data, size, offset));
 	if (rv == -1)
 		*error = errno;
 	return rv;
+}
 void
 rumpuser_write_bio(int fd, const void *data, size_t size, off_t offset,
 	rump_biodone_fn biodone, void *biodonecookie)
+{
 	ssize_t rv;
 	int error = 0;
 	KLOCK_WRAP(rv = rumpuser_pwrite(fd, data, size, offset, &error));
 	/* check against <0 instead of ==-1 to get typing below right */
 	if (rv < 0)
 		rv = 0;
 	/* LINTED: see above */
 	biodone(biodonecookie, rv, error);
+}
 ssize_t
 rumpuser_readv(int fd, const struct rumpuser_iovec *riov, int iovcnt,
 	int *error)
+{
 	struct iovec *iovp;
 	ssize_t rv;
 	int i;
 	iovp = malloc(iovcnt * sizeof(struct iovec));
 	if (iovp == NULL) {
 		*error = ENOMEM;
 		return -1;
+	}
 	for (i = 0; i < iovcnt; i++) {
 		iovp[i].iov_base = riov[i].iov_base;
 		/*LINTED*/
 		iovp[i].iov_len = riov[i].iov_len;
+	}
 	KLOCK_WRAP(rv = readv(fd, iovp, iovcnt));
 	if (rv == -1)
 		*error = errno;
 	free(iovp);
 	return rv;
+}
 ssize_t
 rumpuser_writev(int fd, const struct rumpuser_iovec *riov, int iovcnt,
 	int *error)
+{
 	struct iovec *iovp;
 	ssize_t rv;
 	int i;
 	iovp = malloc(iovcnt * sizeof(struct iovec));
 	if (iovp == NULL) {
 		*error = ENOMEM;
 		return -1;
+	}
 	for (i = 0; i < iovcnt; i++) {
 		iovp[i].iov_base = riov[i].iov_base;
 		/*LINTED*/
 		iovp[i].iov_len = riov[i].iov_len;
+	}
 	KLOCK_WRAP(rv = writev(fd, iovp, iovcnt));
 	if (rv == -1)
 		*error = errno;
 	free(iovp);
 	return rv;
+}
 int
 rumpuser_gettime(uint64_t *sec, uint64_t *nsec, int *error)
+{
 	struct timeval tv;
 	int rv;
 	rv = gettimeofday(&tv, NULL);
 	if (rv == -1) {
 		*error = errno;
 		return rv;
+	}
 	*sec = tv.tv_sec;
 	*nsec = tv.tv_usec * 1000;
 	return 0;
+}
 int
 rumpuser_getenv(const char *name, char *buf, size_t blen, int *error)
+{
 	DOCALL(int, getenv_r(name, buf, blen));
+}
 int
 rumpuser_gethostname(char *name, size_t namelen, int *error)
+{
 	DOCALL(int, (gethostname(name, namelen)));
+}
 char *
 rumpuser_realpath(const char *path, char resolvedname[MAXPATHLEN], int *error)
+{
 	char *rv;
 	rv = realpath(path, resolvedname);
 	if (rv == NULL)
 		*error = errno;
 	else
 		*error = 0;
 	return rv;
+}
 int
 rumpuser_poll(struct pollfd *fds, int nfds, int timeout, int *error)
+{
 	DOCALL_KLOCK(int, (poll(fds, (nfds_t)nfds, timeout)));
+}
 int
 rumpuser_putchar(int c, int *error)
+{
 	DOCALL(int, (putchar(c)));
+}
 void
 rumpuser_panic(void)
+{
 	abort();
+}
 void
 rumpuser_seterrno(int error)
+{
 	errno = error;
+}
 int
 rumpuser_writewatchfile_setup(int kq, int fd, intptr_t opaque, int *error)
+{
 	struct kevent kev;
 	if (kq == -1) {
 		kq = kqueue();
 		if (kq == -1) {
 			*error = errno;
 			return -1;
+		}
+	}
 	EV_SET(&kev, fd, EVFILT_VNODE, EV_ADD|EV_ENABLE|EV_CLEAR,
 	    NOTE_WRITE, 0, opaque);
 	if (kevent(kq, &kev, 1, NULL, 0, NULL) == -1) {
 		*error = errno;
 		return -1;
+	}
 	return kq;
+}
 int
 rumpuser_writewatchfile_wait(int kq, intptr_t *opaque, int *error)
+{
 	struct kevent kev;
 	int rv;
 	KLOCK_WRAP(rv = kevent(kq, NULL, 0, &kev, 1, NULL));
 	if (rv == -1) {
 		*error = errno;
 		return -1;
+	}
 	if (opaque)
 		*opaque = kev.udata;
 	return rv;
+}

 @@ -1,377 +1,378 @@
-/*	$NetBSD: if_shmem.c,v 1.4 2009/03/01 20:50:04 pooka Exp $	*/
+/*	$NetBSD: if_shmem.c,v 1.5 2009/03/18 15:32:27 pooka Exp $	*/
 /*
  * Copyright (c) 2009 Antti Kantee.  All Rights Reserved.
+ *
  * Development of this software was supported by The Nokia Foundation.
+ *
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  * 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: if_shmem.c,v 1.4 2009/03/01 20:50:04 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_shmem.c,v 1.5 2009/03/18 15:32:27 pooka Exp $");
 #include <sys/param.h>
 #include <sys/fcntl.h>
 #include <sys/kmem.h>
 #include <sys/kthread.h>
 #include <sys/lock.h>
 #include <sys/atomic.h>
 #include <net/if.h>
 #include <net/if_ether.h>
 #include <netinet/in.h>
 #include <netinet/in_var.h>
 #include <rump/rump.h>
 #include <rump/rumpuser.h>
 #include "rump_private.h"
 /*
  * A virtual ethernet interface which uses shared memory from a
  * memory mapped file as the bus.
  */
 static int	shmif_init(struct ifnet *);
 static int	shmif_ioctl(struct ifnet *, u_long, void *);
 static void	shmif_start(struct ifnet *);
 static void	shmif_stop(struct ifnet *, int);
 struct shmif_sc {
 	struct ethercom sc_ec;
 	uint8_t sc_myaddr[6];
 	uint8_t *sc_busmem;
 	int sc_memfd;
 	int sc_kq;
 	uint32_t sc_nextpacket;
 	uint32_t sc_prevgen;
 };
 #define IFMEM_LOCK		(0)
 #define IFMEM_GENERATION	(8)
 #define IFMEM_LASTPACKET	(12)
 #define IFMEM_WAKEUP		(16)
 #define IFMEM_DATA		(20)
 #define BUSCTRL_ATOFF(sc, off)	((uint32_t *)(sc->sc_busmem+(off)))
 #define BUSMEM_SIZE 65536 /* enough? */
 static void shmif_rcv(void *);
 static uint32_t numif;
 /*
  * This locking needs work and will misbehave severely if:
  * 1) the backing memory has to be paged in
  * 2) some lockholder exits while holding the lock
  */
 static void
 lockbus(struct shmif_sc *sc)
+{
 	__cpu_simple_lock((__cpu_simple_lock_t *)sc->sc_busmem);
+}
 static void
 unlockbus(struct shmif_sc *sc)
+{
 	__cpu_simple_unlock((__cpu_simple_lock_t *)sc->sc_busmem);
+}
 static uint32_t
 busread(struct shmif_sc *sc, void *dest, uint32_t off, size_t len)
+{
 	size_t chunk;
 	KASSERT(len < (BUSMEM_SIZE - IFMEM_DATA) && off <= BUSMEM_SIZE);
 	chunk = MIN(len, BUSMEM_SIZE - off);
 	memcpy(dest, sc->sc_busmem + off, chunk);
 	len -= chunk;
 	if (len == 0)
 		return off + chunk;
 	/* else, wraps around */
 	off = IFMEM_DATA;
 	sc->sc_prevgen = *BUSCTRL_ATOFF(sc, IFMEM_GENERATION);
 	/* finish reading */
 	memcpy((uint8_t *)dest + chunk, sc->sc_busmem + off, len);
 	return off + len;
+}
 static uint32_t
 buswrite(struct shmif_sc *sc, uint32_t off, void *data, size_t len)
+{
 	size_t chunk;
 	KASSERT(len < (BUSMEM_SIZE - IFMEM_DATA) && off <= BUSMEM_SIZE);
 	chunk = MIN(len, BUSMEM_SIZE - off);
 	memcpy(sc->sc_busmem + off, data, chunk);
 	len -= chunk;
 	if (len == 0)
 		return off + chunk;
 	DPRINTF(("buswrite wrap: wrote %d bytes to %d, left %d to %d",
 	    chunk, off, len, IFMEM_DATA));
 	/* else, wraps around */
 	off = IFMEM_DATA;
 	(*BUSCTRL_ATOFF(sc, IFMEM_GENERATION))++;
 	sc->sc_prevgen = *BUSCTRL_ATOFF(sc, IFMEM_GENERATION);
 	/* finish writing */
 	memcpy(sc->sc_busmem + off, (uint8_t *)data + chunk, len);
 	return off + len;
+}
 static inline uint32_t
 advance(uint32_t oldoff, uint32_t delta)
+{
 	uint32_t newoff;
 	newoff = oldoff + delta;
 	if (newoff >= BUSMEM_SIZE)
 		newoff -= (BUSMEM_SIZE - IFMEM_DATA);
 	return newoff;
+}
 static uint32_t
 nextpktoff(struct shmif_sc *sc, uint32_t oldoff)
+{
 	uint32_t oldlen;
 	busread(sc, &oldlen, oldoff, 4);
 	KASSERT(oldlen < BUSMEM_SIZE - IFMEM_DATA);
 	return advance(oldoff, 4 + oldlen);
+}
 int rump_shmif_create(const char *, int *); /* XXX */
 int
 rump_shmif_create(const char *path, int *ifnum)
+{
 	struct shmif_sc *sc;
 	struct ifnet *ifp;
 	uint8_t enaddr[ETHER_ADDR_LEN] = { 0xb2, 0xa0, 0x00, 0x00, 0x00, 0x00 };
 	uint32_t randnum;
 	unsigned mynum;
 	int error;
 	randnum = arc4random();
 	memcpy(&enaddr[2], &randnum, 4);
 	mynum = atomic_inc_uint_nv(&numif)-1;
 	sc = kmem_zalloc(sizeof(*sc), KM_SLEEP);
 	ifp = &sc->sc_ec.ec_if;
 	memcpy(sc->sc_myaddr, enaddr, sizeof(enaddr));
 	sc->sc_memfd = rumpuser_open(path, O_RDWR | O_CREAT, &error);
 	if (sc->sc_memfd == -1)
 		goto fail;
 	sc->sc_busmem = rumpuser_filemmap(sc->sc_memfd, 0, BUSMEM_SIZE,
-, 1, &error);
+	    RUMPUSER_FILEMMAP_TRUNCATE | RUMPUSER_FILEMMAP_SHARED
 	    | RUMPUSER_FILEMMAP_READ | RUMPUSER_FILEMMAP_WRITE, &error);
 	if (error)
 		goto fail;
 	lockbus(sc);
 	if (*BUSCTRL_ATOFF(sc, IFMEM_LASTPACKET) == 0)
 		*BUSCTRL_ATOFF(sc, IFMEM_LASTPACKET) = IFMEM_DATA;
 	sc->sc_nextpacket = *BUSCTRL_ATOFF(sc, IFMEM_LASTPACKET);
 	sc->sc_prevgen = *BUSCTRL_ATOFF(sc, IFMEM_GENERATION);
 	unlockbus(sc);
 	sc->sc_kq = rumpuser_writewatchfile_setup(-1, sc->sc_memfd, 0, &error);
 	if (sc->sc_kq == -1)
 		goto fail;
 	sprintf(ifp->if_xname, "shmif%d", mynum);
 	ifp->if_softc = sc;
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 	ifp->if_init = shmif_init;
 	ifp->if_ioctl = shmif_ioctl;
 	ifp->if_start = shmif_start;
 	ifp->if_stop = shmif_stop;
 	ifp->if_mtu = 1518;
 	if_attach(ifp);
 	ether_ifattach(ifp, enaddr);
 	if (ifnum)
 		*ifnum = mynum;
 	return 0;
  fail:
 	panic("rump_shmemif_create: fixme");
+}
 static int
 shmif_init(struct ifnet *ifp)
+{
 	int error = 0;
 	if (rump_threads) {
 		error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
 		    shmif_rcv, ifp, NULL, "shmif");
 	} else {
 		printf("WARNING: threads not enabled, shmif NOT working\n");
+	}
 	ifp->if_flags |= IFF_RUNNING;
 	return error;
+}
 static int
 shmif_ioctl(struct ifnet *ifp, u_long cmd, void *data)
+{
 	int s, rv;
 	s = splnet();
 	rv = ether_ioctl(ifp, cmd, data);
 	splx(s);
 	return rv;
+}
 /* send everything in-context */
 static void
 shmif_start(struct ifnet *ifp)
+{
 	struct shmif_sc *sc = ifp->if_softc;
 	struct mbuf *m, *m0;
 	uint32_t lastoff, dataoff, npktlenoff;
 	uint32_t pktsize = 0;
 	bool wrote = false;
 	int error;
 	for (;;) {
 		IF_DEQUEUE(&ifp->if_snd, m0);
 		if (m0 == NULL) {
 			break;
+		}
 		lockbus(sc);
 		lastoff = *BUSCTRL_ATOFF(sc, IFMEM_LASTPACKET);
 		npktlenoff = nextpktoff(sc, lastoff);
 		dataoff = advance(npktlenoff, 4);
 		for (m = m0; m != NULL; m = m->m_next) {
 			pktsize += m->m_len;
 			dataoff = buswrite(sc, dataoff, mtod(m, void *),
 			    m->m_len);
+		}
 		buswrite(sc, npktlenoff, &pktsize, 4);
 		*BUSCTRL_ATOFF(sc, IFMEM_LASTPACKET) = npktlenoff;
 		unlockbus(sc);
 		m_freem(m0);
 		wrote = true;
 		DPRINTF(("shmif_start: send %d bytes at off %d\n",
 		    pktsize, npktlenoff));
+	}
 	/* wakeup */
 	if (wrote)
 		rumpuser_pwrite(sc->sc_memfd, &error, 4, IFMEM_WAKEUP, &error);
+}
 static void
 shmif_stop(struct ifnet *ifp, int disable)
+{
 	panic("%s: unimpl", __func__);
+}
 static void
 shmif_rcv(void *arg)
+{
 	struct ifnet *ifp = arg;
 	struct shmif_sc *sc = ifp->if_softc;
 	struct mbuf *m = NULL;
 	struct ether_header *eth;
 	uint32_t nextpkt, pktlen, lastpkt, busgen, lastnext;
 	int error;
 	for (;;) {
 		if (m == NULL) {
 			m = m_gethdr(M_WAIT, MT_DATA);
 			MCLGET(m, M_WAIT);
+		}
 		DPRINTF(("waiting %d/%d\n", sc->sc_nextpacket, sc->sc_prevgen));
 		KASSERT(m->m_flags & M_EXT);
 		lockbus(sc);
 		lastpkt = *BUSCTRL_ATOFF(sc, IFMEM_LASTPACKET);
 		busgen = *BUSCTRL_ATOFF(sc, IFMEM_GENERATION);
 		lastnext = nextpktoff(sc, lastpkt);
 		if ((lastnext > sc->sc_nextpacket && busgen > sc->sc_prevgen)
 		    || (busgen > sc->sc_prevgen+1)) {
 			nextpkt = lastpkt;
 			sc->sc_prevgen = busgen;
 			printf("DROPPING\n");
 		} else {
 			nextpkt = sc->sc_nextpacket;
+		}
 		/* need more data? */
 		if (lastnext == nextpkt && sc->sc_prevgen == busgen){
 			unlockbus(sc);
 			error = 0;
 			rumpuser_writewatchfile_wait(sc->sc_kq, NULL, &error);
 			if (__predict_false(error))
 				printf("shmif_rcv: wait failed %d\n", error);
 			continue;
+		}
 		busread(sc, &pktlen, nextpkt, 4);
 		busread(sc, mtod(m, void *), advance(nextpkt, 4), pktlen);
 		DPRINTF(("shmif_rcv: read packet of length %d at %d\n",
 		    pktlen, nextpkt));
 		sc->sc_nextpacket = nextpktoff(sc, nextpkt);
 		sc->sc_prevgen = busgen;
 		unlockbus(sc);
 		m->m_len = m->m_pkthdr.len = pktlen;
 		m->m_pkthdr.rcvif = ifp;
 		/* if it's to us, don't pass up and reuse storage space */
 		eth = mtod(m, struct ether_header *);
 		if (memcmp(eth->ether_shost, sc->sc_myaddr, 6) != 0) {
 			ifp->if_input(ifp, m);
 			m = NULL;
+		}
+	}
 	panic("shmif_worker is a lazy boy %d\n", error);
+}