 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs.h,v 1.194 2015/10/03 08:29:34 dholland Exp $	*/
+/*	$NetBSD: lfs.h,v 1.195 2015/10/15 06:15:48 dholland Exp $	*/
 /*  from NetBSD: dinode.h,v 1.22 2013/01/22 09:39:18 dholland Exp  */
 /*  from NetBSD: dir.h,v 1.21 2009/07/22 04:49:19 dholland Exp  */
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Konrad E. Schroder <perseant@hhhh.org>.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -1018,47 +1018,58 @@ struct lfs {
 	daddr_t  lfs_cleanint[LFS_MAX_CLEANIND]; /* Active cleaning intervals */
 	int 	 lfs_cleanind;		/* Index into intervals */
 	int lfs_sleepers;		/* # procs sleeping this fs */
 	int lfs_pages;			/* dirty pages blaming this fs */
 	lfs_bm_t *lfs_ino_bitmap;	/* Inuse inodes bitmap */
 	int lfs_nowrap;			/* Suspend log wrap */
 	int lfs_wrappass;		/* Allow first log wrap requester to pass */
 	int lfs_wrapstatus;		/* Wrap status */
 	int lfs_reclino;		/* Inode being reclaimed */
 	daddr_t lfs_startseg;           /* Segment we started writing at */
 	LIST_HEAD(, segdelta) lfs_segdhd;	/* List of pending trunc accounting events */
 #ifdef _KERNEL
 	/* The block device we're mounted on. */
 	dev_t lfs_dev;
 	struct vnode *lfs_devvp;
 	/* ULFS-level information */
 	u_int32_t um_flags;			/* ULFS flags (below) */
 	u_long	um_nindir;			/* indirect ptrs per block */
 	u_long	um_lognindir;			/* log2 of um_nindir */
 	u_long	um_bptrtodb;			/* indir ptr to disk block */
 	u_long	um_seqinc;			/* inc between seq blocks */
 	int um_maxsymlinklen;
 	int um_dirblksiz;
 	u_int64_t um_maxfilesize;
 	/* Stuff used by quota2 code, not currently operable */
 	unsigned lfs_use_quota2 : 1;
 	uint32_t lfs_quota_magic;
 	uint8_t lfs_quota_flags;
 	uint64_t lfs_quotaino[2];
 	/* Sleep address replacing &lfs_avail inside the on-disk superblock */
 	/* XXX: should be replaced with a condvar */
 	int lfs_availsleep;
 	/* This one replaces &lfs_nextseg... all ditto */
 	int lfs_nextsegsleep;
 	/* Cleaner lwp, set on first bmapv syscall. */
 	struct lwp *lfs_cleaner_thread;
 	/* Hint from cleaner, only valid if curlwp == um_cleaner_thread. */
 	/* XXX change this to BLOCK_INFO after resorting this file */
 	struct block_info *lfs_cleaner_hint;
 #endif
 };
 /*
  * Structures used by lfs_bmapv and lfs_markv to communicate information
  * about inodes and data blocks.
  */
 typedef struct block_info {
 	u_int64_t bi_inode;		/* inode # */
 	int64_t	bi_lbn;			/* logical block w/in file */
 	int64_t	bi_daddr;		/* disk address of block */
 	u_int64_t bi_segcreate;		/* origin segment create time */
 	int	bi_version;		/* file version number */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs_syscalls.c,v 1.171 2015/10/10 22:34:33 dholland Exp $	*/
+/*	$NetBSD: lfs_syscalls.c,v 1.172 2015/10/15 06:15:48 dholland Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003, 2007, 2007, 2008
  *    The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Konrad E. Schroder <perseant@hhhh.org>.
+ *
  * 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
 @@ -51,27 +51,27 @@
  * 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.
+ *
  *	@(#)lfs_syscalls.c	8.10 (Berkeley) 5/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_syscalls.c,v 1.171 2015/10/10 22:34:33 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_syscalls.c,v 1.172 2015/10/15 06:15:48 dholland Exp $");
 #ifndef LFS
 # define LFS		/* for prototypes in syscallargs.h */
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/buf.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <sys/kernel.h>
 #include <sys/kauth.h>
 @@ -647,37 +647,37 @@ lfs_bmapv(struct lwp *l, fsid_t *fsidp,
 	ino_t lastino;
 	daddr_t v_daddr;
 	int cnt, error;
 	int numrefed = 0;
 	error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_LFS,
 	    KAUTH_REQ_SYSTEM_LFS_BMAPV, NULL, NULL, NULL);
 	if (error)
 		return (error);
 	if ((mntp = vfs_getvfs(fsidp)) == NULL)
 		return (ENOENT);
 	ump = VFSTOULFS(mntp);
 	if ((error = vfs_busy(mntp, NULL)) != 0)
 		return (error);
-	if (ump->um_cleaner_thread == NULL)
+	ump = VFSTOULFS(mntp);
-		ump->um_cleaner_thread = curlwp;
+	fs = ump->um_lfs;
 	KASSERT(ump->um_cleaner_thread == curlwp);
-	cnt = blkcnt;
+	if (fs->lfs_cleaner_thread == NULL)
 		fs->lfs_cleaner_thread = curlwp;
 	KASSERT(fs->lfs_cleaner_thread == curlwp);
-	fs = VFSTOULFS(mntp)->um_lfs;
+	cnt = blkcnt;
 	error = 0;
 	/* these were inside the initialization for the for loop */
 	vp = NULL;
 	v_daddr = LFS_UNUSED_DADDR;
 	lastino = LFS_UNUSED_INUM;
 	for (blkp = blkiov; cnt--; ++blkp)
+	{
 		/*
 		 * Get the IFILE entry (only once) and see if the file still
 		 * exists.
 		 */
 @@ -966,32 +966,34 @@ sys___lfs_segwait50(struct lwp *l, const
 /*
  * VFS_VGET call specialized for the cleaner.  If the cleaner is
  * processing IINFO structures, it may have the ondisk inode already, so
  * don't go retrieving it again.
+ *
  * Return the vnode referenced and locked.
  */
 static int
 lfs_fastvget(struct mount *mp, ino_t ino, BLOCK_INFO *blkp, int lk_flags,
     struct vnode **vpp)
+{
 	struct ulfsmount *ump;
 	struct lfs *fs;
 	int error;
 	ump = VFSTOULFS(mp);
-	ump->um_cleaner_hint = blkp;
+	fs = ump->um_lfs;
 	fs->lfs_cleaner_hint = blkp;
 	error = vcache_get(mp, &ino, sizeof(ino), vpp);
-	ump->um_cleaner_hint = NULL;
+	fs->lfs_cleaner_hint = NULL;
 	if (error)
 		return error;
 	error = vn_lock(*vpp, lk_flags);
 	if (error) {
 		if (error == EBUSY)
 			error = EAGAIN;
 		vrele(*vpp);
 		*vpp = NULL;
 		return error;
+	}
 	return 0;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs_vfsops.c,v 1.346 2015/10/10 22:33:57 dholland Exp $	*/
+/*	$NetBSD: lfs_vfsops.c,v 1.347 2015/10/15 06:15:48 dholland Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003, 2007, 2007
  *     The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Konrad E. Schroder <perseant@hhhh.org>.
+ *
  * 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
 @@ -51,27 +51,27 @@
  * 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.
+ *
  *	@(#)lfs_vfsops.c	8.20 (Berkeley) 6/10/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_vfsops.c,v 1.346 2015/10/10 22:33:57 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_vfsops.c,v 1.347 2015/10/15 06:15:48 dholland Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_lfs.h"
 #include "opt_quota.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 @@ -662,46 +662,54 @@ lfs_mount(struct mount *mp, const char *
 		if (!update) {
 			/*
 			 * Be sure this is a valid block device
 			 */
 			if (devvp->v_type != VBLK)
 				error = ENOTBLK;
 			else if (bdevsw_lookup(devvp->v_rdev) == NULL)
 				error = ENXIO;
 		} else {
 			/*
 			 * Be sure we're still naming the same device
 			 * used for our initial mount
+			 *
 			 * XXX dholland 20151010: if namei gives us a
 			 * different vnode for the same device,
 			 * wouldn't it be better to use it going
 			 * forward rather than ignore it in favor of
 			 * the old one?
 			 */
 			ump = VFSTOULFS(mp);
-			if (devvp != ump->um_devvp) {
+			fs = ump->um_lfs;
-				if (devvp->v_rdev != ump->um_devvp->v_rdev)
+			if (devvp != fs->lfs_devvp) {
 				if (devvp->v_rdev != fs->lfs_devvp->v_rdev)
 					error = EINVAL;
 				else {
 					vrele(devvp);
-					devvp = ump->um_devvp;
+					devvp = fs->lfs_devvp;
 					vref(devvp);
+				}
+			}
+		}
 	} else {
 		if (!update) {
 			/* New mounts must have a filename for the device */
 			return (EINVAL);
 		} else {
 			/* Use the extant mount */
 			ump = VFSTOULFS(mp);
-			devvp = ump->um_devvp;
+			fs = ump->um_lfs;
 			devvp = fs->lfs_devvp;
 			vref(devvp);
+		}
+	}
 	/*
 	 * If mount by non-root, then verify that user has necessary
 	 * permissions on the device.
 	 */
 	if (error == 0) {
 		accessmode = VREAD;
 		if (update ?
 		    (mp->mnt_iflag & IMNT_WANTRDWR) != 0 :
 @@ -1026,62 +1034,64 @@ lfs_mountfs(struct vnode *devvp, struct
 	fs->lfs_seglock = 0;
 	fs->lfs_pdflush = 0;
 	fs->lfs_sleepers = 0;
 	fs->lfs_pages = 0;
 	rw_init(&fs->lfs_fraglock);
 	rw_init(&fs->lfs_iflock);
 	cv_init(&fs->lfs_stopcv, "lfsstop");
 	/* Set the file system readonly/modify bits. */
 	fs->lfs_ronly = ronly;
 	if (ronly == 0)
 		fs->lfs_fmod = 1;
 	/* Device we're using */
 	dev = devvp->v_rdev;
 	fs->lfs_dev = dev;
 	fs->lfs_devvp = devvp;
 	/* ulfs-level information */
 	fs->um_flags = 0;
 	fs->um_bptrtodb = lfs_sb_getffshift(fs) - DEV_BSHIFT;
 	fs->um_seqinc = lfs_sb_getfrag(fs);
 	fs->um_nindir = lfs_sb_getnindir(fs);
 	fs->um_lognindir = ffs(lfs_sb_getnindir(fs)) - 1;
 	fs->um_maxsymlinklen = lfs_sb_getmaxsymlinklen(fs);
 	fs->um_dirblksiz = LFS_DIRBLKSIZ;
 	fs->um_maxfilesize = lfs_sb_getmaxfilesize(fs);
 	/* quota stuff */
 	/* XXX: these need to come from the on-disk superblock to be used */
 	fs->lfs_use_quota2 = 0;
 	fs->lfs_quota_magic = 0;
 	fs->lfs_quota_flags = 0;
 	fs->lfs_quotaino[0] = 0;
 	fs->lfs_quotaino[1] = 0;
 	/* Initialize the mount structure. */
 	dev = devvp->v_rdev;
 	mp->mnt_data = ump;
 	mp->mnt_stat.f_fsidx.__fsid_val[0] = (long)dev;
 	mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_LFS);
 	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
 	mp->mnt_stat.f_namemax = LFS_MAXNAMLEN;
 	mp->mnt_stat.f_iosize = lfs_sb_getbsize(fs);
 	mp->mnt_flag |= MNT_LOCAL;
 	mp->mnt_fs_bshift = lfs_sb_getbshift(fs);
 	if (fs->um_maxsymlinklen > 0)
 		mp->mnt_iflag |= IMNT_DTYPE;
 	else
 		fs->lfs_hasolddirfmt = true;
 	ump->um_mountp = mp;
 	ump->um_dev = dev;
 	ump->um_devvp = devvp;
 	for (i = 0; i < ULFS_MAXQUOTAS; i++)
 		ump->um_quotas[i] = NULLVP;
 	spec_node_setmountedfs(devvp, mp);
 	/* Set up reserved memory for pageout */
 	lfs_setup_resblks(fs);
 	/* Set up vdirop tailq */
 	TAILQ_INIT(&fs->lfs_dchainhd);
 	/* and paging tailq */
 	TAILQ_INIT(&fs->lfs_pchainhd);
 	/* and delayed segment accounting for truncation list */
 	LIST_INIT(&fs->lfs_segdhd);
 @@ -1318,32 +1328,32 @@ lfs_unmount(struct mount *mp, int mntfla
 	lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) | LFS_PF_CLEAN);
 	lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));
 	lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));
 	mutex_enter(&lfs_lock);
 	while (fs->lfs_iocount)
 		mtsleep(&fs->lfs_iocount, PRIBIO + 1, "lfs_umount", 0,
 			&lfs_lock);
 	mutex_exit(&lfs_lock);
 	/* Finish with the Ifile, now that we're done with it */
 	vgone(fs->lfs_ivnode);
 	ronly = !fs->lfs_ronly;
