xref: /src/sys/rump/librump/rumpvfs/rumpfs.c

/*	$NetBSD: rumpfs.c,v 1.167 2023/06/27 19:30:27 andvar Exp $	*/

/*
 * Copyright (c) 2009, 2010, 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.
 *
 * 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: rumpfs.c,v 1.167 2023/06/27 19:30:27 andvar Exp $");

#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/buf.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>
#include <sys/lockf.h>
#include <sys/queue.h>
#include <sys/stat.h>
#include <sys/syscallargs.h>
#include <sys/vnode.h>
#include <sys/fstrans.h>
#include <sys/unistd.h>

#include <miscfs/specfs/specdev.h>
#include <miscfs/genfs/genfs.h>
#include <miscfs/genfs/genfs_node.h>

#include <uvm/uvm_extern.h>

#include <rump-sys/kern.h>
#include <rump-sys/vfs.h>

#include <rump/rumpfs.h>
#include <rump/rumpuser.h>

static int rump_vop_parsepath(void *);
static int rump_vop_lookup(void *);
static int rump_vop_getattr(void *);
static int rump_vop_setattr(void *);
static int rump_vop_mkdir(void *);
static int rump_vop_rmdir(void *);
static int rump_vop_remove(void *);
static int rump_vop_mknod(void *);
static int rump_vop_create(void *);
static int rump_vop_inactive(void *);
static int rump_vop_reclaim(void *);
static int rump_vop_success(void *);
static int rump_vop_readdir(void *);
static int rump_vop_spec(void *);
static int rump_vop_read(void *);
static int rump_vop_write(void *);
static int rump_vop_open(void *);
static int rump_vop_symlink(void *);
static int rump_vop_readlink(void *);
static int rump_vop_whiteout(void *);
static int rump_vop_pathconf(void *);
static int rump_vop_bmap(void *);
static int rump_vop_strategy(void *);
static int rump_vop_advlock(void *);
static int rump_vop_access(void *);
static int rump_vop_fcntl(void *);

int (**rump_vnodeop_p)(void *);
const struct vnodeopv_entry_desc rump_vnodeop_entries[] = {
	{ &vop_default_desc, vn_default_error },
	{ &vop_parsepath_desc, rump_vop_parsepath },
	{ &vop_lookup_desc, rump_vop_lookup },
	{ &vop_getattr_desc, rump_vop_getattr },
	{ &vop_setattr_desc, rump_vop_setattr },
	{ &vop_mkdir_desc, rump_vop_mkdir },
	{ &vop_rmdir_desc, rump_vop_rmdir },
	{ &vop_remove_desc, rump_vop_remove },
	{ &vop_mknod_desc, rump_vop_mknod },
	{ &vop_create_desc, rump_vop_create },
	{ &vop_symlink_desc, rump_vop_symlink },
	{ &vop_readlink_desc, rump_vop_readlink },
	{ &vop_access_desc, rump_vop_access },
	{ &vop_accessx_desc, genfs_accessx },
	{ &vop_readdir_desc, rump_vop_readdir },
	{ &vop_read_desc, rump_vop_read },
	{ &vop_write_desc, rump_vop_write },
	{ &vop_open_desc, rump_vop_open },
	{ &vop_close_desc, genfs_nullop },
	{ &vop_seek_desc, genfs_seek },
	{ &vop_getpages_desc, genfs_getpages },
	{ &vop_putpages_desc, genfs_putpages },
	{ &vop_whiteout_desc, rump_vop_whiteout },
	{ &vop_fsync_desc, rump_vop_success },
	{ &vop_lock_desc, genfs_lock },
	{ &vop_unlock_desc, genfs_unlock },
	{ &vop_islocked_desc, genfs_islocked },
	{ &vop_inactive_desc, rump_vop_inactive },
	{ &vop_reclaim_desc, rump_vop_reclaim },
	{ &vop_link_desc, genfs_eopnotsupp },
	{ &vop_pathconf_desc, rump_vop_pathconf },
	{ &vop_bmap_desc, rump_vop_bmap },
	{ &vop_strategy_desc, rump_vop_strategy },
	{ &vop_advlock_desc, rump_vop_advlock },
	{ &vop_fcntl_desc, rump_vop_fcntl },
	{ NULL, NULL }
};
const struct vnodeopv_desc rump_vnodeop_opv_desc =
	{ &rump_vnodeop_p, rump_vnodeop_entries };

int (**rump_specop_p)(void *);
const struct vnodeopv_entry_desc rump_specop_entries[] = {
	{ &vop_default_desc, rump_vop_spec },
	{ NULL, NULL }
};
const struct vnodeopv_desc rump_specop_opv_desc =
	{ &rump_specop_p, rump_specop_entries };

const struct vnodeopv_desc * const rump_opv_descs[] = {
	&rump_vnodeop_opv_desc,
	&rump_specop_opv_desc,
	NULL
};

#define RUMPFS_WHITEOUT ((void *)-1)
#define RDENT_ISWHITEOUT(rdp) (rdp->rd_node == RUMPFS_WHITEOUT)
struct rumpfs_dent {
	char *rd_name;
	int rd_namelen;
	struct rumpfs_node *rd_node;

	LIST_ENTRY(rumpfs_dent) rd_entries;
};

struct genfs_ops rumpfs_genfsops = {
	.gop_size = genfs_size,
	.gop_write = genfs_gop_write,
	.gop_putrange = genfs_gop_putrange,

	/* optional */
	.gop_alloc = NULL,
	.gop_markupdate = NULL,
};

struct rumpfs_node {
	struct genfs_node rn_gn;
	struct vattr rn_va;
	struct vnode *rn_vp;
	char *rn_hostpath;
	int rn_flags;
	struct lockf *rn_lockf;

	union {
		struct {		/* VREG */
			int readfd;
			int writefd;
			uint64_t offset;
		} reg;
		struct {
			void *data;
			size_t dlen;
		} reg_noet;
		struct {		/* VDIR */
			LIST_HEAD(, rumpfs_dent) dents;
			struct rumpfs_node *parent;
			int flags;
		} dir;
		struct {
			char *target;
			size_t len;
		} link;
	} rn_u;
};
#define rn_readfd	rn_u.reg.readfd
#define rn_writefd	rn_u.reg.writefd
#define rn_offset	rn_u.reg.offset
#define rn_data		rn_u.reg_noet.data
#define rn_dlen		rn_u.reg_noet.dlen
#define rn_dir		rn_u.dir.dents
#define rn_parent	rn_u.dir.parent
#define rn_linktarg	rn_u.link.target
#define rn_linklen	rn_u.link.len

#define RUMPNODE_CANRECLAIM	0x01
#define RUMPNODE_DIR_ET		0x02
#define RUMPNODE_DIR_ETSUBS	0x04
#define RUMPNODE_ET_PHONE_HOST	0x10
#define RUMPNODE_EXTSTORAGE	0x20

struct rumpfs_mount {
	struct vnode *rfsmp_rvp;
};

#define INO_WHITEOUT 1
static int lastino = 2;
static kmutex_t reclock;

#define RUMPFS_DEFAULTMODE 0755
static void freedir(struct rumpfs_node *, struct componentname *);
static struct rumpfs_node *makeprivate(enum vtype, mode_t, dev_t, off_t, bool);
static void freeprivate(struct rumpfs_node *);

