xref: /illumos-gate/usr/src/uts/common/fs/fem.c (revision c6f039c7)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/atomic.h>
#include <sys/kmem.h>
#include <sys/mutex.h>
#include <sys/errno.h>
#include <sys/param.h>
#include <sys/sysmacros.h>
#include <sys/systm.h>
#include <sys/cmn_err.h>
#include <sys/debug.h>

#include <sys/fem.h>
#include <sys/vfs.h>
#include <sys/vnode.h>
#include <sys/vfs_opreg.h>

#define	NNODES_DEFAULT	8	/* Default number of nodes in a fem_list */
/*
 * fl_ntob(n) - Fem_list: number of nodes to bytes
 * Given the number of nodes in a fem_list return the size, in bytes,
 * of the fem_list structure.
 */
#define	fl_ntob(n)	(sizeof (struct fem_list) + \
			((n) - 1) * sizeof (struct fem_node))

typedef enum {
	FEMTYPE_NULL,	/* Uninitialized */
	FEMTYPE_VNODE,
	FEMTYPE_VFS,
	FEMTYPE_NTYPES
} femtype_t;

#define	FEM_HEAD(_t) femtype[(_t)].head.fn_op.anon
#define	FEM_GUARD(_t) femtype[(_t)].guard

static struct fem_type_info {
	struct fem_node		head;
	struct fem_node		guard;
	femop_t			*errf;
}	femtype[FEMTYPE_NTYPES];


/*
 * For each type, two tables - the translation offset definition, which
 * is used by fs_build_vector to layout the operation(s) vector; and the
 * guard_operation_vector which protects from stack under-run.
 */

int fem_err();
int fsem_err();


