 @@ -1,23 +1,23 @@
-/*	$NetBSD: vnode_if.c,v 1.80 2008/11/17 08:59:33 pooka Exp $	*/
+/*	$NetBSD: vnode_if.c,v 1.81 2009/09/29 11:54:52 pooka Exp $	*/
 /*
  * Warning: DO NOT EDIT! This file is automatically generated!
  * (Modifications made here may easily be lost!)
+ *
  * Created from the file:
  *	NetBSD: vnode_if.src,v 1.58 2008/11/15 19:08:12 pooka Exp
  * by the script:
- *	NetBSD: vnode_if.sh,v 1.50 2008/11/17 08:46:03 pooka Exp
+ *	NetBSD: vnode_if.sh,v 1.52 2009/09/29 11:51:02 pooka Exp
  */
 /*
  * Copyright (c) 1992, 1993, 1994, 1995
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -30,30 +30,27 @@
  * 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 REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vnode_if.c,v 1.80 2008/11/17 08:59:33 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vnode_if.c,v 1.81 2009/09/29 11:54:52 pooka Exp $");
 #include "opt_vnode_lockdebug.h"
 #include <sys/param.h>
 #include <sys/mount.h>
 #include <sys/buf.h>
 #include <sys/vnode.h>
 #include <sys/lock.h>
 const struct vnodeop_desc vop_default_desc = {
 ,
 	"default",
 ,
 	NULL,
 	VDESC_NO_OFFSET,
 @@ -74,28 +71,26 @@ const struct vnodeop_desc vop_bwrite_des
 ,
 	vop_bwrite_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_BWRITE(struct buf *bp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_bwrite_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_bwrite);
 	a.a_bp = bp;
 	mpsafe = (bp->b_vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(bp->b_vp, VOFFSET(vop_bwrite), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 /* End of special cases */
 const int vop_lookup_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_lookup_args,a_dvp),
 @@ -109,28 +104,26 @@ const struct vnodeop_desc vop_lookup_des
 	VOPARG_OFFSETOF(struct vop_lookup_args, a_vpp),
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_lookup_args, a_cnp),
 	NULL,
 };
 int
 VOP_LOOKUP(struct vnode *dvp,
     struct vnode **vpp,
     struct componentname *cnp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_lookup_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_lookup);
 	a.a_dvp = dvp;
 	a.a_vpp = vpp;
 	a.a_cnp = cnp;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(vop_lookup), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 #ifdef DIAGNOSTIC
 	if (error == 0)
 		KASSERT((*vpp)->v_size != VSIZENOTSET
 		    && (*vpp)->v_writesize != VSIZENOTSET);
 #endif /* DIAGNOSTIC */
 @@ -150,36 +143,28 @@ const struct vnodeop_desc vop_create_des
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_create_args, a_cnp),
 	NULL,
 };
 int
 VOP_CREATE(struct vnode *dvp,
     struct vnode **vpp,
     struct componentname *cnp,
     struct vattr *vap)
+{
 	int error;
 	bool mpsafe;
 	struct vop_create_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 #endif
 	a.a_desc = VDESC(vop_create);
 	a.a_dvp = dvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("vop_create: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vpp = vpp;
 	a.a_cnp = cnp;
 	a.a_vap = vap;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(vop_create), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 #ifdef DIAGNOSTIC
 	if (error == 0)
 		KASSERT((*vpp)->v_size != VSIZENOTSET
 		    && (*vpp)->v_writesize != VSIZENOTSET);
 #endif /* DIAGNOSTIC */
 	return error;
 @@ -198,36 +183,28 @@ const struct vnodeop_desc vop_mknod_desc
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_mknod_args, a_cnp),
 	NULL,
 };
 int
 VOP_MKNOD(struct vnode *dvp,
     struct vnode **vpp,
     struct componentname *cnp,
     struct vattr *vap)
+{
 	int error;
 	bool mpsafe;
 	struct vop_mknod_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 #endif
 	a.a_desc = VDESC(vop_mknod);
 	a.a_dvp = dvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("vop_mknod: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vpp = vpp;
 	a.a_cnp = cnp;
 	a.a_vap = vap;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(vop_mknod), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 #ifdef DIAGNOSTIC
 	if (error == 0)
 		KASSERT((*vpp)->v_size != VSIZENOTSET
 		    && (*vpp)->v_writesize != VSIZENOTSET);
 #endif /* DIAGNOSTIC */
 	return error;
 @@ -245,36 +222,28 @@ const struct vnodeop_desc vop_open_desc
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_open_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_OPEN(struct vnode *vp,
     int mode,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_open_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_open);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_open: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_mode = mode;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_open), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_close_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_close_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -286,36 +255,28 @@ const struct vnodeop_desc vop_close_desc
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_close_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_CLOSE(struct vnode *vp,
     int fflag,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_close_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_close);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_close: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_fflag = fflag;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_close), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_access_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_access_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -327,36 +288,28 @@ const struct vnodeop_desc vop_access_des
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_access_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_ACCESS(struct vnode *vp,
     int mode,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_access_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_access);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_access: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_mode = mode;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_access), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_getattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_getattr_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -368,28 +321,26 @@ const struct vnodeop_desc vop_getattr_de
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_getattr_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_GETATTR(struct vnode *vp,
     struct vattr *vap,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_getattr_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_getattr);
 	a.a_vp = vp;
 	a.a_vap = vap;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_getattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_setattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_setattr_args,a_vp),
 @@ -403,36 +354,28 @@ const struct vnodeop_desc vop_setattr_de
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_setattr_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_SETATTR(struct vnode *vp,
     struct vattr *vap,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_setattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_setattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_setattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_vap = vap;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_setattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_read_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_read_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -445,36 +388,28 @@ const struct vnodeop_desc vop_read_desc
 	VOPARG_OFFSETOF(struct vop_read_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_READ(struct vnode *vp,
     struct uio *uio,
     int ioflag,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_read_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_read);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_read: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_uio = uio;
 	a.a_ioflag = ioflag;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_read), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_write_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_write_args,a_vp),
 	VDESC_NO_OFFSET
 @@ -488,36 +423,28 @@ const struct vnodeop_desc vop_write_desc
 	VOPARG_OFFSETOF(struct vop_write_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_WRITE(struct vnode *vp,
     struct uio *uio,
     int ioflag,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_write_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_write);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_write: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_uio = uio;
 	a.a_ioflag = ioflag;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_write), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_ioctl_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_ioctl_args,a_vp),
 	VDESC_NO_OFFSET
 @@ -532,36 +459,28 @@ const struct vnodeop_desc vop_ioctl_desc
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_IOCTL(struct vnode *vp,
     u_long command,
     void *data,
     int fflag,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_ioctl_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_ioctl);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("vop_ioctl: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_command = command;
 	a.a_data = data;
 	a.a_fflag = fflag;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_ioctl), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_fcntl_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_fcntl_args,a_vp),
 @@ -577,36 +496,28 @@ const struct vnodeop_desc vop_fcntl_desc
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_FCNTL(struct vnode *vp,
     u_int command,
     void *data,
     int fflag,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_fcntl_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_fcntl);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("vop_fcntl: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_command = command;
 	a.a_data = data;
 	a.a_fflag = fflag;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_fcntl), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_poll_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_poll_args,a_vp),
 @@ -619,36 +530,28 @@ const struct vnodeop_desc vop_poll_desc
 	vop_poll_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_POLL(struct vnode *vp,
     int events)