/*
 * 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;

	switch (et) {
	case RUMP_ETFS_REG:
		vt = VREG;
		break;
	case RUMP_ETFS_BLK:
		vt = VBLK;
		break;
	case RUMP_ETFS_CHR:
		vt = VCHR;
		break;
	case RUMP_ETFS_DIR:
		vt = VDIR;
		break;
	case RUMP_ETFS_DIR_SUBDIRS:
		vt = VDIR;
		break;
	default:
		panic("invalid et type: %d", et);
	}

	return vt;
}

static enum vtype
hft_to_vtype(int hft)
{
	enum vtype vt;

	switch (hft) {
	case RUMPUSER_FT_OTHER:
		vt = VNON;
		break;
	case RUMPUSER_FT_DIR:
		vt = VDIR;
		break;
	case RUMPUSER_FT_REG:
		vt = VREG;
		break;
	case RUMPUSER_FT_BLK:
		vt = VBLK;
		break;
	case RUMPUSER_FT_CHR:
		vt = VCHR;
		break;
	default:
		vt = VNON;
		break;
	}

	return vt;
}

static bool
etfs_find(const char *key, struct etfs **etp, bool forceprefix)
{
	struct etfs *et;
	size_t keylen = strlen(key);

	KASSERT(mutex_owned(&etfs_lock));

	LIST_FOREACH(et, &etfs_list, et_entries) {
		if ((keylen == et->et_keylen || et->et_prefixkey || forceprefix)
		    && strncmp(key, et->et_key, et->et_keylen) == 0) {
			if (etp)
				*etp = et;
			return true;
		}
	}

	return false;
}

#define REGDIR(ftype) \
    ((ftype) == RUMP_ETFS_DIR || (ftype) == RUMP_ETFS_DIR_SUBDIRS)
static int
etfsregister(const char *key, const char *hostpath,
	enum rump_etfs_type ftype, uint64_t begin, uint64_t size)
{
	char buf[9];
	struct etfs *et;
	struct rumpfs_node *rn;
	uint64_t fsize;
	dev_t rdev = NODEV;
	devminor_t dmin = -1;
	int hft, error;

	if (key[0] != '/') {
		return EINVAL;
	}
	while (key[0] == '/') {
		key++;
	}

	if ((error = rumpuser_getfileinfo(hostpath, &fsize, &hft)) != 0)
		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;
		size = fsize;
	} else {
		if (begin > fsize)
			return EINVAL;
		if (size == RUMP_ETFS_SIZE_ENDOFF)
			size = fsize - begin;
		if (begin + size > fsize)
			return EINVAL;
	}

	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), RUMPFS_DEFAULTMODE,
	    rdev, size, true);
	et->et_removing = false;
	et->et_blkmin = dmin;

	rn->rn_flags |= RUMPNODE_ET_PHONE_HOST;

	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);
		freeprivate(et->et_rn);
		kmem_free(et, sizeof(*et));
		return EEXIST;
	}
	LIST_INSERT_HEAD(&etfs_list, et, et_entries);
	mutex_exit(&etfs_lock);

	if (ftype == RUMP_ETFS_BLK) {
		format_bytes(buf, sizeof(buf), size);
		aprint_verbose("/%s: hostpath %s (%s)\n", key, hostpath, buf);
	}

	return 0;
}
#undef REGDIR

/* remove etfs mapping.  caller's responsibility to make sure it's not in use */
static int
etfsremove(const char *key)
{
	struct etfs *et;
	size_t keylen;
	int rv __diagused;

	if (key[0] != '/') {
		return EINVAL;
	}
	while (key[0] == '/') {
		key++;
	}

	keylen = strlen(key);

	mutex_enter(&etfs_lock);
	LIST_FOREACH(et, &etfs_list, et_entries) {
		if (keylen == et->et_keylen && strcmp(et->et_key, key) == 0) {
			if (et->et_removing)
				et = NULL;
			else
				et->et_removing = true;
			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);
	} else {
		struct vnode *vp;
		struct mount *mp;
		struct rumpfs_node *rn;

		mutex_enter(&reclock);
		if ((vp = et->et_rn->rn_vp) != NULL) {
			mp = vp->v_mount;
			rn = vp->v_data;
			KASSERT(rn == et->et_rn);
		} else {
			mp = NULL;
		}
		mutex_exit(&reclock);
		if (mp && vcache_get(mp, &rn, sizeof(rn), &vp) == 0) {
			rv = vfs_suspend(mp, 0);
			KASSERT(rv == 0);
			vgone(vp);
			vfs_resume(mp);
		}
	}

	if (et->et_rn->rn_hostpath != NULL)
		free(et->et_rn->rn_hostpath, M_TEMP);
	freeprivate(et->et_rn);
	kmem_free(et, sizeof(*et));

	return 0;
}

/*
 * rumpfs
 */

static struct rumpfs_node *
makeprivate(enum vtype vt, mode_t mode, dev_t rdev, off_t size, bool et)
{
	struct rumpfs_node *rn;
	struct vattr *va;
	struct timespec ts;

	KASSERT((mode & ~ALLPERMS) == 0);
	rn = kmem_zalloc(sizeof(*rn), KM_SLEEP);

	switch (vt) {
	case VDIR:
		LIST_INIT(&rn->rn_dir);
		break;
	case VREG:
		if (et) {
			rn->rn_readfd = -1;
			rn->rn_writefd = -1;
		}
		break;
	default:
		break;
	}

	nanotime(&ts);

	va = &rn->rn_va;
	va->va_type = vt;
	va->va_mode = mode;
	if (vt == VDIR)
		va->va_nlink = 2;
	else
		va->va_nlink = 1;
	va->va_uid = 0;
	va->va_gid = 0;
	va->va_fsid =
	va->va_fileid = atomic_inc_uint_nv(&lastino);
	va->va_size = size;
	va->va_blocksize = 512;
	va->va_atime = ts;
	va->va_mtime = ts;
	va->va_ctime = ts;
	va->va_birthtime = ts;
	va->va_gen = 0;
	va->va_flags = 0;
	va->va_rdev = rdev;
	va->va_bytes = 512;
	va->va_filerev = 0;
	va->va_vaflags = 0;

	return rn;
}

static void
freeprivate(struct rumpfs_node *rn)
{

	kmem_free(rn, sizeof(*rn));
}

static void
makedir(struct rumpfs_node *rnd,
	struct componentname *cnp, struct rumpfs_node *rn)
{
	struct rumpfs_dent *rdent;

	rdent = kmem_alloc(sizeof(*rdent), KM_SLEEP);
	rdent->rd_name = kmem_alloc(cnp->cn_namelen+1, KM_SLEEP);
	rdent->rd_node = rn;
	strlcpy(rdent->rd_name, cnp->cn_nameptr, cnp->cn_namelen+1);
	rdent->rd_namelen = strlen(rdent->rd_name);

	if ((cnp->cn_flags & ISWHITEOUT) != 0) {
		KASSERT((cnp->cn_flags & DOWHITEOUT) == 0);
		freedir(rnd, cnp);
	}
	LIST_INSERT_HEAD(&rnd->rn_dir, rdent, rd_entries);
}

