 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs_vfsops.c,v 1.347 2015/10/15 06:15:48 dholland Exp $	*/
+/*	$NetBSD: lfs_vfsops.c,v 1.348 2015/10/15 06:25:34 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.347 2015/10/15 06:15:48 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_vfsops.c,v 1.348 2015/10/15 06:25:34 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>
 @@ -819,163 +819,228 @@ lfs_mount(struct mount *mp, const char *
+	}
 	error = set_statvfs_info(path, UIO_USERSPACE, args->fspec,
 	    UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
 	if (error == 0)
 		lfs_sb_setfsmnt(fs, mp->mnt_stat.f_mntonname);
 	return error;
 fail:
 	vrele(devvp);
 	return (error);
+}
 /*
  * Helper for mountfs. Note that the fs pointer may be a dummy one
  * pointing into a superblock buffer. (Which is gross; see below.)
  */
 static int
 lfs_checkmagic(struct lfs *fs)
+{
 	switch (fs->lfs_dlfs_u.u_32.dlfs_magic) {
 	    case LFS_MAGIC:
 		fs->lfs_is64 = false;
 		fs->lfs_dobyteswap = false;
 		break;
 	    case LFS64_MAGIC:
 		fs->lfs_is64 = true;
 		fs->lfs_dobyteswap = false;
 		break;
 #ifdef LFS_EI
 	    case LFS_MAGIC_SWAPPED:
 		fs->lfs_is64 = false;
 		fs->lfs_dobyteswap = true;
 		break;
 	    case LFS64_MAGIC_SWAPPED:
 		fs->lfs_is64 = true;
 		fs->lfs_dobyteswap = true;
 		break;
 #endif
 	    default:
 		/* XXX needs translation */
 		return EINVAL;
+	}
 	return 0;
+}
 /*
  * Common code for mount and mountroot
  * LFS specific
  */
 int
 lfs_mountfs(struct vnode *devvp, struct mount *mp, struct lwp *l)
