 @@ -1,1291 +1,1292 @@
-/*	$NetBSD: vfs_subr.c,v 1.356 2008/09/07 13:09:36 tron Exp $	*/
+/*	$NetBSD: vfs_subr.c,v 1.357 2008/09/24 09:33:40 ad Exp $	*/
 /*-
  * Copyright (c) 1997, 1998, 2004, 2005, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, by Charles M. Hannum, and by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION 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.
  */
 /*
  * Copyright (c) 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE 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.
+ *
  *	@(#)vfs_subr.c	8.13 (Berkeley) 4/18/94
  */
 /*
  * Note on v_usecount and locking:
+ *
  * At nearly all points it is known that v_usecount could be zero, the
  * vnode interlock will be held.
+ *
  * To change v_usecount away from zero, the interlock must be held.  To
  * change from a non-zero value to zero, again the interlock must be
  * held.
+ *
  * Changing the usecount from a non-zero value to a non-zero value can
  * safely be done using atomic operations, without the interlock held.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_subr.c,v 1.356 2008/09/07 13:09:36 tron Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_subr.c,v 1.357 2008/09/24 09:33:40 ad Exp $");
 #include "opt_ddb.h"
 #include "opt_compat_netbsd.h"
 #include "opt_compat_43.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/mount.h>
 #include <sys/fcntl.h>
 #include <sys/vnode.h>
 #include <sys/stat.h>
 #include <sys/namei.h>
 #include <sys/ucred.h>
 #include <sys/buf.h>
 #include <sys/errno.h>
 #include <sys/malloc.h>
 #include <sys/syscallargs.h>
 #include <sys/device.h>
 #include <sys/filedesc.h>
 #include <sys/kauth.h>
 #include <sys/atomic.h>
 #include <sys/kthread.h>
 #include <sys/wapbl.h>
 #include <miscfs/specfs/specdev.h>
 #include <miscfs/syncfs/syncfs.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_readahead.h>
 #include <uvm/uvm_ddb.h>
 #include <sys/sysctl.h>
 const enum vtype iftovt_tab[16] = {
 	VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
 	VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
 };
 const int	vttoif_tab[9] = {
 , S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK,
 	S_IFSOCK, S_IFIFO, S_IFMT,
 };
 /*
  * Insq/Remq for the vnode usage lists.
  */
 #define	bufinsvn(bp, dp)	LIST_INSERT_HEAD(dp, bp, b_vnbufs)
 #define	bufremvn(bp) {							\
 	LIST_REMOVE(bp, b_vnbufs);					\
 	(bp)->b_vnbufs.le_next = NOLIST;				\
+}
 int doforce = 1;		/* 1 => permit forcible unmounting */
 int prtactive = 0;		/* 1 => print out reclaim of active vnodes */
 extern int dovfsusermount;	/* 1 => permit any user to mount filesystems */
 extern int vfs_magiclinks;	/* 1 => expand "magic" symlinks */
 static vnodelst_t vnode_free_list = TAILQ_HEAD_INITIALIZER(vnode_free_list);
 static vnodelst_t vnode_hold_list = TAILQ_HEAD_INITIALIZER(vnode_hold_list);
 static vnodelst_t vrele_list = TAILQ_HEAD_INITIALIZER(vrele_list);
 struct mntlist mountlist =			/* mounted filesystem list */
     CIRCLEQ_HEAD_INITIALIZER(mountlist);
 u_int numvnodes;
 static specificdata_domain_t mount_specificdata_domain;
 static int vrele_pending;
 static int vrele_gen;
 static kmutex_t	vrele_lock;
 static kcondvar_t vrele_cv;
 static lwp_t *vrele_lwp;
 kmutex_t mountlist_lock;
 kmutex_t mntid_lock;
 kmutex_t mntvnode_lock;
 kmutex_t vnode_free_list_lock;
 kmutex_t vfs_list_lock;
 static pool_cache_t vnode_cache;
 MALLOC_DEFINE(M_VNODE, "vnodes", "Dynamically allocated vnodes");
 /*
  * These define the root filesystem and device.
  */
 struct vnode *rootvnode;
 struct device *root_device;			/* root device */
 /*
  * Local declarations.
  */
 static void vrele_thread(void *);
 static void insmntque(vnode_t *, struct mount *);
 static int getdevvp(dev_t, vnode_t **, enum vtype);
 static vnode_t *getcleanvnode(void);;
 void vpanic(vnode_t *, const char *);
 #ifdef DEBUG
 void printlockedvnodes(void);
 #endif
 #ifdef DIAGNOSTIC
 void
 vpanic(vnode_t *vp, const char *msg)
+{
 	vprint(NULL, vp);
 	panic("%s\n", msg);
+}
 #else
 #define	vpanic(vp, msg)	/* nothing */
 #endif
 void
 vn_init1(void)
+{
 	vnode_cache = pool_cache_init(sizeof(struct vnode), 0, 0, 0, "vnodepl",
 	    NULL, IPL_NONE, NULL, NULL, NULL);
 	KASSERT(vnode_cache != NULL);
 	/* Create deferred release thread. */
 	mutex_init(&vrele_lock, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&vrele_cv, "vrele");
 	if (kthread_create(PRI_VM, KTHREAD_MPSAFE, NULL, vrele_thread,
 	    NULL, &vrele_lwp, "vrele"))
 		panic("fork vrele");
+}
 /*
  * Initialize the vnode management data structures.
  */
 void
 vntblinit(void)