-	if (ump->um_devvp->v_type != VBAD)
+	if (fs->lfs_devvp->v_type != VBAD)
-		spec_node_setmountedfs(ump->um_devvp, NULL);
+		spec_node_setmountedfs(fs->lfs_devvp, NULL);
-	vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
+	vn_lock(fs->lfs_devvp, LK_EXCLUSIVE | LK_RETRY);
-	error = VOP_CLOSE(ump->um_devvp,
+	error = VOP_CLOSE(fs->lfs_devvp,
 	    ronly ? FREAD : FREAD|FWRITE, NOCRED);
-	vput(ump->um_devvp);
+	vput(fs->lfs_devvp);
 	/* Complain about page leakage */
 	if (fs->lfs_pages > 0)
 		printf("lfs_unmount: still claim %d pages (%d in subsystem)\n",
 			fs->lfs_pages, lfs_subsys_pages);
 	/* Free per-mount data structures */
 	free(fs->lfs_ino_bitmap, M_SEGMENT);
 	free(fs->lfs_suflags[0], M_SEGMENT);
 	free(fs->lfs_suflags[1], M_SEGMENT);
 	free(fs->lfs_suflags, M_SEGMENT);
 	lfs_free_resblks(fs);
 	cv_destroy(&fs->lfs_stopcv);
 @@ -1476,42 +1486,42 @@ lfs_vget(struct mount *mp, ino_t ino, st
 	return 0;
+}
 /*
  * Create a new vnode/inode pair and initialize what fields we can.
  */
 static void
 lfs_init_vnode(struct ulfsmount *ump, ino_t ino, struct vnode *vp)
+{
 	struct lfs *fs = ump->um_lfs;
 	struct inode *ip;
 	union lfs_dinode *dp;
-	ASSERT_NO_SEGLOCK(ump->um_lfs);
+	ASSERT_NO_SEGLOCK(fs);
 	/* Initialize the inode. */
 	ip = pool_get(&lfs_inode_pool, PR_WAITOK);
 	memset(ip, 0, sizeof(*ip));
 	dp = pool_get(&lfs_dinode_pool, PR_WAITOK);
 	memset(dp, 0, sizeof(*dp));
 	ip->inode_ext.lfs = pool_get(&lfs_inoext_pool, PR_WAITOK);
 	memset(ip->inode_ext.lfs, 0, sizeof(*ip->inode_ext.lfs));
 	ip->i_din = dp;
 	ip->i_ump = ump;
 	ip->i_vnode = vp;
-	ip->i_dev = ump->um_dev;
+	ip->i_dev = fs->lfs_dev;
 	lfs_dino_setinumber(fs, dp, ino);
 	ip->i_number = ino;
-	ip->i_lfs = ump->um_lfs;
+	ip->i_lfs = fs;
 	ip->i_lfs_effnblks = 0;
 	SPLAY_INIT(&ip->i_lfs_lbtree);
 	ip->i_lfs_nbtree = 0;
 	LIST_INIT(&ip->i_lfs_segdhd);
 	vp->v_tag = VT_LFS;
 	vp->v_op = lfs_vnodeop_p;
 	vp->v_data = ip;
+}
 /*
  * Undo lfs_init_vnode().
  */
 @@ -1575,48 +1585,48 @@ lfs_loadvnode(struct mount *mp, struct v
 			ts.tv_nsec = lfs_if_getatime_nsec(fs, ifp);
+		}
 		brelse(bp, 0);
 		if (daddr == LFS_UNUSED_DADDR)
 			return (ENOENT);
+	}
 	/* Allocate/init new vnode/inode. */
 	lfs_init_vnode(ump, ino, vp);
 	ip = VTOI(vp);
 	/* If the cleaner supplied the inode, use it. */