static void
freedir(struct rumpfs_node *rnd, struct componentname *cnp)
{
	struct rumpfs_dent *rd = NULL;

	LIST_FOREACH(rd, &rnd->rn_dir, rd_entries) {
		if (rd->rd_namelen == cnp->cn_namelen &&
		    strncmp(rd->rd_name, cnp->cn_nameptr,
		            cnp->cn_namelen) == 0)
			break;
	}
	if (rd == NULL)
		panic("could not find directory entry: %s", cnp->cn_nameptr);

	if (cnp->cn_flags & DOWHITEOUT) {
		rd->rd_node = RUMPFS_WHITEOUT;
	} else {
		LIST_REMOVE(rd, rd_entries);
		kmem_free(rd->rd_name, rd->rd_namelen+1);
		kmem_free(rd, sizeof(*rd));
	}
}

#define	RUMPFS_ACCESS	1
#define	RUMPFS_MODIFY	2
#define	RUMPFS_CHANGE	4

static int
rumpfs_update(int flags, struct vnode *vp, const struct timespec *acc,
    const struct timespec *mod, const struct timespec *chg)
{
	struct rumpfs_node *rn = vp->v_data;

	if (flags == 0)
		return 0;

	if (vp->v_mount->mnt_flag & MNT_RDONLY)
		return EROFS;

	if (flags & RUMPFS_ACCESS)
		rn->rn_va.va_atime = *acc;
	if (flags & RUMPFS_MODIFY)
		rn->rn_va.va_mtime = *mod;
	if (flags & RUMPFS_CHANGE)
		rn->rn_va.va_ctime = *chg;

	return 0;
}

/*
 * parsepath for rump file systems - check for etfs entries.
 */
static int
rump_vop_parsepath(void *v)
{
	struct vop_parsepath_args /* {
		struct vnode *a_dvp;
		const char *a_name;
		size_t *a_retval;
	}; */ *ap = v;
	struct etfs *et;
	bool found;

	/* check for etfs */
	if (ap->a_dvp == rootvnode) {
		mutex_enter(&etfs_lock);
		found = etfs_find(ap->a_name, &et, false);
		mutex_exit(&etfs_lock);
		if (found) {
			*ap->a_retval = et->et_keylen;
			return 0;
		}
	}
	return genfs_parsepath(v);
}

/*
 * Simple lookup for rump file systems.
 *
 * uhm, this is twisted.  C F C C, hope of C C F C looming
 */
static int
rump_vop_lookup(void *v)
{
	struct vop_lookup_v2_args /* {
		struct vnode *a_dvp;
		struct vnode **a_vpp;
		struct componentname *a_cnp;
	}; */ *ap = v;
	struct componentname *cnp = ap->a_cnp;
	struct vnode *dvp = ap->a_dvp;
	struct vnode **vpp = ap->a_vpp;
	struct rumpfs_node *rnd = dvp->v_data, *rn;
	struct rumpfs_dent *rd = NULL;
	struct etfs *et;
	bool dotdot = (cnp->cn_flags & ISDOTDOT) != 0;
	int rv = 0;

	*vpp = NULL;

	rv = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred);
	if (rv)
		return rv;

	if ((cnp->cn_flags & ISLASTCN)
	    && (dvp->v_mount->mnt_flag & MNT_RDONLY)
	    && (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
		return EROFS;

	/* check for dot, return directly if the case */
	if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
		vref(dvp);
		*vpp = dvp;
		return 0;
	}

	/* we don't do rename */
	if (!(((cnp->cn_flags & ISLASTCN) == 0) || (cnp->cn_nameiop != RENAME)))
		return EOPNOTSUPP;

	/* check for etfs */
	if (dvp == rootvnode &&
	    (cnp->cn_nameiop == LOOKUP || cnp->cn_nameiop == CREATE)) {
		bool found;
		mutex_enter(&etfs_lock);
		found = etfs_find(cnp->cn_nameptr, &et, false);
		mutex_exit(&etfs_lock);

		if (found) {
			if (et->et_keylen != cnp->cn_namelen) {
				/*
				 * This can theoretically happen if an
				 * etfs entry is added or removed
				 * while lookups are being done as we
				 * don't hold etfs_lock across here
				 * and parsepath. Won't ordinarily be
				 * the case. No biggie, just retry.
				 */
				return ERESTART;
			}
			rn = et->et_rn;
			goto getvnode;
		}
	}

	if (rnd->rn_flags & RUMPNODE_DIR_ET) {
		uint64_t fsize;
		char *newpath;
		size_t newpathlen;
		int hft, error;

		if (dotdot)
			return EOPNOTSUPP;

		newpathlen = strlen(rnd->rn_hostpath) + 1 + cnp->cn_namelen + 1;
		newpath = malloc(newpathlen, M_TEMP, M_WAITOK);

		strlcpy(newpath, rnd->rn_hostpath, newpathlen);
		strlcat(newpath, "/", newpathlen);
		strlcat(newpath, cnp->cn_nameptr, newpathlen);

		if ((error = rumpuser_getfileinfo(newpath, &fsize, &hft)) != 0){
			free(newpath, M_TEMP);
			return error;
		}

		/* allow only dirs and regular files */
		if (hft != RUMPUSER_FT_REG && hft != RUMPUSER_FT_DIR) {
			free(newpath, M_TEMP);
			return ENOENT;
		}

		rn = makeprivate(hft_to_vtype(hft), RUMPFS_DEFAULTMODE,
		    NODEV, fsize, true);
		rn->rn_flags |= RUMPNODE_CANRECLAIM;
		if (rnd->rn_flags & RUMPNODE_DIR_ETSUBS) {
			rn->rn_flags |= RUMPNODE_DIR_ET | RUMPNODE_DIR_ETSUBS;
			rn->rn_flags |= RUMPNODE_ET_PHONE_HOST;
		}
		rn->rn_hostpath = newpath;

		goto getvnode;
	} else {
		if (dotdot) {
			if ((rn = rnd->rn_parent) != NULL)
				goto getvnode;
		} else {
			LIST_FOREACH(rd, &rnd->rn_dir, rd_entries) {
				if (rd->rd_namelen == cnp->cn_namelen &&
				    strncmp(rd->rd_name, cnp->cn_nameptr,
				      cnp->cn_namelen) == 0)
					break;
			}
		}
	}

	if (!rd && ((cnp->cn_flags & ISLASTCN) == 0||cnp->cn_nameiop != CREATE))
		return ENOENT;

	if (!rd && (cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) {
		if (dvp->v_mount->mnt_flag & MNT_RDONLY)
			return EROFS;
		rv = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
		if (rv)
			return rv;
		return EJUSTRETURN;
	}

	if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == DELETE) {
		rv = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
		if (rv)
			return rv;
	}

	if (RDENT_ISWHITEOUT(rd)) {
		cnp->cn_flags |= ISWHITEOUT;
		if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE)
			return EJUSTRETURN;
		return ENOENT;
	}

	rn = rd->rd_node;

 getvnode:
	KASSERT(rn);
	rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp);
	if (rv) {
		if (rnd->rn_flags & RUMPNODE_DIR_ET)
			freeprivate(rn);
		return rv;
	}

	return 0;
}

static int
rump_check_possible(struct vnode *vp, struct rumpfs_node *rnode,
    mode_t mode)
{

	if ((mode & VWRITE) == 0)
		return 0;

	switch (vp->v_type) {
	case VDIR:
	case VLNK:
	case VREG:
		break;
	default:
		/* special file is always writable. */
		return 0;
	}

	return vp->v_mount->mnt_flag & MNT_RDONLY ? EROFS : 0;
}