+{
 	mutex_init(&mountlist_lock, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&mntid_lock, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&mntvnode_lock, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&vnode_free_list_lock, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&specfs_lock, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&vfs_list_lock, MUTEX_DEFAULT, IPL_NONE);
 	mount_specificdata_domain = specificdata_domain_create();
 	/* Initialize the filesystem syncer. */
 	vn_initialize_syncerd();
 	vn_init1();
+}
 int
 vfs_drainvnodes(long target, struct lwp *l)
+{
 	while (numvnodes > target) {
 		vnode_t *vp;
 		mutex_enter(&vnode_free_list_lock);
 		vp = getcleanvnode();
 		if (vp == NULL)
 			return EBUSY; /* give up */
 		ungetnewvnode(vp);
+	}
 	return 0;
+}
 /*
  * Lookup a mount point by filesystem identifier.
+ *
  * XXX Needs to add a reference to the mount point.
  */
 struct mount *
 vfs_getvfs(fsid_t *fsid)
+{
 	struct mount *mp;
 	mutex_enter(&mountlist_lock);
 	CIRCLEQ_FOREACH(mp, &mountlist, mnt_list) {
 		if (mp->mnt_stat.f_fsidx.__fsid_val[0] == fsid->__fsid_val[0] &&
 		    mp->mnt_stat.f_fsidx.__fsid_val[1] == fsid->__fsid_val[1]) {
 			mutex_exit(&mountlist_lock);
 			return (mp);
+		}
+	}
 	mutex_exit(&mountlist_lock);
 	return ((struct mount *)0);
+}
 /*
  * Drop a reference to a mount structure, freeing if the last reference.
  */
 void
 vfs_destroy(struct mount *mp)