#define	_FEMOPDEF(name, member)  \
	{ VOPNAME_##name, offsetof(fem_t, femop_##member), NULL, fem_err }

static fs_operation_trans_def_t	fem_opdef[] = {
	_FEMOPDEF(OPEN,		open),
	_FEMOPDEF(CLOSE,	close),
	_FEMOPDEF(READ,		read),
	_FEMOPDEF(WRITE,	write),
	_FEMOPDEF(IOCTL,	ioctl),
	_FEMOPDEF(SETFL,	setfl),
	_FEMOPDEF(GETATTR,	getattr),
	_FEMOPDEF(SETATTR,	setattr),
	_FEMOPDEF(ACCESS,	access),
	_FEMOPDEF(LOOKUP,	lookup),
	_FEMOPDEF(CREATE,	create),
	_FEMOPDEF(REMOVE,	remove),
	_FEMOPDEF(LINK,		link),
	_FEMOPDEF(RENAME,	rename),
	_FEMOPDEF(MKDIR,	mkdir),
	_FEMOPDEF(RMDIR,	rmdir),
	_FEMOPDEF(READDIR,	readdir),
	_FEMOPDEF(SYMLINK,	symlink),
	_FEMOPDEF(READLINK,	readlink),
	_FEMOPDEF(FSYNC,	fsync),
	_FEMOPDEF(INACTIVE,	inactive),
	_FEMOPDEF(FID,		fid),
	_FEMOPDEF(RWLOCK,	rwlock),
	_FEMOPDEF(RWUNLOCK,	rwunlock),
	_FEMOPDEF(SEEK,		seek),
	_FEMOPDEF(CMP,		cmp),
	_FEMOPDEF(FRLOCK,	frlock),
	_FEMOPDEF(SPACE,	space),
	_FEMOPDEF(REALVP,	realvp),
	_FEMOPDEF(GETPAGE,	getpage),
	_FEMOPDEF(PUTPAGE,	putpage),
	_FEMOPDEF(MAP,		map),
	_FEMOPDEF(ADDMAP,	addmap),
	_FEMOPDEF(DELMAP,	delmap),
	_FEMOPDEF(POLL,		poll),
	_FEMOPDEF(DUMP,		dump),
	_FEMOPDEF(PATHCONF,	pathconf),
	_FEMOPDEF(PAGEIO,	pageio),
	_FEMOPDEF(DUMPCTL,	dumpctl),
	_FEMOPDEF(DISPOSE,	dispose),
	_FEMOPDEF(SETSECATTR,	setsecattr),
	_FEMOPDEF(GETSECATTR,	getsecattr),
	_FEMOPDEF(SHRLOCK,	shrlock),
	_FEMOPDEF(VNEVENT,	vnevent),
	_FEMOPDEF(REQZCBUF,	reqzcbuf),
	_FEMOPDEF(RETZCBUF,	retzcbuf),
	{ NULL, 0, NULL, NULL }
};


#define	_FEMGUARD(name, ignore)  \
	{ VOPNAME_##name, (femop_t *)fem_err }

static struct fs_operation_def fem_guard_ops[] = {
	_FEMGUARD(OPEN,		open),
	_FEMGUARD(CLOSE,	close),
	_FEMGUARD(READ,		read),
	_FEMGUARD(WRITE,	write),
	_FEMGUARD(IOCTL,	ioctl),
	_FEMGUARD(SETFL,	setfl),
	_FEMGUARD(GETATTR,	getattr),
	_FEMGUARD(SETATTR,	setattr),
	_FEMGUARD(ACCESS,	access),
	_FEMGUARD(LOOKUP,	lookup),
	_FEMGUARD(CREATE,	create),
	_FEMGUARD(REMOVE,	remove),
	_FEMGUARD(LINK,		link),
	_FEMGUARD(RENAME,	rename),
	_FEMGUARD(MKDIR,	mkdir),
	_FEMGUARD(RMDIR,	rmdir),
	_FEMGUARD(READDIR,	readdir),
	_FEMGUARD(SYMLINK,	symlink),
	_FEMGUARD(READLINK,	readlink),
	_FEMGUARD(FSYNC,	fsync),
	_FEMGUARD(INACTIVE,	inactive),
	_FEMGUARD(FID,		fid),
	_FEMGUARD(RWLOCK,	rwlock),
	_FEMGUARD(RWUNLOCK,	rwunlock),
	_FEMGUARD(SEEK,		seek),
	_FEMGUARD(CMP,		cmp),
	_FEMGUARD(FRLOCK,	frlock),
	_FEMGUARD(SPACE,	space),
	_FEMGUARD(REALVP,	realvp),
	_FEMGUARD(GETPAGE,	getpage),
	_FEMGUARD(PUTPAGE,	putpage),
	_FEMGUARD(MAP,		map),
	_FEMGUARD(ADDMAP,	addmap),
	_FEMGUARD(DELMAP,	delmap),
	_FEMGUARD(POLL,		poll),
	_FEMGUARD(DUMP,		dump),
	_FEMGUARD(PATHCONF,	pathconf),
	_FEMGUARD(PAGEIO,	pageio),
	_FEMGUARD(DUMPCTL,	dumpctl),
	_FEMGUARD(DISPOSE,	dispose),
	_FEMGUARD(SETSECATTR,	setsecattr),
	_FEMGUARD(GETSECATTR,	getsecattr),
	_FEMGUARD(SHRLOCK,	shrlock),
	_FEMGUARD(VNEVENT,	vnevent),
	_FEMGUARD(REQZCBUF,	reqzcbuf),
	_FEMGUARD(RETZCBUF,	retzcbuf),
	{ NULL, NULL }
};


#define	_FSEMOPDEF(name, member)  \
	{ VFSNAME_##name, offsetof(fsem_t, fsemop_##member), NULL, fsem_err }

static fs_operation_trans_def_t fsem_opdef[] = {
	_FSEMOPDEF(MOUNT,	mount),
	_FSEMOPDEF(UNMOUNT,	unmount),
	_FSEMOPDEF(ROOT,	root),
	_FSEMOPDEF(STATVFS,	statvfs),
	_FSEMOPDEF(SYNC,	sync),
	_FSEMOPDEF(VGET,	vget),
	_FSEMOPDEF(MOUNTROOT,	mountroot),
	_FSEMOPDEF(FREEVFS,	freevfs),
	_FSEMOPDEF(VNSTATE,	vnstate),
	{ NULL, 0, NULL, NULL }
};

#define	_FSEMGUARD(name, ignore)  \
	{ VFSNAME_##name, (femop_t *)fsem_err }

static struct fs_operation_def fsem_guard_ops[] = {
	_FSEMGUARD(MOUNT,	mount),
	_FSEMGUARD(UNMOUNT,	unmount),
	_FSEMGUARD(ROOT,	root),
	_FSEMGUARD(STATVFS,	statvfs),
	_FSEMGUARD(SYNC,	sync),
	_FSEMGUARD(VGET,	vget),
	_FSEMGUARD(MOUNTROOT,	mountroot),
	_FSEMGUARD(FREEVFS,	freevfs),
	_FSEMGUARD(VNSTATE,	vnstate),
	{ NULL, NULL}
};


/*
 * vsop_find, vfsop_find -
 *
 * These macros descend the stack until they find either a basic
 * vnode/vfs operation [ indicated by a null fn_available ] or a
 * stacked item where this method is non-null [_vsop].
 *
 * The DEBUG one is written with a single function which manually applies
 * the structure offsets.  It can have additional debugging support.
 */

#ifndef DEBUG

#define	vsop_find(ap, func, funct, arg0, _vop, _vsop) \
for (;;) { \
	if ((ap)->fa_fnode->fn_available == NULL) { \
		*(func) = (funct (*)())((ap)->fa_fnode->fn_op.vnode->_vop); \
		*(arg0) = (void *)(ap)->fa_vnode.vp; \
		break;	\
	} else if ((*(func) = (funct (*)())((ap)->fa_fnode->fn_op.fem->_vsop))\
		    != NULL) { \
		*(arg0) = (void *) (ap); \
		break;	\
	} else { \
		(ap)->fa_fnode--; \
	} \
} \

#define	vfsop_find(ap, func, funct, arg0, _vop, _vsop) \
for (;;) { \
	if ((ap)->fa_fnode->fn_available == NULL) { \
		*(func) = (funct (*)())((ap)->fa_fnode->fn_op.vfs->_vop); \
		*(arg0) = (void *)(ap)->fa_vnode.vp; \
		break; \
	} else if ((*(func) = (funct (*)())((ap)->fa_fnode->fn_op.fsem->_vsop))\
		    != NULL) { \
		*(arg0) = (void *) (ap); \
		break; \
	} else { \
		(ap)->fa_fnode--; \
	} \
} \

#else

#define	vsop_find(ap, func, funct, arg0, _vop, _vsop) \
	*(arg0) = _op_find((ap), (void **)(func), \
			offsetof(vnodeops_t, _vop), offsetof(fem_t, _vsop))

#define	vfsop_find(ap, func, funct, arg0, _fop, _fsop) \
	*(arg0) = _op_find((ap), (void **)(func), \
			offsetof(vfsops_t, _fop), offsetof(fsem_t, _fsop))

static void *
_op_find(femarg_t *ap, void **fp, int offs0, int offs1)
{
	void *ptr;
	for (;;) {
		struct fem_node	*fnod = ap->fa_fnode;
		if (fnod->fn_available == NULL) {
			*fp = *(void **)((char *)fnod->fn_op.anon + offs0);
			ptr = (void *)(ap->fa_vnode.anon);
			break;
		} else if ((*fp = *(void **)((char *)fnod->fn_op.anon+offs1))
		    != NULL) {
			ptr = (void *)(ap);
			break;
		} else {
			ap->fa_fnode--;
		}
	}
	return (ptr);
}
#endif

static fem_t *
fem_alloc()
{
	fem_t	*p;

	p = (fem_t *)kmem_alloc(sizeof (*p), KM_SLEEP);
	return (p);
}

void
fem_free(fem_t *p)
{
	kmem_free(p, sizeof (*p));
}

static fsem_t *
fsem_alloc()
{
	fsem_t	*p;

	p = (fsem_t *)kmem_alloc(sizeof (*p), KM_SLEEP);
	return (p);
}

void
fsem_free(fsem_t *p)
{
	kmem_free(p, sizeof (*p));
}


/*
 * fem_get, fem_release - manage reference counts on the stack.
 *
 * The list of monitors can be updated while operations are in
 * progress on the object.
 *
 * The reference count facilitates this by counting the number of
 * current accessors, and deconstructing the list when it is exhausted.
 *
 * fem_lock() is required to:
 *	look at femh_list
 *	update what femh_list points to
 *	update femh_list
 *	increase femh_list->feml_refc.
 *
 * the feml_refc can decrement without holding the lock;
 * when feml_refc becomes zero, the list is destroyed.
 *
 */

static struct fem_list *
fem_lock(struct fem_head *fp)
{
	struct fem_list	*sp = NULL;

	ASSERT(fp != NULL);
	mutex_enter(&fp->femh_lock);
	sp = fp->femh_list;
	return (sp);
}

static void
fem_unlock(struct fem_head *fp)
{
	ASSERT(fp != NULL);
	mutex_exit(&fp->femh_lock);
}

/*
 * Addref can only be called while its head->lock is held.
 */

static void
fem_addref(struct fem_list *sp)
{
	atomic_inc_32(&sp->feml_refc);
}

static uint32_t
fem_delref(struct fem_list *sp)
{
	return (atomic_dec_32_nv(&sp->feml_refc));
}

static struct fem_list *
fem_get(struct fem_head *fp)
{
	struct fem_list *sp = NULL;

	if (fp != NULL) {
		if ((sp = fem_lock(fp)) != NULL) {
			fem_addref(sp);
		}
		fem_unlock(fp);
	}
	return (sp);
}

static void
fem_release(struct fem_list *sp)
{
	int	i;

	ASSERT(sp->feml_refc != 0);
	if (fem_delref(sp) == 0) {
		/*
		 * Before freeing the list, we need to release the
		 * caller-provided data.
		 */
		for (i = sp->feml_tos; i > 0; i--) {
			struct fem_node *fnp = &sp->feml_nodes[i];

			if (fnp->fn_av_rele)
				(*(fnp->fn_av_rele))(fnp->fn_available);
		}
		kmem_free(sp, fl_ntob(sp->feml_ssize));
	}
}


/*
 * These are the 'head' operations which perform the interposition.
 *
 * This set must be 1:1, onto with the (vnodeops, vfsos).
 *
 * If there is a desire to globally disable interposition for a particular
 * method, the corresponding 'head' routine should unearth the base method
 * and invoke it directly rather than bypassing the function.
 *
 * All the functions are virtually the same, save for names, types & args.
 *  1. get a reference to the monitor stack for this object.
 *  2. store the top of stack into the femarg structure.
 *  3. store the basic object (vnode *, vnode **, vfs *) in the femarg struc.
 *  4. invoke the "top" method for this object.
 *  5. release the reference to the monitor stack.
 *
 */

static int
vhead_open(vnode_t **vpp, int mode, cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock((*vpp)->v_femhead)) == NULL) {
		func = (int (*)()) ((*vpp)->v_op->vop_open);
		arg0 = (void *)vpp;
		fem_unlock((*vpp)->v_femhead);
		errc = (*func)(arg0, mode, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock((*vpp)->v_femhead);
		farg.fa_vnode.vpp = vpp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_open, femop_open);
		errc = (*func)(arg0, mode, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_close);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, flag, count, offset, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_close, femop_close);
		errc = (*func)(arg0, flag, count, offset, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_read(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_read);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, uiop, ioflag, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_read, femop_read);
		errc = (*func)(arg0, uiop, ioflag, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_write(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_write);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, uiop, ioflag, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_write, femop_write);
		errc = (*func)(arg0, uiop, ioflag, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_ioctl(vnode_t *vp, int cmd, intptr_t arg, int flag, cred_t *cr,
    int *rvalp, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_ioctl);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, cmd, arg, flag, cr, rvalp, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_ioctl, femop_ioctl);
		errc = (*func)(arg0, cmd, arg, flag, cr, rvalp, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_setfl(vnode_t *vp, int oflags, int nflags, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_setfl);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, oflags, nflags, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_setfl, femop_setfl);
		errc = (*func)(arg0, oflags, nflags, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_getattr);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, vap, flags, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_getattr,
		    femop_getattr);
		errc = (*func)(arg0, vap, flags, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_setattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_setattr);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, vap, flags, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_setattr,
		    femop_setattr);
		errc = (*func)(arg0, vap, flags, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_access(vnode_t *vp, int mode, int flags, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_access);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, mode, flags, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_access,
		    femop_access);
		errc = (*func)(arg0, mode, flags, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp,
    int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
    int *direntflags, pathname_t *realpnp)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
		func = (int (*)()) (dvp->v_op->vop_lookup);
		arg0 = dvp;
		fem_unlock(dvp->v_femhead);
		errc = (*func)(arg0, nm, vpp, pnp, flags, rdir, cr, ct,
		    direntflags, realpnp);
	} else {
		fem_addref(femsp);
		fem_unlock(dvp->v_femhead);
		farg.fa_vnode.vp = dvp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_lookup,
		    femop_lookup);
		errc = (*func)(arg0, nm, vpp, pnp, flags, rdir, cr, ct,
		    direntflags, realpnp);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_create(vnode_t *dvp, char *name, vattr_t *vap, vcexcl_t excl,
    int mode, vnode_t **vpp, cred_t *cr, int flag, caller_context_t *ct,
    vsecattr_t *vsecp)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
		func = (int (*)()) (dvp->v_op->vop_create);
		arg0 = dvp;
		fem_unlock(dvp->v_femhead);
		errc = (*func)(arg0, name, vap, excl, mode, vpp, cr, flag,
		    ct, vsecp);
	} else {
		fem_addref(femsp);
		fem_unlock(dvp->v_femhead);
		farg.fa_vnode.vp = dvp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_create,
		    femop_create);
		errc = (*func)(arg0, name, vap, excl, mode, vpp, cr, flag,
		    ct, vsecp);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_remove(vnode_t *dvp, char *nm, cred_t *cr, caller_context_t *ct,
    int flags)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
		func = (int (*)()) (dvp->v_op->vop_remove);
		arg0 = dvp;
		fem_unlock(dvp->v_femhead);
		errc = (*func)(arg0, nm, cr, ct, flags);
	} else {
		fem_addref(femsp);
		fem_unlock(dvp->v_femhead);
		farg.fa_vnode.vp = dvp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_remove,
		    femop_remove);
		errc = (*func)(arg0, nm, cr, ct, flags);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_link(vnode_t *tdvp, vnode_t *svp, char *tnm, cred_t *cr,
    caller_context_t *ct, int flags)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(tdvp->v_femhead)) == NULL) {
		func = (int (*)()) (tdvp->v_op->vop_link);
		arg0 = tdvp;
		fem_unlock(tdvp->v_femhead);
		errc = (*func)(arg0, svp, tnm, cr, ct, flags);
	} else {
		fem_addref(femsp);
		fem_unlock(tdvp->v_femhead);
		farg.fa_vnode.vp = tdvp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_link, femop_link);
		errc = (*func)(arg0, svp, tnm, cr, ct, flags);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_rename(vnode_t *sdvp, char *snm, vnode_t *tdvp, char *tnm,
    cred_t *cr, caller_context_t *ct, int flags)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(sdvp->v_femhead)) == NULL) {
		func = (int (*)()) (sdvp->v_op->vop_rename);
		arg0 = sdvp;
		fem_unlock(sdvp->v_femhead);
		errc = (*func)(arg0, snm, tdvp, tnm, cr, ct, flags);
	} else {
		fem_addref(femsp);
		fem_unlock(sdvp->v_femhead);
		farg.fa_vnode.vp = sdvp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_rename,
		    femop_rename);
		errc = (*func)(arg0, snm, tdvp, tnm, cr, ct, flags);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_mkdir(vnode_t *dvp, char *dirname, vattr_t *vap, vnode_t **vpp,
    cred_t *cr, caller_context_t *ct, int flags, vsecattr_t *vsecp)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
		func = (int (*)()) (dvp->v_op->vop_mkdir);
		arg0 = dvp;
		fem_unlock(dvp->v_femhead);
		errc = (*func)(arg0, dirname, vap, vpp, cr, ct, flags, vsecp);
	} else {
		fem_addref(femsp);
		fem_unlock(dvp->v_femhead);
		farg.fa_vnode.vp = dvp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_mkdir, femop_mkdir);
		errc = (*func)(arg0, dirname, vap, vpp, cr, ct, flags, vsecp);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_rmdir(vnode_t *dvp, char *nm, vnode_t *cdir, cred_t *cr,
    caller_context_t *ct, int flags)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
		func = (int (*)()) (dvp->v_op->vop_rmdir);
		arg0 = dvp;
		fem_unlock(dvp->v_femhead);
		errc = (*func)(arg0, nm, cdir, cr, ct, flags);
	} else {
		fem_addref(femsp);
		fem_unlock(dvp->v_femhead);
		farg.fa_vnode.vp = dvp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_rmdir, femop_rmdir);
		errc = (*func)(arg0, nm, cdir, cr, ct, flags);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_readdir(vnode_t *vp, uio_t *uiop, cred_t *cr, int *eofp,
    caller_context_t *ct, int flags)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_readdir);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, uiop, cr, eofp, ct, flags);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_readdir,
		    femop_readdir);
		errc = (*func)(arg0, uiop, cr, eofp, ct, flags);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_symlink(vnode_t *dvp, char *linkname, vattr_t *vap, char *target,
    cred_t *cr, caller_context_t *ct, int flags)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
		func = (int (*)()) (dvp->v_op->vop_symlink);
		arg0 = dvp;
		fem_unlock(dvp->v_femhead);
		errc = (*func)(arg0, linkname, vap, target, cr, ct, flags);
	} else {
		fem_addref(femsp);
		fem_unlock(dvp->v_femhead);
		farg.fa_vnode.vp = dvp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_symlink,
		    femop_symlink);
		errc = (*func)(arg0, linkname, vap, target, cr, ct, flags);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_readlink(vnode_t *vp, uio_t *uiop, cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_readlink);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, uiop, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_readlink,
		    femop_readlink);
		errc = (*func)(arg0, uiop, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_fsync(vnode_t *vp, int syncflag, cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_fsync);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, syncflag, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_fsync, femop_fsync);
		errc = (*func)(arg0, syncflag, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	void		(*func)();
	void		*arg0;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (void (*)()) (vp->v_op->vop_inactive);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		(*func)(arg0, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, void, &arg0, vop_inactive,
		    femop_inactive);
		(*func)(arg0, cr, ct);
		fem_release(femsp);
	}
	return (0);
}