+{
-	struct dlfs *tdfs, *dfs, *adfs;
+	struct lfs *primarysb, *altsb, *thesb;
 	struct buf *primarybuf, *altbuf;
 	struct lfs *fs;
 	struct ulfsmount *ump;
 	struct vnode *vp;
 	struct buf *bp, *abp;
 	dev_t dev;
 	int error, i, ronly, fsbsize;
 	kauth_cred_t cred;
 	CLEANERINFO *cip;
 	SEGUSE *sup;
 	daddr_t sb_addr;
 	cred = l ? l->l_cred : NOCRED;
 	/* The superblock is supposed to be 512 bytes. */
 	__CTASSERT(sizeof(struct dlfs) == DEV_BSIZE);
 	/*
 	 * Flush out any old buffers remaining from a previous use.
 	 */
 	vn_lock(devvp, LK_EXCLUSIVE | LK_RETRY);
 	error = vinvalbuf(devvp, V_SAVE, cred, l, 0, 0);
 	VOP_UNLOCK(devvp);
 	if (error)
 		return (error);
 	ronly = (mp->mnt_flag & MNT_RDONLY) != 0;
 	/* Don't free random space on error. */
-	bp = NULL;
+	primarybuf = NULL;
-	abp = NULL;
+	altbuf = NULL;
 	ump = NULL;
 	sb_addr = LFS_LABELPAD / DEV_BSIZE;
 	while (1) {
-		/* Read in the superblock. */
+		/*
-		error = bread(devvp, sb_addr, LFS_SBPAD, 0, &bp);
+		 * Read in the superblock.
+		 *
 		 * Note that because LFS_SBPAD is substantially larger
 		 * (8K) than the actual on-disk superblock (512 bytes)
 		 * the buffer contains enough space to be used as a
 		 * whole struct lfs (in-memory superblock) - we do this
 		 * only so we can set and use the is64 and dobyteswap
 		 * members. XXX this is gross and the logic here should
 		 * be reworked.
 		 */
 		error = bread(devvp, sb_addr, LFS_SBPAD, 0, &primarybuf);
 		if (error)
 			goto out;
-		dfs = (struct dlfs *)bp->b_data;
+		primarysb = (struct lfs *)primarybuf->b_data;
 		/* Check the basics. */
-		if (dfs->dlfs_magic != LFS_MAGIC || dfs->dlfs_bsize > MAXBSIZE ||
+		error = lfs_checkmagic(primarysb);
-		    dfs->dlfs_version > LFS_VERSION ||
+		if (error) {
-		    dfs->dlfs_bsize < sizeof(struct dlfs)) {
+			DLOG((DLOG_MOUNT, "lfs_mountfs: primary superblock wrong magic\n"));
 			goto out;
+		}
 		if (lfs_sb_getbsize(primarysb) > MAXBSIZE ||
 		    lfs_sb_getversion(primarysb) > LFS_VERSION ||
 		    lfs_sb_getbsize(primarysb) < sizeof(struct dlfs)) {
 			DLOG((DLOG_MOUNT, "lfs_mountfs: primary superblock sanity failed\n"));
-			error = EINVAL;		/* XXX needs translation */
+			/* XXX needs translation */
 			error = EINVAL;
 			goto out;
+		}
-		if (dfs->dlfs_inodefmt > LFS_MAXINODEFMT) {
+		if (lfs_sb_getinodefmt(primarysb) > LFS_MAXINODEFMT) {
 			DLOG((DLOG_MOUNT, "lfs_mountfs: unknown inode format %d\n",
-			       dfs->dlfs_inodefmt));
+			       lfs_sb_getinodefmt(primarysb)));
 			error = EINVAL;
 			goto out;
+		}
-		if (dfs->dlfs_version == 1)
+		if (lfs_sb_getversion(primarysb) == 1)
 			fsbsize = DEV_BSIZE;
 		else {
-			fsbsize = 1 << dfs->dlfs_ffshift;
+			fsbsize = 1 << lfs_sb_getffshift(primarysb);
 			/*
 			 * Could be, if the frag size is large enough, that we
 			 * don't have the "real" primary superblock.  If that's
 			 * the case, get the real one, and try again.
 			 */
-			if (sb_addr != (dfs->dlfs_sboffs[0] << (dfs->dlfs_ffshift - DEV_BSHIFT))) {
+			if (sb_addr != (lfs_sb_getsboff(primarysb, 0) << (lfs_sb_getffshift(primarysb) - DEV_BSHIFT))) {
 				DLOG((DLOG_MOUNT, "lfs_mountfs: sb daddr"
 				      " 0x%llx is not right, trying 0x%llx\n",
 				      (long long)sb_addr,
-				      (long long)(dfs->dlfs_sboffs[0] << (dfs->dlfs_ffshift - DEV_BSHIFT))));
+				      (long long)(lfs_sb_getsboff(primarysb, 0) << (lfs_sb_getffshift(primarysb) - DEV_BSHIFT))));
-				sb_addr = dfs->dlfs_sboffs[0] << (dfs->dlfs_ffshift - DEV_BSHIFT);
+				sb_addr = lfs_sb_getsboff(primarysb, 0) << (lfs_sb_getffshift(primarysb) - DEV_BSHIFT);
-				brelse(bp, 0);
+				brelse(primarybuf, BC_INVAL);
 				continue;
+			}
+		}
 		break;
+	}
 	/*
 	 * Check the second superblock to see which is newer; then mount
 	 * using the older of the two.	This is necessary to ensure that
 	 * the filesystem is valid if it was not unmounted cleanly.
 	 */