+{
-	if (__predict_true(atomic_dec_uint_nv(&mp->mnt_refcnt) > 0)) {
+	if (__predict_true((int)atomic_dec_uint_nv(&mp->mnt_refcnt) > 0)) {
 		return;
+	}
 	/*
 	 * Nothing else has visibility of the mount: we can now
 	 * free the data structures.
 	 */
 	KASSERT(mp->mnt_refcnt == 0);
 	specificdata_fini(mount_specificdata_domain, &mp->mnt_specdataref);
 	rw_destroy(&mp->mnt_unmounting);
 	mutex_destroy(&mp->mnt_updating);
 	mutex_destroy(&mp->mnt_renamelock);
 	if (mp->mnt_op != NULL) {
 		vfs_delref(mp->mnt_op);
+	}
 	kmem_free(mp, sizeof(*mp));
+}
 /*
  * grab a vnode from freelist and clean it.
  */
 vnode_t *
 getcleanvnode(void)
+{
 	vnode_t *vp;
 	vnodelst_t *listhd;
 	KASSERT(mutex_owned(&vnode_free_list_lock));
 retry:
 	listhd = &vnode_free_list;
 try_nextlist:
 	TAILQ_FOREACH(vp, listhd, v_freelist) {
 		/*
 		 * It's safe to test v_usecount and v_iflag
 		 * without holding the interlock here, since
 		 * these vnodes should never appear on the
 		 * lists.
 		 */
 		if (vp->v_usecount != 0) {
 			vpanic(vp, "free vnode isn't");
+		}
 		if ((vp->v_iflag & VI_CLEAN) != 0) {
 			vpanic(vp, "clean vnode on freelist");
+		}
 		if (vp->v_freelisthd != listhd) {
 			printf("vnode sez %p, listhd %p\n", vp->v_freelisthd, listhd);
 			vpanic(vp, "list head mismatch");
+		}
 		if (!mutex_tryenter(&vp->v_interlock))
 			continue;
 		/*
 		 * Our lwp might hold the underlying vnode
 		 * locked, so don't try to reclaim a VI_LAYER
 		 * node if it's locked.
 		 */
 		if ((vp->v_iflag & VI_XLOCK) == 0 &&
 		    ((vp->v_iflag & VI_LAYER) == 0 || VOP_ISLOCKED(vp) == 0)) {
 			break;
+		}
 		mutex_exit(&vp->v_interlock);
+	}
 	if (vp == NULL) {
 		if (listhd == &vnode_free_list) {
 			listhd = &vnode_hold_list;
 			goto try_nextlist;
+		}
 		mutex_exit(&vnode_free_list_lock);
 		return NULL;
+	}
 	/* Remove it from the freelist. */
 	TAILQ_REMOVE(listhd, vp, v_freelist);
 	vp->v_freelisthd = NULL;
 	mutex_exit(&vnode_free_list_lock);
 	/*
 	 * The vnode is still associated with a file system, so we must
 	 * clean it out before reusing it.  We need to add a reference
 	 * before doing this.  If the vnode gains another reference while
 	 * being cleaned out then we lose - retry.
 	 */
 	atomic_inc_uint(&vp->v_usecount);
 	vclean(vp, DOCLOSE);
 	if (vp->v_usecount == 1) {
 		/* We're about to dirty it. */
 		vp->v_iflag &= ~VI_CLEAN;
 		mutex_exit(&vp->v_interlock);
 		if (vp->v_type == VBLK || vp->v_type == VCHR) {
 			spec_node_destroy(vp);
+		}
 		vp->v_type = VNON;
 	} else {
 		/*
 		 * Don't return to freelist - the holder of the last
 		 * reference will destroy it.
 		 */
 		vrelel(vp, 0); /* releases vp->v_interlock */
 		mutex_enter(&vnode_free_list_lock);
 		goto retry;
+	}
 	if (vp->v_data != NULL || vp->v_uobj.uo_npages != 0 ||
 	    !TAILQ_EMPTY(&vp->v_uobj.memq)) {
 		vpanic(vp, "cleaned vnode isn't");
+	}
 	if (vp->v_numoutput != 0) {
 		vpanic(vp, "clean vnode has pending I/O's");
+	}
 	if ((vp->v_iflag & VI_ONWORKLST) != 0) {
 		vpanic(vp, "clean vnode on syncer list");
+	}
 	return vp;
+}
 /*
  * Mark a mount point as busy, and gain a new reference to it.  Used to
  * prevent the file system from being unmounted during critical sections.
+ *
  * => The caller must hold a pre-existing reference to the mount.
  * => Will fail if the file system is being unmounted, or is unmounted.
  */
 int
 vfs_busy(struct mount *mp, struct mount **nextp)
+{
 	KASSERT(mp->mnt_refcnt > 0);
 	if (__predict_false(!rw_tryenter(&mp->mnt_unmounting, RW_READER))) {
 		if (nextp != NULL) {
 			KASSERT(mutex_owned(&mountlist_lock));
 			*nextp = CIRCLEQ_NEXT(mp, mnt_list);
+		}
 		return EBUSY;
+	}
 	if (__predict_false((mp->mnt_iflag & IMNT_GONE) != 0)) {
 		rw_exit(&mp->mnt_unmounting);
 		if (nextp != NULL) {
 			KASSERT(mutex_owned(&mountlist_lock));
 			*nextp = CIRCLEQ_NEXT(mp, mnt_list);
+		}
 		return ENOENT;
+	}
 	if (nextp != NULL) {
 		mutex_exit(&mountlist_lock);
+	}
 	atomic_inc_uint(&mp->mnt_refcnt);
 	return 0;
+}
 /*
  * Unbusy a busy filesystem.
+ *
  * => If keepref is true, preserve reference added by vfs_busy().
  * => If nextp != NULL, acquire mountlist_lock.
  */
 void
 vfs_unbusy(struct mount *mp, bool keepref, struct mount **nextp)
+{
 	KASSERT(mp->mnt_refcnt > 0);
 	if (nextp != NULL) {
 		mutex_enter(&mountlist_lock);
+	}
 	rw_exit(&mp->mnt_unmounting);
 	if (!keepref) {
 		vfs_destroy(mp);
+	}
 	if (nextp != NULL) {
 		KASSERT(mutex_owned(&mountlist_lock));
 		*nextp = CIRCLEQ_NEXT(mp, mnt_list);
+	}
+}
 /*
  * Lookup a filesystem type, and if found allocate and initialize
  * a mount structure for it.
+ *
  * Devname is usually updated by mount(8) after booting.
  */
 int
 vfs_rootmountalloc(const char *fstypename, const char *devname,
     struct mount **mpp)
+{
 	struct vfsops *vfsp = NULL;
 	struct mount *mp;
 	mutex_enter(&vfs_list_lock);
 	LIST_FOREACH(vfsp, &vfs_list, vfs_list)
 		if (!strncmp(vfsp->vfs_name, fstypename,
 		    sizeof(mp->mnt_stat.f_fstypename)))
 			break;
 	if (vfsp == NULL) {
 		mutex_exit(&vfs_list_lock);
 		return (ENODEV);
+	}
 	vfsp->vfs_refcount++;
 	mutex_exit(&vfs_list_lock);
 	mp = kmem_zalloc(sizeof(*mp), KM_SLEEP);
 	if (mp == NULL)
 		return ENOMEM;
 	mp->mnt_refcnt = 1;
 	rw_init(&mp->mnt_unmounting);
 	mutex_init(&mp->mnt_updating, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&mp->mnt_renamelock, MUTEX_DEFAULT, IPL_NONE);
 	(void)vfs_busy(mp, NULL);
 	TAILQ_INIT(&mp->mnt_vnodelist);
 	mp->mnt_op = vfsp;
 	mp->mnt_flag = MNT_RDONLY;
 	mp->mnt_vnodecovered = NULL;
 	(void)strlcpy(mp->mnt_stat.f_fstypename, vfsp->vfs_name,
 	    sizeof(mp->mnt_stat.f_fstypename));
 	mp->mnt_stat.f_mntonname[0] = '/';
 	mp->mnt_stat.f_mntonname[1] = '\0';
 	mp->mnt_stat.f_mntfromname[sizeof(mp->mnt_stat.f_mntfromname) - 1] =
 	    '\0';
 	(void)copystr(devname, mp->mnt_stat.f_mntfromname,
 	    sizeof(mp->mnt_stat.f_mntfromname) - 1, 0);
 	mount_initspecific(mp);
 	*mpp = mp;
 	return (0);
+}
 /*
  * Routines having to do with the management of the vnode table.
  */
 extern int (**dead_vnodeop_p)(void *);
 /*
  * Return the next vnode from the free list.
  */
 int
 getnewvnode(enum vtagtype tag, struct mount *mp, int (**vops)(void *),
 	    vnode_t **vpp)
+{
 	struct uvm_object *uobj;
 	static int toggle;
 	vnode_t *vp;
 	int error = 0, tryalloc;
  try_again:
 	if (mp != NULL) {
 		/*
 		 * Mark filesystem busy while we're creating a
 		 * vnode.  If unmount is in progress, this will
 		 * fail.
 		 */
 		error = vfs_busy(mp, NULL);
 		if (error)
 			return error;
+	}
 	/*
 	 * We must choose whether to allocate a new vnode or recycle an
 	 * existing one. The criterion for allocating a new one is that
 	 * the total number of vnodes is less than the number desired or
 	 * there are no vnodes on either free list. Generally we only
 	 * want to recycle vnodes that have no buffers associated with
 	 * them, so we look first on the vnode_free_list. If it is empty,
 	 * we next consider vnodes with referencing buffers on the
 	 * vnode_hold_list. The toggle ensures that half the time we
 	 * will use a buffer from the vnode_hold_list, and half the time
 	 * we will allocate a new one unless the list has grown to twice
 	 * the desired size. We are reticent to recycle vnodes from the
 	 * vnode_hold_list because we will lose the identity of all its
 	 * referencing buffers.
 	 */
 	vp = NULL;
 	mutex_enter(&vnode_free_list_lock);
 	toggle ^= 1;
 	if (numvnodes > 2 * desiredvnodes)
 		toggle = 0;
 	tryalloc = numvnodes < desiredvnodes ||
 	    (TAILQ_FIRST(&vnode_free_list) == NULL &&
 	     (TAILQ_FIRST(&vnode_hold_list) == NULL || toggle));
 	if (tryalloc) {
 		numvnodes++;
 		mutex_exit(&vnode_free_list_lock);
 		if ((vp = vnalloc(NULL)) == NULL) {
 			mutex_enter(&vnode_free_list_lock);
 			numvnodes--;
 		} else
 			vp->v_usecount = 1;
+	}
 	if (vp == NULL) {
 		vp = getcleanvnode();
 		if (vp == NULL) {
 			if (mp != NULL) {
 				vfs_unbusy(mp, false, NULL);
+			}
 			if (tryalloc) {
 				printf("WARNING: unable to allocate new "
 				    "vnode, retrying...\n");
 				kpause("newvn", false, hz, NULL);
 				goto try_again;
+			}
 			tablefull("vnode", "increase kern.maxvnodes or NVNODE");
 			*vpp = 0;
 			return (ENFILE);
+		}
 		vp->v_iflag = 0;
 		vp->v_vflag = 0;
 		vp->v_uflag = 0;
 		vp->v_socket = NULL;
+	}
 	KASSERT(vp->v_usecount == 1);
 	KASSERT(vp->v_freelisthd == NULL);
 	KASSERT(LIST_EMPTY(&vp->v_nclist));
 	KASSERT(LIST_EMPTY(&vp->v_dnclist));
 	vp->v_type = VNON;
 	vp->v_vnlock = &vp->v_lock;
 	vp->v_tag = tag;
 	vp->v_op = vops;
 	insmntque(vp, mp);
 	*vpp = vp;
 	vp->v_data = 0;
 	/*
 	 * initialize uvm_object within vnode.
 	 */
 	uobj = &vp->v_uobj;
 	KASSERT(uobj->pgops == &uvm_vnodeops);
 	KASSERT(uobj->uo_npages == 0);
 	KASSERT(TAILQ_FIRST(&uobj->memq) == NULL);
 	vp->v_size = vp->v_writesize = VSIZENOTSET;
 	if (mp != NULL) {
 		if ((mp->mnt_iflag & IMNT_MPSAFE) != 0)
 			vp->v_vflag |= VV_MPSAFE;
 		vfs_unbusy(mp, true, NULL);
+	}
 	return (0);
+}
 /*
  * This is really just the reverse of getnewvnode(). Needed for
  * VFS_VGET functions who may need to push back a vnode in case
  * of a locking race.
  */
 void
 ungetnewvnode(vnode_t *vp)
+{
 	KASSERT(vp->v_usecount == 1);
 	KASSERT(vp->v_data == NULL);
 	KASSERT(vp->v_freelisthd == NULL);
 	mutex_enter(&vp->v_interlock);
 	vp->v_iflag |= VI_CLEAN;
 	vrelel(vp, 0);
+}
 /*
  * Allocate a new, uninitialized vnode.  If 'mp' is non-NULL, this is a
  * marker vnode and we are prepared to wait for the allocation.
  */
 vnode_t *
 vnalloc(struct mount *mp)
+{
 	vnode_t *vp;
 	vp = pool_cache_get(vnode_cache, (mp != NULL ? PR_WAITOK : PR_NOWAIT));
 	if (vp == NULL) {
 		return NULL;
+	}
 	memset(vp, 0, sizeof(*vp));
 	UVM_OBJ_INIT(&vp->v_uobj, &uvm_vnodeops, 0);
 	cv_init(&vp->v_cv, "vnode");
 	/*
 	 * done by memset() above.
 	 *	LIST_INIT(&vp->v_nclist);
 	 *	LIST_INIT(&vp->v_dnclist);
 	 */
 	if (mp != NULL) {
 		vp->v_mount = mp;
 		vp->v_type = VBAD;
 		vp->v_iflag = VI_MARKER;
 	} else {
 		rw_init(&vp->v_lock.vl_lock);
+	}
 	return vp;
+}
 /*
  * Free an unused, unreferenced vnode.
  */
 void
 vnfree(vnode_t *vp)
+{
 	KASSERT(vp->v_usecount == 0);
 	if ((vp->v_iflag & VI_MARKER) == 0) {
 		rw_destroy(&vp->v_lock.vl_lock);
 		mutex_enter(&vnode_free_list_lock);
 		numvnodes--;
 		mutex_exit(&vnode_free_list_lock);
+	}
 	UVM_OBJ_DESTROY(&vp->v_uobj);
 	cv_destroy(&vp->v_cv);
 	pool_cache_put(vnode_cache, vp);
+}
 /*
  * Remove a vnode from its freelist.
  */
 static inline void
 vremfree(vnode_t *vp)
+{
 	KASSERT(mutex_owned(&vp->v_interlock));
 	KASSERT(vp->v_usecount == 0);
 	/*
 	 * Note that the reference count must not change until
 	 * the vnode is removed.
 	 */
 	mutex_enter(&vnode_free_list_lock);
 	if (vp->v_holdcnt > 0) {
 		KASSERT(vp->v_freelisthd == &vnode_hold_list);
 	} else {
 		KASSERT(vp->v_freelisthd == &vnode_free_list);
+	}
 	TAILQ_REMOVE(vp->v_freelisthd, vp, v_freelist);
 	vp->v_freelisthd = NULL;
 	mutex_exit(&vnode_free_list_lock);
+}
 /*
  * Move a vnode from one mount queue to another.
  */
 static void
 insmntque(vnode_t *vp, struct mount *mp)
+{
 	struct mount *omp;
 #ifdef DIAGNOSTIC
 	if ((mp != NULL) &&
 	    (mp->mnt_iflag & IMNT_UNMOUNT) &&
 	    !(mp->mnt_flag & MNT_SOFTDEP) &&
 	    vp->v_tag != VT_VFS) {
 		panic("insmntque into dying filesystem");
+	}
 #endif
 	mutex_enter(&mntvnode_lock);
 	/*
 	 * Delete from old mount point vnode list, if on one.
 	 */
 	if ((omp = vp->v_mount) != NULL)
 		TAILQ_REMOVE(&vp->v_mount->mnt_vnodelist, vp, v_mntvnodes);
 	/*
 	 * Insert into list of vnodes for the new mount point, if
 	 * available.  The caller must take a reference on the mount
 	 * structure and donate to the vnode.
 	 */
 	if ((vp->v_mount = mp) != NULL)
 		TAILQ_INSERT_TAIL(&mp->mnt_vnodelist, vp, v_mntvnodes);
 	mutex_exit(&mntvnode_lock);
 	if (omp != NULL) {
 		/* Release reference to old mount. */
 		vfs_destroy(omp);
+	}
+}
 /*
  * Wait for a vnode (typically with VI_XLOCK set) to be cleaned or
  * recycled.
  */
 void
 vwait(vnode_t *vp, int flags)
+{
 	KASSERT(mutex_owned(&vp->v_interlock));
 	KASSERT(vp->v_usecount != 0);
 	while ((vp->v_iflag & flags) != 0)
 		cv_wait(&vp->v_cv, &vp->v_interlock);
+}
 /*
  * Insert a marker vnode into a mount's vnode list, after the
  * specified vnode.  mntvnode_lock must be held.
  */
 void
 vmark(vnode_t *mvp, vnode_t *vp)
+{
 	struct mount *mp;
 	mp = mvp->v_mount;
 	KASSERT(mutex_owned(&mntvnode_lock));
 	KASSERT((mvp->v_iflag & VI_MARKER) != 0);
 	KASSERT(vp->v_mount == mp);
 	TAILQ_INSERT_AFTER(&mp->mnt_vnodelist, vp, mvp, v_mntvnodes);
+}
 /*
  * Remove a marker vnode from a mount's vnode list, and return
  * a pointer to the next vnode in the list.  mntvnode_lock must
  * be held.
  */
 vnode_t *
 vunmark(vnode_t *mvp)
+{
 	vnode_t *vp;
 	struct mount *mp;
 	mp = mvp->v_mount;
 	KASSERT(mutex_owned(&mntvnode_lock));
 	KASSERT((mvp->v_iflag & VI_MARKER) != 0);
 	vp = TAILQ_NEXT(mvp, v_mntvnodes);
 	TAILQ_REMOVE(&mp->mnt_vnodelist, mvp, v_mntvnodes);
 	KASSERT(vp == NULL || vp->v_mount == mp);
 	return vp;
+}
 /*
  * Update outstanding I/O count and do wakeup if requested.
  */
 void
 vwakeup(struct buf *bp)
+{
 	struct vnode *vp;
 	if ((vp = bp->b_vp) == NULL)
 		return;
 	KASSERT(bp->b_objlock == &vp->v_interlock);
 	KASSERT(mutex_owned(bp->b_objlock));
 	if (--vp->v_numoutput < 0)
 		panic("vwakeup: neg numoutput, vp %p", vp);
 	if (vp->v_numoutput == 0)
 		cv_broadcast(&vp->v_cv);
+}
 /*
  * Flush out and invalidate all buffers associated with a vnode.
  * Called with the underlying vnode locked, which should prevent new dirty
  * buffers from being queued.
  */
 int
 vinvalbuf(struct vnode *vp, int flags, kauth_cred_t cred, struct lwp *l,
 	  bool catch, int slptimeo)
+{
 	struct buf *bp, *nbp;
 	int error;
 	int flushflags = PGO_ALLPAGES | PGO_FREE | PGO_SYNCIO |
 	    (flags & V_SAVE ? PGO_CLEANIT | PGO_RECLAIM : 0);
 	/* XXXUBC this doesn't look at flags or slp* */
 	mutex_enter(&vp->v_interlock);
 	error = VOP_PUTPAGES(vp, 0, 0, flushflags);
 	if (error) {
 		return error;
+	}
 	if (flags & V_SAVE) {
 		error = VOP_FSYNC(vp, cred, FSYNC_WAIT|FSYNC_RECLAIM, 0, 0);
 		if (error)
 		        return (error);
 		KASSERT(LIST_EMPTY(&vp->v_dirtyblkhd));
+	}
 	mutex_enter(&bufcache_lock);
 restart:
 	for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
 		nbp = LIST_NEXT(bp, b_vnbufs);
 		error = bbusy(bp, catch, slptimeo, NULL);
 		if (error != 0) {
 			if (error == EPASSTHROUGH)
 				goto restart;
 			mutex_exit(&bufcache_lock);
 			return (error);
+		}
 		brelsel(bp, BC_INVAL | BC_VFLUSH);
+	}
 	for (bp = LIST_FIRST(&vp->v_cleanblkhd); bp; bp = nbp) {
 		nbp = LIST_NEXT(bp, b_vnbufs);
 		error = bbusy(bp, catch, slptimeo, NULL);
 		if (error != 0) {
 			if (error == EPASSTHROUGH)
 				goto restart;
 			mutex_exit(&bufcache_lock);
 			return (error);
+		}
 		/*
 		 * XXX Since there are no node locks for NFS, I believe
 		 * there is a slight chance that a delayed write will
 		 * occur while sleeping just above, so check for it.
 		 */
 		if ((bp->b_oflags & BO_DELWRI) && (flags & V_SAVE)) {
 #ifdef DEBUG
 			printf("buffer still DELWRI\n");
 #endif
 			bp->b_cflags |= BC_BUSY | BC_VFLUSH;
 			mutex_exit(&bufcache_lock);
 			VOP_BWRITE(bp);
 			mutex_enter(&bufcache_lock);
 			goto restart;
+		}
 		brelsel(bp, BC_INVAL | BC_VFLUSH);
+	}
 #ifdef DIAGNOSTIC
 	if (!LIST_EMPTY(&vp->v_cleanblkhd) || !LIST_EMPTY(&vp->v_dirtyblkhd))
 		panic("vinvalbuf: flush failed, vp %p", vp);
 #endif
 	mutex_exit(&bufcache_lock);
 	return (0);
+}
 /*
  * Destroy any in core blocks past the truncation length.
  * Called with the underlying vnode locked, which should prevent new dirty
  * buffers from being queued.
  */
 int
 vtruncbuf(struct vnode *vp, daddr_t lbn, bool catch, int slptimeo)
