 @@ -1,1308 +1,1308 @@
-/*	$NetBSD: vfs_subr.c,v 1.426 2011/12/02 12:32:38 yamt Exp $	*/
+/*	$NetBSD: vfs_subr.c,v 1.427 2012/01/29 06:32:43 dholland 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
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_subr.c,v 1.426 2011/12/02 12:32:38 yamt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_subr.c,v 1.427 2012/01/29 06:32:43 dholland 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/conf.h>
 #include <sys/dirent.h>
 #include <sys/filedesc.h>
 #include <sys/kernel.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/namei.h>
 #include <sys/buf.h>
 #include <sys/errno.h>
 #include <sys/kmem.h>
 #include <sys/syscallargs.h>
 #include <sys/kauth.h>
 #include <sys/module.h>
 #include <miscfs/genfs/genfs.h>
 #include <miscfs/syncfs/syncfs.h>
 #include <miscfs/specfs/specdev.h>
 #include <uvm/uvm_ddb.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 */
 /*
  * Local declarations.
  */
 static int getdevvp(dev_t, vnode_t **, enum vtype);
 /*
  * Initialize the vnode management data structures.
  */
 void
 vntblinit(void)
+{
 	vn_initialize_syncerd();
 	vfs_vnode_sysinit();
 	vfs_mount_sysinit();
+}
 /*
  * 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) {
 		KASSERT(bp->b_vp == vp);
 		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) {
 		KASSERT(bp->b_vp == vp);
 		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->b_vp, 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) {
 		KASSERT(bp->b_vp == vp);
 		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) {
 		KASSERT(bp->b_vp == vp);
 		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.
  */
 int
 vflushbuf(struct vnode *vp, int sync)
+{
 	struct buf *bp, *nbp;
 	int error, 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) {
 		KASSERT(bp->b_vp == vp);
 		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 {
 			error = bwrite(bp);
 			if (error)
 				return error;
+		}
 		goto loop;
+	}
 	mutex_exit(&bufcache_lock);
 	if (sync == 0)
 		return 0;
 	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;
+	}
 	return 0;
+}
 /*
  * 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 (vp->v_uobj.uo_npages == 0 && (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 (vp->v_uobj.uo_npages == 0 &&
 		    (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, NULL, &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);
+}
 /*
  * Lookup a vnode by device number and return it referenced.
  */
 int
 vfinddev(dev_t dev, enum vtype type, vnode_t **vpp)
+{
 	vnode_t *vp;
 	mutex_enter(&device_lock);
 	for (vp = specfs_hash[SPECHASH(dev)]; vp; vp = vp->v_specnext) {
 		if (type == vp->v_type && dev == vp->v_rdev)
 			break;
+	}
 	if (vp == NULL) {
 		mutex_exit(&device_lock);
 		return 0;
+	}
 	mutex_enter(vp->v_interlock);
 	mutex_exit(&device_lock);
 	if (vget(vp, 0) != 0)
 		return 0;
 	*vpp = vp;
 	return 1;
+}
 /*
  * Revoke all the vnodes corresponding to the specified minor number
  * range (endpoints inclusive) of the specified major.
  */
 void
 vdevgone(int maj, int minl, int minh, enum vtype type)
+{
 	vnode_t *vp, **vpp;
 	dev_t dev;
 	int mn;
 	vp = NULL;	/* XXX gcc */
 	mutex_enter(&device_lock);
 	for (mn = minl; mn <= minh; mn++) {
 		dev = makedev(maj, mn);
 		vpp = &specfs_hash[SPECHASH(dev)];
 		for (vp = *vpp; vp != NULL;) {
 			mutex_enter(vp->v_interlock);
 			if ((vp->v_iflag & VI_CLEAN) != 0 ||
 			    type != vp->v_type || dev != vp->v_rdev) {
 				mutex_exit(vp->v_interlock);
 				vp = vp->v_specnext;
 				continue;
+			}
 			mutex_exit(&device_lock);
 			if (vget(vp, 0) == 0) {
 				VOP_REVOKE(vp, REVOKEALL);
 				vrele(vp);
+			}
 			mutex_enter(&device_lock);
 			vp = *vpp;
+		}
+	}
 	mutex_exit(&device_lock);
+}
 /*
  * sysctl helper routine to return list of supported fstypes
  */
 int
 sysctl_vfs_generic_fstypes(SYSCTLFN_ARGS)
+{
 	char bf[sizeof(((struct statvfs *)NULL)->f_fstypename)];
 	char *where = oldp;
 	struct vfsops *v;
 	size_t needed, left, slen;
 	int error, first;
 	if (newp != NULL)
 		return (EPERM);
 	if (namelen != 0)
 		return (EINVAL);
 	first = 1;
 	error = 0;
 	needed = 0;
 	left = *oldlenp;
 	sysctl_unlock();
 	mutex_enter(&vfs_list_lock);
 	LIST_FOREACH(v, &vfs_list, vfs_list) {
 		if (where == NULL)
 			needed += strlen(v->vfs_name) + 1;
 		else {
 			memset(bf, 0, sizeof(bf));
 			if (first) {
 				strncpy(bf, v->vfs_name, sizeof(bf));
 				first = 0;
 			} else {
 				bf[0] = ' ';
 				strncpy(bf + 1, v->vfs_name, sizeof(bf) - 1);
+			}
 			bf[sizeof(bf)-1] = '\0';
 			slen = strlen(bf);
 			if (left < slen + 1)
 				break;
 			v->vfs_refcount++;
 			mutex_exit(&vfs_list_lock);
 			/* +1 to copy out the trailing NUL byte */
 			error = copyout(bf, where, slen + 1);
 			mutex_enter(&vfs_list_lock);
 			v->vfs_refcount--;
 			if (error)
 				break;
 			where += slen;
 			needed += slen;
 			left -= slen;
+		}
+	}
 	mutex_exit(&vfs_list_lock);
 	sysctl_relock();
 	*oldlenp = needed;
 	return (error);
+}
 int kinfo_vdebug = 1;
 int kinfo_vgetfailed;
 #define KINFO_VNODESLOP	10
 /*
  * Dump vnode list (via sysctl).
  * Copyout address of vnode followed by vnode.
  */
 int
 sysctl_kern_vnode(SYSCTLFN_ARGS)
+{
 	char *where = oldp;
 	size_t *sizep = oldlenp;
 	struct mount *mp, *nmp;
 	vnode_t *vp, *mvp, vbuf;
 	char *bp = where;
 	char *ewhere;
 	int error;
 	if (namelen != 0)
 		return (EOPNOTSUPP);
 	if (newp != NULL)
 		return (EPERM);
 #define VPTRSZ	sizeof(vnode_t *)
 #define VNODESZ	sizeof(vnode_t)
 	if (where == NULL) {
 		*sizep = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ);
 		return (0);
+	}
 	ewhere = where + *sizep;
 	sysctl_unlock();
 	mutex_enter(&mountlist_lock);
 	for (mp = CIRCLEQ_FIRST(&mountlist); mp != (void *)&mountlist;
 	    mp = nmp) {
 		if (vfs_busy(mp, &nmp)) {
 			continue;
+		}
 		/* Allocate a marker vnode. */
 		mvp = vnalloc(mp);
 		/* Should never fail for mp != NULL */
 		KASSERT(mvp != NULL);
 		mutex_enter(&mntvnode_lock);
 		for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp;
 		    vp = vunmark(mvp)) {
 			vmark(mvp, vp);
 			/*
 			 * Check that the vp is still associated with
 			 * this filesystem.  RACE: could have been
 			 * recycled onto the same filesystem.
 			 */
 			if (vp->v_mount != mp || vismarker(vp))
 				continue;
 			if (bp + VPTRSZ + VNODESZ > ewhere) {
 				(void)vunmark(mvp);
 				mutex_exit(&mntvnode_lock);
 				vnfree(mvp);
 				vfs_unbusy(mp, false, NULL);
 				sysctl_relock();
 				*sizep = bp - where;
 				return (ENOMEM);
+			}
 			memcpy(&vbuf, vp, VNODESZ);
 			mutex_exit(&mntvnode_lock);
 			if ((error = copyout(&vp, bp, VPTRSZ)) ||
 			    (error = copyout(&vbuf, bp + VPTRSZ, VNODESZ))) {
 			   	mutex_enter(&mntvnode_lock);
 				(void)vunmark(mvp);
 				mutex_exit(&mntvnode_lock);
 				vnfree(mvp);
 				vfs_unbusy(mp, false, NULL);
 				sysctl_relock();
 				return (error);
+			}
 			bp += VPTRSZ + VNODESZ;
 			mutex_enter(&mntvnode_lock);
+		}
 		mutex_exit(&mntvnode_lock);
 		vnfree(mvp);
 		vfs_unbusy(mp, false, &nmp);