-	if (curlwp == ump->um_cleaner_thread && ump->um_cleaner_hint != NULL &&
+	if (curlwp == fs->lfs_cleaner_thread && fs->lfs_cleaner_hint != NULL &&
-	    ump->um_cleaner_hint->bi_lbn == LFS_UNUSED_LBN) {
+	    fs->lfs_cleaner_hint->bi_lbn == LFS_UNUSED_LBN) {
-		dip = ump->um_cleaner_hint->bi_bp;
+		dip = fs->lfs_cleaner_hint->bi_bp;
 		if (fs->lfs_is64) {
 			error = copyin(dip, &ip->i_din->u_64,
 				       sizeof(struct lfs64_dinode));
 		} else {
 			error = copyin(dip, &ip->i_din->u_32,
 				       sizeof(struct lfs32_dinode));
+		}
 		if (error) {
 			lfs_deinit_vnode(ump, vp);
 			return error;
+		}
 		KASSERT(ip->i_number == ino);
 		goto out;
+	}
 	/* Read in the disk contents for the inode, copy into the inode. */
 	retries = 0;
 again:
-	error = bread(ump->um_devvp, LFS_FSBTODB(fs, daddr),
+	error = bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr),
 		(lfs_sb_getversion(fs) == 1 ? lfs_sb_getbsize(fs) : lfs_sb_getibsize(fs)),
 , &bp);
 	if (error) {
 		lfs_deinit_vnode(ump, vp);
 		return error;
+	}
 	dip = lfs_ifind(fs, ino, bp);
 	if (dip == NULL) {
 		/* Assume write has not completed yet; try again */
 		brelse(bp, BC_INVAL);
 		++retries;
 		if (retries <= LFS_IFIND_RETRIES) {
 @@ -2256,27 +2266,27 @@ lfs_vinit(struct mount *mp, struct vnode
 # ifdef DEBUG
 		lfs_dump_dinode(fs, ip->i_din);
 # endif
 		panic("lfs_vinit: ino %llu is type VNON! (ifmt=%o)\n",
 		      (unsigned long long)ip->i_number,
 		      (ip->i_mode & LFS_IFMT) >> 12);
+	}
 #endif /* DIAGNOSTIC */
 	/*
 	 * Finish inode initialization now that aliasing has been resolved.
 	 */
-	ip->i_devvp = ump->um_devvp;
+	ip->i_devvp = fs->lfs_devvp;
 	vref(ip->i_devvp);
 #if defined(LFS_QUOTA) || defined(LFS_QUOTA2)
 	ulfsquota_init(ip);
 #endif
 	genfs_node_init(vp, &lfs_genfsops);
 	uvm_vnp_setsize(vp, ip->i_size);
 	/* Initialize hiblk from file size */
 	ip->i_lfs_hiblk = lfs_lblkno(ip->i_lfs, ip->i_size + lfs_sb_getbsize(ip->i_lfs) - 1) - 1;
 	*vpp = vp;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ulfsmount.h,v 1.13 2015/05/31 15:48:03 hannken Exp $	*/
+/*	$NetBSD: ulfsmount.h,v 1.14 2015/10/15 06:15:48 dholland Exp $	*/
 /*  from NetBSD: ufsmount.h,v 1.39 2012/10/19 17:09:08 drochner Exp  */
 /*
  * Copyright (c) 1982, 1986, 1989, 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
 @@ -50,44 +50,35 @@
 struct buf;
 struct inode;
 struct nameidata;
 struct timeval;
 struct uio;
 struct vnode;
 /* This structure describes the ULFS specific mount structure data. */
 struct ulfsmount {
 	/* Abstract vfs-level filesystem structure. */
 	struct mount *um_mountp;
 	/* The block device we're mounted on. */
 	dev_t um_dev;
 	struct vnode *um_devvp;
 	/* type of fs; currently always ULFS1, theoretically also ULFS2 */
 	u_long um_fstype;
 	/* pointer to the filesystem-specific filesystem structure */
 	struct lfs *um_lfs;
 	/* Extended attribute information. */
 	struct ulfs_extattr_per_mount um_extattr;
 	/* Cleaner lwp, set on first bmapv syscall. */
 	struct lwp *um_cleaner_thread;
 	/* Hint from cleaner, only valid if curlwp == um_cleaner_thread. */
 	BLOCK_INFO *um_cleaner_hint;
 	/* Quota-related material. */
 	struct vnode *um_quotas[ULFS_MAXQUOTAS]; /* quota files */
 	kauth_cred_t um_cred[ULFS_MAXQUOTAS];	/* quota file access cred */
 	union {
 	    struct um_q1 {
 		time_t	q1_btime[ULFS_MAXQUOTAS]; /* block quota time limit */
 		time_t	q1_itime[ULFS_MAXQUOTAS]; /* inode quota time limit */
 		char	q1_qflags[ULFS_MAXQUOTAS]; /* quota flags */
 	    } um_q1;
 	    struct um_q2 {
 		uint64_t q2_bsize;		/* block size of quota file */
 		uint64_t q2_bmask;		/* mask for above */
 	    } um_q2;