-	if (dfs->dlfs_sboffs[1] &&
+	if (lfs_sb_getsboff(primarysb, 1) &&
-	    dfs->dlfs_sboffs[1] - LFS_LABELPAD / fsbsize > LFS_SBPAD / fsbsize)
+	    lfs_sb_getsboff(primarysb, 1) - LFS_LABELPAD / fsbsize > LFS_SBPAD / fsbsize)
+	{
-		error = bread(devvp, dfs->dlfs_sboffs[1] * (fsbsize / DEV_BSIZE),
+		error = bread(devvp, lfs_sb_getsboff(primarysb, 1) * (fsbsize / DEV_BSIZE),
-			LFS_SBPAD, 0, &abp);
+			LFS_SBPAD, 0, &altbuf);
 		if (error)
 			goto out;
-		adfs = (struct dlfs *)abp->b_data;
+		altsb = (struct lfs *)altbuf->b_data;
-		if (dfs->dlfs_version == 1) {
+		/*
-			/* 1s resolution comparison */
+		 * Note: this used to do the sanity check only if the
-			if (adfs->dlfs_tstamp < dfs->dlfs_tstamp)
+		 * timestamp/serial comparison required use of altsb;
-				tdfs = adfs;
+		 * this way is less tolerant, but if altsb is corrupted
-			else
+		 * enough that the magic number, version, and blocksize
-				tdfs = dfs;
+		 * are bogus, why would the timestamp or serial fields
-		} else {
+		 * mean anything either? If this kind of thing happens,
-			/* monotonic infinite-resolution comparison */
+		 * you need to fsck anyway.
-			if (adfs->dlfs_serial < dfs->dlfs_serial)
+		 */
 				tdfs = adfs;
-			else
+		error = lfs_checkmagic(altsb);
-				tdfs = dfs;
+		if (error)
 			goto out;
 		/* Check the basics. */
-		if (tdfs->dlfs_magic != LFS_MAGIC ||
+		if (lfs_sb_getbsize(altsb) > MAXBSIZE ||
-		    tdfs->dlfs_bsize > MAXBSIZE ||
+		    lfs_sb_getversion(altsb) > LFS_VERSION ||
-		    tdfs->dlfs_version > LFS_VERSION ||
+		    lfs_sb_getbsize(altsb) < sizeof(struct dlfs)) {
 		    tdfs->dlfs_bsize < sizeof(struct dlfs)) {
 			DLOG((DLOG_MOUNT, "lfs_mountfs: alt superblock"
 			      " sanity failed\n"));
 			error = EINVAL;		/* XXX needs translation */
 			goto out;
+		}
 		if (lfs_sb_getversion(primarysb) == 1) {
 			/* 1s resolution comparison */
 			if (lfs_sb_gettstamp(altsb) < lfs_sb_gettstamp(primarysb))
 				thesb = altsb;
 			else
 				thesb = primarysb;
 		} else {
 			/* monotonic infinite-resolution comparison */
 			if (lfs_sb_getserial(altsb) < lfs_sb_getserial(primarysb))
 				thesb = altsb;
 			else
 				thesb = primarysb;
+		}
 	} else {
-		DLOG((DLOG_MOUNT, "lfs_mountfs: invalid alt superblock"
+		DLOG((DLOG_MOUNT, "lfs_mountfs: invalid alt superblock location"
-		      " daddr=0x%x\n", dfs->dlfs_sboffs[1]));
+		      " daddr=0x%x\n", lfs_sb_getsboff(primarysb, 1)));
 		error = EINVAL;
 		goto out;
+	}
-	/* Allocate the mount structure, copy the superblock into it. */
+	/*
 	 * Allocate the mount structure, copy the superblock into it.
 	 * Note that the 32-bit and 64-bit superblocks are the same size.
 	 */
 	fs = kmem_zalloc(sizeof(struct lfs), KM_SLEEP);
-	memcpy(&fs->lfs_dlfs_u.u_32, tdfs, sizeof(struct dlfs));
+	memcpy(&fs->lfs_dlfs_u.u_32, &thesb->lfs_dlfs_u.u_32,
-	fs->lfs_is64 = false; /* XXX notyet */
+	       sizeof(struct dlfs));
-	fs->lfs_dobyteswap = false; /* XXX notyet */
+	fs->lfs_is64 = thesb->lfs_is64;
 	fs->lfs_dobyteswap = thesb->lfs_dobyteswap;
 	fs->lfs_hasolddirfmt = false; /* set for real below */
 	/* Compatibility */
 	if (lfs_sb_getversion(fs) < 2) {
 		lfs_sb_setsumsize(fs, LFS_V1_SUMMARY_SIZE);
 		lfs_sb_setibsize(fs, lfs_sb_getbsize(fs));
 		lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 0));
 		lfs_sb_settstamp(fs, lfs_sb_getotstamp(fs));
 		lfs_sb_setfsbtodb(fs, 0);
+	}
 	if (lfs_sb_getresvseg(fs) == 0)
 		lfs_sb_setresvseg(fs, MIN(lfs_sb_getminfreeseg(fs) - 1, \
 			MAX(MIN_RESV_SEGS, lfs_sb_getminfreeseg(fs) / 2 + 1)));
 @@ -995,35 +1060,30 @@ lfs_mountfs(struct vnode *devvp, struct
 		goto out;
+	}
 	/* Before rolling forward, lock so vget will sleep for other procs */
 	if (l != NULL) {
 		fs->lfs_flags = LFS_NOTYET;
 		fs->lfs_rfpid = l->l_proc->p_pid;
+	}
 	ump = kmem_zalloc(sizeof(*ump), KM_SLEEP);
 	ump->um_lfs = fs;
 	ump->um_fstype = ULFS1;
 	/* ump->um_cleaner_thread = NULL; */
