[dragonfly.git] / sys / vfs / puffs / puffs_vnops.c

/*	$NetBSD: puffs_vnops.c,v 1.154 2011/07/04 08:07:30 manu Exp $	*/

/*
 * Copyright (c) 2005, 2006, 2007  Antti Kantee.  All Rights Reserved.
 *
 * Development of this software was supported by the
 * Google Summer of Code program and the Ulla Tuominen Foundation.
 * The Google SoC project was mentored by Bill Studenmund.
 *
 * 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/param.h>
#include <sys/buf.h>
#include <sys/lockf.h>
#include <sys/malloc.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/proc.h>

#include <vfs/fifofs/fifo.h>

#include <vfs/puffs/puffs_msgif.h>
#include <vfs/puffs/puffs_sys.h>

int (**puffs_vnodeop_p)(void *);

#define ERROUT(err)							\
do {									\
	error = err;							\
	goto out;							\
} while (/*CONSTCOND*/0)

static int callremove(struct puffs_mount *, puffs_cookie_t, puffs_cookie_t,
			    struct namecache *, struct ucred *);
static int callrmdir(struct puffs_mount *, puffs_cookie_t, puffs_cookie_t,
			   struct namecache *, struct ucred *);
static void callinactive(struct puffs_mount *, puffs_cookie_t, int);
static void callreclaim(struct puffs_mount *, puffs_cookie_t);
static int  flushvncache(struct vnode *, int);


#define PUFFS_ABORT_LOOKUP	1
#define PUFFS_ABORT_CREATE	2
#define PUFFS_ABORT_MKNOD	3
#define PUFFS_ABORT_MKDIR	4
#define PUFFS_ABORT_SYMLINK	5

/*
 * Press the pani^Wabort button!  Kernel resource allocation failed.
 */
static void
puffs_abortbutton(struct puffs_mount *pmp, int what,
	puffs_cookie_t dck, puffs_cookie_t ck,
	struct namecache *ncp, struct ucred *cred)
{

	switch (what) {
	case PUFFS_ABORT_CREATE:
	case PUFFS_ABORT_MKNOD:
	case PUFFS_ABORT_SYMLINK:
		callremove(pmp, dck, ck, ncp, cred);
		break;
	case PUFFS_ABORT_MKDIR:
		callrmdir(pmp, dck, ck, ncp, cred);
		break;
	}

	callinactive(pmp, ck, 0);
	callreclaim(pmp, ck);
}

/*
 * Begin vnode operations.
 *
 * A word from the keymaster about locks: generally we don't want
 * to use the vnode locks at all: it creates an ugly dependency between
 * the userlandia file server and the kernel.  But we'll play along with
 * the kernel vnode locks for now.  However, even currently we attempt
 * to release locks as early as possible.  This is possible for some
 * operations which a) don't need a locked vnode after the userspace op
 * and b) return with the vnode unlocked.  Theoretically we could
 * unlock-do op-lock for others and order the graph in userspace, but I
 * don't want to think of the consequences for the time being.
 */
static int
puffs_vnop_lookup(struct vop_nresolve_args *ap)
{
	PUFFS_MSG_VARS(vn, lookup);
	struct puffs_mount *pmp = MPTOPUFFSMP(ap->a_dvp->v_mount);
	struct nchandle *nch = ap->a_nch;
	struct namecache *ncp = nch->ncp;
	struct ucred *cred = ap->a_cred;
	struct vnode *vp = NULL, *dvp = ap->a_dvp;
	struct puffs_node *dpn;
	int error;

	DPRINTF(("puffs_lookup: \"%s\", parent vnode %p\n",
	    ncp->nc_name, dvp));

	PUFFS_MSG_ALLOC(vn, lookup);
	puffs_makecn(&lookup_msg->pvnr_cn, &lookup_msg->pvnr_cn_cred,
	    ncp, cred);

	puffs_msg_setinfo(park_lookup, PUFFSOP_VN,
	    PUFFS_VN_LOOKUP, VPTOPNC(dvp));
	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_lookup, dvp->v_data, NULL, error);
	DPRINTF(("puffs_lookup: return of the userspace, part %d\n", error));
	if (error) {
		error = checkerr(pmp, error, __func__);
		if (error == ENOENT)
			cache_setvp(nch, NULL);
		goto out;
	}

	/*
	 * Check that we don't get our parent node back, that would cause
	 * a pretty obvious deadlock.
	 */
	dpn = VPTOPP(dvp);
	if (lookup_msg->pvnr_newnode == dpn->pn_cookie) {
		puffs_senderr(pmp, PUFFS_ERR_LOOKUP, EINVAL,
		    "lookup produced parent cookie", lookup_msg->pvnr_newnode);
		error = EPROTO;
		goto out;
	}

	error = puffs_cookie2vnode(pmp, lookup_msg->pvnr_newnode, 1, &vp);
	if (error == PUFFS_NOSUCHCOOKIE) {
		error = puffs_getvnode(dvp->v_mount,
		    lookup_msg->pvnr_newnode, lookup_msg->pvnr_vtype,
		    lookup_msg->pvnr_size, &vp);
		if (error) {
			puffs_abortbutton(pmp, PUFFS_ABORT_LOOKUP, VPTOPNC(dvp),
			    lookup_msg->pvnr_newnode, ncp, cred);
			goto out;
		}
	} else if (error) {
		puffs_abortbutton(pmp, PUFFS_ABORT_LOOKUP, VPTOPNC(dvp),
		    lookup_msg->pvnr_newnode, ncp, cred);
		goto out;
	}

 out:
	if (!error && vp != NULL) {
		vn_unlock(vp);
		cache_setvp(nch, vp);
		vrele(vp);
	}
	DPRINTF(("puffs_lookup: returning %d\n", error));
	PUFFS_MSG_RELEASE(lookup);
	return error;
}