+	}
 	mutex_exit(&mountlist_lock);
 	sysctl_relock();
 	*sizep = bp - where;
 	return (0);
+}
 /*
  * Set vnode attributes to VNOVAL
  */
 void
 vattr_null(struct vattr *vap)
+{
 	memset(vap, 0, sizeof(*vap));
 	vap->va_type = VNON;
 	/*
 	 * Assign individually so that it is safe even if size and
 	 * sign of each member are varied.
 	 */
 	vap->va_mode = VNOVAL;
 	vap->va_nlink = VNOVAL;
 	vap->va_uid = VNOVAL;
 	vap->va_gid = VNOVAL;
 	vap->va_fsid = VNOVAL;
 	vap->va_fileid = VNOVAL;
 	vap->va_size = VNOVAL;
 	vap->va_blocksize = VNOVAL;
 	vap->va_atime.tv_sec =
 	    vap->va_mtime.tv_sec =
 	    vap->va_ctime.tv_sec =
 	    vap->va_birthtime.tv_sec = VNOVAL;
 	vap->va_atime.tv_nsec =
 	    vap->va_mtime.tv_nsec =
 	    vap->va_ctime.tv_nsec =
 	    vap->va_birthtime.tv_nsec = VNOVAL;
 	vap->va_gen = VNOVAL;
 	vap->va_flags = VNOVAL;
 	vap->va_rdev = VNOVAL;
 	vap->va_bytes = VNOVAL;
+}
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
 #define ARRAY_PRINT(idx, arr) \
     ((unsigned int)(idx) < ARRAY_SIZE(arr) ? (arr)[(idx)] : "UNKNOWN")
 const char * const vnode_tags[] = { VNODE_TAGS };
 const char * const vnode_types[] = { VNODE_TYPES };
 const char vnode_flagbits[] = VNODE_FLAGBITS;
 /*
  * Print out a description of a vnode.
  */
 void
 vprint(const char *label, struct vnode *vp)
+{
 	char bf[96];
 	int flag;
 	flag = vp->v_iflag | vp->v_vflag | vp->v_uflag;
 	snprintb(bf, sizeof(bf), vnode_flagbits, flag);
 	if (label != NULL)
 		printf("%s: ", label);
 	printf("vnode @ %p, flags (%s)\n\ttag %s(%d), type %s(%d), "
 	    "usecount %d, writecount %d, holdcount %d\n"
 	    "\tfreelisthd %p, mount %p, data %p lock %p\n",
 	    vp, bf, ARRAY_PRINT(vp->v_tag, vnode_tags), vp->v_tag,
 	    ARRAY_PRINT(vp->v_type, vnode_types), vp->v_type,
 	    vp->v_usecount, vp->v_writecount, vp->v_holdcnt,
 	    vp->v_freelisthd, vp->v_mount, vp->v_data, &vp->v_lock);
 	if (vp->v_data != NULL) {
 		printf("\t");
 		VOP_PRINT(vp);
+	}
+}
 /* Deprecated. Kept for KPI compatibility. */
 int
 vaccess(enum vtype type, mode_t file_mode, uid_t uid, gid_t gid,
     mode_t acc_mode, kauth_cred_t cred)
+{
 #ifdef DIAGNOSTIC
 	printf("vaccess: deprecated interface used.\n");
 #endif /* DIAGNOSTIC */
 	return genfs_can_access(type, file_mode, uid, gid, acc_mode, cred);
+}
 /*
  * Given a file system name, look up the vfsops for that
  * file system, or return NULL if file system isn't present
  * in the kernel.
  */
 struct vfsops *
 vfs_getopsbyname(const char *name)
+{
 	struct vfsops *v;
 	mutex_enter(&vfs_list_lock);
 	LIST_FOREACH(v, &vfs_list, vfs_list) {
 		if (strcmp(v->vfs_name, name) == 0)
 			break;
+	}
 	if (v != NULL)
 		v->vfs_refcount++;
 	mutex_exit(&vfs_list_lock);
 	return (v);
+}
 void
 copy_statvfs_info(struct statvfs *sbp, const struct mount *mp)
+{
 	const struct statvfs *mbp;
 	if (sbp == (mbp = &mp->mnt_stat))
 		return;
 	(void)memcpy(&sbp->f_fsidx, &mbp->f_fsidx, sizeof(sbp->f_fsidx));
 	sbp->f_fsid = mbp->f_fsid;
 	sbp->f_owner = mbp->f_owner;
 	sbp->f_flag = mbp->f_flag;
 	sbp->f_syncwrites = mbp->f_syncwrites;
 	sbp->f_asyncwrites = mbp->f_asyncwrites;
 	sbp->f_syncreads = mbp->f_syncreads;
 	sbp->f_asyncreads = mbp->f_asyncreads;
 	(void)memcpy(sbp->f_spare, mbp->f_spare, sizeof(mbp->f_spare));
 	(void)memcpy(sbp->f_fstypename, mbp->f_fstypename,
 	    sizeof(sbp->f_fstypename));
 	(void)memcpy(sbp->f_mntonname, mbp->f_mntonname,
 	    sizeof(sbp->f_mntonname));
 	(void)memcpy(sbp->f_mntfromname, mp->mnt_stat.f_mntfromname,
 	    sizeof(sbp->f_mntfromname));
 	sbp->f_namemax = mbp->f_namemax;
+}
 int
 set_statvfs_info(const char *onp, int ukon, const char *fromp, int ukfrom,
     const char *vfsname, struct mount *mp, struct lwp *l)
+{
 	int error;
 	size_t size;
 	struct statvfs *sfs = &mp->mnt_stat;
 	int (*fun)(const void *, void *, size_t, size_t *);
 	(void)strlcpy(mp->mnt_stat.f_fstypename, vfsname,
 	    sizeof(mp->mnt_stat.f_fstypename));
 	if (onp) {
 		struct cwdinfo *cwdi = l->l_proc->p_cwdi;
 		fun = (ukon == UIO_SYSSPACE) ? copystr : copyinstr;
 		if (cwdi->cwdi_rdir != NULL) {
 			size_t len;
 			char *bp;
 			char *path = PNBUF_GET();
 			bp = path + MAXPATHLEN;
 			*--bp = '\0';
 			rw_enter(&cwdi->cwdi_lock, RW_READER);
 			error = getcwd_common(cwdi->cwdi_rdir, rootvnode, &bp,
 			    path, MAXPATHLEN / 2, 0, l);
 			rw_exit(&cwdi->cwdi_lock);
 			if (error) {
 				PNBUF_PUT(path);
 				return error;
+			}
 			len = strlen(bp);
 			if (len > sizeof(sfs->f_mntonname) - 1)
 				len = sizeof(sfs->f_mntonname) - 1;
 			(void)strncpy(sfs->f_mntonname, bp, len);
 			PNBUF_PUT(path);
 			if (len < sizeof(sfs->f_mntonname) - 1) {
 				error = (*fun)(onp, &sfs->f_mntonname[len],
 				    sizeof(sfs->f_mntonname) - len - 1, &size);
 				if (error)
 					return error;
 				size += len;
 			} else {
 				size = len;
+			}
 		} else {
 			error = (*fun)(onp, &sfs->f_mntonname,
 			    sizeof(sfs->f_mntonname) - 1, &size);
 			if (error)
 				return error;
+		}
 		(void)memset(sfs->f_mntonname + size, 0,
 		    sizeof(sfs->f_mntonname) - size);
+	}
 	if (fromp) {
 		fun = (ukfrom == UIO_SYSSPACE) ? copystr : copyinstr;
 		error = (*fun)(fromp, sfs->f_mntfromname,
 		    sizeof(sfs->f_mntfromname) - 1, &size);
 		if (error)
 			return error;
 		(void)memset(sfs->f_mntfromname + size, 0,
 		    sizeof(sfs->f_mntfromname) - size);
+	}
 	return 0;
+}
 void
 vfs_timestamp(struct timespec *ts)
+{
 	nanotime(ts);
+}
 time_t	rootfstime;			/* recorded root fs time, if known */
 void
 setrootfstime(time_t t)
+{
 	rootfstime = t;
+}
 static const uint8_t vttodt_tab[9] = {
 	DT_UNKNOWN,	/* VNON  */
 	DT_REG,		/* VREG  */
 	DT_DIR,		/* VDIR  */
 	DT_BLK,		/* VBLK  */
 	DT_CHR,		/* VCHR  */
 	DT_LNK,		/* VLNK  */
 	DT_SOCK,	/* VSUCK */
 	DT_FIFO,	/* VFIFO */
 	DT_UNKNOWN	/* VBAD  */
 };
 uint8_t
 vtype2dt(enum vtype vt)