+{
 	struct buf *bp, *nbp;
 	int error;
 	voff_t off;
 	off = round_page((voff_t)lbn << vp->v_mount->mnt_fs_bshift);
 	mutex_enter(&vp->v_interlock);
 	error = VOP_PUTPAGES(vp, off, 0, PGO_FREE | PGO_SYNCIO);
 	if (error) {
 		return error;
+	}
 	mutex_enter(&bufcache_lock);
 restart:
 	for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
 		nbp = LIST_NEXT(bp, b_vnbufs);
 		if (bp->b_lblkno < lbn)
 			continue;
 		error = bbusy(bp, catch, slptimeo, NULL);
 		if (error != 0) {
 			if (error == EPASSTHROUGH)
 				goto restart;
 			mutex_exit(&bufcache_lock);
 			return (error);
+		}
 		brelsel(bp, BC_INVAL | BC_VFLUSH);
+	}
 	for (bp = LIST_FIRST(&vp->v_cleanblkhd); bp; bp = nbp) {
 		nbp = LIST_NEXT(bp, b_vnbufs);
 		if (bp->b_lblkno < lbn)
 			continue;
 		error = bbusy(bp, catch, slptimeo, NULL);
 		if (error != 0) {
 			if (error == EPASSTHROUGH)
 				goto restart;
 			mutex_exit(&bufcache_lock);
 			return (error);
+		}
 		brelsel(bp, BC_INVAL | BC_VFLUSH);
+	}
 	mutex_exit(&bufcache_lock);
 	return (0);