static int
vhead_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_fid);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, fidp, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_fid, femop_fid);
		errc = (*func)(arg0, fidp, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_rwlock(vnode_t *vp, int write_lock, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_rwlock);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, write_lock, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_rwlock,
		    femop_rwlock);
		errc = (*func)(arg0, write_lock, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_rwunlock(vnode_t *vp, int write_lock, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	void		(*func)();
	void		*arg0;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (void (*)()) (vp->v_op->vop_rwunlock);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		(*func)(arg0, write_lock, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, void, &arg0, vop_rwunlock,
		    femop_rwunlock);
		(*func)(arg0, write_lock, ct);
		fem_release(femsp);
	}
	return (0);
}

static int
vhead_seek(vnode_t *vp, offset_t ooff, offset_t *noffp, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_seek);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, ooff, noffp, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_seek, femop_seek);
		errc = (*func)(arg0, ooff, noffp, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_cmp(vnode_t *vp1, vnode_t *vp2, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp1->v_femhead)) == NULL) {
		func = (int (*)()) (vp1->v_op->vop_cmp);
		arg0 = vp1;
		fem_unlock(vp1->v_femhead);
		errc = (*func)(arg0, vp2, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp1->v_femhead);
		farg.fa_vnode.vp = vp1;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_cmp, femop_cmp);
		errc = (*func)(arg0, vp2, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_frlock(vnode_t *vp, int cmd, struct flock64 *bfp, int flag,
    offset_t offset, struct flk_callback *flk_cbp, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_frlock);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, cmd, bfp, flag, offset, flk_cbp, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_frlock,
		    femop_frlock);
		errc = (*func)(arg0, cmd, bfp, flag, offset, flk_cbp, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_space(vnode_t *vp, int cmd, struct flock64 *bfp, int flag,
    offset_t offset, cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_space);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, cmd, bfp, flag, offset, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_space, femop_space);
		errc = (*func)(arg0, cmd, bfp, flag, offset, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_realvp(vnode_t *vp, vnode_t **vpp, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_realvp);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, vpp, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_realvp,
		    femop_realvp);
		errc = (*func)(arg0, vpp, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_getpage(vnode_t *vp, offset_t off, size_t len, uint_t *protp,
    struct page **plarr, size_t plsz, struct seg *seg, caddr_t addr,
    enum seg_rw rw, cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_getpage);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, off, len, protp, plarr, plsz, seg,
		    addr, rw, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_getpage,
		    femop_getpage);
		errc = (*func)(arg0, off, len, protp, plarr, plsz, seg,
		    addr, rw, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_putpage(vnode_t *vp, offset_t off, size_t len, int flags, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_putpage);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, off, len, flags, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_putpage,
		    femop_putpage);
		errc = (*func)(arg0, off, len, flags, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_map(vnode_t *vp, offset_t off, struct as *as, caddr_t *addrp,
    size_t len, uchar_t prot, uchar_t maxprot, uint_t flags,
    cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_map);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, off, as, addrp, len, prot, maxprot,
		    flags, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_map, femop_map);
		errc = (*func)(arg0, off, as, addrp, len, prot, maxprot,
		    flags, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_addmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
    size_t len, uchar_t prot, uchar_t maxprot, uint_t flags,
    cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_addmap);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, off, as, addr, len, prot, maxprot,
		    flags, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_addmap,
		    femop_addmap);
		errc = (*func)(arg0, off, as, addr, len, prot, maxprot,
		    flags, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_delmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
    size_t len, uint_t prot, uint_t maxprot, uint_t flags, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_delmap);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, off, as, addr, len, prot, maxprot,
		    flags, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_delmap,
		    femop_delmap);
		errc = (*func)(arg0, off, as, addr, len, prot, maxprot,
		    flags, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_poll(vnode_t *vp, short events, int anyyet, short *reventsp,
    struct pollhead **phpp, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_poll);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, events, anyyet, reventsp, phpp, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_poll, femop_poll);
		errc = (*func)(arg0, events, anyyet, reventsp, phpp, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_dump(vnode_t *vp, caddr_t addr, offset_t lbdn, offset_t dblks,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_dump);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, addr, lbdn, dblks, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_dump, femop_dump);
		errc = (*func)(arg0, addr, lbdn, dblks, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_pathconf);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, cmd, valp, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_pathconf,
		    femop_pathconf);
		errc = (*func)(arg0, cmd, valp, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_pageio(vnode_t *vp, struct page *pp, u_offset_t io_off,
    size_t io_len, int flags, cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_pageio);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, pp, io_off, io_len, flags, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_pageio,
		    femop_pageio);
		errc = (*func)(arg0, pp, io_off, io_len, flags, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_dumpctl(vnode_t *vp, int action, offset_t *blkp, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_dumpctl);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, action, blkp, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_dumpctl,
		    femop_dumpctl);
		errc = (*func)(arg0, action, blkp, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_dispose(vnode_t *vp, struct page *pp, int flag, int dn, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	void		(*func)();
	void		*arg0;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (void (*)()) (vp->v_op->vop_dispose);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		(*func)(arg0, pp, flag, dn, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, void, &arg0, vop_dispose,
		    femop_dispose);
		(*func)(arg0, pp, flag, dn, cr, ct);
		fem_release(femsp);
	}
	return (0);
}

