 @@ -1,14 +1,14 @@
-/*	$NetBSD: rump_vfs_private.h,v 1.12 2010/04/30 21:02:36 pooka Exp $	*/
+/*	$NetBSD: rump_vfs_private.h,v 1.13 2010/06/15 18:53:48 pooka Exp $	*/
 /*
  * Copyright (c) 2008 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.
+ *
 @@ -31,26 +31,27 @@
 #include <sys/types.h>
 #include <sys/conf.h>
 void		rump_vfs_init(void);
 void		rump_vfs_fini(void);
 void		rumpfs_init(void);
 int		rump_devnull_init(void);
 #define RUMPBLK_DEVMAJOR 197 /* from conf/majors, XXX: not via config yet */
 #define RUMPBLK_SIZENOTSET ((uint64_t)-1)
 int	rumpblk_register(const char *, devminor_t *, uint64_t, uint64_t);
 int	rumpblk_deregister(const char *);
 int	rumpblk_init(void);
 void	rump_biodone(void *, size_t, int);
 int     rump_vfs_makeonedevnode(dev_t, const char *, devmajor_t, devminor_t);
 int     rump_vfs_makedevnodes(dev_t, const char *, char,
 			      devmajor_t, devminor_t, int);
 void	rump_vfs_builddevs(struct devsw_conv *, size_t numelem);
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <rump/rump.h>

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rumpblk.c,v 1.39 2010/05/01 14:37:53 pooka Exp $	*/
+/*	$NetBSD: rumpblk.c,v 1.40 2010/06/15 18:53:48 pooka Exp $	*/
 /*
  * Copyright (c) 2009 Antti Kantee.  All Rights Reserved.
+ *
  * Development of this software was supported by 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
 @@ -42,27 +42,27 @@
  * we get way less carnage.
+ *
  * However, it is quite costly in writing large amounts of
  * file data, since old contents cannot merely be overwritten, but
  * must be paged in first before replacing (i.e. r/m/w).  Ideally,
  * we should use directio.  The problem is that directio can fail
  * silently causing improper file system semantics (i.e. unflushed
  * data).  Therefore, default to mmap for now.  Even so, directio
  * _should_ be safe and can be enabled by compiling this module
  * with -DHAS_DIRECTIO.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rumpblk.c,v 1.39 2010/05/01 14:37:53 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rumpblk.c,v 1.40 2010/06/15 18:53:48 pooka Exp $");
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/conf.h>
 #include <sys/condvar.h>
 #include <sys/disklabel.h>
 #include <sys/evcnt.h>
 #include <sys/fcntl.h>
 #include <sys/kmem.h>
 #include <sys/malloc.h>
 #include <sys/queue.h>
 #include <sys/stat.h>
 @@ -374,27 +374,26 @@ rumpblk_init(void)
 	    "rumpblk", "all windows busy");
 	if (blkfail) {
 		return devsw_attach("rumpblk",
 		    &rumpblk_bdevsw_fail, &rumpblkmaj,
 		    &rumpblk_cdevsw, &rumpblkmaj);
 	} else {
 		return devsw_attach("rumpblk",
 		    &rumpblk_bdevsw, &rumpblkmaj,
 		    &rumpblk_cdevsw, &rumpblkmaj);
+	}
+}
 /* XXX: no deregister */
 int
 rumpblk_register(const char *path, devminor_t *dmin,
 	uint64_t offset, uint64_t size)
+{
 	struct rblkdev *rblk;
 	uint64_t flen;
 	size_t len;
 	int ftype, error, i;
 	/* devices might not report correct size unless they're open */
 	if (rumpuser_getfileinfo(path, &flen, &ftype, &error) == -1)
 		return error;
 @@ -432,26 +431,59 @@ rumpblk_register(const char *path, devmi
 		rblk->rblk_size = size;
 	} else {
 		KASSERT(offset < flen);
 		rblk->rblk_size = flen - offset;
+	}
 	rblk->rblk_ftype = ftype;
 	makedefaultlabel(&rblk->rblk_label, rblk->rblk_size, i);
 	mutex_exit(&rumpblk_lock);
 	*dmin = i;
 	return 0;
+}
 /*
  * Unregister rumpblk.  It's the callers responsibility to make
  * sure it's no longer in use.
  */
 int
 rumpblk_deregister(const char *path)