+}
 /*
  * Flush all dirty buffers from a vnode.
  * Called with the underlying vnode locked, which should prevent new dirty
  * buffers from being queued.
  */
 void
 vflushbuf(struct vnode *vp, int sync)
+{
 	struct buf *bp, *nbp;
 	int flags = PGO_CLEANIT | PGO_ALLPAGES | (sync ? PGO_SYNCIO : 0);
 	bool dirty;
 	mutex_enter(&vp->v_interlock);
 	(void) VOP_PUTPAGES(vp, 0, 0, flags);
 loop:
 	mutex_enter(&bufcache_lock);
 	for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
 		nbp = LIST_NEXT(bp, b_vnbufs);
 		if ((bp->b_cflags & BC_BUSY))
 			continue;
 		if ((bp->b_oflags & BO_DELWRI) == 0)
 			panic("vflushbuf: not dirty, bp %p", bp);
 		bp->b_cflags |= BC_BUSY | BC_VFLUSH;
 		mutex_exit(&bufcache_lock);
 		/*
 		 * Wait for I/O associated with indirect blocks to complete,
 		 * since there is no way to quickly wait for them below.
 		 */
 		if (bp->b_vp == vp || sync == 0)
 			(void) bawrite(bp);
 		else
 			(void) bwrite(bp);
 		goto loop;
+	}
 	mutex_exit(&bufcache_lock);
 	if (sync == 0)
 		return;
 	mutex_enter(&vp->v_interlock);
 	while (vp->v_numoutput != 0)
 		cv_wait(&vp->v_cv, &vp->v_interlock);
 	dirty = !LIST_EMPTY(&vp->v_dirtyblkhd);
 	mutex_exit(&vp->v_interlock);
 	if (dirty) {
 		vprint("vflushbuf: dirty", vp);
 		goto loop;
+	}
+}
 /*
  * Create a vnode for a block device.
  * Used for root filesystem and swap areas.
  * Also used for memory file system special devices.
  */
 int
 bdevvp(dev_t dev, vnode_t **vpp)