static int
vhead_setsecattr(vnode_t *vp, vsecattr_t *vsap, int flag, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_setsecattr);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, vsap, flag, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_setsecattr,
		    femop_setsecattr);
		errc = (*func)(arg0, vsap, flag, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_getsecattr(vnode_t *vp, vsecattr_t *vsap, int flag, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_getsecattr);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, vsap, flag, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_getsecattr,
		    femop_getsecattr);
		errc = (*func)(arg0, vsap, flag, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_shrlock(vnode_t *vp, int cmd, struct shrlock *shr, int flag,
    cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_shrlock);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, cmd, shr, flag, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_shrlock,
		    femop_shrlock);
		errc = (*func)(arg0, cmd, shr, flag, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_vnevent(vnode_t *vp, vnevent_t vnevent, vnode_t *dvp, char *cname,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_vnevent);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, vnevent, dvp, cname, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_vnevent,
		    femop_vnevent);
		errc = (*func)(arg0, vnevent, dvp, cname, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_reqzcbuf(vnode_t *vp, enum uio_rw ioflag, xuio_t *xuiop, cred_t *cr,
    caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_reqzcbuf);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, ioflag, xuiop, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_reqzcbuf,
		    femop_reqzcbuf);
		errc = (*func)(arg0, ioflag, xuiop, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
vhead_retzcbuf(vnode_t *vp, xuio_t *xuiop, cred_t *cr, caller_context_t *ct)
{
	femarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
		func = (int (*)()) (vp->v_op->vop_retzcbuf);
		arg0 = vp;
		fem_unlock(vp->v_femhead);
		errc = (*func)(arg0, xuiop, cr, ct);
	} else {
		fem_addref(femsp);
		fem_unlock(vp->v_femhead);
		farg.fa_vnode.vp = vp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vsop_find(&farg, &func, int, &arg0, vop_retzcbuf,
		    femop_retzcbuf);
		errc = (*func)(arg0, xuiop, cr, ct);
		fem_release(femsp);
	}
	return (errc);
}