+{
 	struct rblkdev *rblk;
 	int i;
 	mutex_enter(&rumpblk_lock);
 	for (i = 0; i < RUMPBLK_SIZE; i++) {
 		if (minors[i].rblk_path&&strcmp(minors[i].rblk_path, path)==0) {
 			break;
+		}
+	}
 	mutex_exit(&rumpblk_lock);
 	if (i == RUMPBLK_SIZE)
 		return ENOENT;
 	rblk = &minors[i];
 	KASSERT(rblk->rblk_fd == -1);
 	KASSERT(rblk->rblk_opencnt == 0);
 	wincleanup(rblk);
 	free(rblk->rblk_path, M_TEMP);
 	rblk->rblk_path = NULL;
 	memset(&rblk->rblk_label, 0, sizeof(rblk->rblk_label));
 	return 0;
+}
 int
 rumpblk_open(dev_t dev, int flag, int fmt, struct lwp *l)
+{
 	struct rblkdev *rblk = &minors[minor(dev)];
 	int error, fd;
 	if (rblk->rblk_path == NULL)
 		return ENXIO;
 	if (rblk->rblk_fd != -1)
 		return 0; /* XXX: refcount, open mode */
 	fd = rumpuser_open(rblk->rblk_path, OFLAGS(flag), &error);
 	if (error)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: rumpfs.c,v 1.52 2010/06/15 17:23:31 njoly Exp $	*/
+/*	$NetBSD: rumpfs.c,v 1.53 2010/06/15 18:53:48 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: rumpfs.c,v 1.52 2010/06/15 17:23:31 njoly Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rumpfs.c,v 1.53 2010/06/15 18:53:48 pooka Exp $");
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/dirent.h>
 #include <sys/errno.h>
 #include <sys/filedesc.h>
 #include <sys/fcntl.h>
 #include <sys/kauth.h>
 #include <sys/malloc.h>
 #include <sys/module.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/lock.h>
 @@ -162,26 +162,28 @@ static struct rumpfs_node *makeprivate(e
 /*
  * Extra Terrestrial stuff.  We map a given key (pathname) to a file on
  * the host FS.  ET phones home only from the root node of rumpfs.
+ *
  * When an etfs node is removed, a vnode potentially behind it is not
  * immediately recycled.
  */
 struct etfs {
 	char et_key[MAXPATHLEN];
 	size_t et_keylen;
 	bool et_prefixkey;
 	bool et_removing;
 	devminor_t et_blkmin;
 	LIST_ENTRY(etfs) et_entries;
 	struct rumpfs_node *et_rn;
 };
 static kmutex_t etfs_lock;
 static LIST_HEAD(, etfs) etfs_list = LIST_HEAD_INITIALIZER(etfs_list);
 static enum vtype
 ettype_to_vtype(enum rump_etfs_type et)
+{
 	enum vtype vt;
 @@ -257,27 +259,27 @@ etfs_find(const char *key, struct etfs *
 	return false;
+}
 #define REGDIR(ftype) \
     ((ftype) == RUMP_ETFS_DIR || (ftype) == RUMP_ETFS_DIR_SUBDIRS)
 static int
 doregister(const char *key, const char *hostpath,
 	enum rump_etfs_type ftype, uint64_t begin, uint64_t size)
+{
 	struct etfs *et;
 	struct rumpfs_node *rn;
 	uint64_t fsize;
 	dev_t rdev = NODEV;
-	devminor_t dmin;
+	devminor_t dmin = -1;
 	int hft, error;
 	if (rumpuser_getfileinfo(hostpath, &fsize, &hft, &error))
 		return error;
 	/* etfs directory requires a directory on the host */
 	if (REGDIR(ftype)) {
 		if (hft != RUMPUSER_FT_DIR)
 			return ENOTDIR;
 		if (begin != 0)
 			return EISDIR;
 		if (size != RUMP_ETFS_SIZE_ENDOFF)
 			return EISDIR;
 @@ -293,53 +295,56 @@ doregister(const char *key, const char *
 	if (ftype == RUMP_ETFS_BLK || ftype == RUMP_ETFS_CHR) {
 		error = rumpblk_register(hostpath, &dmin, begin, size);
 		if (error != 0) {
 			return error;
+		}
 		rdev = makedev(RUMPBLK_DEVMAJOR, dmin);
+	}
 	et = kmem_alloc(sizeof(*et), KM_SLEEP);
 	strcpy(et->et_key, key);
 	et->et_keylen = strlen(et->et_key);
 	et->et_rn = rn = makeprivate(ettype_to_vtype(ftype), rdev, size);
 	et->et_removing = false;
 	et->et_blkmin = dmin;
-	if (ftype == RUMP_ETFS_REG || REGDIR(ftype)) {
+	if (ftype == RUMP_ETFS_REG || REGDIR(ftype) || et->et_blkmin != -1) {
 		size_t len = strlen(hostpath)+1;
 		rn->rn_hostpath = malloc(len, M_TEMP, M_WAITOK | M_ZERO);
 		memcpy(rn->rn_hostpath, hostpath, len);
 		rn->rn_offset = begin;
+	}
 	if (REGDIR(ftype)) {
 		rn->rn_flags |= RUMPNODE_DIR_ET;
 		et->et_prefixkey = true;
 	} else {
 		et->et_prefixkey = false;
+	}
 	if (ftype == RUMP_ETFS_DIR_SUBDIRS)
 		rn->rn_flags |= RUMPNODE_DIR_ETSUBS;
 	mutex_enter(&etfs_lock);
 	if (etfs_find(key, NULL, REGDIR(ftype))) {
 		mutex_exit(&etfs_lock);
 		if (et->et_blkmin != -1)
 			rumpblk_deregister(hostpath);
 		if (et->et_rn->rn_hostpath != NULL)
 			free(et->et_rn->rn_hostpath, M_TEMP);
 		kmem_free(et->et_rn, sizeof(*et->et_rn));
 		kmem_free(et, sizeof(*et));
 		/* XXX: rumpblk_deregister(hostpath); */
 		return EEXIST;
+	}
 	LIST_INSERT_HEAD(&etfs_list, et, et_entries);
 	mutex_exit(&etfs_lock);
 	return 0;
+}
 #undef REGDIR
 int
 rump_etfs_register(const char *key, const char *hostpath,
 	enum rump_etfs_type ftype)
+{
 @@ -356,47 +361,73 @@ rump_etfs_register_withsize(const char *
 	 * Check that we're mapping at block offsets.  I guess this
 	 * is not technically necessary except for BLK/CHR backends
 	 * (i.e. what getfileinfo() returns, not ftype) and can be
 	 * removed later if there are problems.
 	 */
 	if ((begin & (DEV_BSIZE-1)) != 0)
 		return EINVAL;
 	if (size != RUMP_ETFS_SIZE_ENDOFF && (size & (DEV_BSIZE-1)) != 0)
 		return EINVAL;
 	return doregister(key, hostpath, ftype, begin, size);
+}
 /* remove etfs mapping.  caller's responsibility to make sure it's not in use */
 int
 rump_etfs_remove(const char *key)
+{
 	struct etfs *et;
 	size_t keylen = strlen(key);
 	int rv;
 	mutex_enter(&etfs_lock);
 	LIST_FOREACH(et, &etfs_list, et_entries) {
 		if (keylen == et->et_keylen && strcmp(et->et_key, key) == 0) {
-			LIST_REMOVE(et, et_entries);
+			if (et->et_removing)
-			if (et->et_rn->rn_hostpath != NULL)
+				et = NULL;
-				free(et->et_rn->rn_hostpath, M_TEMP);
+			else
-			kmem_free(et->et_rn, sizeof(*et->et_rn));
+				et->et_removing = true;
 			kmem_free(et, sizeof(*et));
 			break;
+		}
+	}
 	mutex_exit(&etfs_lock);
 	if (!et)
 		return ENOENT;
 	/*
 	 * ok, we know what we want to remove and have signalled there
 	 * actually are men at work.  first, unregister from rumpblk
 	 */
 	if (et->et_blkmin != -1) {
 		rv = rumpblk_deregister(et->et_rn->rn_hostpath);
 	} else {
 		rv = 0;
+	}
 	KASSERT(rv == 0);
 	/* then do the actual removal */
 	mutex_enter(&etfs_lock);
 	LIST_REMOVE(et, et_entries);
 	mutex_exit(&etfs_lock);
 	/* node is unreachable, safe to nuke all device copies */
 	if (et->et_blkmin != -1)
 		vdevgone(RUMPBLK_DEVMAJOR, et->et_blkmin, et->et_blkmin, VBLK);
 	if (et->et_rn->rn_hostpath != NULL)
 		free(et->et_rn->rn_hostpath, M_TEMP);
 	kmem_free(et->et_rn, sizeof(*et->et_rn));
 	kmem_free(et, sizeof(*et));
 	return 0;
+}
 /*
  * rumpfs
  */
 static int lastino = 1;
 static kmutex_t reclock;
 static struct rumpfs_node *
 makeprivate(enum vtype vt, dev_t rdev, off_t size)
+{