static int
puffs_vnop_lookupdotdot(struct vop_nlookupdotdot_args *ap)
{
	PUFFS_MSG_VARS(vn, lookupdotdot);
	struct puffs_mount *pmp = MPTOPUFFSMP(ap->a_dvp->v_mount);
	struct ucred *cred = ap->a_cred;
	struct vnode *vp, *dvp = ap->a_dvp;
	struct puffs_node *dpn;
	int error;

	*ap->a_vpp = NULL;

	DPRINTF(("puffs_lookupdotdot: vnode %p\n", dvp));

	PUFFS_MSG_ALLOC(vn, lookupdotdot);
	puffs_credcvt(&lookupdotdot_msg->pvnr_cred, cred);

	puffs_msg_setinfo(park_lookupdotdot, PUFFSOP_VN,
	    PUFFS_VN_LOOKUPDOTDOT, VPTOPNC(dvp));
	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_lookupdotdot, dvp->v_data, NULL,
	    error);
	DPRINTF(("puffs_lookupdotdot: return of the userspace, part %d\n",
	    error));
	if (error) {
		error = checkerr(pmp, error, __func__);
		goto out;
	}

	/*
	 * Check that we don't get our node back, that would cause
	 * a pretty obvious deadlock.
	 */
	dpn = VPTOPP(dvp);
	if (lookupdotdot_msg->pvnr_newnode == dpn->pn_cookie) {
		puffs_senderr(pmp, PUFFS_ERR_LOOKUP, EINVAL,
		    "lookupdotdot produced the same cookie",
		    lookupdotdot_msg->pvnr_newnode);
		error = EPROTO;
		goto out;
	}

	error = puffs_cookie2vnode(pmp, lookupdotdot_msg->pvnr_newnode,
	    1, &vp);
	if (error == PUFFS_NOSUCHCOOKIE) {
		error = puffs_getvnode(dvp->v_mount,
		    lookupdotdot_msg->pvnr_newnode, VDIR, 0, &vp);
		if (error) {
			puffs_abortbutton(pmp, PUFFS_ABORT_LOOKUP, VPTOPNC(dvp),
			    lookupdotdot_msg->pvnr_newnode, NULL, cred);
			goto out;
		}
	} else if (error) {
		puffs_abortbutton(pmp, PUFFS_ABORT_LOOKUP, VPTOPNC(dvp),
		    lookupdotdot_msg->pvnr_newnode, NULL, cred);
		goto out;
	}

	*ap->a_vpp = vp;
	vn_unlock(vp);

 out:
	DPRINTF(("puffs_lookupdotdot: returning %d %p\n", error, *ap->a_vpp));
	PUFFS_MSG_RELEASE(lookupdotdot);
	return error;
}

static int
puffs_vnop_create(struct vop_ncreate_args *ap)
{
	PUFFS_MSG_VARS(vn, create);
	struct vnode *dvp = ap->a_dvp;
	struct vattr *vap = ap->a_vap;
	struct puffs_node *dpn = VPTOPP(dvp);
	struct nchandle *nch = ap->a_nch;
	struct namecache *ncp = nch->ncp;
	struct ucred *cred = ap->a_cred;
	struct mount *mp = dvp->v_mount;
	struct puffs_mount *pmp = MPTOPUFFSMP(mp);
	int error;

	if (!EXISTSOP(pmp, CREATE))
		return EOPNOTSUPP;

	DPRINTF(("puffs_create: dvp %p, name: %s\n",
	    dvp, ncp->nc_name));

	if (vap->va_type != VREG && vap->va_type != VSOCK)
		return EINVAL;

	if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
		DPRINTF(("puffs_vnop_create: EAGAIN on ncp %p %s\n",
		    ncp, ncp->nc_name));
		return EAGAIN;
	}

	PUFFS_MSG_ALLOC(vn, create);
	puffs_makecn(&create_msg->pvnr_cn, &create_msg->pvnr_cn_cred,
	    ncp, cred);
	create_msg->pvnr_va = *ap->a_vap;
	puffs_msg_setinfo(park_create, PUFFSOP_VN,
	    PUFFS_VN_CREATE, VPTOPNC(dvp));
	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_create, dvp->v_data, NULL, error);

	error = checkerr(pmp, error, __func__);
	if (error)
		goto out;

	error = puffs_newnode(mp, dvp, ap->a_vpp,
	    create_msg->pvnr_newnode, vap->va_type);
	if (error)
		puffs_abortbutton(pmp, PUFFS_ABORT_CREATE, dpn->pn_cookie,
		    create_msg->pvnr_newnode, ncp, cred);

 out:
	DPRINTF(("puffs_create: return %d\n", error));
	vput(dvp);
	if (!error) {
		cache_setunresolved(nch);
		cache_setvp(nch, *ap->a_vpp);
	}
	PUFFS_MSG_RELEASE(create);
	return error;
}

static int
puffs_vnop_mknod(struct vop_nmknod_args *ap)
{
	PUFFS_MSG_VARS(vn, mknod);
	struct vnode *dvp = ap->a_dvp;
	struct vattr *vap = ap->a_vap;
	struct puffs_node *dpn = VPTOPP(dvp);
	struct nchandle *nch = ap->a_nch;
	struct namecache *ncp = nch->ncp;
	struct ucred *cred = ap->a_cred;
	struct mount *mp = dvp->v_mount;
	struct puffs_mount *pmp = MPTOPUFFSMP(mp);
	int error;

	if (!EXISTSOP(pmp, MKNOD))
		return EOPNOTSUPP;

	DPRINTF(("puffs_mknod: dvp %p, name: %s\n",
	    dvp, ncp->nc_name));

	if (vap->va_type != VFIFO)
		return EINVAL;

	if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
		DPRINTF(("puffs_vnop_mknod: EAGAIN on ncp %p %s\n",
		    ncp, ncp->nc_name));
		return EAGAIN;
	}

	PUFFS_MSG_ALLOC(vn, mknod);
	puffs_makecn(&mknod_msg->pvnr_cn, &mknod_msg->pvnr_cn_cred,
	    ncp, cred);
	mknod_msg->pvnr_va = *ap->a_vap;
	puffs_msg_setinfo(park_mknod, PUFFSOP_VN,
	    PUFFS_VN_MKNOD, VPTOPNC(dvp));

	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_mknod, dvp->v_data, NULL, error);

	error = checkerr(pmp, error, __func__);
	if (error)
		goto out;

	error = puffs_newnode(mp, dvp, ap->a_vpp,
	    mknod_msg->pvnr_newnode, vap->va_type);
	if (error)
		puffs_abortbutton(pmp, PUFFS_ABORT_MKNOD, dpn->pn_cookie,
		    mknod_msg->pvnr_newnode, ncp, cred);

 out:
	vput(dvp);
	if (!error) {
		cache_setunresolved(nch);
		cache_setvp(nch, *ap->a_vpp);
	}
	PUFFS_MSG_RELEASE(mknod);
	return error;
}

static int
puffs_vnop_open(struct vop_open_args *ap)
{
	PUFFS_MSG_VARS(vn, open);
	struct vnode *vp = ap->a_vp;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	int mode = ap->a_mode;
	int error;

	DPRINTF(("puffs_open: vp %p, mode 0x%x\n", vp, mode));

	if (vp->v_type == VREG && mode & FWRITE && !EXISTSOP(pmp, WRITE))
		ERROUT(EROFS);

	if (!EXISTSOP(pmp, OPEN))
		ERROUT(0);

	PUFFS_MSG_ALLOC(vn, open);
	open_msg->pvnr_mode = mode;
	puffs_credcvt(&open_msg->pvnr_cred, ap->a_cred);
	puffs_msg_setinfo(park_open, PUFFSOP_VN,
	    PUFFS_VN_OPEN, VPTOPNC(vp));

	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_open, vp->v_data, NULL, error);
	error = checkerr(pmp, error, __func__);

 out:
	DPRINTF(("puffs_open: returning %d\n", error));
	PUFFS_MSG_RELEASE(open);
	if (error)
		return error;
	return vop_stdopen(ap);
}