+{
 	int error;
 	bool mpsafe;
 	struct vop_poll_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_poll);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("vop_poll: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_events = events;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_poll), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_kqfilter_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_kqfilter_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc vop_kqfilter_desc = {
 @@ -658,36 +561,28 @@ const struct vnodeop_desc vop_kqfilter_d
 	vop_kqfilter_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_KQFILTER(struct vnode *vp,
     struct knote *kn)
+{
 	int error;
 	bool mpsafe;
 	struct vop_kqfilter_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_kqfilter);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("vop_kqfilter: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_kn = kn;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_kqfilter), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_revoke_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_revoke_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc vop_revoke_desc = {
 @@ -697,36 +592,28 @@ const struct vnodeop_desc vop_revoke_des
 	vop_revoke_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_REVOKE(struct vnode *vp,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct vop_revoke_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_revoke);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("vop_revoke: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_revoke), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_mmap_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_mmap_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc vop_mmap_desc = {
 @@ -737,28 +624,26 @@ const struct vnodeop_desc vop_mmap_desc
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_mmap_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_MMAP(struct vnode *vp,
     vm_prot_t prot,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_mmap_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_mmap);
 	a.a_vp = vp;
 	a.a_prot = prot;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_mmap), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_fsync_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_fsync_args,a_vp),
 @@ -774,36 +659,28 @@ const struct vnodeop_desc vop_fsync_desc
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_FSYNC(struct vnode *vp,
     kauth_cred_t cred,
     int flags,
     off_t offlo,
     off_t offhi)
+{
 	int error;
 	bool mpsafe;
 	struct vop_fsync_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_fsync);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_fsync: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_cred = cred;
 	a.a_flags = flags;
 	a.a_offlo = offlo;
 	a.a_offhi = offhi;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_fsync), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_seek_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_seek_args,a_vp),
 @@ -818,28 +695,26 @@ const struct vnodeop_desc vop_seek_desc
 	VOPARG_OFFSETOF(struct vop_seek_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_SEEK(struct vnode *vp,
     off_t oldoff,
     off_t newoff,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_seek_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_seek);
 	a.a_vp = vp;
 	a.a_oldoff = oldoff;
 	a.a_newoff = newoff;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_seek), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_remove_vp_offsets[] = {
 @@ -855,43 +730,29 @@ const struct vnodeop_desc vop_remove_des
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_remove_args, a_cnp),
 	NULL,
 };
 int
 VOP_REMOVE(struct vnode *dvp,
     struct vnode *vp,
     struct componentname *cnp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_remove_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_remove);
 	a.a_dvp = dvp;
-#ifdef VNODE_LOCKDEBUG
+	a.a_vp = vp;
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("vop_remove: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_remove: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_cnp = cnp;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(vop_remove), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_link_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_link_args,a_dvp),
 	VOPARG_OFFSETOF(struct vop_link_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -903,43 +764,29 @@ const struct vnodeop_desc vop_link_desc
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_link_args, a_cnp),
 	NULL,
 };
 int
 VOP_LINK(struct vnode *dvp,
     struct vnode *vp,
     struct componentname *cnp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_link_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_link);
 	a.a_dvp = dvp;
-#ifdef VNODE_LOCKDEBUG
+	a.a_vp = vp;
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("vop_link: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("vop_link: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_cnp = cnp;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(vop_link), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_rename_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_rename_args,a_fdvp),
 	VOPARG_OFFSETOF(struct vop_rename_args,a_fvp),
 	VOPARG_OFFSETOF(struct vop_rename_args,a_tdvp),
 	VOPARG_OFFSETOF(struct vop_rename_args,a_tvp),
 @@ -956,51 +803,31 @@ const struct vnodeop_desc vop_rename_des
 	NULL,
 };
 int
 VOP_RENAME(struct vnode *fdvp,
     struct vnode *fvp,
     struct componentname *fcnp,
     struct vnode *tdvp,
     struct vnode *tvp,
     struct componentname *tcnp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_rename_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_fdvp;
 	int islocked_fvp;
 	int islocked_tdvp;
 #endif
 	a.a_desc = VDESC(vop_rename);
 	a.a_fdvp = fdvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_fdvp = (fdvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE) : 0;
 	if (islocked_fdvp != 0)
 		panic("vop_rename: fdvp: locked %d, expected %d", islocked_fdvp, 0);
 #endif
 	a.a_fvp = fvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_fvp = (fvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(fvp) == LK_EXCLUSIVE) : 0;
 	if (islocked_fvp != 0)
 		panic("vop_rename: fvp: locked %d, expected %d", islocked_fvp, 0);
 #endif
 	a.a_fcnp = fcnp;
 	a.a_tdvp = tdvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_tdvp = (tdvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_tdvp != 1)
 		panic("vop_rename: tdvp: locked %d, expected %d", islocked_tdvp, 1);
 #endif
 	a.a_tvp = tvp;
 	a.a_tcnp = tcnp;
 	mpsafe = (fdvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(fdvp, VOFFSET(vop_rename), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_mkdir_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_mkdir_args,a_dvp),
 	VDESC_NO_OFFSET
 };
 @@ -1013,36 +840,28 @@ const struct vnodeop_desc vop_mkdir_desc
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_mkdir_args, a_cnp),
 	NULL,
 };
 int
 VOP_MKDIR(struct vnode *dvp,
     struct vnode **vpp,
     struct componentname *cnp,
     struct vattr *vap)