+{
 	CTASSERT(VBAD == __arraycount(vttodt_tab) - 1);
 	return vttodt_tab[vt];
+}
 int
 VFS_MOUNT(struct mount *mp, const char *a, void *b, size_t *c)
+{
 	int error;
 	KERNEL_LOCK(1, NULL);
 	error = (*(mp->mnt_op->vfs_mount))(mp, a, b, c);
 	KERNEL_UNLOCK_ONE(NULL);
 	return error;
+}
 int
 VFS_START(struct mount *mp, int a)
+{
 	int error;
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_LOCK(1, NULL);
+	}
 	error = (*(mp->mnt_op->vfs_start))(mp, a);
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_UNLOCK_ONE(NULL);
+	}
 	return error;
+}
 int
 VFS_UNMOUNT(struct mount *mp, int a)
+{
 	int error;
 	KERNEL_LOCK(1, NULL);
 	error = (*(mp->mnt_op->vfs_unmount))(mp, a);
 	KERNEL_UNLOCK_ONE(NULL);
 	return error;
+}
 int
 VFS_ROOT(struct mount *mp, struct vnode **a)
+{
 	int error;
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_LOCK(1, NULL);
+	}
 	error = (*(mp->mnt_op->vfs_root))(mp, a);
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_UNLOCK_ONE(NULL);
+	}
 	return error;
+}
 int
-VFS_QUOTACTL(struct mount *mp, prop_dictionary_t dict)
+VFS_QUOTACTL(struct mount *mp, prop_dictionary_t dict, int dummy)
+{
 	int error;
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_LOCK(1, NULL);
+	}
-	error = (*(mp->mnt_op->vfs_quotactl))(mp, dict);
+	error = (*(mp->mnt_op->vfs_quotactl))(mp, dict, dummy);
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_UNLOCK_ONE(NULL);
+	}
 	return error;
+}
 int
 VFS_STATVFS(struct mount *mp, struct statvfs *a)
+{
 	int error;
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_LOCK(1, NULL);
+	}
 	error = (*(mp->mnt_op->vfs_statvfs))(mp, a);
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_UNLOCK_ONE(NULL);
+	}
 	return error;
+}
 int
 VFS_SYNC(struct mount *mp, int a, struct kauth_cred *b)
+{
 	int error;
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_LOCK(1, NULL);
+	}
 	error = (*(mp->mnt_op->vfs_sync))(mp, a, b);
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_UNLOCK_ONE(NULL);
+	}
 	return error;
+}
 int
 VFS_FHTOVP(struct mount *mp, struct fid *a, struct vnode **b)
+{
 	int error;
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_LOCK(1, NULL);
+	}
 	error = (*(mp->mnt_op->vfs_fhtovp))(mp, a, b);
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_UNLOCK_ONE(NULL);
+	}
 	return error;
+}
 int
 VFS_VPTOFH(struct vnode *vp, struct fid *a, size_t *b)
+{
 	int error;
 	if ((vp->v_vflag & VV_MPSAFE) == 0) {
 		KERNEL_LOCK(1, NULL);
+	}
 	error = (*(vp->v_mount->mnt_op->vfs_vptofh))(vp, a, b);
 	if ((vp->v_vflag & VV_MPSAFE) == 0) {
 		KERNEL_UNLOCK_ONE(NULL);
+	}
 	return error;
+}
 int
 VFS_SNAPSHOT(struct mount *mp, struct vnode *a, struct timespec *b)
+{
 	int error;
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_LOCK(1, NULL);
+	}
 	error = (*(mp->mnt_op->vfs_snapshot))(mp, a, b);
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_UNLOCK_ONE(NULL);
+	}
 	return error;
+}
 int
 VFS_EXTATTRCTL(struct mount *mp, int a, struct vnode *b, int c, const char *d)
+{
 	int error;
 	KERNEL_LOCK(1, NULL);		/* XXXSMP check ffs */
 	error = (*(mp->mnt_op->vfs_extattrctl))(mp, a, b, c, d);
 	KERNEL_UNLOCK_ONE(NULL);	/* XXX */
 	return error;
+}
 int
 VFS_SUSPENDCTL(struct mount *mp, int a)
+{
 	int error;
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_LOCK(1, NULL);
+	}
 	error = (*(mp->mnt_op->vfs_suspendctl))(mp, a);
 	if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) {
 		KERNEL_UNLOCK_ONE(NULL);
+	}
 	return error;
+}
 #if defined(DDB) || defined(DEBUGPRINT)
 static const char buf_flagbits[] = BUF_FLAGBITS;
 void
 vfs_buf_print(struct buf *bp, int full, void (*pr)(const char *, ...))
+{
 	char bf[1024];
 	(*pr)("  vp %p lblkno 0x%"PRIx64" blkno 0x%"PRIx64" rawblkno 0x%"
 	    PRIx64 " dev 0x%x\n",
 	    bp->b_vp, bp->b_lblkno, bp->b_blkno, bp->b_rawblkno, bp->b_dev);
 	snprintb(bf, sizeof(bf),
 	    buf_flagbits, bp->b_flags | bp->b_oflags | bp->b_cflags);
 	(*pr)("  error %d flags 0x%s\n", bp->b_error, bf);
 	(*pr)("  bufsize 0x%lx bcount 0x%lx resid 0x%lx\n",
 		  bp->b_bufsize, bp->b_bcount, bp->b_resid);
 	(*pr)("  data %p saveaddr %p\n",
 		  bp->b_data, bp->b_saveaddr);
 	(*pr)("  iodone %p objlock %p\n", bp->b_iodone, bp->b_objlock);
+}
 void
 vfs_vnode_print(struct vnode *vp, int full, void (*pr)(const char *, ...))
+{
 	char bf[256];
 	uvm_object_printit(&vp->v_uobj, full, pr);
 	snprintb(bf, sizeof(bf),
 	    vnode_flagbits, vp->v_iflag | vp->v_vflag | vp->v_uflag);
 	(*pr)("\nVNODE flags %s\n", bf);
 	(*pr)("mp %p numoutput %d size 0x%llx writesize 0x%llx\n",
 	      vp->v_mount, vp->v_numoutput, vp->v_size, vp->v_writesize);
 	(*pr)("data %p writecount %ld holdcnt %ld\n",
 	      vp->v_data, vp->v_writecount, vp->v_holdcnt);
 	(*pr)("tag %s(%d) type %s(%d) mount %p typedata %p\n",
 	      ARRAY_PRINT(vp->v_tag, vnode_tags), vp->v_tag,
 	      ARRAY_PRINT(vp->v_type, vnode_types), vp->v_type,
 	      vp->v_mount, vp->v_mountedhere);
 	(*pr)("v_lock %p\n", &vp->v_lock);
 	if (full) {
 		struct buf *bp;
 		(*pr)("clean bufs:\n");
 		LIST_FOREACH(bp, &vp->v_cleanblkhd, b_vnbufs) {
 			(*pr)(" bp %p\n", bp);
 			vfs_buf_print(bp, full, pr);
+		}
 		(*pr)("dirty bufs:\n");
 		LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {
 			(*pr)(" bp %p\n", bp);
 			vfs_buf_print(bp, full, pr);
+		}
+	}
+}
 void
 vfs_mount_print(struct mount *mp, int full, void (*pr)(const char *, ...))