static int
rump_check_permitted(struct vnode *vp, struct rumpfs_node *rnode,
    accmode_t accmode, kauth_cred_t cred)
{
	struct vattr *attr = &rnode->rn_va;

	return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(accmode,
	    vp->v_type, attr->va_mode), vp, NULL, genfs_can_access(vp, cred,
	    attr->va_uid, attr->va_gid, attr->va_mode, NULL, accmode));
}

int
rump_vop_access(void *v)
{
	struct vop_access_args /* {
		const struct vnodeop_desc *a_desc;
		struct vnode *a_vp;
		int a_mode;
		kauth_cred_t a_cred;
	} */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;
	int error;

	error = rump_check_possible(vp, rn, ap->a_accmode);
	if (error)
		return error;

	error = rump_check_permitted(vp, rn, ap->a_accmode, ap->a_cred);

	return error;
}

static int
rump_vop_getattr(void *v)
{
	struct vop_getattr_args /* {
		struct vnode *a_vp;
		struct vattr *a_vap;
		kauth_cred_t a_cred;
	} */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;
	struct vattr *vap = ap->a_vap;

	memcpy(vap, &rn->rn_va, sizeof(struct vattr));
	vap->va_size = vp->v_size;
	return 0;
}

static int
rump_vop_setattr(void *v)
{
	struct vop_setattr_args /* {
		struct vnode *a_vp;
		struct vattr *a_vap;
		kauth_cred_t a_cred;
	} */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct vattr *vap = ap->a_vap;
	struct rumpfs_node *rn = vp->v_data;
	struct vattr *attr = &rn->rn_va;
	struct timespec now;
	kauth_cred_t cred = ap->a_cred;
	int error;

#define	CHANGED(a, t)	(vap->a != (t)VNOVAL)
#define SETIFVAL(a,t) if (CHANGED(a, t)) rn->rn_va.a = vap->a
	if (CHANGED(va_atime.tv_sec, time_t) ||
	    CHANGED(va_ctime.tv_sec, time_t) ||
	    CHANGED(va_mtime.tv_sec, time_t) ||
	    CHANGED(va_birthtime.tv_sec, time_t) ||
	    CHANGED(va_atime.tv_nsec, long) ||
	    CHANGED(va_ctime.tv_nsec, long) ||
	    CHANGED(va_mtime.tv_nsec, long) ||
	    CHANGED(va_birthtime.tv_nsec, long)) {
		error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_TIMES, vp,
		    NULL, genfs_can_chtimes(vp, cred, attr->va_uid,
		    vap->va_vaflags));
		if (error)
			return error;
	}

	int flags = 0;
	getnanotime(&now);
	if (vap->va_atime.tv_sec != VNOVAL)
		if (!(vp->v_mount->mnt_flag & MNT_NOATIME))
			flags |= RUMPFS_ACCESS;
	if (vap->va_mtime.tv_sec != VNOVAL) {
		flags |= RUMPFS_CHANGE | RUMPFS_MODIFY;
		if (vp->v_mount->mnt_flag & MNT_RELATIME)
			flags |= RUMPFS_ACCESS;
	} else if (vap->va_size == 0) {
		flags |= RUMPFS_MODIFY;
		vap->va_mtime = now;
	}
	SETIFVAL(va_birthtime.tv_sec, time_t);
	SETIFVAL(va_birthtime.tv_nsec, long);
	flags |= RUMPFS_CHANGE;
	error = rumpfs_update(flags, vp, &vap->va_atime, &vap->va_mtime, &now);
	if (error)
		return error;

	if (CHANGED(va_flags, u_long)) {
		/* XXX Can we handle system flags here...? */
		error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_FLAGS, vp,
		    NULL, genfs_can_chflags(vp, cred, attr->va_uid, false));
		if (error)
			return error;
	}

	SETIFVAL(va_flags, u_long);
#undef  SETIFVAL
#undef	CHANGED

	if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (uid_t)VNOVAL) {
		uid_t uid =
		    (vap->va_uid != (uid_t)VNOVAL) ? vap->va_uid : attr->va_uid;
		gid_t gid =
		    (vap->va_gid != (gid_t)VNOVAL) ? vap->va_gid : attr->va_gid;
		error = kauth_authorize_vnode(cred,
		    KAUTH_VNODE_CHANGE_OWNERSHIP, vp, NULL,
		    genfs_can_chown(vp, cred, attr->va_uid, attr->va_gid, uid,
		    gid));
		if (error)
			return error;
		attr->va_uid = uid;
		attr->va_gid = gid;
	}

	if (vap->va_mode != (mode_t)VNOVAL) {
		mode_t mode = vap->va_mode;
		error = kauth_authorize_vnode(cred, KAUTH_VNODE_WRITE_SECURITY,
		    vp, NULL, genfs_can_chmod(vp, cred, attr->va_uid,
		    attr->va_gid, mode));
		if (error)
			return error;
		attr->va_mode = mode;
	}

	if (vp->v_type == VREG &&
	    vap->va_size != VSIZENOTSET &&
	    vap->va_size != rn->rn_dlen &&
	    (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0) {
		void *newdata;
		size_t copylen, newlen;

		newlen = vap->va_size;
		newdata = rump_hypermalloc(newlen, 0, false, "rumpfs");
		if (newdata == NULL)
			return ENOSPC;

		copylen = MIN(rn->rn_dlen, newlen);
		if (copylen > 0)
			memcpy(newdata, rn->rn_data, copylen);
		memset((char *)newdata + copylen, 0, newlen - copylen);

		if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) {
			rump_hyperfree(rn->rn_data, rn->rn_dlen);
		} else {
			rn->rn_flags &= ~RUMPNODE_EXTSTORAGE;
		}

		rn->rn_data = newdata;
		rn->rn_dlen = newlen;
		uvm_vnp_setsize(vp, newlen);
	}
	return 0;
}

static int
rump_vop_mkdir(void *v)
{
	struct vop_mkdir_v3_args /* {
		struct vnode *a_dvp;
		struct vnode **a_vpp;
		struct componentname *a_cnp;
		struct vattr *a_vap;
	}; */ *ap = v;
	struct vnode *dvp = ap->a_dvp;
	struct vnode **vpp = ap->a_vpp;
	struct componentname *cnp = ap->a_cnp;
	struct vattr *va = ap->a_vap;
	struct rumpfs_node *rnd = dvp->v_data, *rn;
	int rv = 0;

	rn = makeprivate(VDIR, va->va_mode & ALLPERMS, NODEV, DEV_BSIZE, false);
	if ((cnp->cn_flags & ISWHITEOUT) != 0)
		rn->rn_va.va_flags |= UF_OPAQUE;
	rn->rn_parent = rnd;
	rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp);
	if (rv) {
		freeprivate(rn);
		return rv;
	}

	makedir(rnd, cnp, rn);

	return rv;
}

static int
rump_vop_rmdir(void *v)
{
        struct vop_rmdir_v2_args /* {
                struct vnode *a_dvp;
                struct vnode *a_vp;
                struct componentname *a_cnp;
        }; */ *ap = v;
	struct vnode *dvp = ap->a_dvp;
	struct vnode *vp = ap->a_vp;
	struct componentname *cnp = ap->a_cnp;
	struct rumpfs_node *rnd = dvp->v_data;
	struct rumpfs_node *rn = vp->v_data;
	struct rumpfs_dent *rd;
	int rv = 0;

	LIST_FOREACH(rd, &rn->rn_dir, rd_entries) {
		if (rd->rd_node != RUMPFS_WHITEOUT) {
			rv = ENOTEMPTY;
			goto out;
		}
	}
	while ((rd = LIST_FIRST(&rn->rn_dir)) != NULL) {
		KASSERT(rd->rd_node == RUMPFS_WHITEOUT);
		LIST_REMOVE(rd, rd_entries);
		kmem_free(rd->rd_name, rd->rd_namelen+1);
		kmem_free(rd, sizeof(*rd));
	}

	freedir(rnd, cnp);
	rn->rn_flags |= RUMPNODE_CANRECLAIM;
	rn->rn_parent = NULL;
	rn->rn_va.va_nlink = 0;

out:
	vput(vp);
	return rv;
}