+{
 	int error;
 	bool mpsafe;
 	struct vop_mkdir_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 #endif
 	a.a_desc = VDESC(vop_mkdir);
 	a.a_dvp = dvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("vop_mkdir: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vpp = vpp;
 	a.a_cnp = cnp;
 	a.a_vap = vap;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(vop_mkdir), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 #ifdef DIAGNOSTIC
 	if (error == 0)
 		KASSERT((*vpp)->v_size != VSIZENOTSET
 		    && (*vpp)->v_writesize != VSIZENOTSET);
 #endif /* DIAGNOSTIC */
 	return error;
 @@ -1061,43 +880,29 @@ const struct vnodeop_desc vop_rmdir_desc
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_rmdir_args, a_cnp),
 	NULL,
 };
 int
 VOP_RMDIR(struct vnode *dvp,
     struct vnode *vp,
     struct componentname *cnp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_rmdir_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_rmdir);
 	a.a_dvp = dvp;
-#ifdef VNODE_LOCKDEBUG
+	a.a_vp = vp;
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("vop_rmdir: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_rmdir: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_cnp = cnp;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(vop_rmdir), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_symlink_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_symlink_args,a_dvp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc vop_symlink_desc = {
 @@ -1110,36 +915,28 @@ const struct vnodeop_desc vop_symlink_de
 	VOPARG_OFFSETOF(struct vop_symlink_args, a_cnp),
 	NULL,
 };
 int
 VOP_SYMLINK(struct vnode *dvp,
     struct vnode **vpp,
     struct componentname *cnp,
     struct vattr *vap,
     char *target)
+{
 	int error;
 	bool mpsafe;
 	struct vop_symlink_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 #endif
 	a.a_desc = VDESC(vop_symlink);
 	a.a_dvp = dvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("vop_symlink: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vpp = vpp;
 	a.a_cnp = cnp;
 	a.a_vap = vap;
 	a.a_target = target;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(vop_symlink), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 #ifdef DIAGNOSTIC
 	if (error == 0)
 		KASSERT((*vpp)->v_size != VSIZENOTSET
 		    && (*vpp)->v_writesize != VSIZENOTSET);
 #endif /* DIAGNOSTIC */
 @@ -1161,36 +958,28 @@ const struct vnodeop_desc vop_readdir_de
 	NULL,
 };
 int
 VOP_READDIR(struct vnode *vp,
     struct uio *uio,
     kauth_cred_t cred,
     int *eofflag,
     off_t **cookies,
     int *ncookies)
+{
 	int error;
 	bool mpsafe;
 	struct vop_readdir_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_readdir);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_readdir: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_uio = uio;
 	a.a_cred = cred;
 	a.a_eofflag = eofflag;
 	a.a_cookies = cookies;
 	a.a_ncookies = ncookies;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_readdir), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_readlink_vp_offsets[] = {
 @@ -1205,36 +994,28 @@ const struct vnodeop_desc vop_readlink_d
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_readlink_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_READLINK(struct vnode *vp,
     struct uio *uio,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_readlink_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_readlink);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_readlink: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_uio = uio;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_readlink), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_abortop_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_abortop_args,a_dvp),
 	VDESC_NO_OFFSET
 };
 @@ -1245,28 +1026,26 @@ const struct vnodeop_desc vop_abortop_de
 	vop_abortop_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_abortop_args, a_cnp),
 	NULL,
 };
 int
 VOP_ABORTOP(struct vnode *dvp,
     struct componentname *cnp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_abortop_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_abortop);
 	a.a_dvp = dvp;
 	a.a_cnp = cnp;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(vop_abortop), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_inactive_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_inactive_args,a_vp),
 	VDESC_NO_OFFSET
 @@ -1278,36 +1057,28 @@ const struct vnodeop_desc vop_inactive_d
 	vop_inactive_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_INACTIVE(struct vnode *vp,
     bool *recycle)
+{
 	int error;
 	bool mpsafe;
 	struct vop_inactive_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_inactive);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_inactive: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_recycle = recycle;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_inactive), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_reclaim_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_reclaim_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc vop_reclaim_desc = {
 @@ -1316,36 +1087,28 @@ const struct vnodeop_desc vop_reclaim_de
 ,
 	vop_reclaim_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_RECLAIM(struct vnode *vp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_reclaim_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_reclaim);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("vop_reclaim: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_reclaim), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_lock_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_lock_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc vop_lock_desc = {
 	VOP_LOCK_DESCOFFSET,
 @@ -1354,36 +1117,28 @@ const struct vnodeop_desc vop_lock_desc
 	vop_lock_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_LOCK(struct vnode *vp,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct vop_lock_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_lock);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("vop_lock: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_lock), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_unlock_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_unlock_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc vop_unlock_desc = {
 @@ -1393,36 +1148,28 @@ const struct vnodeop_desc vop_unlock_des
 	vop_unlock_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_UNLOCK(struct vnode *vp,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct vop_unlock_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_unlock);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_unlock: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_unlock), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_bmap_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_bmap_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc vop_bmap_desc = {
 @@ -1435,28 +1182,26 @@ const struct vnodeop_desc vop_bmap_desc
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_BMAP(struct vnode *vp,
     daddr_t bn,
     struct vnode **vpp,
     daddr_t *bnp,
     int *runp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_bmap_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_bmap);
 	a.a_vp = vp;
 	a.a_bn = bn;
 	a.a_vpp = vpp;
 	a.a_bnp = bnp;
 	a.a_runp = runp;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_bmap), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 @@ -1471,28 +1216,26 @@ const struct vnodeop_desc vop_strategy_d
 	vop_strategy_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_STRATEGY(struct vnode *vp,
     struct buf *bp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_strategy_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_strategy);
 	a.a_vp = vp;
 	a.a_bp = bp;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_strategy), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_print_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_print_args,a_vp),
 	VDESC_NO_OFFSET
 @@ -1503,28 +1246,26 @@ const struct vnodeop_desc vop_print_desc
 ,
 	vop_print_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_PRINT(struct vnode *vp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_print_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_print);
 	a.a_vp = vp;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_print), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_islocked_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_islocked_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -1534,28 +1275,26 @@ const struct vnodeop_desc vop_islocked_d
 ,
 	vop_islocked_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_ISLOCKED(struct vnode *vp)