+{
 	char sbuf[256];
 	(*pr)("vnodecovered = %p syncer = %p data = %p\n",
 			mp->mnt_vnodecovered,mp->mnt_syncer,mp->mnt_data);
 	(*pr)("fs_bshift %d dev_bshift = %d\n",
 			mp->mnt_fs_bshift,mp->mnt_dev_bshift);
 	snprintb(sbuf, sizeof(sbuf), __MNT_FLAG_BITS, mp->mnt_flag);
 	(*pr)("flag = %s\n", sbuf);
 	snprintb(sbuf, sizeof(sbuf), __IMNT_FLAG_BITS, mp->mnt_iflag);
 	(*pr)("iflag = %s\n", sbuf);
 	(*pr)("refcnt = %d unmounting @ %p updating @ %p\n", mp->mnt_refcnt,
 	    &mp->mnt_unmounting, &mp->mnt_updating);
 	(*pr)("statvfs cache:\n");
 	(*pr)("\tbsize = %lu\n",mp->mnt_stat.f_bsize);
 	(*pr)("\tfrsize = %lu\n",mp->mnt_stat.f_frsize);
 	(*pr)("\tiosize = %lu\n",mp->mnt_stat.f_iosize);
 	(*pr)("\tblocks = %"PRIu64"\n",mp->mnt_stat.f_blocks);
 	(*pr)("\tbfree = %"PRIu64"\n",mp->mnt_stat.f_bfree);
 	(*pr)("\tbavail = %"PRIu64"\n",mp->mnt_stat.f_bavail);
 	(*pr)("\tbresvd = %"PRIu64"\n",mp->mnt_stat.f_bresvd);
 	(*pr)("\tfiles = %"PRIu64"\n",mp->mnt_stat.f_files);
 	(*pr)("\tffree = %"PRIu64"\n",mp->mnt_stat.f_ffree);
 	(*pr)("\tfavail = %"PRIu64"\n",mp->mnt_stat.f_favail);
 	(*pr)("\tfresvd = %"PRIu64"\n",mp->mnt_stat.f_fresvd);
 	(*pr)("\tf_fsidx = { 0x%"PRIx32", 0x%"PRIx32" }\n",
 			mp->mnt_stat.f_fsidx.__fsid_val[0],
 			mp->mnt_stat.f_fsidx.__fsid_val[1]);
 	(*pr)("\towner = %"PRIu32"\n",mp->mnt_stat.f_owner);
 	(*pr)("\tnamemax = %lu\n",mp->mnt_stat.f_namemax);
 	snprintb(sbuf, sizeof(sbuf), __MNT_FLAG_BITS, mp->mnt_stat.f_flag);
 	(*pr)("\tflag = %s\n",sbuf);
 	(*pr)("\tsyncwrites = %" PRIu64 "\n",mp->mnt_stat.f_syncwrites);
 	(*pr)("\tasyncwrites = %" PRIu64 "\n",mp->mnt_stat.f_asyncwrites);
 	(*pr)("\tsyncreads = %" PRIu64 "\n",mp->mnt_stat.f_syncreads);
 	(*pr)("\tasyncreads = %" PRIu64 "\n",mp->mnt_stat.f_asyncreads);
 	(*pr)("\tfstypename = %s\n",mp->mnt_stat.f_fstypename);
 	(*pr)("\tmntonname = %s\n",mp->mnt_stat.f_mntonname);
 	(*pr)("\tmntfromname = %s\n",mp->mnt_stat.f_mntfromname);
+	{
 		int cnt = 0;
 		struct vnode *vp;
 		(*pr)("locked vnodes =");
 		TAILQ_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) {
 			if (VOP_ISLOCKED(vp)) {
 				if ((++cnt % 6) == 0) {
 					(*pr)(" %p,\n\t", vp);
 				} else {
 					(*pr)(" %p,", vp);
+				}
+			}
+		}
 		(*pr)("\n");
+	}
 	if (full) {
 		int cnt = 0;
 		struct vnode *vp;
 		(*pr)("all vnodes =");
 		TAILQ_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) {
 			if (!TAILQ_NEXT(vp, v_mntvnodes)) {
 				(*pr)(" %p", vp);
 			} else if ((++cnt % 6) == 0) {
 				(*pr)(" %p,\n\t", vp);
 			} else {
 				(*pr)(" %p,", vp);
+			}
+		}
 		(*pr)("\n", vp);
+	}
+}
 /*
  * List all of the locked vnodes in the system.
  */
 void printlockedvnodes(void);
 void
 printlockedvnodes(void)
+{
 	struct mount *mp, *nmp;
 	struct vnode *vp;
 	printf("Locked vnodes\n");
 	mutex_enter(&mountlist_lock);
 	for (mp = CIRCLEQ_FIRST(&mountlist); mp != (void *)&mountlist;
 	     mp = nmp) {
 		if (vfs_busy(mp, &nmp)) {
 			continue;
+		}
 		TAILQ_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) {
 			if (VOP_ISLOCKED(vp))
 				vprint(NULL, vp);
+		}
 		mutex_enter(&mountlist_lock);
 		vfs_unbusy(mp, false, &nmp);
+	}
 	mutex_exit(&mountlist_lock);
+}
 #endif /* DDB || DEBUGPRINT */

 @@ -1,307 +1,307 @@
-/*	$NetBSD: layer_vfsops.c,v 1.34 2011/03/06 17:08:36 bouyer Exp $	*/
+/*	$NetBSD: layer_vfsops.c,v 1.35 2012/01/29 06:32:44 dholland Exp $	*/
 /*
  * Copyright (c) 1999 National Aeronautics & Space Administration
  * All rights reserved.
+ *
  * This software was written by William Studenmund of the
  * Numerical Aerospace Simulation Facility, NASA Ames Research Center.
+ *
  * 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 National Aeronautics & Space Administration
  *    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 NATIONAL AERONAUTICS & SPACE ADMINISTRATION
  * ``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 ADMINISTRATION OR CONTRIB-
  * UTORS 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) 1992, 1993, 1995
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software donated to Berkeley by
  * Jan-Simon Pendry.
+ *
  * 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.
+ *
  *	from: Id: lofs_vfsops.c,v 1.9 1992/05/30 10:26:24 jsp Exp
  *	from: @(#)lofs_vfsops.c	1.2 (Berkeley) 6/18/92
  *	@(#)null_vfsops.c	8.7 (Berkeley) 5/14/95
  */
 /*
  * Generic layer VFS operations.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: layer_vfsops.c,v 1.34 2011/03/06 17:08:36 bouyer Exp $");
+__KERNEL_RCSID(0, "$NetBSD: layer_vfsops.c,v 1.35 2012/01/29 06:32:44 dholland Exp $");
 #include <sys/param.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/malloc.h>
 #include <sys/kauth.h>
 #include <sys/module.h>
 #include <miscfs/genfs/layer.h>
 #include <miscfs/genfs/layer_extern.h>
 MODULE(MODULE_CLASS_MISC, layerfs, NULL);
 static int
 layerfs_modcmd(modcmd_t cmd, void *arg)
+{
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		return 0;
 	case MODULE_CMD_FINI:
 		return 0;
 	default:
 		return ENOTTY;
+	}
 	return 0;
+}
 /*
  * VFS start.  Nothing needed here - the start routine on the underlying
  * filesystem will have been called when that filesystem was mounted.
  */
 int
 layerfs_start(struct mount *mp, int flags)
+{
 #ifdef notyet
 	return VFS_START(MOUNTTOLAYERMOUNT(mp)->layerm_vfs, flags);
 #else
 	return 0;
 #endif
+}
 int
 layerfs_root(struct mount *mp, struct vnode **vpp)
+{
 	struct vnode *vp;
 	vp = MOUNTTOLAYERMOUNT(mp)->layerm_rootvp;
 	if (vp == NULL) {
 		*vpp = NULL;
 		return EINVAL;
+	}
 	/*
 	 * Return root vnode with locked and with a reference held.
 	 */
 	vref(vp);
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 	*vpp = vp;
 	return 0;
+}
 int
-layerfs_quotactl(struct mount *mp, prop_dictionary_t dict)
+layerfs_quotactl(struct mount *mp, prop_dictionary_t dict, int dummy)
+{
-	return VFS_QUOTACTL(MOUNTTOLAYERMOUNT(mp)->layerm_vfs, dict);
+	return VFS_QUOTACTL(MOUNTTOLAYERMOUNT(mp)->layerm_vfs, dict, dummy);
+}
 int
 layerfs_statvfs(struct mount *mp, struct statvfs *sbp)
+{
 	struct statvfs *sbuf;
 	int error;
 	sbuf = kmem_zalloc(sizeof(*sbuf), KM_SLEEP);
 	if (sbuf == NULL) {
 		return ENOMEM;
+	}
 	error = VFS_STATVFS(MOUNTTOLAYERMOUNT(mp)->layerm_vfs, sbuf);
 	if (error) {
 		goto done;
+	}
 	/* Copy across the relevant data and fake the rest. */
 	sbp->f_flag = sbuf->f_flag;
 	sbp->f_bsize = sbuf->f_bsize;
 	sbp->f_frsize = sbuf->f_frsize;
 	sbp->f_iosize = sbuf->f_iosize;
 	sbp->f_blocks = sbuf->f_blocks;
 	sbp->f_bfree = sbuf->f_bfree;
 	sbp->f_bavail = sbuf->f_bavail;
 	sbp->f_bresvd = sbuf->f_bresvd;
 	sbp->f_files = sbuf->f_files;
 	sbp->f_ffree = sbuf->f_ffree;
 	sbp->f_favail = sbuf->f_favail;
 	sbp->f_fresvd = sbuf->f_fresvd;
 	sbp->f_namemax = sbuf->f_namemax;
 	copy_statvfs_info(sbp, mp);
 done:
 	kmem_free(sbuf, sizeof(*sbuf));
 	return error;
+}
 int
 layerfs_sync(struct mount *mp, int waitfor,
     kauth_cred_t cred)