static int
rump_vop_remove(void *v)
{
        struct vop_remove_v3_args /* {
                struct vnode *a_dvp;
                struct vnode *a_vp;
                struct componentname *a_cnp;
		nlink_t ctx_vp_new_nlink;
        }; */ *ap = v;
	struct vnode *dvp = ap->a_dvp;
	struct vnode *vp = ap->a_vp;
	struct componentname *cnp = ap->a_cnp;
	struct rumpfs_node *rnd = dvp->v_data;
	struct rumpfs_node *rn = vp->v_data;
	int rv = 0;

	if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST)
		return EOPNOTSUPP;

	freedir(rnd, cnp);
	rn->rn_flags |= RUMPNODE_CANRECLAIM;
	rn->rn_va.va_nlink = 0;

	vput(vp);
	return rv;
}

static int
rump_vop_mknod(void *v)
{
	struct vop_mknod_v3_args /* {
		struct vnode *a_dvp;
		struct vnode **a_vpp;
		struct componentname *a_cnp;
		struct vattr *a_vap;
	}; */ *ap = v;
	struct vnode *dvp = ap->a_dvp;
	struct vnode **vpp = ap->a_vpp;
	struct componentname *cnp = ap->a_cnp;
	struct vattr *va = ap->a_vap;
	struct rumpfs_node *rnd = dvp->v_data, *rn;
	int rv;

	rn = makeprivate(va->va_type, va->va_mode & ALLPERMS, va->va_rdev,
	    DEV_BSIZE, false);
	if ((cnp->cn_flags & ISWHITEOUT) != 0)
		rn->rn_va.va_flags |= UF_OPAQUE;
	rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp);
	if (rv) {
		freeprivate(rn);
		return rv;
	}

	makedir(rnd, cnp, rn);

	return rv;
}

static int
rump_vop_create(void *v)
{
	struct vop_create_v3_args /* {
		struct vnode *a_dvp;
		struct vnode **a_vpp;
		struct componentname *a_cnp;
		struct vattr *a_vap;
	}; */ *ap = v;
	struct vnode *dvp = ap->a_dvp;
	struct vnode **vpp = ap->a_vpp;
	struct componentname *cnp = ap->a_cnp;
	struct vattr *va = ap->a_vap;
	struct rumpfs_node *rnd = dvp->v_data, *rn;
	off_t newsize;
	int rv;

	newsize = va->va_type == VSOCK ? DEV_BSIZE : 0;
	rn = makeprivate(va->va_type, va->va_mode & ALLPERMS, NODEV,
	    newsize, false);
	if ((cnp->cn_flags & ISWHITEOUT) != 0)
		rn->rn_va.va_flags |= UF_OPAQUE;
	rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp);
	if (rv) {
		freeprivate(rn);
		return rv;
	}

	makedir(rnd, cnp, rn);

	return rv;
}

static int
rump_vop_symlink(void *v)
{
	struct vop_symlink_v3_args /* {
		struct vnode *a_dvp;
		struct vnode **a_vpp;
		struct componentname *a_cnp;
		struct vattr *a_vap;
		char *a_target;
	}; */ *ap = v;
	struct vnode *dvp = ap->a_dvp;
	struct vnode **vpp = ap->a_vpp;
	struct componentname *cnp = ap->a_cnp;
	struct vattr *va = ap->a_vap;
	struct rumpfs_node *rnd = dvp->v_data, *rn;
	const char *target = ap->a_target;
	size_t linklen;
	int rv;

	linklen = strlen(target);
	KASSERT(linklen < MAXPATHLEN);
	rn = makeprivate(VLNK, va->va_mode & ALLPERMS, NODEV, linklen, false);
	if ((cnp->cn_flags & ISWHITEOUT) != 0)
		rn->rn_va.va_flags |= UF_OPAQUE;
	rv = vcache_get(dvp->v_mount, &rn, sizeof(rn), vpp);
	if (rv) {
		freeprivate(rn);
		return rv;
	}

	makedir(rnd, cnp, rn);

	KASSERT(linklen < MAXPATHLEN);
	rn->rn_linktarg = PNBUF_GET();
	rn->rn_linklen = linklen;
	strcpy(rn->rn_linktarg, target);

	return rv;
}

static int
rump_vop_readlink(void *v)
{
	struct vop_readlink_args /* {
		struct vnode *a_vp;
		struct uio *a_uio;
		kauth_cred_t a_cred;
	}; */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;
	struct uio *uio = ap->a_uio;

	return uiomove(rn->rn_linktarg, rn->rn_linklen, uio);
}

static int
rump_vop_whiteout(void *v)
{
	struct vop_whiteout_args /* {
		struct vnode            *a_dvp;
		struct componentname    *a_cnp;
		int                     a_flags;
	} */ *ap = v;
	struct vnode *dvp = ap->a_dvp;
	struct rumpfs_node *rnd = dvp->v_data;
	struct componentname *cnp = ap->a_cnp;
	int flags = ap->a_flags;

	switch (flags) {
	case LOOKUP:
		break;
	case CREATE:
		makedir(rnd, cnp, RUMPFS_WHITEOUT);
		break;
	case DELETE:
		cnp->cn_flags &= ~DOWHITEOUT; /* cargo culting never fails ? */
		freedir(rnd, cnp);
		break;
	default:
		panic("unknown whiteout op %d", flags);
	}

	return 0;
}