+{
 	return (getdevvp(dev, vpp, VBLK));
+}
 /*
  * Create a vnode for a character device.
  * Used for kernfs and some console handling.
  */
 int
 cdevvp(dev_t dev, vnode_t **vpp)
+{
 	return (getdevvp(dev, vpp, VCHR));
+}
 /*
  * Associate a buffer with a vnode.  There must already be a hold on
  * the vnode.
  */
 void
 bgetvp(struct vnode *vp, struct buf *bp)
+{
 	KASSERT(bp->b_vp == NULL);
 	KASSERT(bp->b_objlock == &buffer_lock);
 	KASSERT(mutex_owned(&vp->v_interlock));
 	KASSERT(mutex_owned(&bufcache_lock));
 	KASSERT((bp->b_cflags & BC_BUSY) != 0);
 	KASSERT(!cv_has_waiters(&bp->b_done));
 	vholdl(vp);
 	bp->b_vp = vp;
 	if (vp->v_type == VBLK || vp->v_type == VCHR)
 		bp->b_dev = vp->v_rdev;
 	else
 		bp->b_dev = NODEV;
 	/*
 	 * Insert onto list for new vnode.
 	 */
 	bufinsvn(bp, &vp->v_cleanblkhd);
 	bp->b_objlock = &vp->v_interlock;
+}
 /*
  * Disassociate a buffer from a vnode.
  */
 void
 brelvp(struct buf *bp)