+{
 	/*
 	 * XXX - Assumes no data cached at layer.
 	 */
 	return 0;
+}
 int
 layerfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
+{
 	struct vnode *vp;
 	int error;
 	error = VFS_VGET(MOUNTTOLAYERMOUNT(mp)->layerm_vfs, ino, &vp);
 	if (error) {
 		*vpp = NULL;
 		return error;
+	}
 	error = layer_node_create(mp, vp, vpp);
 	if (error) {
 		vput(vp);
 		*vpp = NULL;
 		return error;
+	}
 	return 0;
+}
 int
 layerfs_fhtovp(struct mount *mp, struct fid *fidp, struct vnode **vpp)
+{
 	struct vnode *vp;
 	int error;
 	error = VFS_FHTOVP(MOUNTTOLAYERMOUNT(mp)->layerm_vfs, fidp, &vp);
 	if (error) {
 		return error;
+	}
 	error = layer_node_create(mp, vp, vpp);
 	if (error) {
 		vput(vp);
 		*vpp = NULL;
 		return (error);
+	}
 	return 0;
+}
 int
 layerfs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
+{
 	return VFS_VPTOFH(LAYERVPTOLOWERVP(vp), fhp, fh_size);
+}
 /*
  * layerfs_snapshot - handle a snapshot through a layered file system
+ *
  * At present, we do NOT support snapshotting through a layered file
  * system as the ffs implementation changes v_vnlock of the snapshot
  * vnodes to point to one common lock. As there is no way for us to
  * absolutely pass this change up the stack, a layered file system
  * would end up referencing the wrong lock.
+ *
  * This routine serves as a central resource for this behavior; all
  * layered file systems don't need to worry about the above. Also, if
  * things get fixed, all layers get the benefit.
  */
 int
 layerfs_snapshot(struct mount *mp, struct vnode *vp,
     struct timespec *ts)
+{
 	return EOPNOTSUPP;
+}
 SYSCTL_SETUP(sysctl_vfs_layerfs_setup, "sysctl vfs.layerfs subtree setup")
+{
 	const struct sysctlnode *layerfs_node = NULL;
 	sysctl_createv(clog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_NODE, "vfs", NULL,
 		       NULL, 0, NULL, 0,
 		       CTL_VFS, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, &layerfs_node,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_NODE, "layerfs",
 		       SYSCTL_DESCR("Generic layered file system"),
 		       NULL, 0, NULL, 0,
 		       CTL_VFS, CTL_CREATE);
 #ifdef LAYERFS_DIAGNOSTIC
 	sysctl_createv(clog, 0, &layerfs_node, NULL,
 	               CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 	               CTLTYPE_INT,
 	               "debug",
 	               SYSCTL_DESCR("Verbose debugging messages"),
 	               NULL, 0, &layerfs_debug, 0,
 	               CTL_CREATE, CTL_EOL);
 #endif
 	/*
 	 * other subtrees should really be aliases to this, but since
 	 * they can't tell if layerfs has been instantiated yet, they
 	 * can't do that...not easily.  not yet.  :-)
 	 */
+}
 int
 layerfs_renamelock_enter(struct mount *mp)
+{
 	return VFS_RENAMELOCK_ENTER(MOUNTTOLAYERMOUNT(mp)->layerm_vfs);
+}
 void
 layerfs_renamelock_exit(struct mount *mp)
+{
 	VFS_RENAMELOCK_EXIT(MOUNTTOLAYERMOUNT(mp)->layerm_vfs);
+}

 @@ -1,467 +1,467 @@
-/*	$NetBSD: mount.h,v 1.202 2012/01/29 06:29:04 dholland Exp $	*/
+/*	$NetBSD: mount.h,v 1.203 2012/01/29 06:32:43 dholland Exp $	*/
 /*
  * Copyright (c) 1989, 1991, 1993
  *	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
  *    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.
+ *
  *	@(#)mount.h	8.21 (Berkeley) 5/20/95
  */
 #ifndef _SYS_MOUNT_H_
 #define _SYS_MOUNT_H_
 #ifndef _KERNEL
 #include <sys/featuretest.h>
 #if defined(_NETBSD_SOURCE)
 #include <sys/stat.h>
 #endif /* _NETBSD_SOURCE */
 #endif
 #ifndef _STANDALONE
 #include <sys/param.h> /* precautionary upon removal from ucred.h */
 #include <sys/time.h>
 #include <sys/uio.h>
 #include <sys/ucred.h>
 #include <sys/fstypes.h>
 #include <sys/queue.h>
 #include <sys/rwlock.h>
 #include <sys/statvfs.h>
 #include <sys/specificdata.h>
 #include <sys/condvar.h>
 #endif	/* !_STANDALONE */
 /*
  * file system statistics
  */
 #define	MNAMELEN	90	/* length of buffer for returned name */
 /*
  * File system types.
  */
 #define	MOUNT_FFS	"ffs"		/* UNIX "Fast" Filesystem */
 #define	MOUNT_UFS	MOUNT_FFS	/* for compatibility */
 #define	MOUNT_NFS	"nfs"		/* Network Filesystem */
 #define	MOUNT_MFS	"mfs"		/* Memory Filesystem */
 #define	MOUNT_MSDOS	"msdos"		/* MSDOS Filesystem */
 #define	MOUNT_LFS	"lfs"		/* Log-based Filesystem */
 #define	MOUNT_FDESC	"fdesc"		/* File Descriptor Filesystem */
 #define	MOUNT_NULL	"null"		/* Minimal Filesystem Layer */
 #define	MOUNT_OVERLAY	"overlay"	/* Minimal Overlay Filesystem Layer */
 #define	MOUNT_UMAP	"umap"	/* User/Group Identifier Remapping Filesystem */
 #define	MOUNT_KERNFS	"kernfs"	/* Kernel Information Filesystem */
 #define	MOUNT_PROCFS	"procfs"	/* /proc Filesystem */
 #define	MOUNT_AFS	"afs"		/* Andrew Filesystem */
 #define	MOUNT_CD9660	"cd9660"	/* ISO9660 (aka CDROM) Filesystem */
 #define	MOUNT_UNION	"union"		/* Union (translucent) Filesystem */
 #define	MOUNT_ADOSFS	"adosfs"	/* AmigaDOS Filesystem */
 #define	MOUNT_EXT2FS	"ext2fs"	/* Second Extended Filesystem */
 #define	MOUNT_CFS	"coda"		/* Coda Filesystem */
 #define	MOUNT_CODA	MOUNT_CFS	/* Coda Filesystem */
 #define	MOUNT_FILECORE	"filecore"	/* Acorn Filecore Filesystem */
 #define	MOUNT_NTFS	"ntfs"		/* Windows/NT Filesystem */
 #define	MOUNT_SMBFS	"smbfs"		/* CIFS (SMB) */
 #define	MOUNT_PTYFS	"ptyfs"		/* Pseudo tty filesystem */
 #define	MOUNT_TMPFS	"tmpfs"		/* Efficient memory file-system */
 #define MOUNT_UDF	"udf"		/* UDF CD/DVD filesystem */
 #define	MOUNT_SYSVBFS	"sysvbfs"	/* System V Boot Filesystem */
 #define MOUNT_PUFFS	"puffs"		/* Pass-to-Userspace filesystem */
 #define MOUNT_HFS	"hfs"		/* Apple HFS+ Filesystem */
 #define MOUNT_EFS	"efs"		/* SGI's Extent Filesystem */
 #define MOUNT_ZFS	"zfs"		/* Sun ZFS */
 #define MOUNT_NILFS	"nilfs"		/* NTT's NiLFS(2) logging file system */
 #define MOUNT_RUMPFS	"rumpfs"	/* rump virtual file system */
 #define	MOUNT_V7FS	"v7fs"		/* 7th Edition of Unix Filesystem */
 #ifndef _STANDALONE
 struct vnode;
 /*
  * Structure per mounted file system.  Each mounted file system has an
  * array of operations and an instance record.  The file systems are
  * put on a doubly linked list.
  */
 struct mount {
 	CIRCLEQ_ENTRY(mount) mnt_list;		/* mount list */
 	TAILQ_HEAD(, vnode) mnt_vnodelist;	/* list of vnodes this mount */
 	struct vfsops	*mnt_op;		/* operations on fs */
 	struct vnode	*mnt_vnodecovered;	/* vnode we mounted on */
 	struct vnode	*mnt_syncer;		/* syncer vnode */
 	void		*mnt_transinfo;		/* for FS-internal use */
 	void		*mnt_data;		/* private data */
 	krwlock_t	mnt_unmounting;		/* to prevent new activity */
 	kmutex_t	mnt_renamelock;		/* per-fs rename lock */
 	int		mnt_refcnt;		/* ref count on this structure */
 	int		mnt_recursecnt;		/* count of write locks */
 	int		mnt_flag;		/* flags */
 	int		mnt_iflag;		/* internal flags */
 	int		mnt_fs_bshift;		/* offset shift for lblkno */
 	int		mnt_dev_bshift;		/* shift for device sectors */
 	struct statvfs	mnt_stat;		/* cache of filesystem stats */
 	specificdata_reference
 			mnt_specdataref;	/* subsystem specific data */
 	kmutex_t	mnt_updating;		/* to serialize updates */
 	struct wapbl_ops
 			*mnt_wapbl_op;		/* logging ops */
 	struct wapbl	*mnt_wapbl;		/* log info */
 	struct wapbl_replay
 			*mnt_wapbl_replay;	/* replay support XXX: what? */
 	uint64_t	mnt_gen;
 };
 /*
  * Sysctl CTL_VFS definitions.
+ *
  * Second level identifier specifies which filesystem. Second level
  * identifier VFS_GENERIC returns information about all filesystems.
+ *
  * Note the slightly non-flat nature of these sysctl numbers.  Oh for
  * a better sysctl interface.
  */
 #define VFS_GENERIC	0		/* generic filesystem information */
 #define VFS_MAXTYPENUM	1		/* int: highest defined fs type */
 #define VFS_CONF	2		/* struct: vfsconf for filesystem given
 					   as next argument */
 #define VFS_USERMOUNT	3		/* enable/disable fs mnt by non-root */
 #define	VFS_MAGICLINKS  4		/* expand 'magic' symlinks */
 #define	VFSGEN_MAXID	5		/* number of valid vfs.generic ids */
 /*
  * USE THE SAME NAMES AS MOUNT_*!
+ *
  * Only need to add new entry here if the filesystem actually supports
  * sysctl(2).
  */
 #define	CTL_VFS_NAMES { \
 	{ "generic", CTLTYPE_NODE }, \
 	{ MOUNT_FFS, CTLTYPE_NODE }, \
 	{ MOUNT_NFS, CTLTYPE_NODE }, \
 	{ MOUNT_MFS, CTLTYPE_NODE }, \
 	{ MOUNT_MSDOS, CTLTYPE_NODE }, \
 	{ MOUNT_LFS, CTLTYPE_NODE }, \
 	{ 0, 0 }, 			/* MOUNT_LOFS */ \
 	{ MOUNT_FDESC, CTLTYPE_NODE }, \
 	{ MOUNT_NULL, CTLTYPE_NODE }, \
 	{ MOUNT_UMAP, CTLTYPE_NODE }, \
 	{ MOUNT_KERNFS, CTLTYPE_NODE }, \
 	{ MOUNT_PROCFS, CTLTYPE_NODE }, \
 	{ MOUNT_AFS, CTLTYPE_NODE }, \
 	{ MOUNT_CD9660, CTLTYPE_NODE }, \
 	{ MOUNT_UNION, CTLTYPE_NODE }, \
 	{ MOUNT_ADOSFS, CTLTYPE_NODE }, \
 	{ MOUNT_EXT2FS, CTLTYPE_NODE }, \
 	{ MOUNT_CODA, CTLTYPE_NODE }, \
 	{ MOUNT_FILECORE, CTLTYPE_NODE }, \
 	{ MOUNT_NTFS, CTLTYPE_NODE }, \