-	if (sizeof(struct lfs) < LFS_SBPAD) {			/* XXX why? */
+	brelse(primarybuf, BC_INVAL);
-		brelse(bp, BC_INVAL);
+	brelse(altbuf, BC_INVAL);
-		brelse(abp, BC_INVAL);
+	primarybuf = NULL;
-	} else {
+	altbuf = NULL;
 		brelse(bp, 0);
 		brelse(abp, 0);
 	bp = NULL;
 	abp = NULL;
 	/* Set up the I/O information */
 	fs->lfs_devbsize = DEV_BSIZE;
 	fs->lfs_iocount = 0;
 	fs->lfs_diropwait = 0;
 	fs->lfs_activesb = 0;
 	lfs_sb_setuinodes(fs, 0);
 	fs->lfs_ravail = 0;
 	fs->lfs_favail = 0;
 	fs->lfs_sbactive = 0;
 	/* Set up the ifile and lock aflags */
 @@ -1112,26 +1172,27 @@ lfs_mountfs(struct vnode *devvp, struct
 	lfs_order_freelist(fs);
 	/* Set up segment usage flags for the autocleaner. */
 	fs->lfs_nactive = 0;
 	fs->lfs_suflags = malloc(2 * sizeof(u_int32_t *),
 				 M_SEGMENT, M_WAITOK);
 	fs->lfs_suflags[0] = malloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t),
 				    M_SEGMENT, M_WAITOK);
 	fs->lfs_suflags[1] = malloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t),
 				    M_SEGMENT, M_WAITOK);
 	memset(fs->lfs_suflags[1], 0, lfs_sb_getnseg(fs) * sizeof(u_int32_t));
 	for (i = 0; i < lfs_sb_getnseg(fs); i++) {
 		int changed;
 		struct buf *bp;
 		LFS_SEGENTRY(sup, fs, i, bp);
 		changed = 0;
 		if (!ronly) {
 			if (sup->su_nbytes == 0 &&
 			    !(sup->su_flags & SEGUSE_EMPTY)) {
 				sup->su_flags |= SEGUSE_EMPTY;
 				++changed;
 			} else if (!(sup->su_nbytes == 0) &&
 				   (sup->su_flags & SEGUSE_EMPTY)) {
 				sup->su_flags &= ~SEGUSE_EMPTY;
 				++changed;
+			}
 @@ -1208,63 +1269,71 @@ lfs_mountfs(struct vnode *devvp, struct
 		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));
+	}
 	/* Allow vget now that roll-forward is complete */
 	fs->lfs_flags &= ~(LFS_NOTYET);
 	wakeup(&fs->lfs_flags);
 	/*
 	 * Initialize the ifile cleaner info with information from
 	 * the superblock.
 	 */
 	LFS_CLEANERINFO(cip, fs, bp);
-	lfs_ci_setclean(fs, cip, lfs_sb_getnclean(fs));
+		struct buf *bp;
 	lfs_ci_setdirty(fs, cip, lfs_sb_getnseg(fs) - lfs_sb_getnclean(fs));
-	lfs_ci_setavail(fs, cip, lfs_sb_getavail(fs));
+		LFS_CLEANERINFO(cip, fs, bp);
-	lfs_ci_setbfree(fs, cip, lfs_sb_getbfree(fs));
+		lfs_ci_setclean(fs, cip, lfs_sb_getnclean(fs));
-	(void) LFS_BWRITE_LOG(bp); /* Ifile */
+		lfs_ci_setdirty(fs, cip, lfs_sb_getnseg(fs) - lfs_sb_getnclean(fs));
 		lfs_ci_setavail(fs, cip, lfs_sb_getavail(fs));
 		lfs_ci_setbfree(fs, cip, lfs_sb_getbfree(fs));
 		(void) LFS_BWRITE_LOG(bp); /* Ifile */
+	}
 	/*
 	 * Mark the current segment as ACTIVE, since we're going to
 	 * be writing to it.
 	 */
 	LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getoffset(fs)), bp);
-	sup->su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE;
+		struct buf *bp;
 	fs->lfs_nactive++;
-	LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getoffset(fs)), bp);  /* Ifile */
+		LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getoffset(fs)), bp);
 		sup->su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE;
 		fs->lfs_nactive++;
 		LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getoffset(fs)), bp);  /* Ifile */
+	}
 	/* Now that roll-forward is done, unlock the Ifile */
 	vput(vp);
 	/* Start the pagedaemon-anticipating daemon */
 	mutex_enter(&lfs_lock);
 	if (lfs_writer_daemon == 0 && lfs_writer_lid == 0 &&
 	    kthread_create(PRI_BIO, 0, NULL,
 	    lfs_writerd, NULL, NULL, "lfs_writer") != 0)
 		panic("fork lfs_writer");
 	mutex_exit(&lfs_lock);
 	printf("WARNING: the log-structured file system is experimental\n"
 	    "WARNING: it may cause system crashes and/or corrupt data\n");
 	return (0);
 out:
-	if (bp)
+	if (primarybuf)
-		brelse(bp, 0);
+		brelse(primarybuf, BC_INVAL);
-	if (abp)
+	if (altbuf)
-		brelse(abp, 0);
+		brelse(altbuf, BC_INVAL);
 	if (ump) {
 		kmem_free(ump->um_lfs, sizeof(struct lfs));
 		kmem_free(ump, sizeof(*ump));
 		mp->mnt_data = NULL;
+	}
 	return (error);
+}
 /*
  * unmount system call
  */
 int