static int
puffs_vnop_close(struct vop_close_args *ap)
{
	PUFFS_MSG_VARS(vn, close);
	struct vnode *vp = ap->a_vp;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);

	if (!EXISTSOP(pmp, CLOSE))
		return vop_stdclose(ap);

	PUFFS_MSG_ALLOC(vn, close);
	puffs_msg_setfaf(park_close);
	close_msg->pvnr_fflag = ap->a_fflag;
	puffs_msg_setinfo(park_close, PUFFSOP_VN,
	    PUFFS_VN_CLOSE, VPTOPNC(vp));

	puffs_msg_enqueue(pmp, park_close);
	PUFFS_MSG_RELEASE(close);
	return vop_stdclose(ap);
}

static int
puffs_vnop_access(struct vop_access_args *ap)
{
	PUFFS_MSG_VARS(vn, access);
	struct vnode *vp = ap->a_vp;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	int mode = ap->a_mode;
	int error;

	if (mode & VWRITE) {
		switch (vp->v_type) {
		case VDIR:
		case VLNK:
		case VREG:
			if ((vp->v_mount->mnt_flag & MNT_RDONLY)
			    || !EXISTSOP(pmp, WRITE))
				return EROFS;
			break;
		default:
			break;
		}
	}

	if (!EXISTSOP(pmp, ACCESS))
		return 0;

	PUFFS_MSG_ALLOC(vn, access);
	access_msg->pvnr_mode = ap->a_mode;
	puffs_credcvt(&access_msg->pvnr_cred, ap->a_cred);
	puffs_msg_setinfo(park_access, PUFFSOP_VN,
	    PUFFS_VN_ACCESS, VPTOPNC(vp));

	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_access, vp->v_data, NULL, error);
	error = checkerr(pmp, error, __func__);
	PUFFS_MSG_RELEASE(access);

	return error;
}

static int
puffs_vnop_getattr(struct vop_getattr_args *ap)
{
	PUFFS_MSG_VARS(vn, getattr);
	struct vnode *vp = ap->a_vp;
	struct mount *mp = vp->v_mount;
	struct puffs_mount *pmp = MPTOPUFFSMP(mp);
	struct vattr *vap, *rvap;
	struct puffs_node *pn = VPTOPP(vp);
	int error = 0;

	if (vp->v_type == VBLK || vp->v_type == VCHR)
		return ENOTSUP;

	vap = ap->a_vap;

	PUFFS_MSG_ALLOC(vn, getattr);
	vattr_null(&getattr_msg->pvnr_va);
	puffs_credcvt(&getattr_msg->pvnr_cred, curproc->p_ucred);
	puffs_msg_setinfo(park_getattr, PUFFSOP_VN,
	    PUFFS_VN_GETATTR, VPTOPNC(vp));

	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_getattr, vp->v_data, NULL, error);
	error = checkerr(pmp, error, __func__);
	if (error)
		goto out;

	rvap = &getattr_msg->pvnr_va;

	(void) memcpy(vap, rvap, sizeof(struct vattr));
	vap->va_fsid = mp->mnt_stat.f_fsid.val[0];

	if (pn->pn_stat & PNODE_METACACHE_ATIME)
		vap->va_atime = pn->pn_mc_atime;
	if (pn->pn_stat & PNODE_METACACHE_CTIME)
		vap->va_ctime = pn->pn_mc_ctime;
	if (pn->pn_stat & PNODE_METACACHE_MTIME)
		vap->va_mtime = pn->pn_mc_mtime;
	if (pn->pn_stat & PNODE_METACACHE_SIZE) {
		vap->va_size = pn->pn_mc_size;
	} else {
		if (rvap->va_size != VNOVAL
		    && vp->v_type != VBLK && vp->v_type != VCHR) {
			pn->pn_serversize = rvap->va_size;
			if (vp->v_type == VREG)
				puffs_meta_setsize(vp, rvap->va_size, 0);
		}
	}

 out:
	PUFFS_MSG_RELEASE(getattr);
	return error;
}

#define SETATTR_CHSIZE	0x01
#define SETATTR_ASYNC	0x02
static int
dosetattr(struct vnode *vp, struct vattr *vap, struct ucred *cred, int flags)
{
	PUFFS_MSG_VARS(vn, setattr);
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	struct puffs_node *pn = VPTOPP(vp);
	int error = 0;

	if ((vp->v_mount->mnt_flag & MNT_RDONLY) &&
	    (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL
	    || vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL
	    || vap->va_mode != (mode_t)VNOVAL))
		return EROFS;

	if ((vp->v_mount->mnt_flag & MNT_RDONLY)
	    && vp->v_type == VREG && vap->va_size != VNOVAL)
		return EROFS;

	/*
	 * Flush metacache first.  If we are called with some explicit
	 * parameters, treat them as information overriding metacache
	 * information.
	 */
	if (pn->pn_stat & PNODE_METACACHE_MASK) {
		if ((pn->pn_stat & PNODE_METACACHE_ATIME)
		    && vap->va_atime.tv_sec == VNOVAL)
			vap->va_atime = pn->pn_mc_atime;
		if ((pn->pn_stat & PNODE_METACACHE_CTIME)
		    && vap->va_ctime.tv_sec == VNOVAL)
			vap->va_ctime = pn->pn_mc_ctime;
		if ((pn->pn_stat & PNODE_METACACHE_MTIME)
		    && vap->va_mtime.tv_sec == VNOVAL)
			vap->va_mtime = pn->pn_mc_mtime;
		if ((pn->pn_stat & PNODE_METACACHE_SIZE)
		    && vap->va_size == VNOVAL)
			vap->va_size = pn->pn_mc_size;

		pn->pn_stat &= ~PNODE_METACACHE_MASK;
	}

	PUFFS_MSG_ALLOC(vn, setattr);
	(void)memcpy(&setattr_msg->pvnr_va, vap, sizeof(struct vattr));
	puffs_credcvt(&setattr_msg->pvnr_cred, cred);
	puffs_msg_setinfo(park_setattr, PUFFSOP_VN,
	    PUFFS_VN_SETATTR, VPTOPNC(vp));
	if (flags & SETATTR_ASYNC)
		puffs_msg_setfaf(park_setattr);

	puffs_msg_enqueue(pmp, park_setattr);
	if ((flags & SETATTR_ASYNC) == 0)
		error = puffs_msg_wait2(pmp, park_setattr, vp->v_data, NULL);
	PUFFS_MSG_RELEASE(setattr);
	if ((flags & SETATTR_ASYNC) == 0) {
		error = checkerr(pmp, error, __func__);
		if (error)
			return error;
	} else {
		error = 0;
	}

	if (vap->va_size != VNOVAL) {
		pn->pn_serversize = vap->va_size;
		if (flags & SETATTR_CHSIZE)
			puffs_meta_setsize(vp, vap->va_size, 0);
	}

	return 0;
}