static int
rump_vop_open(void *v)
{
	struct vop_open_args /* {
		struct vnode *a_vp;
		int a_mode;
		kauth_cred_t a_cred;
	} */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;
	int mode = ap->a_mode;
	int error = EINVAL;

	if (vp->v_type != VREG || (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0)
		return 0;

	if (mode & FREAD) {
		if (rn->rn_readfd != -1)
			return 0;
		error = rumpuser_open(rn->rn_hostpath,
		    RUMPUSER_OPEN_RDONLY, &rn->rn_readfd);
	}

	if (mode & FWRITE) {
		if (rn->rn_writefd != -1)
			return 0;
		error = rumpuser_open(rn->rn_hostpath,
		    RUMPUSER_OPEN_WRONLY, &rn->rn_writefd);
	}

	return error;
}

/* simple readdir.  even omits dotstuff and periods */
static int
rump_vop_readdir(void *v)
{
	struct vop_readdir_args /* {
		struct vnode *a_vp;
		struct uio *a_uio;
		kauth_cred_t a_cred;
		int *a_eofflag;
		off_t **a_cookies;
		int *a_ncookies;
	} */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct uio *uio = ap->a_uio;
	struct rumpfs_node *rnd = vp->v_data;
	struct rumpfs_dent *rdent;
	struct dirent *dentp = NULL;
	unsigned i;
	int rv = 0;

	/* seek to current entry */
	for (i = 0, rdent = LIST_FIRST(&rnd->rn_dir);
	    (i < uio->uio_offset) && rdent;
	    i++, rdent = LIST_NEXT(rdent, rd_entries))
		continue;
	if (!rdent)
		goto out;

	/* copy entries */
	dentp = kmem_alloc(sizeof(*dentp), KM_SLEEP);
	for (; rdent && uio->uio_resid > 0;
	    rdent = LIST_NEXT(rdent, rd_entries), i++) {
		strlcpy(dentp->d_name, rdent->rd_name, sizeof(dentp->d_name));
		dentp->d_namlen = strlen(dentp->d_name);
		dentp->d_reclen = _DIRENT_RECLEN(dentp, dentp->d_namlen);

		if (__predict_false(RDENT_ISWHITEOUT(rdent))) {
			dentp->d_fileno = INO_WHITEOUT;
			dentp->d_type = DT_WHT;
		} else {
			dentp->d_fileno = rdent->rd_node->rn_va.va_fileid;
			dentp->d_type = vtype2dt(rdent->rd_node->rn_va.va_type);
		}

		if (uio->uio_resid < dentp->d_reclen) {
			i--;
			break;
		}

		rv = uiomove(dentp, dentp->d_reclen, uio);
		if (rv) {
			i--;
			break;
		}
	}
	kmem_free(dentp, sizeof(*dentp));
	dentp = NULL;

 out:
	KASSERT(dentp == NULL);
	if (ap->a_cookies) {
		*ap->a_ncookies = 0;
		*ap->a_cookies = NULL;
	}
	if (rdent)
		*ap->a_eofflag = 0;
	else
		*ap->a_eofflag = 1;
	uio->uio_offset = i;

	return rv;
}

static int
etread(struct rumpfs_node *rn, struct uio *uio)
{
	struct rumpuser_iovec iov;
	uint8_t *buf;
	size_t bufsize, n;
	int error = 0;

	bufsize = uio->uio_resid;
	if (bufsize == 0)
		return 0;
	buf = kmem_alloc(bufsize, KM_SLEEP);

	iov.iov_base = buf;
	iov.iov_len = bufsize;
	if ((error = rumpuser_iovread(rn->rn_readfd, &iov, 1,
	    uio->uio_offset + rn->rn_offset, &n)) == 0) {
		KASSERT(n <= bufsize);
		error = uiomove(buf, n, uio);
	}

	kmem_free(buf, bufsize);
	return error;
}

static int
rump_vop_read(void *v)
{
	struct vop_read_args /* {
		struct vnode *a_vp;
		struct uio *a_uio;
		int ioflags a_ioflag;
		kauth_cred_t a_cred;
	}; */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;
	struct uio *uio = ap->a_uio;
	const int advice = IO_ADV_DECODE(ap->a_ioflag);
	off_t chunk;
	int error = 0;
	struct timespec ts;

	if (vp->v_type == VDIR)
		return EISDIR;

	/* et op? */
	if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST)
		return etread(rn, uio);

	getnanotime(&ts);
	(void)rumpfs_update(RUMPFS_ACCESS, vp, &ts, &ts, &ts);

	/* otherwise, it's off to ubc with us */
	while (uio->uio_resid > 0) {
		chunk = MIN(uio->uio_resid, (off_t)rn->rn_dlen-uio->uio_offset);
		if (chunk == 0)
			break;
		error = ubc_uiomove(&vp->v_uobj, uio, chunk, advice,
		    UBC_READ | UBC_PARTIALOK | UBC_VNODE_FLAGS(vp));
		if (error)
			break;
	}

	return error;
}

static int
etwrite(struct rumpfs_node *rn, struct uio *uio)
{
	struct rumpuser_iovec iov;
	uint8_t *buf;
	size_t bufsize, n;
	int error = 0;

	bufsize = uio->uio_resid;
	if (bufsize == 0)
		return 0;
	buf = kmem_alloc(bufsize, KM_SLEEP);
	error = uiomove(buf, bufsize, uio);
	if (error)
		goto out;

	KASSERT(uio->uio_resid == 0);
	iov.iov_base = buf;
	iov.iov_len = bufsize;
	if ((error = rumpuser_iovwrite(rn->rn_writefd, &iov, 1,
	    (uio->uio_offset-bufsize) + rn->rn_offset, &n)) == 0) {
		KASSERT(n <= bufsize);
		uio->uio_resid = bufsize - n;
	}

 out:
	kmem_free(buf, bufsize);
	return error;
}

static int
rump_vop_write(void *v)
{
	struct vop_write_args /* {
		struct vnode *a_vp;
		struct uio *a_uio;
		int ioflags a_ioflag;
		kauth_cred_t a_cred;
	}; */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;
	struct uio *uio = ap->a_uio;
	const int advice = IO_ADV_DECODE(ap->a_ioflag);
	void *olddata;
	size_t oldlen, newlen;
	off_t chunk;
	int error = 0;
	bool allocd = false;
	struct timespec ts;

	getnanotime(&ts);
	(void)rumpfs_update(RUMPFS_MODIFY, vp, &ts, &ts, &ts);

	if (ap->a_ioflag & IO_APPEND)
		uio->uio_offset = vp->v_size;

	/* consult et? */
	if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST)
		return etwrite(rn, uio);

	/*
	 * Otherwise, it's a case of ubcmove.
	 */

	/*
	 * First, make sure we have enough storage.
	 *
	 * No, you don't need to tell me it's not very efficient.
	 * No, it doesn't really support sparse files, just fakes it.
	 */
	newlen = uio->uio_offset + uio->uio_resid;
	oldlen = 0; /* XXXgcc */
	olddata = NULL;
	if (rn->rn_dlen < newlen) {
		oldlen = rn->rn_dlen;
		olddata = rn->rn_data;

		rn->rn_data = rump_hypermalloc(newlen, 0, false, "rumpfs");
		if (rn->rn_data == NULL)
			return ENOSPC;
		rn->rn_dlen = newlen;
		memset(rn->rn_data, 0, newlen);
		if (oldlen > 0)
			memcpy(rn->rn_data, olddata, oldlen);
		allocd = true;
		uvm_vnp_setsize(vp, newlen);
	}

	/* ok, we have enough storage.  write */
	while (uio->uio_resid > 0) {
		chunk = MIN(uio->uio_resid, (off_t)rn->rn_dlen-uio->uio_offset);
		if (chunk == 0)
			break;
		error = ubc_uiomove(&vp->v_uobj, uio, chunk, advice,
		    UBC_WRITE | UBC_PARTIALOK | UBC_VNODE_FLAGS(vp));
		if (error)
			break;
	}

	if (allocd) {
		if (error) {
			rump_hyperfree(rn->rn_data, newlen);
			rn->rn_data = olddata;
			rn->rn_dlen = oldlen;
			uvm_vnp_setsize(vp, oldlen);
		} else {
			if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) {
				rump_hyperfree(olddata, oldlen);
			} else {
				rn->rn_flags &= ~RUMPNODE_EXTSTORAGE;
			}
		}
	}

	return error;
}

static int
rump_vop_bmap(void *v)
{
	struct vop_bmap_args /* {
		struct vnode *a_vp;
		daddr_t a_bn;
		struct vnode **a_vpp;
		daddr_t *a_bnp;
		int *a_runp;
	} */ *ap = v;

	/* 1:1 mapping */
	if (ap->a_vpp)
		*ap->a_vpp = ap->a_vp;
	if (ap->a_bnp)
		*ap->a_bnp = ap->a_bn;
	if (ap->a_runp)
		*ap->a_runp = 16;

	return 0;
}