static int
fshead_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
{
	fsemarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	ASSERT(vfsp->vfs_implp);

	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
		func = (int (*)()) vfsp->vfs_op->vfs_mount;
		fem_unlock(vfsp->vfs_femhead);
		errc = (*func)(vfsp, mvp, uap, cr);
	} else {
		fem_addref(femsp);
		fem_unlock(vfsp->vfs_femhead);
		farg.fa_vnode.vfsp = vfsp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vfsop_find(&farg, &func, int, &arg0, vfs_mount,
		    fsemop_mount);
		errc = (*func)(arg0, mvp, uap, cr);
		fem_release(femsp);
	}
	return (errc);
}

static int
fshead_unmount(vfs_t *vfsp, int flag, cred_t *cr)
{
	fsemarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	ASSERT(vfsp->vfs_implp);

	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
		func = (int (*)()) vfsp->vfs_op->vfs_unmount;
		fem_unlock(vfsp->vfs_femhead);
		errc = (*func)(vfsp, flag, cr);
	} else {
		fem_addref(femsp);
		fem_unlock(vfsp->vfs_femhead);
		farg.fa_vnode.vfsp = vfsp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vfsop_find(&farg, &func, int, &arg0, vfs_unmount,
		    fsemop_unmount);
		errc = (*func)(arg0, flag, cr);
		fem_release(femsp);
	}
	return (errc);
}