static int
puffs_vnop_setattr(struct vop_setattr_args *ap)
{
	return dosetattr(ap->a_vp, ap->a_vap, ap->a_cred, SETATTR_CHSIZE);
}

static __inline int
doinact(struct puffs_mount *pmp, int iaflag)
{

	if (EXISTSOP(pmp, INACTIVE))
		if (pmp->pmp_flags & PUFFS_KFLAG_IAONDEMAND)
			if (iaflag || ALLOPS(pmp))
				return 1;
			else
				return 0;
		else
			return 1;
	else
		return 0;
}

static void
callinactive(struct puffs_mount *pmp, puffs_cookie_t ck, int iaflag)
{
	int error;
	PUFFS_MSG_VARS(vn, inactive);

	if (doinact(pmp, iaflag)) {
		PUFFS_MSG_ALLOC(vn, inactive);
		puffs_msg_setinfo(park_inactive, PUFFSOP_VN,
		    PUFFS_VN_INACTIVE, ck);

		PUFFS_MSG_ENQUEUEWAIT(pmp, park_inactive, error);
		PUFFS_MSG_RELEASE(inactive);
	}
}

/* XXX: callinactive can't setback */
static int
puffs_vnop_inactive(struct vop_inactive_args *ap)
{
	PUFFS_MSG_VARS(vn, inactive);
	struct vnode *vp = ap->a_vp;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	struct puffs_node *pnode = VPTOPP(vp);

	flushvncache(vp, MNT_NOWAIT);

	if (doinact(pmp, pnode->pn_stat & PNODE_DOINACT)) {
		/*
		 * do not wait for reply from userspace, otherwise it may
		 * deadlock.
		 */

		PUFFS_MSG_ALLOC(vn, inactive);
		puffs_msg_setfaf(park_inactive);
		puffs_msg_setinfo(park_inactive, PUFFSOP_VN,
		    PUFFS_VN_INACTIVE, VPTOPNC(vp));

		puffs_msg_enqueue(pmp, park_inactive);
		PUFFS_MSG_RELEASE(inactive);
	}
	pnode->pn_stat &= ~PNODE_DOINACT;

	/*
	 * file server thinks it's gone?  then don't be afraid care,
	 * node's life was already all it would ever be
	 */
	if (pnode->pn_stat & PNODE_NOREFS) {
		pnode->pn_stat |= PNODE_DYING;
		vrecycle(vp);
	}

	return 0;
}

static void
callreclaim(struct puffs_mount *pmp, puffs_cookie_t ck)
{
	PUFFS_MSG_VARS(vn, reclaim);

	if (!EXISTSOP(pmp, RECLAIM))
		return;

	PUFFS_MSG_ALLOC(vn, reclaim);
	puffs_msg_setfaf(park_reclaim);
	puffs_msg_setinfo(park_reclaim, PUFFSOP_VN, PUFFS_VN_RECLAIM, ck);

	puffs_msg_enqueue(pmp, park_reclaim);
	PUFFS_MSG_RELEASE(reclaim);
}

/*
 * always FAF, we don't really care if the server wants to fail to
 * reclaim the node or not
 */
static int
puffs_vnop_reclaim(struct vop_reclaim_args *ap)
{
	struct vnode *vp = ap->a_vp;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	struct puffs_node *pnode = VPTOPP(vp);
	boolean_t notifyserver = TRUE;

	vinvalbuf(vp, V_SAVE, 0, 0);

	/*
	 * first things first: check if someone is trying to reclaim the
	 * root vnode.  do not allow that to travel to userspace.
	 * Note that we don't need to take the lock similarly to
	 * puffs_root(), since there is only one of us.
	 */
	if (vp->v_flag & VROOT) {
		lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
		KKASSERT(pmp->pmp_root != NULL);
		pmp->pmp_root = NULL;
		lockmgr(&pmp->pmp_lock, LK_RELEASE);
		notifyserver = FALSE;
	}

	/*
	 * purge info from kernel before issueing FAF, since we
	 * don't really know when we'll get around to it after
	 * that and someone might race us into node creation
	 */
	lockmgr(&pmp->pmp_lock, LK_EXCLUSIVE);
	LIST_REMOVE(pnode, pn_hashent);
	lockmgr(&pmp->pmp_lock, LK_RELEASE);

	if (notifyserver)
		callreclaim(MPTOPUFFSMP(vp->v_mount), VPTOPNC(vp));

	puffs_putvnode(vp);
	vp->v_data = NULL;

	return 0;
}

#define CSIZE sizeof(**ap->a_cookies)
static int
puffs_vnop_readdir(struct vop_readdir_args *ap)
{
	PUFFS_MSG_VARS(vn, readdir);
	struct vnode *vp = ap->a_vp;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	size_t argsize, tomove, cookiemem, cookiesmax;
	struct uio *uio = ap->a_uio;
	size_t howmuch, resid;
	int error;

	if (!EXISTSOP(pmp, READDIR))
		return EOPNOTSUPP;

	/*
	 * ok, so we need: resid + cookiemem = maxreq
	 * => resid + cookiesize * (resid/minsize) = maxreq
	 * => resid + cookiesize/minsize * resid = maxreq
	 * => (cookiesize/minsize + 1) * resid = maxreq
	 * => resid = maxreq / (cookiesize/minsize + 1)
	 *
	 * Since cookiesize <= minsize and we're not very big on floats,
	 * we approximate that to be 1.  Therefore:
	 *
	 * resid = maxreq / 2;
	 *
	 * Well, at least we didn't have to use differential equations
	 * or the Gram-Schmidt process.
	 *
	 * (yes, I'm very afraid of this)
	 */
	KKASSERT(CSIZE <= _DIRENT_RECLEN(1));

	if (ap->a_cookies) {
		KKASSERT(ap->a_ncookies != NULL);
		if (pmp->pmp_args.pa_fhsize == 0)
			return EOPNOTSUPP;
		resid = PUFFS_TOMOVE(uio->uio_resid, pmp) / 2;
		cookiesmax = resid/_DIRENT_RECLEN(1);
		cookiemem = ALIGN(cookiesmax*CSIZE); /* play safe */
	} else {
		resid = PUFFS_TOMOVE(uio->uio_resid, pmp);
		cookiesmax = 0;
		cookiemem = 0;
	}

	argsize = sizeof(struct puffs_vnmsg_readdir);
	tomove = resid + cookiemem;
	puffs_msgmem_alloc(argsize + tomove, &park_readdir,
	    (void *)&readdir_msg, 1);

	puffs_credcvt(&readdir_msg->pvnr_cred, ap->a_cred);
	readdir_msg->pvnr_offset = uio->uio_offset;
	readdir_msg->pvnr_resid = resid;
	readdir_msg->pvnr_ncookies = cookiesmax;
	readdir_msg->pvnr_eofflag = 0;
	readdir_msg->pvnr_dentoff = cookiemem;
	puffs_msg_setinfo(park_readdir, PUFFSOP_VN,
	    PUFFS_VN_READDIR, VPTOPNC(vp));
	puffs_msg_setdelta(park_readdir, tomove);

	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_readdir, vp->v_data, NULL, error);
	error = checkerr(pmp, error, __func__);
	if (error)
		goto out;

	/* userspace is cheating? */
	if (readdir_msg->pvnr_resid > resid) {
		puffs_senderr(pmp, PUFFS_ERR_READDIR, E2BIG,
		    "resid grew", VPTOPNC(vp));
		ERROUT(EPROTO);
	}
	if (readdir_msg->pvnr_ncookies > cookiesmax) {
		puffs_senderr(pmp, PUFFS_ERR_READDIR, E2BIG,
		    "too many cookies", VPTOPNC(vp));
		ERROUT(EPROTO);
	}

	/* check eof */
	if (readdir_msg->pvnr_eofflag)
		*ap->a_eofflag = 1;

	/* bouncy-wouncy with the directory data */
	howmuch = resid - readdir_msg->pvnr_resid;

	/* force eof if no data was returned (getcwd() needs this) */
	if (howmuch == 0) {
		*ap->a_eofflag = 1;
		goto out;
	}

	error = uiomove(readdir_msg->pvnr_data + cookiemem, howmuch, uio);
	if (error)
		goto out;

	/* provide cookies to caller if so desired */
	if (ap->a_cookies) {
		*ap->a_cookies = kmalloc(readdir_msg->pvnr_ncookies*CSIZE,
		    M_TEMP, M_WAITOK);
		*ap->a_ncookies = readdir_msg->pvnr_ncookies;
		memcpy(*ap->a_cookies, readdir_msg->pvnr_data,
		    *ap->a_ncookies*CSIZE);
	}

	/* next readdir starts here */
	uio->uio_offset = readdir_msg->pvnr_offset;

 out:
	puffs_msgmem_release(park_readdir);
	return error;
}
#undef CSIZE