+{
 	struct vnode *vp = bp->b_vp;
 	KASSERT(vp != NULL);
 	KASSERT(bp->b_objlock == &vp->v_interlock);
 	KASSERT(mutex_owned(&vp->v_interlock));
 	KASSERT(mutex_owned(&bufcache_lock));
 	KASSERT((bp->b_cflags & BC_BUSY) != 0);
 	KASSERT(!cv_has_waiters(&bp->b_done));
 	/*
 	 * Delete from old vnode list, if on one.
 	 */
 	if (LIST_NEXT(bp, b_vnbufs) != NOLIST)
 		bufremvn(bp);
 	if (TAILQ_EMPTY(&vp->v_uobj.memq) && (vp->v_iflag & VI_ONWORKLST) &&
 	    LIST_FIRST(&vp->v_dirtyblkhd) == NULL) {
 		vp->v_iflag &= ~VI_WRMAPDIRTY;
 		vn_syncer_remove_from_worklist(vp);
+	}
 	bp->b_objlock = &buffer_lock;
 	bp->b_vp = NULL;
 	holdrelel(vp);
+}
 /*
  * Reassign a buffer from one vnode list to another.
  * The list reassignment must be within the same vnode.
  * Used to assign file specific control information
  * (indirect blocks) to the list to which they belong.
  */
 void
 reassignbuf(struct buf *bp, struct vnode *vp)