static int
fshead_root(vfs_t *vfsp, vnode_t **vpp)
{
	fsemarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	ASSERT(vfsp->vfs_implp);

	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
		func = (int (*)()) vfsp->vfs_op->vfs_root;
		fem_unlock(vfsp->vfs_femhead);
		errc = (*func)(vfsp, vpp);
	} else {
		fem_addref(femsp);
		fem_unlock(vfsp->vfs_femhead);
		farg.fa_vnode.vfsp = vfsp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vfsop_find(&farg, &func, int, &arg0, vfs_root, fsemop_root);
		errc = (*func)(arg0, vpp);
		fem_release(femsp);
	}
	return (errc);
}

static int
fshead_statvfs(vfs_t *vfsp, statvfs64_t *sp)
{
	fsemarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	ASSERT(vfsp->vfs_implp);

	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
		func = (int (*)()) vfsp->vfs_op->vfs_statvfs;
		fem_unlock(vfsp->vfs_femhead);
		errc = (*func)(vfsp, sp);
	} else {
		fem_addref(femsp);
		fem_unlock(vfsp->vfs_femhead);
		farg.fa_vnode.vfsp = vfsp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vfsop_find(&farg, &func, int, &arg0, vfs_statvfs,
		    fsemop_statvfs);
		errc = (*func)(arg0, sp);
		fem_release(femsp);
	}
	return (errc);
}

static int
fshead_sync(vfs_t *vfsp, short flag, cred_t *cr)
{
	fsemarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	ASSERT(vfsp->vfs_implp);

	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
		func = (int (*)()) vfsp->vfs_op->vfs_sync;
		fem_unlock(vfsp->vfs_femhead);
		errc = (*func)(vfsp, flag, cr);
	} else {
		fem_addref(femsp);
		fem_unlock(vfsp->vfs_femhead);
		farg.fa_vnode.vfsp = vfsp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vfsop_find(&farg, &func, int, &arg0, vfs_sync, fsemop_sync);
		errc = (*func)(arg0, flag, cr);
		fem_release(femsp);
	}
	return (errc);
}

static int
fshead_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
{
	fsemarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	ASSERT(vfsp->vfs_implp);

	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
		func = (int (*)()) vfsp->vfs_op->vfs_vget;
		fem_unlock(vfsp->vfs_femhead);
		errc = (*func)(vfsp, vpp, fidp);
	} else {
		fem_addref(femsp);
		fem_unlock(vfsp->vfs_femhead);
		farg.fa_vnode.vfsp = vfsp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vfsop_find(&farg, &func, int, &arg0, vfs_vget, fsemop_vget);
		errc = (*func)(arg0, vpp, fidp);
		fem_release(femsp);
	}
	return (errc);
}

static int
fshead_mountroot(vfs_t *vfsp, enum whymountroot reason)
{
	fsemarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	ASSERT(vfsp->vfs_implp);

	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
		func = (int (*)()) vfsp->vfs_op->vfs_mountroot;
		fem_unlock(vfsp->vfs_femhead);
		errc = (*func)(vfsp, reason);
	} else {
		fem_addref(femsp);
		fem_unlock(vfsp->vfs_femhead);
		farg.fa_vnode.vfsp = vfsp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vfsop_find(&farg, &func, int, &arg0, vfs_mountroot,
		    fsemop_mountroot);
		errc = (*func)(arg0, reason);
		fem_release(femsp);
	}
	return (errc);
}

static int
fshead_freevfs(vfs_t *vfsp)
{
	fsemarg_t	farg;
	struct fem_list	*femsp;
	void		(*func)();
	void		*arg0;

	ASSERT(vfsp->vfs_implp);

	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
		func = (void (*)()) vfsp->vfs_op->vfs_freevfs;
		fem_unlock(vfsp->vfs_femhead);
		(*func)(vfsp);
	} else {
		fem_addref(femsp);
		fem_unlock(vfsp->vfs_femhead);
		farg.fa_vnode.vfsp = vfsp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vfsop_find(&farg, &func, void, &arg0, vfs_freevfs,
		    fsemop_freevfs);
		(*func)(arg0);
		fem_release(femsp);
	}
	return (0);
}