static int
flushvncache(struct vnode *vp, int waitfor)
{
	struct puffs_node *pn = VPTOPP(vp);
	struct vattr va;
	int error = 0;

	/* flush out information from our metacache, see vop_setattr */
	if (pn->pn_stat & PNODE_METACACHE_MASK
	    && (pn->pn_stat & PNODE_DYING) == 0) {
		vattr_null(&va);
		error = dosetattr(vp, &va, FSCRED, SETATTR_CHSIZE |
		    (waitfor == MNT_NOWAIT ? 0 : SETATTR_ASYNC));
		if (error)
			return error;
	}

	/*
	 * flush pages to avoid being overly dirty
	 */
	vfsync(vp, waitfor, 0, NULL, NULL);

	return error;
}

static int
puffs_vnop_fsync(struct vop_fsync_args *ap)
{
	PUFFS_MSG_VARS(vn, fsync);
	struct vnode *vp = ap->a_vp;
	int waitfor = ap->a_waitfor;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	struct puffs_node *pn = VPTOPP(vp);
	int error, dofaf;

	error = flushvncache(vp, waitfor);
	if (error)
		return error;

	/*
	 * HELLO!  We exit already here if the user server does not
	 * support fsync OR if we should call fsync for a node which
	 * has references neither in the kernel or the fs server.
	 * Otherwise we continue to issue fsync() forward.
	 */
	if (!EXISTSOP(pmp, FSYNC) || (pn->pn_stat & PNODE_DYING))
		return 0;

	dofaf = (waitfor & MNT_WAIT) == 0 || (waitfor & MNT_LAZY) != 0;

	PUFFS_MSG_ALLOC(vn, fsync);
	if (dofaf)
		puffs_msg_setfaf(park_fsync);

	fsync_msg->pvnr_flags = ap->a_flags;
	puffs_msg_setinfo(park_fsync, PUFFSOP_VN,
	    PUFFS_VN_FSYNC, VPTOPNC(vp));

	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_fsync, vp->v_data, NULL, error);
	PUFFS_MSG_RELEASE(fsync);

	error = checkerr(pmp, error, __func__);

	return error;
}

static int
callremove(struct puffs_mount *pmp, puffs_cookie_t dck, puffs_cookie_t ck,
	struct namecache *ncp, struct ucred *cred)
{
	PUFFS_MSG_VARS(vn, remove);
	int error;

	PUFFS_MSG_ALLOC(vn, remove);
	remove_msg->pvnr_cookie_targ = ck;
	puffs_makecn(&remove_msg->pvnr_cn, &remove_msg->pvnr_cn_cred,
	    ncp, cred);
	puffs_msg_setinfo(park_remove, PUFFSOP_VN, PUFFS_VN_REMOVE, dck);

	PUFFS_MSG_ENQUEUEWAIT(pmp, park_remove, error);
	PUFFS_MSG_RELEASE(remove);

	return checkerr(pmp, error, __func__);
}

/*
 * XXX: can't use callremove now because can't catch setbacks with
 * it due to lack of a pnode argument.
 */
static int
puffs_vnop_remove(struct vop_nremove_args *ap)
{
	PUFFS_MSG_VARS(vn, remove);
	struct vnode *dvp = ap->a_dvp;
	struct vnode *vp;
	struct puffs_node *dpn = VPTOPP(dvp);
	struct puffs_node *pn;
	struct nchandle *nch = ap->a_nch;
	struct namecache *ncp = nch->ncp;
	struct ucred *cred = ap->a_cred;
	struct mount *mp = dvp->v_mount;
	struct puffs_mount *pmp = MPTOPUFFSMP(mp);
	int error;

	if (!EXISTSOP(pmp, REMOVE))
		return EOPNOTSUPP;

	error = vget(dvp, LK_EXCLUSIVE);
	if (error != 0) {
		DPRINTF(("puffs_vnop_remove: EAGAIN on parent vnode %p %s\n",
		    dvp, ncp->nc_name));
		return EAGAIN;
	}

	error = cache_vget(nch, cred, LK_EXCLUSIVE, &vp);
	if (error != 0) {
		DPRINTF(("puffs_vnop_remove: cache_vget error: %p %s\n",
		    dvp, ncp->nc_name));
		return EAGAIN;
	}
	if (vp->v_type == VDIR) {
		error = EISDIR;
		goto out;
	}

	pn = VPTOPP(vp);
	PUFFS_MSG_ALLOC(vn, remove);
	remove_msg->pvnr_cookie_targ = VPTOPNC(vp);
	puffs_makecn(&remove_msg->pvnr_cn, &remove_msg->pvnr_cn_cred,
	    ncp, cred);
	puffs_msg_setinfo(park_remove, PUFFSOP_VN,
	    PUFFS_VN_REMOVE, VPTOPNC(dvp));

	puffs_msg_enqueue(pmp, park_remove);
	error = puffs_msg_wait2(pmp, park_remove, dpn, pn);

	PUFFS_MSG_RELEASE(remove);

	error = checkerr(pmp, error, __func__);

 out:
	vput(dvp);
	vn_unlock(vp);
	if (error == 0)
		cache_unlink(nch);
	vrele(vp);
	return error;
}