+{
 	int error;
 	bool mpsafe;
 	struct vop_islocked_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_islocked);
 	a.a_vp = vp;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_islocked), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_pathconf_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_pathconf_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -1567,36 +1306,28 @@ const struct vnodeop_desc vop_pathconf_d
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_PATHCONF(struct vnode *vp,
     int name,
     register_t *retval)
+{
 	int error;
 	bool mpsafe;
 	struct vop_pathconf_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_pathconf);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_name = name;
 	a.a_retval = retval;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_pathconf), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_advlock_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_advlock_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -1610,36 +1341,28 @@ const struct vnodeop_desc vop_advlock_de
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_ADVLOCK(struct vnode *vp,
     void *id,
     int op,
     struct flock *fl,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct vop_advlock_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_advlock);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("vop_advlock: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_id = id;
 	a.a_op = op;
 	a.a_fl = fl;
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_advlock), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_whiteout_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_whiteout_args,a_dvp),
 @@ -1653,36 +1376,28 @@ const struct vnodeop_desc vop_whiteout_d
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_whiteout_args, a_cnp),
 	NULL,
 };
 int
 VOP_WHITEOUT(struct vnode *dvp,
     struct componentname *cnp,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct vop_whiteout_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 #endif
 	a.a_desc = VDESC(vop_whiteout);
 	a.a_dvp = dvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_cnp = cnp;
 	a.a_flags = flags;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(vop_whiteout), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_getpages_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_getpages_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -1699,28 +1414,26 @@ const struct vnodeop_desc vop_getpages_d
 int
 VOP_GETPAGES(struct vnode *vp,
     voff_t offset,
     struct vm_page **m,
     int *count,
     int centeridx,
     vm_prot_t access_type,
     int advice,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct vop_getpages_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_getpages);
 	a.a_vp = vp;
 	a.a_offset = offset;
 	a.a_m = m;
 	a.a_count = count;
 	a.a_centeridx = centeridx;
 	a.a_access_type = access_type;
 	a.a_advice = advice;
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_getpages), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 @@ -1740,28 +1453,26 @@ const struct vnodeop_desc vop_putpages_d
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_PUTPAGES(struct vnode *vp,
     voff_t offlo,
     voff_t offhi,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct vop_putpages_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(vop_putpages);
 	a.a_vp = vp;
 	a.a_offlo = offlo;
 	a.a_offhi = offhi;
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_putpages), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_closeextattr_vp_offsets[] = {
 @@ -1776,36 +1487,28 @@ const struct vnodeop_desc vop_closeextat
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_closeextattr_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_CLOSEEXTATTR(struct vnode *vp,
     int commit,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_closeextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_closeextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_commit = commit;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_closeextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_getextattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_getextattr_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -1820,36 +1523,28 @@ const struct vnodeop_desc vop_getextattr
 	NULL,
 };
 int
 VOP_GETEXTATTR(struct vnode *vp,
     int attrnamespace,
     const char *name,
     struct uio *uio,
     size_t *size,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_getextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_getextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_attrnamespace = attrnamespace;
 	a.a_name = name;
 	a.a_uio = uio;
 	a.a_size = size;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_getextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_listextattr_vp_offsets[] = {
 @@ -1866,36 +1561,28 @@ const struct vnodeop_desc vop_listextatt
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_LISTEXTATTR(struct vnode *vp,
     int attrnamespace,
     struct uio *uio,
     size_t *size,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_listextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_listextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_attrnamespace = attrnamespace;
 	a.a_uio = uio;
 	a.a_size = size;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_listextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_openextattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_openextattr_args,a_vp),
 @@ -1908,36 +1595,28 @@ const struct vnodeop_desc vop_openextatt
 	vop_openextattr_vp_offsets,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct vop_openextattr_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_OPENEXTATTR(struct vnode *vp,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_openextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_openextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_openextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_deleteextattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_deleteextattr_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc vop_deleteextattr_desc = {
 @@ -1949,36 +1628,28 @@ const struct vnodeop_desc vop_deleteexta
 	VOPARG_OFFSETOF(struct vop_deleteextattr_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_DELETEEXTATTR(struct vnode *vp,
     int attrnamespace,
     const char *name,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_deleteextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_deleteextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_attrnamespace = attrnamespace;
 	a.a_name = name;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_deleteextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int vop_setextattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct vop_setextattr_args,a_vp),
 	VDESC_NO_OFFSET
 @@ -1993,36 +1664,28 @@ const struct vnodeop_desc vop_setextattr
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 VOP_SETEXTATTR(struct vnode *vp,
     int attrnamespace,
     const char *name,
     struct uio *uio,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct vop_setextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(vop_setextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_attrnamespace = attrnamespace;
 	a.a_name = name;
 	a.a_uio = uio;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(vop_setextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 /* End of special cases. */

 @@ -1,23 +1,23 @@
-/*	$NetBSD: rumpvnode_if.c,v 1.1 2008/11/19 14:10:49 pooka Exp $	*/
+/*	$NetBSD: rumpvnode_if.c,v 1.2 2009/09/29 11:54:52 pooka Exp $	*/
 /*
  * Warning: DO NOT EDIT! This file is automatically generated!
  * (Modifications made here may easily be lost!)
+ *
  * Created from the file:
  *	NetBSD: vnode_if.src,v 1.58 2008/11/15 19:08:12 pooka Exp
  * by the script:
- *	NetBSD: vnode_if.sh,v 1.50 2008/11/17 08:46:03 pooka Exp
+ *	NetBSD: vnode_if.sh,v 1.52 2009/09/29 11:51:02 pooka Exp
  */
 /*
  * Copyright (c) 1992, 1993, 1994, 1995
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -30,30 +30,27 @@
  * 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 REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: rumpvnode_if.c,v 1.1 2008/11/19 14:10:49 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: rumpvnode_if.c,v 1.2 2009/09/29 11:54:52 pooka Exp $");
 #include "opt_vnode_lockdebug.h"
 #include <sys/param.h>
 #include <sys/mount.h>
 #include <sys/buf.h>
 #include <sys/vnode.h>
 #include <sys/lock.h>
 #include <rump/rumpvnode_if.h>
 const struct vnodeop_desc rump_vop_default_desc = {
 ,
 	"default",
 ,
 	NULL,
 @@ -75,28 +72,26 @@ const struct vnodeop_desc rump_vop_bwrit
 ,
 	rump_vop_bwrite_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_BWRITE(struct buf *bp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_bwrite_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_bwrite);
 	a.a_bp = bp;
 	mpsafe = (bp->b_vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(bp->b_vp, VOFFSET(rump_vop_bwrite), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 /* End of special cases */
 const int rump_vop_lookup_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_lookup_args,a_dvp),
 @@ -110,28 +105,26 @@ const struct vnodeop_desc rump_vop_looku
 	VOPARG_OFFSETOF(struct rump_vop_lookup_args, a_vpp),
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_lookup_args, a_cnp),
 	NULL,
 };
 int
 RUMP_VOP_LOOKUP(struct vnode *dvp,
     struct vnode **vpp,
     struct componentname *cnp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_lookup_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_lookup);
 	a.a_dvp = dvp;
 	a.a_vpp = vpp;
 	a.a_cnp = cnp;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(rump_vop_lookup), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 #ifdef DIAGNOSTIC
 	if (error == 0)
 		KASSERT((*vpp)->v_size != VSIZENOTSET
 		    && (*vpp)->v_writesize != VSIZENOTSET);
 #endif /* DIAGNOSTIC */
 @@ -151,36 +144,28 @@ const struct vnodeop_desc rump_vop_creat
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_create_args, a_cnp),
 	NULL,
 };
 int
 RUMP_VOP_CREATE(struct vnode *dvp,
     struct vnode **vpp,
     struct componentname *cnp,
     struct vattr *vap)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_create_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 #endif
 	a.a_desc = VDESC(rump_vop_create);
 	a.a_dvp = dvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("rump_vop_create: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vpp = vpp;
 	a.a_cnp = cnp;
 	a.a_vap = vap;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(rump_vop_create), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 #ifdef DIAGNOSTIC
 	if (error == 0)
 		KASSERT((*vpp)->v_size != VSIZENOTSET
 		    && (*vpp)->v_writesize != VSIZENOTSET);
 #endif /* DIAGNOSTIC */
 	return error;
 @@ -199,36 +184,28 @@ const struct vnodeop_desc rump_vop_mknod
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_mknod_args, a_cnp),
 	NULL,
 };
 int
 RUMP_VOP_MKNOD(struct vnode *dvp,
     struct vnode **vpp,
     struct componentname *cnp,
     struct vattr *vap)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_mknod_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 #endif
 	a.a_desc = VDESC(rump_vop_mknod);
 	a.a_dvp = dvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("rump_vop_mknod: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vpp = vpp;
 	a.a_cnp = cnp;
 	a.a_vap = vap;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(rump_vop_mknod), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 #ifdef DIAGNOSTIC
 	if (error == 0)
 		KASSERT((*vpp)->v_size != VSIZENOTSET
 		    && (*vpp)->v_writesize != VSIZENOTSET);
 #endif /* DIAGNOSTIC */
 	return error;
 @@ -246,36 +223,28 @@ const struct vnodeop_desc rump_vop_open_
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_open_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_OPEN(struct vnode *vp,
     int mode,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_open_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_open);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_open: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_mode = mode;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_open), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_close_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_close_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -287,36 +256,28 @@ const struct vnodeop_desc rump_vop_close
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_close_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_CLOSE(struct vnode *vp,
     int fflag,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_close_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_close);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_close: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_fflag = fflag;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_close), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_access_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_access_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -328,36 +289,28 @@ const struct vnodeop_desc rump_vop_acces
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_access_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_ACCESS(struct vnode *vp,
     int mode,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_access_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_access);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_access: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_mode = mode;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_access), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_getattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_getattr_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -369,28 +322,26 @@ const struct vnodeop_desc rump_vop_getat
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_getattr_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_GETATTR(struct vnode *vp,
     struct vattr *vap,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_getattr_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_getattr);
 	a.a_vp = vp;
 	a.a_vap = vap;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_getattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_setattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_setattr_args,a_vp),
 @@ -404,36 +355,28 @@ const struct vnodeop_desc rump_vop_setat
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_setattr_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_SETATTR(struct vnode *vp,
     struct vattr *vap,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_setattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_setattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_setattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_vap = vap;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_setattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_read_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_read_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -446,36 +389,28 @@ const struct vnodeop_desc rump_vop_read_
 	VOPARG_OFFSETOF(struct rump_vop_read_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_READ(struct vnode *vp,
     struct uio *uio,
     int ioflag,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_read_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_read);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_read: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_uio = uio;
 	a.a_ioflag = ioflag;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_read), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_write_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_write_args,a_vp),
 	VDESC_NO_OFFSET
 @@ -489,36 +424,28 @@ const struct vnodeop_desc rump_vop_write
 	VOPARG_OFFSETOF(struct rump_vop_write_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_WRITE(struct vnode *vp,
     struct uio *uio,
     int ioflag,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_write_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_write);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_write: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_uio = uio;
 	a.a_ioflag = ioflag;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_write), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_ioctl_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_ioctl_args,a_vp),
 	VDESC_NO_OFFSET
 @@ -533,36 +460,28 @@ const struct vnodeop_desc rump_vop_ioctl
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_IOCTL(struct vnode *vp,
     u_long command,
     void *data,
     int fflag,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_ioctl_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_ioctl);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("rump_vop_ioctl: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_command = command;
 	a.a_data = data;
 	a.a_fflag = fflag;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_ioctl), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_fcntl_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_fcntl_args,a_vp),
 @@ -578,36 +497,28 @@ const struct vnodeop_desc rump_vop_fcntl
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_FCNTL(struct vnode *vp,
     u_int command,
     void *data,
     int fflag,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_fcntl_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_fcntl);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("rump_vop_fcntl: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_command = command;
 	a.a_data = data;
 	a.a_fflag = fflag;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_fcntl), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_poll_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_poll_args,a_vp),
 @@ -620,36 +531,28 @@ const struct vnodeop_desc rump_vop_poll_
 	rump_vop_poll_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_POLL(struct vnode *vp,
     int events)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_poll_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_poll);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("rump_vop_poll: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_events = events;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_poll), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_kqfilter_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_kqfilter_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc rump_vop_kqfilter_desc = {
 @@ -659,36 +562,28 @@ const struct vnodeop_desc rump_vop_kqfil
 	rump_vop_kqfilter_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_KQFILTER(struct vnode *vp,
     struct knote *kn)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_kqfilter_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_kqfilter);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("rump_vop_kqfilter: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_kn = kn;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_kqfilter), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_revoke_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_revoke_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc rump_vop_revoke_desc = {
 @@ -698,36 +593,28 @@ const struct vnodeop_desc rump_vop_revok
 	rump_vop_revoke_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_REVOKE(struct vnode *vp,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_revoke_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_revoke);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("rump_vop_revoke: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_revoke), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_mmap_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_mmap_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc rump_vop_mmap_desc = {
 @@ -738,28 +625,26 @@ const struct vnodeop_desc rump_vop_mmap_
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_mmap_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_MMAP(struct vnode *vp,
     int prot,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_mmap_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_mmap);
 	a.a_vp = vp;
 	a.a_prot = prot;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_mmap), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_fsync_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_fsync_args,a_vp),
 @@ -775,36 +660,28 @@ const struct vnodeop_desc rump_vop_fsync
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_FSYNC(struct vnode *vp,
     kauth_cred_t cred,
     int flags,
     off_t offlo,
     off_t offhi)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_fsync_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_fsync);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_fsync: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_cred = cred;
 	a.a_flags = flags;
 	a.a_offlo = offlo;
 	a.a_offhi = offhi;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_fsync), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_seek_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_seek_args,a_vp),
 @@ -819,28 +696,26 @@ const struct vnodeop_desc rump_vop_seek_
 	VOPARG_OFFSETOF(struct rump_vop_seek_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_SEEK(struct vnode *vp,
     off_t oldoff,
     off_t newoff,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_seek_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_seek);
 	a.a_vp = vp;
 	a.a_oldoff = oldoff;
 	a.a_newoff = newoff;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_seek), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_remove_vp_offsets[] = {
 @@ -856,43 +731,29 @@ const struct vnodeop_desc rump_vop_remov
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_remove_args, a_cnp),
 	NULL,
 };
 int
 RUMP_VOP_REMOVE(struct vnode *dvp,
     struct vnode *vp,
     struct componentname *cnp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_remove_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_remove);
 	a.a_dvp = dvp;