static int
fshead_vnstate(vfs_t *vfsp, vnode_t *vp, vntrans_t nstate)
{
	fsemarg_t	farg;
	struct fem_list	*femsp;
	int		(*func)();
	void		*arg0;
	int		errc;

	ASSERT(vfsp->vfs_implp);

	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
		func = (int (*)()) vfsp->vfs_op->vfs_vnstate;
		fem_unlock(vfsp->vfs_femhead);
		errc = (*func)(vfsp, vp, nstate);
	} else {
		fem_addref(femsp);
		fem_unlock(vfsp->vfs_femhead);
		farg.fa_vnode.vfsp = vfsp;
		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
		vfsop_find(&farg, &func, int, &arg0, vfs_vnstate,
		    fsemop_vnstate);
		errc = (*func)(arg0, vp, nstate);
		fem_release(femsp);
	}
	return (errc);
}


/*
 * specification table for the vhead vnode operations.
 * It is an error for any operations to be missing.
 */

static struct fs_operation_def fhead_vn_spec[] = {
	{ VOPNAME_OPEN, (femop_t *)vhead_open },
	{ VOPNAME_CLOSE, (femop_t *)vhead_close },
	{ VOPNAME_READ, (femop_t *)vhead_read },
	{ VOPNAME_WRITE, (femop_t *)vhead_write },
	{ VOPNAME_IOCTL, (femop_t *)vhead_ioctl },
	{ VOPNAME_SETFL, (femop_t *)vhead_setfl },
	{ VOPNAME_GETATTR, (femop_t *)vhead_getattr },
	{ VOPNAME_SETATTR, (femop_t *)vhead_setattr },
	{ VOPNAME_ACCESS, (femop_t *)vhead_access },
	{ VOPNAME_LOOKUP, (femop_t *)vhead_lookup },
	{ VOPNAME_CREATE, (femop_t *)vhead_create },
	{ VOPNAME_REMOVE, (femop_t *)vhead_remove },
	{ VOPNAME_LINK, (femop_t *)vhead_link },
	{ VOPNAME_RENAME, (femop_t *)vhead_rename },
	{ VOPNAME_MKDIR, (femop_t *)vhead_mkdir },
	{ VOPNAME_RMDIR, (femop_t *)vhead_rmdir },
	{ VOPNAME_READDIR, (femop_t *)vhead_readdir },
	{ VOPNAME_SYMLINK, (femop_t *)vhead_symlink },
	{ VOPNAME_READLINK, (femop_t *)vhead_readlink },
	{ VOPNAME_FSYNC, (femop_t *)vhead_fsync },
	{ VOPNAME_INACTIVE, (femop_t *)vhead_inactive },
	{ VOPNAME_FID, (femop_t *)vhead_fid },
	{ VOPNAME_RWLOCK, (femop_t *)vhead_rwlock },
	{ VOPNAME_RWUNLOCK, (femop_t *)vhead_rwunlock },
	{ VOPNAME_SEEK, (femop_t *)vhead_seek },
	{ VOPNAME_CMP, (femop_t *)vhead_cmp },
	{ VOPNAME_FRLOCK, (femop_t *)vhead_frlock },
	{ VOPNAME_SPACE, (femop_t *)vhead_space },
	{ VOPNAME_REALVP, (femop_t *)vhead_realvp },
	{ VOPNAME_GETPAGE, (femop_t *)vhead_getpage },
	{ VOPNAME_PUTPAGE, (femop_t *)vhead_putpage },
	{ VOPNAME_MAP, (femop_t *)vhead_map },
	{ VOPNAME_ADDMAP, (femop_t *)vhead_addmap },
	{ VOPNAME_DELMAP, (femop_t *)vhead_delmap },
	{ VOPNAME_POLL, (femop_t *)vhead_poll },
	{ VOPNAME_DUMP, (femop_t *)vhead_dump },
	{ VOPNAME_PATHCONF, (femop_t *)vhead_pathconf },
	{ VOPNAME_PAGEIO, (femop_t *)vhead_pageio },
	{ VOPNAME_DUMPCTL, (femop_t *)vhead_dumpctl },
	{ VOPNAME_DISPOSE, (femop_t *)vhead_dispose },
	{ VOPNAME_SETSECATTR, (femop_t *)vhead_setsecattr },
	{ VOPNAME_GETSECATTR, (femop_t *)vhead_getsecattr },
	{ VOPNAME_SHRLOCK, (femop_t *)vhead_shrlock },
	{ VOPNAME_VNEVENT, (femop_t *)vhead_vnevent },
	{ VOPNAME_REQZCBUF, (femop_t *)vhead_reqzcbuf },
	{ VOPNAME_RETZCBUF, (femop_t *)vhead_retzcbuf },
	{	NULL,	NULL	}
};

/*
 * specification table for the vfshead vnode operations.
 * It is an error for any operations to be missing.
 */

static struct fs_operation_def fshead_vfs_spec[]  = {
	{ VFSNAME_MOUNT, (femop_t *)fshead_mount },
	{ VFSNAME_UNMOUNT, (femop_t *)fshead_unmount },
	{ VFSNAME_ROOT, (femop_t *)fshead_root },
	{ VFSNAME_STATVFS, (femop_t *)fshead_statvfs },
	{ VFSNAME_SYNC, (femop_t *)fshead_sync },
	{ VFSNAME_VGET, (femop_t *)fshead_vget },
	{ VFSNAME_MOUNTROOT, (femop_t *)fshead_mountroot },
	{ VFSNAME_FREEVFS, (femop_t *)fshead_freevfs },
	{ VFSNAME_VNSTATE, (femop_t *)fshead_vnstate },
	{	NULL,	NULL	}
};