static int
puffs_vnop_mkdir(struct vop_nmkdir_args *ap)
{
	PUFFS_MSG_VARS(vn, mkdir);
	struct vnode *dvp = ap->a_dvp;
	struct puffs_node *dpn = VPTOPP(dvp);
	struct nchandle *nch = ap->a_nch;
	struct namecache *ncp = nch->ncp;
	struct ucred *cred = ap->a_cred;
	struct mount *mp = dvp->v_mount;
	struct puffs_mount *pmp = MPTOPUFFSMP(mp);
	int error;

	if (!EXISTSOP(pmp, MKDIR))
		return EOPNOTSUPP;

	if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
		DPRINTF(("puffs_vnop_mkdir: EAGAIN on ncp %p %s\n",
		    ncp, ncp->nc_name));
		return EAGAIN;
	}

	PUFFS_MSG_ALLOC(vn, mkdir);
	puffs_makecn(&mkdir_msg->pvnr_cn, &mkdir_msg->pvnr_cn_cred,
	    ncp, cred);
	mkdir_msg->pvnr_va = *ap->a_vap;
	puffs_msg_setinfo(park_mkdir, PUFFSOP_VN,
	    PUFFS_VN_MKDIR, VPTOPNC(dvp));

	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_mkdir, dvp->v_data, NULL, error);

	error = checkerr(pmp, error, __func__);
	if (error)
		goto out;

	error = puffs_newnode(mp, dvp, ap->a_vpp,
	    mkdir_msg->pvnr_newnode, VDIR);
	if (error)
		puffs_abortbutton(pmp, PUFFS_ABORT_MKDIR, dpn->pn_cookie,
		    mkdir_msg->pvnr_newnode, ncp, cred);

 out:
	vput(dvp);
	if (!error) {
		cache_setunresolved(nch);
		cache_setvp(nch, *ap->a_vpp);
	}
	PUFFS_MSG_RELEASE(mkdir);
	return error;
}

static int
callrmdir(struct puffs_mount *pmp, puffs_cookie_t dck, puffs_cookie_t ck,
	struct namecache *ncp, struct ucred *cred)
{
	PUFFS_MSG_VARS(vn, rmdir);
	int error;

	PUFFS_MSG_ALLOC(vn, rmdir);
	rmdir_msg->pvnr_cookie_targ = ck;
	puffs_makecn(&rmdir_msg->pvnr_cn, &rmdir_msg->pvnr_cn_cred,
	    ncp, cred);
	puffs_msg_setinfo(park_rmdir, PUFFSOP_VN, PUFFS_VN_RMDIR, dck);

	PUFFS_MSG_ENQUEUEWAIT(pmp, park_rmdir, error);
	PUFFS_MSG_RELEASE(rmdir);

	return checkerr(pmp, error, __func__);
}

static int
puffs_vnop_rmdir(struct vop_nrmdir_args *ap)
{
	PUFFS_MSG_VARS(vn, rmdir);
	struct vnode *dvp = ap->a_dvp;
	struct vnode *vp;
	struct puffs_node *dpn = VPTOPP(dvp);
	struct puffs_node *pn;
	struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount);
	struct nchandle *nch = ap->a_nch;
	struct namecache *ncp = nch->ncp;
	struct ucred *cred = ap->a_cred;
	int error;

	if (!EXISTSOP(pmp, RMDIR))
		return EOPNOTSUPP;

	error = vget(dvp, LK_EXCLUSIVE);
	if (error != 0) {
		DPRINTF(("puffs_vnop_rmdir: EAGAIN on parent vnode %p %s\n",
		    dvp, ncp->nc_name));
		return EAGAIN;
	}
	error = cache_vget(nch, cred, LK_EXCLUSIVE, &vp);
	if (error != 0) {
		DPRINTF(("puffs_vnop_rmdir: cache_vget error: %p %s\n",
		    dvp, ncp->nc_name));
		return EAGAIN;
	}
	if (vp->v_type != VDIR) {
		error = ENOTDIR;
		goto out;
	}

	pn = VPTOPP(vp);
	PUFFS_MSG_ALLOC(vn, rmdir);
	rmdir_msg->pvnr_cookie_targ = VPTOPNC(vp);
	puffs_makecn(&rmdir_msg->pvnr_cn, &rmdir_msg->pvnr_cn_cred,
	    ncp, cred);
	puffs_msg_setinfo(park_rmdir, PUFFSOP_VN,
	    PUFFS_VN_RMDIR, VPTOPNC(dvp));

	puffs_msg_enqueue(pmp, park_rmdir);
	error = puffs_msg_wait2(pmp, park_rmdir, dpn, pn);

	PUFFS_MSG_RELEASE(rmdir);

	error = checkerr(pmp, error, __func__);

 out:
	vput(dvp);
	vn_unlock(vp);
	if (error == 0)
		cache_unlink(nch);
	vrele(vp);
	return error;
}

static int
puffs_vnop_link(struct vop_nlink_args *ap)
{
	PUFFS_MSG_VARS(vn, link);
	struct vnode *dvp = ap->a_dvp;
	struct vnode *vp = ap->a_vp;
	struct puffs_node *dpn = VPTOPP(dvp);
	struct puffs_node *pn = VPTOPP(vp);
	struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount);
	struct nchandle *nch = ap->a_nch;
	struct namecache *ncp = nch->ncp;
	struct ucred *cred = ap->a_cred;
	int error;

	if (!EXISTSOP(pmp, LINK))
		return EOPNOTSUPP;

	if (vp->v_mount != dvp->v_mount)
		return EXDEV;

	if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
		DPRINTF(("puffs_vnop_link: EAGAIN on ncp %p %s\n",
		    ncp, ncp->nc_name));
		return EAGAIN;
	}

	PUFFS_MSG_ALLOC(vn, link);
	link_msg->pvnr_cookie_targ = VPTOPNC(vp);
	puffs_makecn(&link_msg->pvnr_cn, &link_msg->pvnr_cn_cred,
	    ncp, cred);
	puffs_msg_setinfo(park_link, PUFFSOP_VN,
	    PUFFS_VN_LINK, VPTOPNC(dvp));

	puffs_msg_enqueue(pmp, park_link);
	error = puffs_msg_wait2(pmp, park_link, dpn, pn);

	PUFFS_MSG_RELEASE(link);

	error = checkerr(pmp, error, __func__);

	/*
	 * XXX: stay in touch with the cache.  I don't like this, but
	 * don't have a better solution either.  See also puffs_rename().
	 */
	if (error == 0) {
		puffs_updatenode(pn, PUFFS_UPDATECTIME);
	}

	vput(dvp);
	if (error == 0) {
		cache_setunresolved(nch);
		cache_setvp(nch, vp);
	}
	return error;
}