static int
rump_vop_strategy(void *v)
{
	struct vop_strategy_args /* {
		struct vnode *a_vp;
		struct buf *a_bp;
	} */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;
	struct buf *bp = ap->a_bp;
	off_t copylen, copyoff;
	int error;

	if (vp->v_type != VREG || rn->rn_flags & RUMPNODE_ET_PHONE_HOST) {
		error = EINVAL;
		goto out;
	}

	copyoff = bp->b_blkno << DEV_BSHIFT;
	copylen = MIN(rn->rn_dlen - copyoff, bp->b_bcount);
	if (BUF_ISWRITE(bp)) {
		memcpy((uint8_t *)rn->rn_data + copyoff, bp->b_data, copylen);
	} else {
		memset((uint8_t*)bp->b_data + copylen, 0, bp->b_bcount-copylen);
		memcpy(bp->b_data, (uint8_t *)rn->rn_data + copyoff, copylen);
	}
	bp->b_resid = 0;
	error = 0;

 out:
	bp->b_error = error;
	biodone(bp);
	return 0;
}

static int
rump_vop_pathconf(void *v)
{
	struct vop_pathconf_args /* {
		struct vnode *a_vp;
		int a_name;
		register_t *a_retval;
	}; */ *ap = v;
	int name = ap->a_name;
	register_t *retval = ap->a_retval;

	switch (name) {
	case _PC_LINK_MAX:
		*retval = LINK_MAX;
		return 0;
	case _PC_NAME_MAX:
		*retval = RUMPFS_MAXNAMLEN;
		return 0;
	case _PC_PATH_MAX:
		*retval = PATH_MAX;
		return 0;
	case _PC_PIPE_BUF:
		*retval = PIPE_BUF;
		return 0;
	case _PC_CHOWN_RESTRICTED:
		*retval = 1;
		return 0;
	case _PC_NO_TRUNC:
		*retval = 1;
		return 0;
	case _PC_SYNC_IO:
		*retval = 1;
		return 0;
	case _PC_FILESIZEBITS:
		*retval = 43; /* this one goes to 11 */
		return 0;
	case _PC_SYMLINK_MAX:
		*retval = MAXPATHLEN;
		return 0;
	case _PC_2_SYMLINKS:
		*retval = 1;
		return 0;
	default:
		return EINVAL;
	}
}

static int
rump_vop_success(void *v)
{

	return 0;
}

static int
rump_vop_inactive(void *v)
{
	struct vop_inactive_v2_args /* {
		struct vnode *a_vp;
		bool *a_recycle;
	} */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;

	if (rn->rn_flags & RUMPNODE_ET_PHONE_HOST && vp->v_type == VREG) {
		if (rn->rn_readfd != -1) {
			rumpuser_close(rn->rn_readfd);
			rn->rn_readfd = -1;
		}
		if (rn->rn_writefd != -1) {
			rumpuser_close(rn->rn_writefd);
			rn->rn_writefd = -1;
		}
	}
	*ap->a_recycle = (rn->rn_flags & RUMPNODE_CANRECLAIM) ? true : false;

	return 0;
}

static int
rump_vop_reclaim(void *v)
{
	struct vop_reclaim_v2_args /* {
		struct vnode *a_vp;
	} */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;

	VOP_UNLOCK(vp);

	mutex_enter(&reclock);
	rn->rn_vp = NULL;
	mutex_exit(&reclock);
	genfs_node_destroy(vp);
	vp->v_data = NULL;

	if (rn->rn_flags & RUMPNODE_CANRECLAIM) {
		if (vp->v_type == VREG
		    && (rn->rn_flags & RUMPNODE_ET_PHONE_HOST) == 0
		    && rn->rn_data) {
			if ((rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) {
				rump_hyperfree(rn->rn_data, rn->rn_dlen);
			} else {
				rn->rn_flags &= ~RUMPNODE_EXTSTORAGE;
			}
			rn->rn_data = NULL;
		}

		if (vp->v_type == VLNK)
			PNBUF_PUT(rn->rn_linktarg);
		if (rn->rn_hostpath)
			free(rn->rn_hostpath, M_TEMP);
		freeprivate(rn);
	}

	return 0;
}

static int
rump_vop_spec(void *v)
{
	struct vop_generic_args *ap = v;
	int (**opvec)(void *);

	switch (ap->a_desc->vdesc_offset) {
	case VOP_ACCESS_DESCOFFSET:
	case VOP_ACCESSX_DESCOFFSET:
	case VOP_GETATTR_DESCOFFSET:
	case VOP_SETATTR_DESCOFFSET:
	case VOP_LOCK_DESCOFFSET:
	case VOP_UNLOCK_DESCOFFSET:
	case VOP_ISLOCKED_DESCOFFSET:
	case VOP_INACTIVE_DESCOFFSET:
	case VOP_RECLAIM_DESCOFFSET:
		opvec = rump_vnodeop_p;
		break;
	default:
		opvec = spec_vnodeop_p;
		break;
	}

	return VOCALL(opvec, ap->a_desc->vdesc_offset, v);
}

static int
rump_vop_advlock(void *v)
{
	struct vop_advlock_args /* {
		const struct vnodeop_desc *a_desc;
		struct vnode *a_vp;
		void *a_id;
		int a_op;
		struct flock *a_fl;
		int a_flags;
	} */ *ap = v;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;

	return lf_advlock(ap, &rn->rn_lockf, vp->v_size);
}

static int
rump_vop_fcntl(void *v)
{
	struct vop_fcntl_args /* {
		struct vnode *a_vp;
		u_int a_command;
		void *a_data;
		int a_fflag;
		kauth_cred_t a_cred;
	} */ *ap = v;
	struct proc *p = curproc;
	struct vnode *vp = ap->a_vp;
	struct rumpfs_node *rn = vp->v_data;
	u_int cmd = ap->a_command;
	int fflag = ap->a_fflag;
	struct rumpfs_extstorage *rfse = ap->a_data;
	int error = 0;

	/* none of the current rumpfs fcntlops are defined for remotes */
	if (!RUMP_LOCALPROC_P(p))
		return EINVAL;

	switch (cmd) {
	case RUMPFS_FCNTL_EXTSTORAGE_ADD:
		break;
	default:
		return EINVAL;
	}

	if ((fflag & FWRITE) == 0)
		return EBADF;

	if (vp->v_type != VREG || (rn->rn_flags & RUMPNODE_ET_PHONE_HOST))
		return EINVAL;

	if (rfse->rfse_flags != 0)
		return EINVAL;

	/*
	 * Ok, we are good to go.  Process.
	 */

	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);

	KASSERT(cmd == RUMPFS_FCNTL_EXTSTORAGE_ADD);
	if (rn->rn_data && (rn->rn_flags & RUMPNODE_EXTSTORAGE) == 0) {
		rump_hyperfree(rn->rn_data, rn->rn_dlen);
	}

	rn->rn_data = rfse->rfse_data;
	rn->rn_dlen = rfse->rfse_dlen;
	uvm_vnp_setsize(vp, rn->rn_dlen);
	rn->rn_flags |= RUMPNODE_EXTSTORAGE;

	VOP_UNLOCK(vp);

	return error;
}

/*
 * Begin vfs-level stuff
 */