/*
 * This set of routines transfer control to the next stacked monitor.
 *
 * Each routine is identical except for naming, types and arguments.
 *
 * The basic steps are:
 * 1.  Decrease the stack pointer by one.
 * 2.  If the current item is a base operation (vnode, vfs), goto 5.
 * 3.  If the current item does not have a corresponding operation, goto 1
 * 4.  Return by invoking the current item with the argument handle.
 * 5.  Return by invoking the base operation with the base object.
 *
 * for each classification, there needs to be at least one "next" operation
 * for each "head"operation.
 *
 */

int
vnext_open(femarg_t *vf, int mode, cred_t *cr, caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_open, femop_open);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, mode, cr, ct));
}

int
vnext_close(femarg_t *vf, int flag, int count, offset_t offset, cred_t *cr,
    caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_close, femop_close);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, flag, count, offset, cr, ct));
}

int
vnext_read(femarg_t *vf, uio_t *uiop, int ioflag, cred_t *cr,
    caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_read, femop_read);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, uiop, ioflag, cr, ct));
}

int
vnext_write(femarg_t *vf, uio_t *uiop, int ioflag, cred_t *cr,
    caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_write, femop_write);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, uiop, ioflag, cr, ct));
}

int
vnext_ioctl(femarg_t *vf, int cmd, intptr_t arg, int flag, cred_t *cr,
    int *rvalp, caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_ioctl, femop_ioctl);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, cmd, arg, flag, cr, rvalp, ct));
}

int
vnext_setfl(femarg_t *vf, int oflags, int nflags, cred_t *cr,
    caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_setfl, femop_setfl);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, oflags, nflags, cr, ct));
}

int
vnext_getattr(femarg_t *vf, vattr_t *vap, int flags, cred_t *cr,
    caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_getattr, femop_getattr);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, vap, flags, cr, ct));
}

int
vnext_setattr(femarg_t *vf, vattr_t *vap, int flags, cred_t *cr,
    caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_setattr, femop_setattr);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, vap, flags, cr, ct));
}

int
vnext_access(femarg_t *vf, int mode, int flags, cred_t *cr,
    caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_access, femop_access);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, mode, flags, cr, ct));
}

int
vnext_lookup(femarg_t *vf, char *nm, vnode_t **vpp, pathname_t *pnp,
    int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
    int *direntflags, pathname_t *realpnp)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_lookup, femop_lookup);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, nm, vpp, pnp, flags, rdir, cr, ct,
	    direntflags, realpnp));
}

int
vnext_create(femarg_t *vf, char *name, vattr_t *vap, vcexcl_t excl,
    int mode, vnode_t **vpp, cred_t *cr, int flag, caller_context_t *ct,
    vsecattr_t *vsecp)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_create, femop_create);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, name, vap, excl, mode, vpp, cr, flag, ct, vsecp));
}

int
vnext_remove(femarg_t *vf, char *nm, cred_t *cr, caller_context_t *ct,
    int flags)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_remove, femop_remove);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, nm, cr, ct, flags));
}

int
vnext_link(femarg_t *vf, vnode_t *svp, char *tnm, cred_t *cr,
    caller_context_t *ct, int flags)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_link, femop_link);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, svp, tnm, cr, ct, flags));
}

int
vnext_rename(femarg_t *vf, char *snm, vnode_t *tdvp, char *tnm, cred_t *cr,
    caller_context_t *ct, int flags)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_rename, femop_rename);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, snm, tdvp, tnm, cr, ct, flags));
}

int
vnext_mkdir(femarg_t *vf, char *dirname, vattr_t *vap, vnode_t **vpp,
    cred_t *cr, caller_context_t *ct, int flags, vsecattr_t *vsecp)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_mkdir, femop_mkdir);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, dirname, vap, vpp, cr, ct, flags, vsecp));
}

int
vnext_rmdir(femarg_t *vf, char *nm, vnode_t *cdir, cred_t *cr,
    caller_context_t *ct, int flags)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_rmdir, femop_rmdir);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, nm, cdir, cr, ct, flags));
}

int
vnext_readdir(femarg_t *vf, uio_t *uiop, cred_t *cr, int *eofp,
    caller_context_t *ct, int flags)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_readdir, femop_readdir);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, uiop, cr, eofp, ct, flags));
}

int
vnext_symlink(femarg_t *vf, char *linkname, vattr_t *vap, char *target,
    cred_t *cr, caller_context_t *ct, int flags)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_symlink, femop_symlink);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, linkname, vap, target, cr, ct, flags));
}

int
vnext_readlink(femarg_t *vf, uio_t *uiop, cred_t *cr, caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_readlink, femop_readlink);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, uiop, cr, ct));
}

int
vnext_fsync(femarg_t *vf, int syncflag, cred_t *cr, caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_fsync, femop_fsync);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, syncflag, cr, ct));
}

void
vnext_inactive(femarg_t *vf, cred_t *cr, caller_context_t *ct)
{
	void (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, void, &arg0, vop_inactive, femop_inactive);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	(*func)(arg0, cr, ct);
}

int
vnext_fid(femarg_t *vf, fid_t *fidp, caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_fid, femop_fid);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, fidp, ct));
}

int
vnext_rwlock(femarg_t *vf, int write_lock, caller_context_t *ct)
{
	int (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &func, int, &arg0, vop_rwlock, femop_rwlock);
	ASSERT(func != NULL);
	ASSERT(arg0 != NULL);
	return ((*func)(arg0, write_lock, ct));
}

void
vnext_rwunlock(femarg_t *vf, int write_lock, caller_context_t *ct)
{
	void (*func)() = NULL;
	void *arg0 = NULL;

	ASSERT(vf != NULL);
	vf->fa_fnode--;
	vsop_find(vf, &