static int
puffs_vnop_symlink(struct vop_nsymlink_args *ap)
{
	PUFFS_MSG_VARS(vn, symlink);
	struct vnode *dvp = ap->a_dvp;
	struct puffs_node *dpn = VPTOPP(dvp);
	struct mount *mp = dvp->v_mount;
	struct puffs_mount *pmp = MPTOPUFFSMP(dvp->v_mount);
	struct nchandle *nch = ap->a_nch;
	struct namecache *ncp = nch->ncp;
	struct ucred *cred = ap->a_cred;
	int error;

	if (!EXISTSOP(pmp, SYMLINK))
		return EOPNOTSUPP;

	if ((error = vget(dvp, LK_EXCLUSIVE)) != 0) {
		DPRINTF(("puffs_vnop_symlink: EAGAIN on ncp %p %s\n",
		    ncp, ncp->nc_name));
		return EAGAIN;
	}

	*ap->a_vpp = NULL;

	PUFFS_MSG_ALLOC(vn, symlink);
	puffs_makecn(&symlink_msg->pvnr_cn, &symlink_msg->pvnr_cn_cred,
		ncp, cred);
	symlink_msg->pvnr_va = *ap->a_vap;
	(void)strlcpy(symlink_msg->pvnr_link, ap->a_target,
	    sizeof(symlink_msg->pvnr_link));
	puffs_msg_setinfo(park_symlink, PUFFSOP_VN,
	    PUFFS_VN_SYMLINK, VPTOPNC(dvp));

	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_symlink, dvp->v_data, NULL, error);

	error = checkerr(pmp, error, __func__);
	if (error)
		goto out;

	error = puffs_newnode(mp, dvp, ap->a_vpp,
	    symlink_msg->pvnr_newnode, VLNK);
	if (error)
		puffs_abortbutton(pmp, PUFFS_ABORT_SYMLINK, dpn->pn_cookie,
		    symlink_msg->pvnr_newnode, ncp, cred);

 out:
	vput(dvp);
	PUFFS_MSG_RELEASE(symlink);
	if (!error) {
		cache_setunresolved(nch);
		cache_setvp(nch, *ap->a_vpp);
	}
	return error;
}

static int
puffs_vnop_readlink(struct vop_readlink_args *ap)
{
	PUFFS_MSG_VARS(vn, readlink);
	struct vnode *vp = ap->a_vp;
	struct puffs_mount *pmp = MPTOPUFFSMP(ap->a_vp->v_mount);
	size_t linklen;
	int error;

	if (!EXISTSOP(pmp, READLINK))
		return EOPNOTSUPP;

	PUFFS_MSG_ALLOC(vn, readlink);
	puffs_credcvt(&readlink_msg->pvnr_cred, ap->a_cred);
	linklen = sizeof(readlink_msg->pvnr_link);
	readlink_msg->pvnr_linklen = linklen;
	puffs_msg_setinfo(park_readlink, PUFFSOP_VN,
	    PUFFS_VN_READLINK, VPTOPNC(vp));

	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_readlink, vp->v_data, NULL, error);
	error = checkerr(pmp, error, __func__);
	if (error)
		goto out;

	/* bad bad user file server */
	if (readlink_msg->pvnr_linklen > linklen) {
		puffs_senderr(pmp, PUFFS_ERR_READLINK, E2BIG,
		    "linklen too big", VPTOPNC(ap->a_vp));
		error = EPROTO;
		goto out;
	}

	error = uiomove(readlink_msg->pvnr_link, readlink_msg->pvnr_linklen,
	    ap->a_uio);
 out:
	PUFFS_MSG_RELEASE(readlink);
	return error;
}

static int
puffs_vnop_rename(struct vop_nrename_args *ap)
{
	PUFFS_MSG_VARS(vn, rename);
	struct nchandle *fnch = ap->a_fnch;
	struct nchandle *tnch = ap->a_tnch;
	struct vnode *fdvp = ap->a_fdvp;
	struct vnode *fvp = fnch->ncp->nc_vp;
	struct vnode *tdvp = ap->a_tdvp;
	struct vnode *tvp = tnch->ncp->nc_vp;
	struct ucred *cred = ap->a_cred;
	struct puffs_mount *pmp = MPTOPUFFSMP(fdvp->v_mount);
	int error;

	if (!EXISTSOP(pmp, RENAME))
		return EOPNOTSUPP;

	error = vget(tdvp, LK_EXCLUSIVE);
	if (error != 0) {
		DPRINTF(("puffs_vnop_rename: EAGAIN on tdvp vnode %p %s\n",
		    tdvp, tnch->ncp->nc_name));
		return EAGAIN;
	}
	if (tvp != NULL) {
		error = vget(tvp, LK_EXCLUSIVE);
		if (error != 0) {
			DPRINTF(("puffs_vnop_rename: EAGAIN on tvp vnode %p %s\n",
			    tvp, tnch->ncp->nc_name));
			vput(tdvp);
			return EAGAIN;
		}
	}

	if ((fvp->v_mount != tdvp->v_mount) ||
	    (tvp && (fvp->v_mount != tvp->v_mount))) {
		error = EXDEV;
		goto out;
	}

	if (tvp) {
		if (fvp->v_type == VDIR && tvp->v_type != VDIR) {
			error = ENOTDIR;
			goto out;
		} else if (fvp->v_type != VDIR && tvp->v_type == VDIR) {
			error = EISDIR;
			goto out;
		}
	}

	PUFFS_MSG_ALLOC(vn, rename);
	rename_msg->pvnr_cookie_src = VPTOPNC(fvp);
	rename_msg->pvnr_cookie_targdir = VPTOPNC(tdvp);
	if (tvp)
		rename_msg->pvnr_cookie_targ = VPTOPNC(tvp);
	else
		rename_msg->pvnr_cookie_targ = NULL;
	puffs_makecn(&rename_msg->pvnr_cn_src, &rename_msg->pvnr_cn_src_cred,
	    fnch->ncp, cred);
	puffs_makecn(&rename_msg->pvnr_cn_targ, &rename_msg->pvnr_cn_targ_cred,
	    tnch->ncp, cred);
	puffs_msg_setinfo(park_rename, PUFFSOP_VN,
	    PUFFS_VN_RENAME, VPTOPNC(fdvp));

	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_rename, fdvp->v_data, NULL, error);
	PUFFS_MSG_RELEASE(rename);
	error = checkerr(pmp, error, __func__);

	if (error == 0)
		puffs_updatenode(VPTOPP(fvp), PUFFS_UPDATECTIME);

 out:
	if (tvp != NULL)
		vn_unlock(tvp);
	if (tdvp != tvp)
		vn_unlock(tdvp);
	if (error == 0)
		cache_rename(fnch, tnch);
	if (tvp != NULL)
		vrele(tvp);
	vrele(tdvp);

	return error;
}