+{
 	struct buflists *listheadp;
 	int delayx;
 	KASSERT(mutex_owned(&bufcache_lock));
 	KASSERT(bp->b_objlock == &vp->v_interlock);
 	KASSERT(mutex_owned(&vp->v_interlock));
 	KASSERT((bp->b_cflags & BC_BUSY) != 0);
 	/*
 	 * Delete from old vnode list, if on one.
 	 */
 	if (LIST_NEXT(bp, b_vnbufs) != NOLIST)
 		bufremvn(bp);
 	/*
 	 * If dirty, put on list of dirty buffers;
 	 * otherwise insert onto list of clean buffers.
 	 */
 	if ((bp->b_oflags & BO_DELWRI) == 0) {
 		listheadp = &vp->v_cleanblkhd;
 		if (TAILQ_EMPTY(&vp->v_uobj.memq) &&
 		    (vp->v_iflag & VI_ONWORKLST) &&
 		    LIST_FIRST(&vp->v_dirtyblkhd) == NULL) {
 			vp->v_iflag &= ~VI_WRMAPDIRTY;
 			vn_syncer_remove_from_worklist(vp);
+		}
 	} else {
 		listheadp = &vp->v_dirtyblkhd;
 		if ((vp->v_iflag & VI_ONWORKLST) == 0) {
 			switch (vp->v_type) {
 			case VDIR:
 				delayx = dirdelay;
 				break;
 			case VBLK:
 				if (vp->v_specmountpoint != NULL) {
 					delayx = metadelay;
 					break;
+				}
 				/* fall through */
 			default:
 				delayx = filedelay;
 				break;
+			}
 			if (!vp->v_mount ||
 			    (vp->v_mount->mnt_flag & MNT_ASYNC) == 0)
 				vn_syncer_add_to_worklist(vp, delayx);
+		}
+	}
 	bufinsvn(bp, listheadp);
+}
 /*
  * Create a vnode for a device.
  * Used by bdevvp (block device) for root file system etc.,
  * and by cdevvp (character device) for console and kernfs.
  */
 static int
 getdevvp(dev_t dev, vnode_t **vpp, enum vtype type)
+{
 	vnode_t *vp;
 	vnode_t *nvp;
 	int error;
 	if (dev == NODEV) {
 		*vpp = NULL;
 		return (0);
+	}
 	error = getnewvnode(VT_NON, NULL, spec_vnodeop_p, &nvp);
 	if (error) {
 		*vpp = NULL;
 		return (error);
+	}
 	vp = nvp;
 	vp->v_type = type;
 	vp->v_vflag |= VV_MPSAFE;
 	uvm_vnp_setsize(vp, 0);
 	spec_node_init(vp, dev);
 	*vpp = vp;
 	return (0);
+}
 /*
  * Try to gain a reference to a vnode, without acquiring its interlock.
  * The caller must hold a lock that will prevent the vnode from being
  * recycled or freed.
  */
 bool
 vtryget(vnode_t *vp)
+{
 	u_int use, next;
 	/*
 	 * If the vnode is being freed, don't make life any harder
 	 * for vclean() by adding another reference without waiting.
 	 * This is not strictly necessary, but we'll do it anyway.
 	 */
 	if (__predict_false((vp->v_iflag & (VI_XLOCK | VI_FREEING)) != 0)) {
 		return false;
+	}
 	for (use = vp->v_usecount;; use = next) {
 		if (use == 0) {
 			/* Need interlock held if first reference. */
 			return false;
+		}
 		next = atomic_cas_uint(&vp->v_usecount, use, use + 1);
 		if (__predict_true(next == use)) {
 			return true;
+		}
+	}
+}
 /*
  * Grab a particular vnode from the free list, increment its
  * reference count and lock it. If the vnode lock bit is set the
  * vnode is being eliminated in vgone. In that case, we can not
  * grab the vnode, so the process is awakened when the transition is
  * completed, and an error returned to indicate that the vnode is no
  * longer usable (possibly having been changed to a new file system type).
  */
 int
 vget(vnode_t *vp, int flags)
+{
 	int error;
 	KASSERT((vp->v_iflag & VI_MARKER) == 0);
 	if ((flags & LK_INTERLOCK) == 0)
 		mutex_enter(&vp->v_interlock);
 	/*
 	 * Before adding a reference, we must remove the vnode
 	 * from its freelist.
 	 */
 	if (vp->v_usecount == 0) {
 		vremfree(vp);
 		vp->v_usecount = 1;
 	} else {
 		atomic_inc_uint(&vp->v_usecount);
+	}
 	/*
 	 * If the vnode is in the process of being cleaned out for
 	 * another use, we wait for the cleaning to finish and then
 	 * return failure.  Cleaning is determined by checking if
 	 * the VI_XLOCK or VI_FREEING flags are set.
 	 */
 	if ((vp->v_iflag & (VI_XLOCK | VI_FREEING)) != 0) {
 		if ((flags & LK_NOWAIT) != 0) {
 			vrelel(vp, 0);
 			return EBUSY;
+		}
 		vwait(vp, VI_XLOCK | VI_FREEING);
 		vrelel(vp, 0);
 		return ENOENT;
+	}
 	if (flags & LK_TYPE_MASK) {
 		error = vn_lock(vp, flags | LK_INTERLOCK);
 		if (error != 0) {
 			vrele(vp);
+		}
 		return error;
+	}
 	mutex_exit(&vp->v_interlock);
 	return 0;
+}
 /*
  * vput(), just unlock and vrele()
  */