+}
 #define	VFS_MAXID	20		/* number of valid vfs ids */
 #define	CTL_VFSGENCTL_NAMES { \
 	{ 0, 0 }, \
 	{ "maxtypenum", CTLTYPE_INT }, \
 	{ "conf", CTLTYPE_NODE }, 	/* Special */ \
 	{ "usermount", CTLTYPE_INT }, \
 	{ "magiclinks", CTLTYPE_INT }, \
+}
 #if defined(_KERNEL)
 #include <prop/proplib.h>
 #if __STDC__
 struct nameidata;
 #endif
 /*
  * Operations supported on mounted file system.
  */
 struct vfsops {
 	const char *vfs_name;
 	size_t	vfs_min_mount_data;
 	int	(*vfs_mount)	(struct mount *, const char *, void *,
 				    size_t *);
 	int	(*vfs_start)	(struct mount *, int);
 	int	(*vfs_unmount)	(struct mount *, int);
 	int	(*vfs_root)	(struct mount *, struct vnode **);
-	int	(*vfs_quotactl)	(struct mount *, prop_dictionary_t);
+	int	(*vfs_quotactl)	(struct mount *, prop_dictionary_t, int);
 	int	(*vfs_statvfs)	(struct mount *, struct statvfs *);
 	int	(*vfs_sync)	(struct mount *, int, struct kauth_cred *);
 	int	(*vfs_vget)	(struct mount *, ino_t, struct vnode **);
 	int	(*vfs_fhtovp)	(struct mount *, struct fid *,
 				    struct vnode **);
 	int	(*vfs_vptofh)	(struct vnode *, struct fid *, size_t *);
 	void	(*vfs_init)	(void);
 	void	(*vfs_reinit)	(void);
 	void	(*vfs_done)	(void);
 	int	(*vfs_mountroot)(void);
 	int	(*vfs_snapshot)	(struct mount *, struct vnode *,
 				    struct timespec *);
 	int	(*vfs_extattrctl) (struct mount *, int,
 				    struct vnode *, int, const char *);
 	int	(*vfs_suspendctl) (struct mount *, int);
 	int	(*vfs_renamelock_enter)(struct mount *);
 	void	(*vfs_renamelock_exit)(struct mount *);
 	int	(*vfs_fsync)	(struct vnode *, int);
 	const struct vnodeopv_desc * const *vfs_opv_descs;
 	int	vfs_refcount;
 	LIST_ENTRY(vfsops) vfs_list;
 };
 /* XXX vget is actually file system internal. */
 #define VFS_VGET(MP, INO, VPP)    (*(MP)->mnt_op->vfs_vget)(MP, INO, VPP)
 #define VFS_RENAMELOCK_ENTER(MP)  (*(MP)->mnt_op->vfs_renamelock_enter)(MP)
 #define VFS_RENAMELOCK_EXIT(MP)   (*(MP)->mnt_op->vfs_renamelock_exit)(MP)
 #define VFS_FSYNC(MP, VP, FLG)	  (*(MP)->mnt_op->vfs_fsync)(VP, FLG)
 int	VFS_MOUNT(struct mount *, const char *, void *, size_t *);
 int	VFS_START(struct mount *, int);
 int	VFS_UNMOUNT(struct mount *, int);
 int	VFS_ROOT(struct mount *, struct vnode **);