static int
puffs_vnop_read(struct vop_read_args *ap)
{
	struct vnode *vp = ap->a_vp;
	struct uio *uio = ap->a_uio;
	int ioflag = ap->a_ioflag;
	struct ucred * cred = ap->a_cred;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	int error;

	if (!EXISTSOP(pmp, READ))
		return EOPNOTSUPP;

	if (vp->v_type == VDIR)
		return EISDIR;
	else if (vp->v_type != VREG)
		return EINVAL;

	if (PUFFS_USE_PAGECACHE(pmp))
		error = puffs_bioread(vp, uio, ioflag, cred);
	else
		error = puffs_directread(vp, uio, ioflag, cred);

	return error;
}

static int
puffs_vnop_write(struct vop_write_args *ap)
{
	struct vnode *vp = ap->a_vp;
	struct uio *uio = ap->a_uio;
	int ioflag = ap->a_ioflag;
	struct ucred * cred = ap->a_cred;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	int error;

	if (!EXISTSOP(pmp, WRITE))
		return EOPNOTSUPP;

	if (vp->v_type == VDIR)
		return EISDIR;
	else if (vp->v_type != VREG)
		return EINVAL;

	if (PUFFS_USE_PAGECACHE(pmp))
		error = puffs_biowrite(vp, uio, ioflag, cred);
	else
		error = puffs_directwrite(vp, uio, ioflag, cred);

	return error;
}

static int
puffs_vnop_print(struct vop_print_args *ap)
{
	PUFFS_MSG_VARS(vn, print);
	struct vnode *vp = ap->a_vp;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	struct puffs_node *pn = VPTOPP(vp);
	int error;

	/* kernel portion */
	kprintf("tag VT_PUFFS, vnode %p, puffs node: %p,\n"
	    "\tuserspace cookie: %p", vp, pn, pn->pn_cookie);
	if (vp->v_type == VFIFO)
		fifo_printinfo(vp);
	kprintf("\n");

	/* userspace portion */
	if (EXISTSOP(pmp, PRINT)) {
		PUFFS_MSG_ALLOC(vn, print);
		puffs_msg_setinfo(park_print, PUFFSOP_VN,
		    PUFFS_VN_PRINT, VPTOPNC(vp));
		PUFFS_MSG_ENQUEUEWAIT2(pmp, park_print, vp->v_data,
		    NULL, error);
		PUFFS_MSG_RELEASE(print);
	}

	return 0;
}

static int
puffs_vnop_pathconf(struct vop_pathconf_args *ap)
{
	PUFFS_MSG_VARS(vn, pathconf);
	struct vnode *vp = ap->a_vp;
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	int error;

	if (!EXISTSOP(pmp, PATHCONF))
		return EOPNOTSUPP;

	PUFFS_MSG_ALLOC(vn, pathconf);
	pathconf_msg->pvnr_name = ap->a_name;
	puffs_msg_setinfo(park_pathconf, PUFFSOP_VN,
	    PUFFS_VN_PATHCONF, VPTOPNC(vp));
	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_pathconf, vp->v_data, NULL, error);
	error = checkerr(pmp, error, __func__);
	if (!error)
		*ap->a_retval = pathconf_msg->pvnr_retval;
	PUFFS_MSG_RELEASE(pathconf);

	return error;
}

static int
puffs_vnop_advlock(struct vop_advlock_args *ap)
{
	PUFFS_MSG_VARS(vn, advlock);
	struct vnode *vp = ap->a_vp;
	struct puffs_node *pn = VPTOPP(vp);
	struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
	int error;

	if (!EXISTSOP(pmp, ADVLOCK))
		return lf_advlock(ap, &pn->pn_lockf, vp->v_filesize);

	PUFFS_MSG_ALLOC(vn, advlock);
	(void)memcpy(&advlock_msg->pvnr_fl, ap->a_fl,
		     sizeof(advlock_msg->pvnr_fl));
	advlock_msg->pvnr_id = ap->a_id;
	advlock_msg->pvnr_op = ap->a_op;
	advlock_msg->pvnr_flags = ap->a_flags;
	puffs_msg_setinfo(park_advlock, PUFFSOP_VN,
	    PUFFS_VN_ADVLOCK, VPTOPNC(vp));
	PUFFS_MSG_ENQUEUEWAIT2(pmp, park_advlock, vp->v_data, NULL, error);
	error = checkerr(pmp, error, __func__);
	PUFFS_MSG_RELEASE(advlock);

	return error;
}

static int
puffs_vnop_bmap(struct vop_bmap_args *ap)
{
	if (ap->a_doffsetp != NULL)
		*ap->a_doffsetp = ap->a_loffset;
	if (ap->a_runp != NULL)
		*ap->a_runp = 0;
	if (ap->a_runb != NULL)
		*ap->a_runb = 0;
	return (0);
}

static int
puffs_vnop_mmap(struct vop_mmap_args *ap)
{
	return EINVAL;
}


static int
puffs_vnop_strategy(struct vop_strategy_args *ap)
{
	return puffs_doio(ap->a_vp, ap->a_bio, curthread);
}

struct vop_ops puffs_fifo_vops = {
	.vop_default =			fifo_vnoperate,
	.vop_access =			puffs_vnop_access,
	.vop_getattr =			puffs_vnop_getattr,
	.vop_setattr =			puffs_vnop_setattr,
	.vop_inactive =			puffs_vnop_inactive,
	.vop_reclaim =			puffs_vnop_reclaim,
	.vop_print =			puffs_vnop_print,
};

struct vop_ops puffs_vnode_vops = {
	.vop_default =			vop_defaultop,
	.vop_nresolve =			puffs_vnop_lookup,
	.vop_nlookupdotdot =		puffs_vnop_lookupdotdot,
	.vop_ncreate =			puffs_vnop_create,
	.vop_nmkdir =			puffs_vnop_mkdir,
	.vop_nrmdir =			puffs_vnop_rmdir,
	.vop_nremove =			puffs_vnop_remove,
	.vop_nrename =			puffs_vnop_rename,
	.vop_nlink =			puffs_vnop_link,
	.vop_nsymlink =			puffs_vnop_symlink,
	.vop_nmknod =			puffs_vnop_mknod,
	.vop_access =			puffs_vnop_access,
	.vop_getattr =			puffs_vnop_getattr,
	.vop_setattr =			puffs_vnop_setattr,
	.vop_readdir =			puffs_vnop_readdir,
	.vop_open =			puffs_vnop_open,
	.vop_close =			puffs_vnop_close,
	.vop_read =			puffs_vnop_read,
	.vop_write =			puffs_vnop_write,
	.vop_readlink =			puffs_vnop_readlink,
	.vop_advlock =			puffs_vnop_advlock,
	.vop_bmap =			puffs_vnop_bmap,
	.vop_mmap =			puffs_vnop_mmap,
	.vop_strategy =			puffs_vnop_strategy,
	.vop_getpages =			vop_stdgetpages,
	.vop_putpages =			vop_stdputpages,
	.vop_fsync = 			puffs_vnop_fsync,
	.vop_inactive =			puffs_vnop_inactive,
	.vop_reclaim =			puffs_vnop_reclaim,
	.vop_pathconf =			puffs_vnop_pathconf,
	.vop_print =			puffs_vnop_print,
};