VFS_PROTOS(rumpfs);
struct vfsops rumpfs_vfsops = {
	.vfs_name =		MOUNT_RUMPFS,
	.vfs_min_mount_data = 	0,
	.vfs_mount =		rumpfs_mount,
	.vfs_start =		(void *)nullop,
	.vfs_unmount = 		rumpfs_unmount,
	.vfs_root =		rumpfs_root,
	.vfs_quotactl =		(void *)eopnotsupp,
	.vfs_statvfs =		genfs_statvfs,
	.vfs_sync =		(void *)nullop,
	.vfs_vget =		rumpfs_vget,
	.vfs_loadvnode =	rumpfs_loadvnode,
	.vfs_fhtovp =		(void *)eopnotsupp,
	.vfs_vptofh =		(void *)eopnotsupp,
	.vfs_init =		rumpfs_init,
	.vfs_reinit =		NULL,
	.vfs_done =		rumpfs_done,
	.vfs_mountroot =	rumpfs_mountroot,
	.vfs_snapshot =		(void *)eopnotsupp,
	.vfs_extattrctl =	(void *)eopnotsupp,
	.vfs_suspendctl =	genfs_suspendctl,
	.vfs_renamelock_enter =	genfs_renamelock_enter,
	.vfs_renamelock_exit =	genfs_renamelock_exit,
	.vfs_opv_descs =	rump_opv_descs,
	/* vfs_refcount */
	/* vfs_list */
};

static int
rumpfs_mountfs(struct mount *mp)
{
	struct rumpfs_mount *rfsmp;
	struct rumpfs_node *rn;
	int error;

	rfsmp = kmem_alloc(sizeof(*rfsmp), KM_SLEEP);

	rn = makeprivate(VDIR, RUMPFS_DEFAULTMODE, NODEV, DEV_BSIZE, false);
	rn->rn_parent = rn;
	if ((error = vcache_get(mp, &rn, sizeof(rn), &rfsmp->rfsmp_rvp))
	    != 0) {
		freeprivate(rn);
		kmem_free(rfsmp, sizeof(*rfsmp));
		return error;
	}

	rfsmp->rfsmp_rvp->v_vflag |= VV_ROOT;

	mp->mnt_data = rfsmp;
	mp->mnt_stat.f_namemax = RUMPFS_MAXNAMLEN;
	mp->mnt_stat.f_iosize = 512;
	mp->mnt_flag |= MNT_LOCAL;
	mp->mnt_iflag |= IMNT_MPSAFE | IMNT_CAN_RWTORO;
	mp->mnt_fs_bshift = DEV_BSHIFT;
	vfs_getnewfsid(mp);

	return 0;
}

int
rumpfs_mount(struct mount *mp, const char *mntpath, void *arg, size_t *alen)
{
	int error, flags;

	if (mp->mnt_flag & MNT_GETARGS) {
		return 0;
	}
	if (mp->mnt_flag & MNT_UPDATE) {
		if ((mp->mnt_iflag & IMNT_WANTRDONLY)) {
			/* Changing from read/write to read-only. */
			flags = WRITECLOSE;
			if ((mp->mnt_flag & MNT_FORCE))
				flags |= FORCECLOSE;
			error = vflush(mp, NULL, flags);
			if (error)
				return error;
		}
		return 0;
	}

	error = set_statvfs_info(mntpath, UIO_USERSPACE, "rumpfs", UIO_SYSSPACE,
	    mp->mnt_op->vfs_name, mp, curlwp);
	if (error)
		return error;

	return rumpfs_mountfs(mp);
}

int
rumpfs_unmount(struct mount *mp, int mntflags)
{
	struct rumpfs_mount *rfsmp = mp->mnt_data;
	int flags = 0, error;

	if (panicstr || mntflags & MNT_FORCE)
		flags |= FORCECLOSE;

	if (vrefcnt(rfsmp->rfsmp_rvp) > 1 && (flags & FORCECLOSE) == 0)
		return EBUSY;

	if ((error = vflush(mp, rfsmp->rfsmp_rvp, flags)) != 0)
		return error;
	vgone(rfsmp->rfsmp_rvp);

	kmem_free(rfsmp, sizeof(*rfsmp));

	return 0;
}

int
rumpfs_root(struct mount *mp, int lktype, struct vnode **vpp)
{
	struct rumpfs_mount *rfsmp = mp->mnt_data;

	vref(rfsmp->rfsmp_rvp);
	vn_lock(rfsmp->rfsmp_rvp, lktype | LK_RETRY);
	*vpp = rfsmp->rfsmp_rvp;
	return 0;
}

int
rumpfs_vget(struct mount *mp, ino_t ino, int lktype, struct vnode **vpp)
{

	return EOPNOTSUPP;
}

int
rumpfs_loadvnode(struct mount *mp, struct vnode *vp,
    const void *key, size_t key_len, const void **new_key)
{
	struct rumpfs_node *rn;
	struct vattr *va;

	KASSERT(!mutex_owned(&reclock));

	KASSERT(key_len == sizeof(rn));
	memcpy(&rn, key, key_len);

	va = &rn->rn_va;

	vp->v_tag = VT_RUMP;
	vp->v_type = va->va_type;
	switch (vp->v_type) {
	case VCHR:
	case VBLK:
		vp->v_op = rump_specop_p;
		spec_node_init(vp, va->va_rdev);
		break;
	default:
		vp->v_op = rump_vnodeop_p;
		break;
	}
	vp->v_size = vp->v_writesize = va->va_size;
	vp->v_data = rn;

	genfs_node_init(vp, &rumpfs_genfsops);
	mutex_enter(&reclock);
	rn->rn_vp = vp;
	mutex_exit(&reclock);

	*new_key = &vp->v_data;

	return 0;
}

void
rumpfs_init()
{
	extern rump_etfs_register_withsize_fn rump__etfs_register;
	extern rump_etfs_remove_fn rump__etfs_remove;
	extern struct rump_boot_etfs *ebstart;
	struct rump_boot_etfs *eb;

	CTASSERT(RUMP_ETFS_SIZE_ENDOFF == RUMPBLK_SIZENOTSET);

	mutex_init(&reclock, MUTEX_DEFAULT, IPL_NONE);
	mutex_init(&etfs_lock, MUTEX_DEFAULT, IPL_NONE);

	rump__etfs_register = etfsregister;
	rump__etfs_remove = etfsremove;

	for (eb = ebstart; eb; eb = eb->_eb_next) {
		eb->eb_status = etfsregister(eb->eb_key, eb->eb_hostpath,
		    eb->eb_type, eb->eb_begin, eb->eb_size);
	}
}

void
rumpfs_done()
{

	mutex_destroy(&reclock);
	mutex_destroy(&etfs_lock);
}

int
rumpfs_mountroot()
{
	struct mount *mp;
	int error;

	if ((error = vfs_rootmountalloc(MOUNT_RUMPFS, "rootdev", &mp)) != 0) {
		vrele(rootvp);
		return error;
	}

	if ((error = rumpfs_mountfs(mp)) != 0)
		panic("mounting rootfs failed: %d", error);

	mountlist_append(mp);

	error = set_statvfs_info("/", UIO_SYSSPACE, "rumpfs", UIO_SYSSPACE,
	    mp->mnt_op->vfs_name, mp, curlwp);
	if (error)
		panic("set_statvfs_info failed for rootfs: %d", error);

	mp->mnt_flag &= ~MNT_RDONLY;
	vfs_unbusy(mp);

	return 0;
}