-int	VFS_QUOTACTL(struct mount *, prop_dictionary_t);
+int	VFS_QUOTACTL(struct mount *, prop_dictionary_t, int);
 int	VFS_STATVFS(struct mount *, struct statvfs *);
 int	VFS_SYNC(struct mount *, int, struct kauth_cred *);
 int	VFS_FHTOVP(struct mount *, struct fid *, struct vnode **);
 int	VFS_VPTOFH(struct vnode *, struct fid *, size_t *);
 int	VFS_SNAPSHOT(struct mount *, struct vnode *, struct timespec *);
 int	VFS_EXTATTRCTL(struct mount *, int, struct vnode *, int, const char *);
 int	VFS_SUSPENDCTL(struct mount *, int);
 #endif /* _KERNEL */
 #ifdef _KERNEL
 #if __STDC__
 struct mbuf;
 struct vnodeopv_desc;
 struct kauth_cred;
 #endif
 #define	VFS_MAX_MOUNT_DATA	8192
 #define VFS_PROTOS(fsname)						\
 int	fsname##_mount(struct mount *, const char *, void *,		\
 		size_t *);						\
 int	fsname##_start(struct mount *, int);				\
 int	fsname##_unmount(struct mount *, int);				\
 int	fsname##_root(struct mount *, struct vnode **);			\
 int	fsname##_quotactl(struct mount *, prop_dictionary_t);		\
 int	fsname##_statvfs(struct mount *, struct statvfs *);		\
 int	fsname##_sync(struct mount *, int, struct kauth_cred *);	\
 int	fsname##_vget(struct mount *, ino_t, struct vnode **);		\
 int	fsname##_fhtovp(struct mount *, struct fid *, struct vnode **);	\
 int	fsname##_vptofh(struct vnode *, struct fid *, size_t *);	\
 void	fsname##_init(void);						\
 void	fsname##_reinit(void);						\
 void	fsname##_done(void);						\
 int	fsname##_mountroot(void);					\
 int	fsname##_snapshot(struct mount *, struct vnode *,		\
 		struct timespec *);					\
 int	fsname##_extattrctl(struct mount *, int, struct vnode *, int,	\
 		const char *);						\
 int	fsname##_suspendctl(struct mount *, int)
 /*
  * This operations vector is so wapbl can be wrapped into a filesystem lkm.
  * XXX Eventually, we want to move this functionality
  * down into the filesystems themselves so that this isn't needed.
  */
 struct wapbl_ops {
 	void (*wo_wapbl_discard)(struct wapbl *);
 	int (*wo_wapbl_replay_isopen)(struct wapbl_replay *);
 	int (*wo_wapbl_replay_can_read)(struct wapbl_replay *, daddr_t, long);
 	int (*wo_wapbl_replay_read)(struct wapbl_replay *, void *, daddr_t, long);
 	void (*wo_wapbl_add_buf)(struct wapbl *, struct buf *);
 	void (*wo_wapbl_remove_buf)(struct wapbl *, struct buf *);
 	void (*wo_wapbl_resize_buf)(struct wapbl *, struct buf *, long, long);
 	int (*wo_wapbl_begin)(struct wapbl *, const char *, int);
 	void (*wo_wapbl_end)(struct wapbl *);
 	void (*wo_wapbl_junlock_assert)(struct wapbl *);
 	void (*wo_wapbl_biodone)(struct buf *);
 };
 #define WAPBL_DISCARD(MP)						\
     (*(MP)->mnt_wapbl_op->wo_wapbl_discard)((MP)->mnt_wapbl)
 #define WAPBL_REPLAY_ISOPEN(MP)						\
     (*(MP)->mnt_wapbl_op->wo_wapbl_replay_isopen)((MP)->mnt_wapbl_replay)
 #define WAPBL_REPLAY_CAN_READ(MP, BLK, LEN)				\
     (*(MP)->mnt_wapbl_op->wo_wapbl_replay_can_read)((MP)->mnt_wapbl_replay, \
     (BLK), (LEN))
 #define WAPBL_REPLAY_READ(MP, DATA, BLK, LEN)				\
     (*(MP)->mnt_wapbl_op->wo_wapbl_replay_read)((MP)->mnt_wapbl_replay,	\
     (DATA), (BLK), (LEN))
 #define WAPBL_ADD_BUF(MP, BP)						\
     (*(MP)->mnt_wapbl_op->wo_wapbl_add_buf)((MP)->mnt_wapbl, (BP))
 #define WAPBL_REMOVE_BUF(MP, BP)					\
     (*(MP)->mnt_wapbl_op->wo_wapbl_remove_buf)((MP)->mnt_wapbl, (BP))
 #define WAPBL_RESIZE_BUF(MP, BP, OLDSZ, OLDCNT)				\
     (*(MP)->mnt_wapbl_op->wo_wapbl_resize_buf)((MP)->mnt_wapbl, (BP),	\
     (OLDSZ), (OLDCNT))
 #define WAPBL_BEGIN(MP)							\
     (*(MP)->mnt_wapbl_op->wo_wapbl_begin)((MP)->mnt_wapbl,		\
     __FILE__, __LINE__)
 #define WAPBL_END(MP)							\
     (*(MP)->mnt_wapbl_op->wo_wapbl_end)((MP)->mnt_wapbl)
 #define WAPBL_JUNLOCK_ASSERT(MP)					\
     (*(MP)->mnt_wapbl_op->wo_wapbl_junlock_assert)((MP)->mnt_wapbl)
 struct vfs_hooks {
 	LIST_ENTRY(vfs_hooks) vfs_hooks_list;
 	void	(*vh_unmount)(struct mount *);
 	int	(*vh_reexport)(struct mount *, const char *, void *);
 	void	(*vh_future_expansion_1)(void);
 	void	(*vh_future_expansion_2)(void);
 	void	(*vh_future_expansion_3)(void);
 	void	(*vh_future_expansion_4)(void);
 	void	(*vh_future_expansion_5)(void);
 };
 void	vfs_hooks_init(void);
 int	vfs_hooks_attach(struct vfs_hooks *);
 int	vfs_hooks_detach(struct vfs_hooks *);
 void	vfs_hooks_unmount(struct mount *);
 int	vfs_hooks_reexport(struct mount *, const char *, void *);
 #endif /* _KERNEL */
 /*
  * Export arguments for local filesystem mount calls.
+ *
  * This structure is deprecated and is only provided for compatibility
  * reasons with old binary utilities; several file systems expose an
  * instance of this structure in their mount arguments structure, thus
  * needing a padding in place of the old values.  This definition cannot
  * change in the future due to this reason.
  * XXX: This should be moved to the compat subtree but cannot be done
  * until we can move the mount args structures themselves.
+ *
  * The current export_args structure can be found in nfs/nfs.h.
  */
 struct export_args30 {
 	int	ex_flags;		/* export related flags */
 	uid_t	ex_root;		/* mapping for root uid */
 	struct	uucred ex_anon;		/* mapping for anonymous user */
 	struct	sockaddr *ex_addr;	/* net address to which exported */
 	int	ex_addrlen;		/* and the net address length */
 	struct	sockaddr *ex_mask;	/* mask of valid bits in saddr */
 	int	ex_masklen;		/* and the smask length */
 	char	*ex_indexfile;		/* index file for WebNFS URLs */
 };
 struct mnt_export_args30 {
 	const char *fspec;		/* Always NULL */
 	struct export_args30 eargs;
 };
 #ifdef _KERNEL
 /*
  * exported VFS interface (see vfssubr(9))
  */
 struct	mount *vfs_getvfs(fsid_t *);    /* return vfs given fsid */
 int	vfs_composefh(struct vnode *, fhandle_t *, size_t *);
 int	vfs_composefh_alloc(struct vnode *, fhandle_t **);
 void	vfs_composefh_free(fhandle_t *);
 int	vfs_fhtovp(fhandle_t *, struct vnode **);
 int	vfs_mountedon(struct vnode *);/* is a vfs mounted on vp */
 int	vfs_mountroot(void);
 void	vfs_shutdown(void);	    /* unmount and sync file systems */
 void	vfs_sync_all(struct lwp *);
 bool	vfs_unmountall(struct lwp *);	    /* unmount file systems */
 bool	vfs_unmountall1(struct lwp *, bool, bool);
 bool	vfs_unmount_forceone(struct lwp *);
 int 	vfs_busy(struct mount *, struct mount **);
 int	vfs_rootmountalloc(const char *, const char *, struct mount **);
 void	vfs_unbusy(struct mount *, bool, struct mount **);
 int	vfs_attach(struct vfsops *);
 int	vfs_detach(struct vfsops *);
 void	vfs_reinit(void);
 struct vfsops *vfs_getopsbyname(const char *);
 void	vfs_delref(struct vfsops *);
 void	vfs_destroy(struct mount *);
 void	vfs_scrubvnlist(struct mount *);
 struct mount *vfs_mountalloc(struct vfsops *, struct vnode *);
 int	vfs_stdextattrctl(struct mount *, int, struct vnode *,
 	    int, const char *);
 void	vfs_insmntque(struct vnode *, struct mount *);
 int	vfs_quotactl(struct mount *, prop_dictionary_t);
 extern	CIRCLEQ_HEAD(mntlist, mount) mountlist;	/* mounted filesystem list */
 extern	struct vfsops *vfssw[];			/* filesystem type table */
 extern	int nvfssw;
 extern  kmutex_t mountlist_lock;
 extern	kmutex_t vfs_list_lock;
 void	vfs_mount_sysinit(void);
 long	makefstype(const char *);
 int	mount_domount(struct lwp *, struct vnode **, struct vfsops *,
 	    const char *, int, void *, size_t *);
 int	dounmount(struct mount *, int, struct lwp *);
 int	do_sys_mount(struct lwp *, struct vfsops *, const char *, const char *,
 	    int, void *, enum uio_seg, size_t, register_t *);
 void	vfsinit(void);
 void	vfs_opv_init(const struct vnodeopv_desc * const *);
 void	vfs_opv_free(const struct vnodeopv_desc * const *);
 #ifdef DEBUG
 void	vfs_bufstats(void);
 #endif
 int	mount_specific_key_create(specificdata_key_t *, specificdata_dtor_t);
 void	mount_specific_key_delete(specificdata_key_t);
 void 	mount_initspecific(struct mount *);
 void 	mount_finispecific(struct mount *);
 void *	mount_getspecific(struct mount *, specificdata_key_t);
 void	mount_setspecific(struct mount *, specificdata_key_t, void *);
 int	usermount_common_policy(struct mount *, u_long);
 LIST_HEAD(vfs_list_head, vfsops);
 extern struct vfs_list_head vfs_list;
 #else /* _KERNEL */
 #include <sys/cdefs.h>
 __BEGIN_DECLS
 #if !defined(__LIBC12_SOURCE__) && !defined(_STANDALONE)
 int	getfh(const char *, void *, size_t *)
 	__RENAME(__getfh30);
 #endif
 int	unmount(const char *, int);
 #if defined(_NETBSD_SOURCE)
 #ifndef __LIBC12_SOURCE__
 int mount(const char *, const char *, int, void *, size_t) __RENAME(__mount50);
 int	fhopen(const void *, size_t, int) __RENAME(__fhopen40);
 int	fhstat(const void *, size_t, struct stat *) __RENAME(__fhstat50);
 #endif
 #endif /* _NETBSD_SOURCE */
 __END_DECLS
 #endif /* _KERNEL */
 #endif /* !_STANDALONE */
 #endif /* !_SYS_MOUNT_H_ */

 @@ -1,308 +1,292 @@