-#ifdef VNODE_LOCKDEBUG
+	a.a_vp = vp;
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("rump_vop_remove: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_remove: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_cnp = cnp;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(rump_vop_remove), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_link_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_link_args,a_dvp),
 	VOPARG_OFFSETOF(struct rump_vop_link_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -904,43 +765,29 @@ const struct vnodeop_desc rump_vop_link_
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_link_args, a_cnp),
 	NULL,
 };
 int
 RUMP_VOP_LINK(struct vnode *dvp,
     struct vnode *vp,
     struct componentname *cnp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_link_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_link);
 	a.a_dvp = dvp;
-#ifdef VNODE_LOCKDEBUG
+	a.a_vp = vp;
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("rump_vop_link: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("rump_vop_link: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_cnp = cnp;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(rump_vop_link), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_rename_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_rename_args,a_fdvp),
 	VOPARG_OFFSETOF(struct rump_vop_rename_args,a_fvp),
 	VOPARG_OFFSETOF(struct rump_vop_rename_args,a_tdvp),
 	VOPARG_OFFSETOF(struct rump_vop_rename_args,a_tvp),
 @@ -957,51 +804,31 @@ const struct vnodeop_desc rump_vop_renam
 	NULL,
 };
 int
 RUMP_VOP_RENAME(struct vnode *fdvp,
     struct vnode *fvp,
     struct componentname *fcnp,
     struct vnode *tdvp,
     struct vnode *tvp,
     struct componentname *tcnp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_rename_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_fdvp;
 	int islocked_fvp;
 	int islocked_tdvp;
 #endif
 	a.a_desc = VDESC(rump_vop_rename);
 	a.a_fdvp = fdvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_fdvp = (fdvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE) : 0;
 	if (islocked_fdvp != 0)
 		panic("rump_vop_rename: fdvp: locked %d, expected %d", islocked_fdvp, 0);
 #endif
 	a.a_fvp = fvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_fvp = (fvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(fvp) == LK_EXCLUSIVE) : 0;
 	if (islocked_fvp != 0)
 		panic("rump_vop_rename: fvp: locked %d, expected %d", islocked_fvp, 0);
 #endif
 	a.a_fcnp = fcnp;
 	a.a_tdvp = tdvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_tdvp = (tdvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_tdvp != 1)
 		panic("rump_vop_rename: tdvp: locked %d, expected %d", islocked_tdvp, 1);
 #endif
 	a.a_tvp = tvp;
 	a.a_tcnp = tcnp;
 	mpsafe = (fdvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(fdvp, VOFFSET(rump_vop_rename), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_mkdir_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_mkdir_args,a_dvp),
 	VDESC_NO_OFFSET
 };
 @@ -1014,36 +841,28 @@ const struct vnodeop_desc rump_vop_mkdir
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_mkdir_args, a_cnp),
 	NULL,
 };
 int
 RUMP_VOP_MKDIR(struct vnode *dvp,
     struct vnode **vpp,
     struct componentname *cnp,
     struct vattr *vap)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_mkdir_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 #endif
 	a.a_desc = VDESC(rump_vop_mkdir);
 	a.a_dvp = dvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("rump_vop_mkdir: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vpp = vpp;
 	a.a_cnp = cnp;
 	a.a_vap = vap;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(rump_vop_mkdir), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 #ifdef DIAGNOSTIC
 	if (error == 0)
 		KASSERT((*vpp)->v_size != VSIZENOTSET
 		    && (*vpp)->v_writesize != VSIZENOTSET);
 #endif /* DIAGNOSTIC */
 	return error;
 @@ -1062,43 +881,29 @@ const struct vnodeop_desc rump_vop_rmdir
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_rmdir_args, a_cnp),
 	NULL,
 };
 int
 RUMP_VOP_RMDIR(struct vnode *dvp,
     struct vnode *vp,
     struct componentname *cnp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_rmdir_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_rmdir);
 	a.a_dvp = dvp;
-#ifdef VNODE_LOCKDEBUG
+	a.a_vp = vp;
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("rump_vop_rmdir: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_rmdir: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_cnp = cnp;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(rump_vop_rmdir), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_symlink_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_symlink_args,a_dvp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc rump_vop_symlink_desc = {
 @@ -1111,36 +916,28 @@ const struct vnodeop_desc rump_vop_symli
 	VOPARG_OFFSETOF(struct rump_vop_symlink_args, a_cnp),
 	NULL,
 };
 int
 RUMP_VOP_SYMLINK(struct vnode *dvp,
     struct vnode **vpp,
     struct componentname *cnp,
     struct vattr *vap,
     char *target)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_symlink_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 #endif
 	a.a_desc = VDESC(rump_vop_symlink);
 	a.a_dvp = dvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("rump_vop_symlink: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_vpp = vpp;
 	a.a_cnp = cnp;
 	a.a_vap = vap;
 	a.a_target = target;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(rump_vop_symlink), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 #ifdef DIAGNOSTIC
 	if (error == 0)
 		KASSERT((*vpp)->v_size != VSIZENOTSET
 		    && (*vpp)->v_writesize != VSIZENOTSET);
 #endif /* DIAGNOSTIC */
 @@ -1162,36 +959,28 @@ const struct vnodeop_desc rump_vop_readd
 	NULL,
 };
 int
 RUMP_VOP_READDIR(struct vnode *vp,
     struct uio *uio,
     kauth_cred_t cred,
     int *eofflag,
     off_t **cookies,
     int *ncookies)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_readdir_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_readdir);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_readdir: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_uio = uio;
 	a.a_cred = cred;
 	a.a_eofflag = eofflag;
 	a.a_cookies = cookies;
 	a.a_ncookies = ncookies;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_readdir), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_readlink_vp_offsets[] = {
 @@ -1206,36 +995,28 @@ const struct vnodeop_desc rump_vop_readl
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_readlink_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_READLINK(struct vnode *vp,
     struct uio *uio,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_readlink_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_readlink);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_readlink: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_uio = uio;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_readlink), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_abortop_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_abortop_args,a_dvp),
 	VDESC_NO_OFFSET
 };
 @@ -1246,28 +1027,26 @@ const struct vnodeop_desc rump_vop_abort
 	rump_vop_abortop_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_abortop_args, a_cnp),
 	NULL,
 };
 int
 RUMP_VOP_ABORTOP(struct vnode *dvp,
     struct componentname *cnp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_abortop_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_abortop);
 	a.a_dvp = dvp;
 	a.a_cnp = cnp;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(rump_vop_abortop), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_inactive_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_inactive_args,a_vp),
 	VDESC_NO_OFFSET
 @@ -1279,36 +1058,28 @@ const struct vnodeop_desc rump_vop_inact
 	rump_vop_inactive_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_INACTIVE(struct vnode *vp,
     bool *recycle)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_inactive_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_inactive);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_inactive: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_recycle = recycle;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_inactive), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_reclaim_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_reclaim_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc rump_vop_reclaim_desc = {
 @@ -1317,36 +1088,28 @@ const struct vnodeop_desc rump_vop_recla
 ,
 	rump_vop_reclaim_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_RECLAIM(struct vnode *vp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_reclaim_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_reclaim);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("rump_vop_reclaim: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_reclaim), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_lock_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_lock_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc rump_vop_lock_desc = {
 	RUMP_VOP_LOCK_DESCOFFSET,
 @@ -1355,36 +1118,28 @@ const struct vnodeop_desc rump_vop_lock_
 	rump_vop_lock_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_LOCK(struct vnode *vp,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_lock_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_lock);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("rump_vop_lock: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_lock), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_unlock_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_unlock_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc rump_vop_unlock_desc = {
 @@ -1394,36 +1149,28 @@ const struct vnodeop_desc rump_vop_unloc
 	rump_vop_unlock_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_UNLOCK(struct vnode *vp,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_unlock_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_unlock);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_unlock: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_unlock), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_bmap_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_bmap_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc rump_vop_bmap_desc = {
 @@ -1436,28 +1183,26 @@ const struct vnodeop_desc rump_vop_bmap_
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_BMAP(struct vnode *vp,
     daddr_t bn,
     struct vnode **vpp,
     daddr_t *bnp,
     int *runp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_bmap_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_bmap);
 	a.a_vp = vp;
 	a.a_bn = bn;
 	a.a_vpp = vpp;
 	a.a_bnp = bnp;
 	a.a_runp = runp;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_bmap), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 @@ -1472,28 +1217,26 @@ const struct vnodeop_desc rump_vop_strat
 	rump_vop_strategy_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_STRATEGY(struct vnode *vp,
     struct buf *bp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_strategy_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_strategy);
 	a.a_vp = vp;
 	a.a_bp = bp;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_strategy), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_print_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_print_args,a_vp),
 	VDESC_NO_OFFSET
 @@ -1504,28 +1247,26 @@ const struct vnodeop_desc rump_vop_print
 ,
 	rump_vop_print_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_PRINT(struct vnode *vp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_print_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_print);
 	a.a_vp = vp;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_print), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_islocked_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_islocked_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -1535,28 +1276,26 @@ const struct vnodeop_desc rump_vop_isloc
 ,
 	rump_vop_islocked_vp_offsets,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_ISLOCKED(struct vnode *vp)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_islocked_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_islocked);
 	a.a_vp = vp;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_islocked), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_pathconf_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_pathconf_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -1568,36 +1307,28 @@ const struct vnodeop_desc rump_vop_pathc
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_PATHCONF(struct vnode *vp,
     int name,
     register_t *retval)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_pathconf_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_pathconf);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_pathconf: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_name = name;
 	a.a_retval = retval;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_pathconf), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_advlock_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_advlock_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -1611,36 +1342,28 @@ const struct vnodeop_desc rump_vop_advlo
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_ADVLOCK(struct vnode *vp,
     void *id,
     int op,
     struct flock *fl,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_advlock_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_advlock);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 0;
 	if (islocked_vp != 0)
 		panic("rump_vop_advlock: vp: locked %d, expected %d", islocked_vp, 0);
 #endif
 	a.a_id = id;
 	a.a_op = op;
 	a.a_fl = fl;
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_advlock), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_whiteout_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_whiteout_args,a_dvp),
 @@ -1654,36 +1377,28 @@ const struct vnodeop_desc rump_vop_white
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_whiteout_args, a_cnp),
 	NULL,
 };
 int
 RUMP_VOP_WHITEOUT(struct vnode *dvp,
     struct componentname *cnp,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_whiteout_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_dvp;
 #endif
 	a.a_desc = VDESC(rump_vop_whiteout);
 	a.a_dvp = dvp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_dvp = (dvp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(dvp) == LK_EXCLUSIVE) : 1;
 	if (islocked_dvp != 1)
 		panic("rump_vop_whiteout: dvp: locked %d, expected %d", islocked_dvp, 1);
 #endif
 	a.a_cnp = cnp;
 	a.a_flags = flags;
 	mpsafe = (dvp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(dvp, VOFFSET(rump_vop_whiteout), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_getpages_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_getpages_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -1700,28 +1415,26 @@ const struct vnodeop_desc rump_vop_getpa
 int
 RUMP_VOP_GETPAGES(struct vnode *vp,
     off_t offset,
     struct vm_page **m,
     int *count,
     int centeridx,
     int access_type,
     int advice,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_getpages_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_getpages);
 	a.a_vp = vp;
 	a.a_offset = offset;
 	a.a_m = m;
 	a.a_count = count;
 	a.a_centeridx = centeridx;
 	a.a_access_type = access_type;
 	a.a_advice = advice;
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_getpages), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 @@ -1741,28 +1454,26 @@ const struct vnodeop_desc rump_vop_putpa
 	VDESC_NO_OFFSET,
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_PUTPAGES(struct vnode *vp,
     off_t offlo,
     off_t offhi,
     int flags)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_putpages_args a;
 #ifdef VNODE_LOCKDEBUG
 #endif
 	a.a_desc = VDESC(rump_vop_putpages);
 	a.a_vp = vp;
 	a.a_offlo = offlo;
 	a.a_offhi = offhi;
 	a.a_flags = flags;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_putpages), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_closeextattr_vp_offsets[] = {
 @@ -1777,36 +1488,28 @@ const struct vnodeop_desc rump_vop_close
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_closeextattr_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_CLOSEEXTATTR(struct vnode *vp,
     int commit,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_closeextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_closeextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_closeextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_commit = commit;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_closeextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_getextattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_getextattr_args,a_vp),
 	VDESC_NO_OFFSET
 };
 @@ -1821,36 +1524,28 @@ const struct vnodeop_desc rump_vop_getex
 	NULL,
 };
 int
 RUMP_VOP_GETEXTATTR(struct vnode *vp,
     int attrnamespace,
     const char *name,
     struct uio *uio,
     size_t *size,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_getextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_getextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_getextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_attrnamespace = attrnamespace;
 	a.a_name = name;
 	a.a_uio = uio;
 	a.a_size = size;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_getextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_listextattr_vp_offsets[] = {
 @@ -1867,36 +1562,28 @@ const struct vnodeop_desc rump_vop_liste
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_LISTEXTATTR(struct vnode *vp,
     int attrnamespace,
     struct uio *uio,
     size_t *size,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_listextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_listextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_listextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_attrnamespace = attrnamespace;
 	a.a_uio = uio;
 	a.a_size = size;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_listextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_openextattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_openextattr_args,a_vp),
 @@ -1909,36 +1596,28 @@ const struct vnodeop_desc rump_vop_opene
 	rump_vop_openextattr_vp_offsets,
 	VDESC_NO_OFFSET,
 	VOPARG_OFFSETOF(struct rump_vop_openextattr_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_OPENEXTATTR(struct vnode *vp,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_openextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_openextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_openextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_openextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_deleteextattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_deleteextattr_args,a_vp),
 	VDESC_NO_OFFSET
 };
 const struct vnodeop_desc rump_vop_deleteextattr_desc = {
 @@ -1950,36 +1629,28 @@ const struct vnodeop_desc rump_vop_delet
 	VOPARG_OFFSETOF(struct rump_vop_deleteextattr_args, a_cred),
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_DELETEEXTATTR(struct vnode *vp,
     int attrnamespace,
     const char *name,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_deleteextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_deleteextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_deleteextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_attrnamespace = attrnamespace;
 	a.a_name = name;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_deleteextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 const int rump_vop_setextattr_vp_offsets[] = {
 	VOPARG_OFFSETOF(struct rump_vop_setextattr_args,a_vp),
 	VDESC_NO_OFFSET
 @@ -1994,36 +1665,28 @@ const struct vnodeop_desc rump_vop_setex
 	VDESC_NO_OFFSET,
 	NULL,
 };
 int
 RUMP_VOP_SETEXTATTR(struct vnode *vp,
     int attrnamespace,
     const char *name,
     struct uio *uio,
     kauth_cred_t cred)
+{
 	int error;
 	bool mpsafe;
 	struct rump_vop_setextattr_args a;
 #ifdef VNODE_LOCKDEBUG
 	int islocked_vp;
 #endif
 	a.a_desc = VDESC(rump_vop_setextattr);
 	a.a_vp = vp;
 #ifdef VNODE_LOCKDEBUG
 	islocked_vp = (vp->v_vflag & VV_LOCKSWORK) ? (VOP_ISLOCKED(vp) == LK_EXCLUSIVE) : 1;
 	if (islocked_vp != 1)
 		panic("rump_vop_setextattr: vp: locked %d, expected %d", islocked_vp, 1);
 #endif
 	a.a_attrnamespace = attrnamespace;
 	a.a_name = name;
 	a.a_uio = uio;
 	a.a_cred = cred;
 	mpsafe = (vp->v_vflag & VV_MPSAFE);
 	if (!mpsafe) { KERNEL_LOCK(1, curlwp); }
 	error = (VCALL(vp, VOFFSET(rump_vop_setextattr), &a));
 	if (!mpsafe) { KERNEL_UNLOCK_ONE(curlwp); }
 	return error;
+}
 /* End of special cases. */