-/*	$NetBSD: ufs_vfsops.c,v 1.43 2012/01/27 19:22:50 para Exp $	*/
+/*	$NetBSD: ufs_vfsops.c,v 1.44 2012/01/29 06:32:44 dholland Exp $	*/
 /*
  * Copyright (c) 1991, 1993, 1994
  *	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.
+ *
  *	@(#)ufs_vfsops.c	8.8 (Berkeley) 5/20/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ufs_vfsops.c,v 1.43 2012/01/27 19:22:50 para Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ufs_vfsops.c,v 1.44 2012/01/29 06:32:44 dholland Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_ffs.h"
 #include "opt_quota.h"
 #endif
 #include <sys/param.h>
 #include <sys/mbuf.h>
 #include <sys/mount.h>
 #include <sys/proc.h>
 #include <sys/buf.h>
 #include <sys/vnode.h>
 #include <sys/kmem.h>
 #include <sys/kauth.h>
 #include <miscfs/specfs/specdev.h>
 #include <ufs/ufs/quota.h>
 #include <ufs/ufs/inode.h>
 #include <ufs/ufs/ufsmount.h>
 #include <ufs/ufs/ufs_extern.h>
 #ifdef UFS_DIRHASH
 #include <ufs/ufs/dirhash.h>
 #endif
 #include <quota/quotaprop.h>
 /* how many times ufs_init() was called */
 static int ufs_initcount = 0;
 pool_cache_t ufs_direct_cache;
 /*
  * Make a filesystem operational.
  * Nothing to do at the moment.
  */
 /* ARGSUSED */
 int
 ufs_start(struct mount *mp, int flags)
+{
 	return (0);
+}
 /*
  * Return the root of a filesystem.
  */
 int
 ufs_root(struct mount *mp, struct vnode **vpp)
+{
 	struct vnode *nvp;
 	int error;
 	if ((error = VFS_VGET(mp, (ino_t)ROOTINO, &nvp)) != 0)
 		return (error);
 	*vpp = nvp;
 	return (0);
+}
 /*
  * Do operations associated with quotas
  */
 int
-ufs_quotactl(struct mount *mp, prop_dictionary_t dict)
+ufs_quotactl(struct mount *mp, prop_dictionary_t cmddict, int dummy)
+{
 	struct lwp *l = curlwp;
 #if !defined(QUOTA) && !defined(QUOTA2)
 	(void) mp;
-	(void) dict;
+	(void) cmddict;
 	(void) dummy;
 	(void) l;
 	return (EOPNOTSUPP);
 #else
 	int  error;
 	prop_dictionary_t cmddict;
-	prop_array_t commands;
+	KASSERT(prop_object_type(cmddict) == PROP_TYPE_DICTIONARY);
 	prop_object_iterator_t iter;
 	/* Mark the mount busy, as we're passing it to kauth(9). */
 	error = vfs_busy(mp, NULL);
-	if (error)
+	if (error) {
 		return (error);
 	error = quota_get_cmds(dict, &commands);
 	if (error)
 		goto out_vfs;
 	iter = prop_array_iterator(commands);
 	if (iter == NULL) {
 		error = ENOMEM;
 		goto out_vfs;
+	}
 	mutex_enter(&mp->mnt_updating);
 	while ((cmddict = prop_object_iterator_next(iter)) != NULL) {
-		if (prop_object_type(cmddict) != PROP_TYPE_DICTIONARY)
+	error = quota_handle_cmd(mp, l, cmddict);
 			continue;
 		error = quota_handle_cmd(mp, l, cmddict);
 		if (error)
 			break;
 	prop_object_iterator_release(iter);
 	mutex_exit(&mp->mnt_updating);
 out_vfs:
 	vfs_unbusy(mp, false, NULL);
 	return (error);
 #endif
+}
 #if 0
 	switch (cmd) {
 	case Q_SYNC:
 		break;
 	case Q_GETQUOTA:
 		/* The user can always query about his own quota. */
 		if (uid == kauth_cred_getuid(l->l_cred))
 			break;
 		error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 		    KAUTH_REQ_SYSTEM_FS_QUOTA_GET, mp, KAUTH_ARG(uid), NULL);
 		break;
 	case Q_QUOTAON:
 	case Q_QUOTAOFF:
 		error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 		    KAUTH_REQ_SYSTEM_FS_QUOTA_ONOFF, mp, NULL, NULL);
 		break;
 	case Q_SETQUOTA:
 	case Q_SETUSE:
 		error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 		    KAUTH_REQ_SYSTEM_FS_QUOTA_MANAGE, mp, KAUTH_ARG(uid), NULL);
 		break;
 	default:
 		error = EINVAL;
 		break;
+	}
 	type = cmds & SUBCMDMASK;
 	if (!error) {
 		/* Only check if there was no error above. */
 		if ((u_int)type >= MAXQUOTAS)
 			error = EINVAL;
+	}
 	if (error) {
 		vfs_unbusy(mp, false, NULL);
 		return (error);
+	}
 	mutex_enter(&mp->mnt_updating);
 	switch (cmd) {
 	case Q_QUOTAON:
 		error = quotaon(l, mp, type, arg);
 		break;
 	case Q_QUOTAOFF:
 		error = quotaoff(l, mp, type);
 		break;
 	case Q_SETQUOTA:
 		error = setquota(mp, uid, type, arg);
 		break;
 	case Q_SETUSE:
 		error = setuse(mp, uid, type, arg);
 		break;
 	case Q_GETQUOTA:
 		error = getquota(mp, uid, type, arg);
 		break;
 	case Q_SYNC:
 		error = qsync(mp);
 		break;
 	default:
 		error = EINVAL;
+	}
 	mutex_exit(&mp->mnt_updating);
 	vfs_unbusy(mp, false, NULL);
 	return (error);
 #endif
 /*
  * This is the generic part of fhtovp called after the underlying
  * filesystem has validated the file handle.
  */
 int
 ufs_fhtovp(struct mount *mp, struct ufid *ufhp, struct vnode **vpp)
+{
 	struct vnode *nvp;
 	struct inode *ip;
 	int error;
 	if ((error = VFS_VGET(mp, ufhp->ufid_ino, &nvp)) != 0) {
 		*vpp = NULLVP;
 		return (error);
+	}
 	ip = VTOI(nvp);
 	if (ip->i_mode == 0 || ip->i_gen != ufhp->ufid_gen) {
 		vput(nvp);
 		*vpp = NULLVP;
 		return (ESTALE);
+	}
 	*vpp = nvp;
 	return (0);
+}
 /*
  * Initialize UFS filesystems, done only once.
  */
 void
 ufs_init(void)
+{
 	if (ufs_initcount++ > 0)
 		return;
 	ufs_direct_cache = pool_cache_init(sizeof(struct direct), 0, 0, 0,
 	    "ufsdir", NULL, IPL_NONE, NULL, NULL, NULL);
 	ufs_ihashinit();
 #if defined(QUOTA) || defined(QUOTA2)
 	dqinit();
 #endif
 #ifdef UFS_DIRHASH
 	ufsdirhash_init();
 #endif
 #ifdef UFS_EXTATTR
 	ufs_extattr_init();
 #endif
+}
 void
 ufs_reinit(void)
+{
 	ufs_ihashreinit();
 #if defined(QUOTA) || defined(QUOTA2)
 	dqreinit();
 #endif
+}
 /*
  * Free UFS filesystem resources, done only once.
  */
 void
 ufs_done(void)
+{
 	if (--ufs_initcount > 0)
 		return;
 	ufs_ihashdone();
 #if defined(QUOTA) || defined(QUOTA2)
 	dqdone();
 #endif
 	pool_cache_destroy(ufs_direct_cache);
 #ifdef UFS_DIRHASH
 	ufsdirhash_done();
 #endif
 #ifdef UFS_EXTATTR
 	ufs_extattr_done();
 #endif
+}