 @@ -1,844 +1,844 @@
-/*	$NetBSD: lfs_bio.c,v 1.130 2015/07/24 06:59:32 dholland Exp $	*/
+/*	$NetBSD: lfs_bio.c,v 1.131 2015/07/25 10:40:35 martin Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003, 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
  *    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) 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.
+ *
  *	@(#)lfs_bio.c	8.10 (Berkeley) 6/10/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.130 2015/07/24 06:59:32 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.131 2015/07/25 10:40:35 martin Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/buf.h>
 #include <sys/vnode.h>
 #include <sys/resourcevar.h>
 #include <sys/mount.h>
 #include <sys/kernel.h>
 #include <sys/kauth.h>
 #include <ufs/lfs/ulfs_inode.h>
 #include <ufs/lfs/ulfsmount.h>
 #include <ufs/lfs/ulfs_extern.h>
 #include <ufs/lfs/lfs.h>
 #include <ufs/lfs/lfs_extern.h>
 #include <ufs/lfs/lfs_kernel.h>
 #include <uvm/uvm.h>
 /*
  * LFS block write function.
+ *
  * XXX
  * No write cost accounting is done.
  * This is almost certainly wrong for synchronous operations and NFS.
+ *
  * protected by lfs_lock.
  */
 int	locked_queue_count   = 0;	/* Count of locked-down buffers. */
 long	locked_queue_bytes   = 0L;	/* Total size of locked buffers. */
 int	lfs_subsys_pages     = 0L;	/* Total number LFS-written pages */
 int	lfs_fs_pagetrip	     = 0;	/* # of pages to trip per-fs write */
 int	lfs_writing	     = 0;	/* Set if already kicked off a writer
 					   because of buffer space */
 int	locked_queue_waiters = 0;	/* Number of processes waiting on lq */
 /* Lock and condition variables for above. */
 kcondvar_t	locked_queue_cv;
 kcondvar_t	lfs_writing_cv;
 kmutex_t	lfs_lock;
 extern int lfs_dostats;
 /*
  * reserved number/bytes of locked buffers
  */
 int locked_queue_rcount = 0;
 long locked_queue_rbytes = 0L;
 static int lfs_fits_buf(struct lfs *, int, int);
 static int lfs_reservebuf(struct lfs *, struct vnode *vp, struct vnode *vp2,
     int, int);
 static int lfs_reserveavail(struct lfs *, struct vnode *vp, struct vnode *vp2,
     int);
 static int
 lfs_fits_buf(struct lfs *fs, int n, int bytes)
+{
 	int count_fit, bytes_fit;
 	ASSERT_NO_SEGLOCK(fs);
 	KASSERT(mutex_owned(&lfs_lock));
 	count_fit =
 	    (locked_queue_count + locked_queue_rcount + n <= LFS_WAIT_BUFS);
 	bytes_fit =
 	    (locked_queue_bytes + locked_queue_rbytes + bytes <= LFS_WAIT_BYTES);
 #ifdef DEBUG
 	if (!count_fit) {
 		DLOG((DLOG_AVAIL, "lfs_fits_buf: no fit count: %d + %d + %d >= %d\n",
 		      locked_queue_count, locked_queue_rcount,
 		      n, LFS_WAIT_BUFS));
+	}
 	if (!bytes_fit) {
 		DLOG((DLOG_AVAIL, "lfs_fits_buf: no fit bytes: %ld + %ld + %d >= %ld\n",
 		      locked_queue_bytes, locked_queue_rbytes,
 		      bytes, LFS_WAIT_BYTES));
+	}
 #endif /* DEBUG */
 	return (count_fit && bytes_fit);
+}
 /* ARGSUSED */
 static int
 lfs_reservebuf(struct lfs *fs, struct vnode *vp,
     struct vnode *vp2, int n, int bytes)
+{
 	int cantwait;
 	ASSERT_MAYBE_SEGLOCK(fs);
 	KASSERT(locked_queue_rcount >= 0);
 	KASSERT(locked_queue_rbytes >= 0);
 	cantwait = (VTOI(vp)->i_flag & IN_ADIROP) || fs->lfs_unlockvp == vp;
 	mutex_enter(&lfs_lock);
 	while (!cantwait && n > 0 && !lfs_fits_buf(fs, n, bytes)) {
 		int error;
 		lfs_flush(fs, 0, 0);
 		DLOG((DLOG_AVAIL, "lfs_reservebuf: waiting: count=%d, bytes=%ld\n",
 		      locked_queue_count, locked_queue_bytes));
 		++locked_queue_waiters;
 		error = cv_timedwait_sig(&locked_queue_cv, &lfs_lock,
 		    hz * LFS_BUFWAIT);
 		--locked_queue_waiters;
 		if (error && error != EWOULDBLOCK) {
 			mutex_exit(&lfs_lock);
 			return error;
+		}
+	}
 	locked_queue_rcount += n;
 	locked_queue_rbytes += bytes;
 	if (n < 0 && locked_queue_waiters > 0) {
 		DLOG((DLOG_AVAIL, "lfs_reservebuf: broadcast: count=%d, bytes=%ld\n",
 		      locked_queue_count, locked_queue_bytes));
 		cv_broadcast(&locked_queue_cv);
+	}
 	mutex_exit(&lfs_lock);
 	KASSERT(locked_queue_rcount >= 0);
 	KASSERT(locked_queue_rbytes >= 0);
 	return 0;
+}
 /*
  * Try to reserve some blocks, prior to performing a sensitive operation that
  * requires the vnode lock to be honored.  If there is not enough space, give
  * up the vnode lock temporarily and wait for the space to become available.
+ *
  * Called with vp locked.  (Note nowever that if fsb < 0, vp is ignored.)
+ *
  * XXX YAMT - it isn't safe to unlock vp here
  * because the node might be modified while we sleep.
  * (eg. cached states like i_offset might be stale,
  *  the vnode might be truncated, etc..)
  * maybe we should have a way to restart the vnodeop (EVOPRESTART?)
  * or rearrange vnodeop interface to leave vnode locking to file system
  * specific code so that each file systems can have their own vnode locking and
  * vnode re-using strategies.
  */
 static int
 lfs_reserveavail(struct lfs *fs, struct vnode *vp,
     struct vnode *vp2, int fsb)
+{
 	CLEANERINFO *cip;
 	struct buf *bp;
 	int error, slept;
 	int cantwait;
 	ASSERT_MAYBE_SEGLOCK(fs);
 	slept = 0;
 	mutex_enter(&lfs_lock);
 	cantwait = (VTOI(vp)->i_flag & IN_ADIROP) || fs->lfs_unlockvp == vp;
 	while (!cantwait && fsb > 0 &&
 	       !lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail)) {
 		mutex_exit(&lfs_lock);
 		if (!slept) {
 			DLOG((DLOG_AVAIL, "lfs_reserve: waiting for %ld (bfree = %d,"
 			      " est_bfree = %d)\n",
 			      fsb + fs->lfs_ravail + fs->lfs_favail,
-			      fs->lfs_bfree, LFS_EST_BFREE(fs)));
+			      lfs_sb_getbfree(fs), LFS_EST_BFREE(fs)));
+		}
 		++slept;
 		/* Wake up the cleaner */
 		LFS_CLEANERINFO(cip, fs, bp);
 		LFS_SYNC_CLEANERINFO(cip, fs, bp, 0);
 		lfs_wakeup_cleaner(fs);
 		mutex_enter(&lfs_lock);
 		/* Cleaner might have run while we were reading, check again */
 		if (lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail))
 			break;
 		error = mtsleep(&fs->lfs_availsleep, PCATCH | PUSER,
 				"lfs_reserve", 0, &lfs_lock);
 		if (error) {
 			mutex_exit(&lfs_lock);
 			return error;
+		}
+	}
 #ifdef DEBUG
 	if (slept) {
 		DLOG((DLOG_AVAIL, "lfs_reserve: woke up\n"));
+	}
 #endif
 	fs->lfs_ravail += fsb;
 	mutex_exit(&lfs_lock);
 	return 0;
+}
 #ifdef DIAGNOSTIC
 int lfs_rescount;
 int lfs_rescountdirop;
 #endif
 int
 lfs_reserve(struct lfs *fs, struct vnode *vp, struct vnode *vp2, int fsb)
+{
 	int error;
 	ASSERT_MAYBE_SEGLOCK(fs);
 	if (vp2) {
 		/* Make sure we're not in the process of reclaiming vp2 */
 		mutex_enter(&lfs_lock);
 		while(fs->lfs_flags & LFS_UNDIROP) {
 			mtsleep(&fs->lfs_flags, PRIBIO + 1, "lfsrundirop", 0,
 			    &lfs_lock);
+		}
 		mutex_exit(&lfs_lock);
+	}
 	KASSERT(fsb < 0 || VOP_ISLOCKED(vp));
 	KASSERT(vp2 == NULL || fsb < 0 || VOP_ISLOCKED(vp2));
 	KASSERT(vp2 == NULL || vp2 != fs->lfs_unlockvp);
 #ifdef DIAGNOSTIC
 	mutex_enter(&lfs_lock);
 	if (fsb > 0)
 		lfs_rescount++;
 	else if (fsb < 0)
 		lfs_rescount--;
 	if (lfs_rescount < 0)
 		panic("lfs_rescount");
 	mutex_exit(&lfs_lock);
 #endif
 	/*
 	 * XXX
 	 * vref vnodes here so that cleaner doesn't try to reuse them.
 	 * (see XXX comment in lfs_reserveavail)
 	 */
 	vhold(vp);
 	if (vp2 != NULL) {
 		vhold(vp2);
+	}
 	error = lfs_reserveavail(fs, vp, vp2, fsb);
 	if (error)
 		goto done;
 	/*
 	 * XXX just a guess. should be more precise.
 	 */
 	error = lfs_reservebuf(fs, vp, vp2, fsb, lfs_fsbtob(fs, fsb));
 	if (error)
 		lfs_reserveavail(fs, vp, vp2, -fsb);
 done:
 	holdrele(vp);
 	if (vp2 != NULL) {
 		holdrele(vp2);
+	}
 	return error;
+}
 int
 lfs_bwrite(void *v)
+{
 	struct vop_bwrite_args /* {
 		struct vnode *a_vp;
 		struct buf *a_bp;
 	} */ *ap = v;
 	struct buf *bp = ap->a_bp;
 #ifdef DIAGNOSTIC
 	if (VTOI(bp->b_vp)->i_lfs->lfs_ronly == 0 && (bp->b_flags & B_ASYNC)) {
 		panic("bawrite LFS buffer");
+	}
 #endif /* DIAGNOSTIC */
 	return lfs_bwrite_ext(bp, 0);
+}
 /*
  * Determine if there is enough room currently available to write fsb
  * blocks.  We need enough blocks for the new blocks, the current
  * inode blocks (including potentially the ifile inode), a summary block,
  * and the segment usage table, plus an ifile block.
  */
 int
 lfs_fits(struct lfs *fs, int fsb)
+{
 	int64_t needed;
 	ASSERT_NO_SEGLOCK(fs);
 	needed = fsb + lfs_btofsb(fs, lfs_sb_getsumsize(fs)) +
 		 ((howmany(lfs_sb_getuinodes(fs) + 1, LFS_INOPB(fs)) +
 		   lfs_sb_getsegtabsz(fs) +
 ) << (lfs_sb_getbshift(fs) - lfs_sb_getffshift(fs)));
 	if (needed >= lfs_sb_getavail(fs)) {
 #ifdef DEBUG
 		DLOG((DLOG_AVAIL, "lfs_fits: no fit: fsb = %ld, uinodes = %ld, "
 		      "needed = %jd, avail = %jd\n",
-		      (long)fsb, (long)fs->lfs_uinodes, (intmax_t)needed,
+		      (long)fsb, (long)lfs_sb_getuinodes(fs), (intmax_t)needed,
 		      (intmax_t)lfs_sb_getavail(fs)));
 #endif
 		return 0;
+	}
 	return 1;
+}
 int
 lfs_availwait(struct lfs *fs, int fsb)
+{
 	int error;
 	CLEANERINFO *cip;
 	struct buf *cbp;
 	ASSERT_NO_SEGLOCK(fs);
 	/* Push cleaner blocks through regardless */
 	mutex_enter(&lfs_lock);
 	if (LFS_SEGLOCK_HELD(fs) &&
 	    fs->lfs_sp->seg_flags & (SEGM_CLEAN | SEGM_FORCE_CKP)) {
 		mutex_exit(&lfs_lock);
 		return 0;
+	}
 	mutex_exit(&lfs_lock);
 	while (!lfs_fits(fs, fsb)) {
 		/*
 		 * Out of space, need cleaner to run.
 		 * Update the cleaner info, then wake it up.
 		 * Note the cleanerinfo block is on the ifile
 		 * so it CANT_WAIT.
 		 */
 		LFS_CLEANERINFO(cip, fs, cbp);
 		LFS_SYNC_CLEANERINFO(cip, fs, cbp, 0);
 #ifdef DEBUG
 		DLOG((DLOG_AVAIL, "lfs_availwait: out of available space, "
 		      "waiting on cleaner\n"));
 #endif
 		lfs_wakeup_cleaner(fs);
 #ifdef DIAGNOSTIC
 		if (LFS_SEGLOCK_HELD(fs))
 			panic("lfs_availwait: deadlock");
 #endif
 		error = tsleep(&fs->lfs_availsleep, PCATCH | PUSER,
 			       "cleaner", 0);
 		if (error)
 			return (error);
+	}
 	return 0;
+}
 int
 lfs_bwrite_ext(struct buf *bp, int flags)
+{
 	struct lfs *fs;
 	struct inode *ip;
 	struct vnode *vp;
 	int fsb;
 	vp = bp->b_vp;
 	fs = VFSTOULFS(vp->v_mount)->um_lfs;
 	ASSERT_MAYBE_SEGLOCK(fs);
 	KASSERT(bp->b_cflags & BC_BUSY);
 	KASSERT(flags & BW_CLEAN || !LFS_IS_MALLOC_BUF(bp));
 	KASSERT(((bp->b_oflags | bp->b_flags) & (BO_DELWRI|B_LOCKED))
 	    != BO_DELWRI);
 	/*
 	 * Don't write *any* blocks if we're mounted read-only, or
 	 * if we are "already unmounted".
+	 *
 	 * In particular the cleaner can't write blocks either.
 	 */
 	if (fs->lfs_ronly || (lfs_sb_getpflags(fs) & LFS_PF_CLEAN)) {
 		bp->b_oflags &= ~BO_DELWRI;
 		bp->b_flags |= B_READ; /* XXX is this right? --ks */
 		bp->b_error = 0;
 		mutex_enter(&bufcache_lock);
 		LFS_UNLOCK_BUF(bp);
 		if (LFS_IS_MALLOC_BUF(bp))
 			bp->b_cflags &= ~BC_BUSY;
 		else
 			brelsel(bp, 0);
 		mutex_exit(&bufcache_lock);
 		return (fs->lfs_ronly ? EROFS : 0);
+	}
 	/*
 	 * Set the delayed write flag and use reassignbuf to move the buffer
 	 * from the clean list to the dirty one.
+	 *
 	 * Set the B_LOCKED flag and unlock the buffer, causing brelse to move
 	 * the buffer onto the LOCKED free list.  This is necessary, otherwise
 	 * getnewbuf() would try to reclaim the buffers using bawrite, which
 	 * isn't going to work.
+	 *
 	 * XXX we don't let meta-data writes run out of space because they can
 	 * come from the segment writer.  We need to make sure that there is
 	 * enough space reserved so that there's room to write meta-data
 	 * blocks.
 	 */
 	if ((bp->b_flags & B_LOCKED) == 0) {
 		fsb = lfs_numfrags(fs, bp->b_bcount);
 		ip = VTOI(vp);
 		mutex_enter(&lfs_lock);
 		if (flags & BW_CLEAN) {
 			LFS_SET_UINO(ip, IN_CLEANING);
 		} else {
 			LFS_SET_UINO(ip, IN_MODIFIED);
+		}
 		mutex_exit(&lfs_lock);
 		lfs_sb_subavail(fs, fsb);
 		mutex_enter(&bufcache_lock);
 		mutex_enter(vp->v_interlock);
 		bp->b_oflags = (bp->b_oflags | BO_DELWRI) & ~BO_DONE;
 		LFS_LOCK_BUF(bp);
 		bp->b_flags &= ~B_READ;
 		bp->b_error = 0;
 		reassignbuf(bp, bp->b_vp);
 		mutex_exit(vp->v_interlock);
 	} else {
 		mutex_enter(&bufcache_lock);
+	}
 	if (bp->b_iodone != NULL)
 		bp->b_cflags &= ~BC_BUSY;
 	else
 		brelsel(bp, 0);
 	mutex_exit(&bufcache_lock);
 	return (0);
+}
 /*
  * Called and return with the lfs_lock held.
  */
 void
 lfs_flush_fs(struct lfs *fs, int flags)
+{
 	ASSERT_NO_SEGLOCK(fs);
 	KASSERT(mutex_owned(&lfs_lock));
 	if (fs->lfs_ronly)
 		return;
 	if (lfs_dostats)
 		++lfs_stats.flush_invoked;
 	fs->lfs_pdflush = 0;
 	mutex_exit(&lfs_lock);
 	lfs_writer_enter(fs, "fldirop");
 	lfs_segwrite(fs->lfs_ivnode->v_mount, flags);
 	lfs_writer_leave(fs);
 	mutex_enter(&lfs_lock);
 	fs->lfs_favail = 0; /* XXX */
+}
 /*
  * This routine initiates segment writes when LFS is consuming too many
  * resources.  Ideally the pageout daemon would be able to direct LFS
  * more subtly.
  * XXX We have one static count of locked buffers;
  * XXX need to think more about the multiple filesystem case.
+ *
  * Called and return with lfs_lock held.
  * If fs != NULL, we hold the segment lock for fs.
  */
 void
 lfs_flush(struct lfs *fs, int flags, int only_onefs)
+{
 	extern u_int64_t locked_fakequeue_count;
 	struct mount *mp, *nmp;
 	struct lfs *tfs;
 	KASSERT(mutex_owned(&lfs_lock));
 	KDASSERT(fs == NULL || !LFS_SEGLOCK_HELD(fs));
 	if (lfs_dostats)
 		++lfs_stats.write_exceeded;
 	/* XXX should we include SEGM_CKP here? */
 	if (lfs_writing && !(flags & SEGM_SYNC)) {
 		DLOG((DLOG_FLUSH, "lfs_flush: not flushing because another flush is active\n"));
 		return;
+	}
 	while (lfs_writing)
 		cv_wait(&lfs_writing_cv, &lfs_lock);
 	lfs_writing = 1;
 	mutex_exit(&lfs_lock);
 	if (only_onefs) {
 		KASSERT(fs != NULL);
 		if (vfs_busy(fs->lfs_ivnode->v_mount, NULL))
 			goto errout;
 		mutex_enter(&lfs_lock);
 		lfs_flush_fs(fs, flags);
 		mutex_exit(&lfs_lock);
 		vfs_unbusy(fs->lfs_ivnode->v_mount, false, NULL);
 	} else {
 		locked_fakequeue_count = 0;
 		mutex_enter(&mountlist_lock);
 		for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
 			if (vfs_busy(mp, &nmp)) {
 				DLOG((DLOG_FLUSH, "lfs_flush: fs vfs_busy\n"));
 				continue;
+			}
 			if (strncmp(&mp->mnt_stat.f_fstypename[0], MOUNT_LFS,
 			    sizeof(mp->mnt_stat.f_fstypename)) == 0) {
 				tfs = VFSTOULFS(mp)->um_lfs;
 				mutex_enter(&lfs_lock);
 				lfs_flush_fs(tfs, flags);
 				mutex_exit(&lfs_lock);
+			}
 			vfs_unbusy(mp, false, &nmp);
+		}
 		mutex_exit(&mountlist_lock);
+	}
 	LFS_DEBUG_COUNTLOCKED("flush");
 	wakeup(&lfs_subsys_pages);
     errout:
 	mutex_enter(&lfs_lock);
 	KASSERT(lfs_writing);
 	lfs_writing = 0;
 	wakeup(&lfs_writing);
+}
 #define INOCOUNT(fs) howmany(lfs_sb_getuinodes(fs), LFS_INOPB(fs))
 #define INOBYTES(fs) (lfs_sb_getuinodes(fs) * sizeof (struct ulfs1_dinode))
 /*
  * make sure that we don't have too many locked buffers.
  * flush buffers if needed.
  */
 int
 lfs_check(struct vnode *vp, daddr_t blkno, int flags)
+{
 	int error;
 	struct lfs *fs;
 	struct inode *ip;
 	extern pid_t lfs_writer_daemon;
 	error = 0;
 	ip = VTOI(vp);
 	/* If out of buffers, wait on writer */
 	/* XXX KS - if it's the Ifile, we're probably the cleaner! */
 	if (ip->i_number == LFS_IFILE_INUM)
 		return 0;
 	/* If we're being called from inside a dirop, don't sleep */
 	if (ip->i_flag & IN_ADIROP)
 		return 0;
 	fs = ip->i_lfs;
 	ASSERT_NO_SEGLOCK(fs);
 	/*
 	 * If we would flush below, but dirops are active, sleep.
 	 * Note that a dirop cannot ever reach this code!
 	 */
 	mutex_enter(&lfs_lock);
 	while (fs->lfs_dirops > 0 &&
 	       (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS ||
 		locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES ||
 		lfs_subsys_pages > LFS_MAX_PAGES ||
 		fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) ||
 		lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0))
+	{
 		++fs->lfs_diropwait;
 		mtsleep(&fs->lfs_writer, PRIBIO+1, "bufdirop", 0,
 			&lfs_lock);
 		--fs->lfs_diropwait;
+	}
 #ifdef DEBUG
 	if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS)
 		DLOG((DLOG_FLUSH, "lfs_check: lqc = %d, max %d\n",
 		      locked_queue_count + INOCOUNT(fs), LFS_MAX_BUFS));
 	if (locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES)
 		DLOG((DLOG_FLUSH, "lfs_check: lqb = %ld, max %ld\n",
 		      locked_queue_bytes + INOBYTES(fs), LFS_MAX_BYTES));
 	if (lfs_subsys_pages > LFS_MAX_PAGES)
 		DLOG((DLOG_FLUSH, "lfs_check: lssp = %d, max %d\n",
 		      lfs_subsys_pages, LFS_MAX_PAGES));
 	if (lfs_fs_pagetrip && fs->lfs_pages > lfs_fs_pagetrip)
 		DLOG((DLOG_FLUSH, "lfs_check: fssp = %d, trip at %d\n",
 		      fs->lfs_pages, lfs_fs_pagetrip));
 	if (lfs_dirvcount > LFS_MAX_DIROP)
 		DLOG((DLOG_FLUSH, "lfs_check: ldvc = %d, max %d\n",
 		      lfs_dirvcount, LFS_MAX_DIROP));
 	if (fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs))
 		DLOG((DLOG_FLUSH, "lfs_check: lfdvc = %d, max %d\n",
 		      fs->lfs_dirvcount, LFS_MAX_FSDIROP(fs)));
 	if (fs->lfs_diropwait > 0)
 		DLOG((DLOG_FLUSH, "lfs_check: ldvw = %d\n",
 		      fs->lfs_diropwait));
 #endif
 	/* If there are too many pending dirops, we have to flush them. */
 	if (fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) ||
 	    lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0) {
 		mutex_exit(&lfs_lock);
 		lfs_flush_dirops(fs);
 		mutex_enter(&lfs_lock);
 	} else if (locked_queue_count + INOCOUNT(fs) > LFS_MAX_BUFS ||
 	    locked_queue_bytes + INOBYTES(fs) > LFS_MAX_BYTES ||
 	    lfs_subsys_pages > LFS_MAX_PAGES ||
 	    fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) ||
 	    lfs_dirvcount > LFS_MAX_DIROP || fs->lfs_diropwait > 0) {
 		lfs_flush(fs, flags, 0);
 	} else if (lfs_fs_pagetrip && fs->lfs_pages > lfs_fs_pagetrip) {
 		/*
 		 * If we didn't flush the whole thing, some filesystems
 		 * still might want to be flushed.
 		 */
 		++fs->lfs_pdflush;
 		wakeup(&lfs_writer_daemon);
+	}
 	while (locked_queue_count + INOCOUNT(fs) >= LFS_WAIT_BUFS ||
 		locked_queue_bytes + INOBYTES(fs) >= LFS_WAIT_BYTES ||
 		lfs_subsys_pages > LFS_WAIT_PAGES ||
 		fs->lfs_dirvcount > LFS_MAX_FSDIROP(fs) ||
 		lfs_dirvcount > LFS_MAX_DIROP) {
 		if (lfs_dostats)
 			++lfs_stats.wait_exceeded;
 		DLOG((DLOG_AVAIL, "lfs_check: waiting: count=%d, bytes=%ld\n",
 		      locked_queue_count, locked_queue_bytes));
 		++locked_queue_waiters;
 		error = cv_timedwait_sig(&locked_queue_cv, &lfs_lock,
 		    hz * LFS_BUFWAIT);
 		--locked_queue_waiters;
 		if (error != EWOULDBLOCK)
 			break;
 		/*
 		 * lfs_flush might not flush all the buffers, if some of the
 		 * inodes were locked or if most of them were Ifile blocks
 		 * and we weren't asked to checkpoint.	Try flushing again
 		 * to keep us from blocking indefinitely.
 		 */
 		if (locked_queue_count + INOCOUNT(fs) >= LFS_MAX_BUFS ||
 		    locked_queue_bytes + INOBYTES(fs) >= LFS_MAX_BYTES) {
 			lfs_flush(fs, flags | SEGM_CKP, 0);
+		}
+	}
 	mutex_exit(&lfs_lock);
 	return (error);
+}
 /*
  * Allocate a new buffer header.
  */
 struct buf *
 lfs_newbuf(struct lfs *fs, struct vnode *vp, daddr_t daddr, size_t size, int type)
+{
 	struct buf *bp;
 	size_t nbytes;
 	ASSERT_MAYBE_SEGLOCK(fs);
 	nbytes = roundup(size, lfs_fsbtob(fs, 1));
 	bp = getiobuf(NULL, true);
 	if (nbytes) {
 		bp->b_data = lfs_malloc(fs, nbytes, type);
 		/* memset(bp->b_data, 0, nbytes); */
+	}
 #ifdef DIAGNOSTIC
 	if (vp == NULL)
 		panic("vp is NULL in lfs_newbuf");
 	if (bp == NULL)
 		panic("bp is NULL after malloc in lfs_newbuf");
 #endif
 	bp->b_bufsize = size;
 	bp->b_bcount = size;
 	bp->b_lblkno = daddr;
 	bp->b_blkno = daddr;
 	bp->b_error = 0;
 	bp->b_resid = 0;
 	bp->b_iodone = lfs_callback;
 	bp->b_cflags = BC_BUSY | BC_NOCACHE;
 	bp->b_private = fs;
 	mutex_enter(&bufcache_lock);
 	mutex_enter(vp->v_interlock);
 	bgetvp(vp, bp);
 	mutex_exit(vp->v_interlock);
 	mutex_exit(&bufcache_lock);
 	return (bp);
+}
 void
 lfs_freebuf(struct lfs *fs, struct buf *bp)
+{
 	struct vnode *vp;
 	if ((vp = bp->b_vp) != NULL) {
 		mutex_enter(&bufcache_lock);
 		mutex_enter(vp->v_interlock);
 		brelvp(bp);
 		mutex_exit(vp->v_interlock);
 		mutex_exit(&bufcache_lock);
+	}
 	if (!(bp->b_cflags & BC_INVAL)) { /* BC_INVAL indicates a "fake" buffer */
 		lfs_free(fs, bp->b_data, LFS_NB_UNKNOWN);
 		bp->b_data = NULL;
+	}
 	putiobuf(bp);
+}
 /*
  * Count buffers on the "locked" queue, and compare it to a pro-forma count.
  * Don't count malloced buffers, since they don't detract from the total.
  */
 void
 lfs_countlocked(int *count, long *bytes, const char *msg)
+{
 	struct buf *bp;
 	int n = 0;
 	long int size = 0L;
 	mutex_enter(&bufcache_lock);
 	TAILQ_FOREACH(bp, &bufqueues[BQ_LOCKED].bq_queue, b_freelist) {
 		KASSERT(bp->b_iodone == NULL);
 		n++;
 		size += bp->b_bufsize;
 #ifdef DIAGNOSTIC
 		if (n > nbuf)
 			panic("lfs_countlocked: this can't happen: more"
 			      " buffers locked than exist");
 #endif
+	}
 	/*
 	 * Theoretically this function never really does anything.
 	 * Give a warning if we have to fix the accounting.
 	 */
 	if (n != *count) {
 		DLOG((DLOG_LLIST, "lfs_countlocked: %s: adjusted buf count"
 		      " from %d to %d\n", msg, *count, n));
+	}
 	if (size != *bytes) {
 		DLOG((DLOG_LLIST, "lfs_countlocked: %s: adjusted byte count"
 		      " from %ld to %ld\n", msg, *bytes, size));
+	}
 	*count = n;
 	*bytes = size;
 	mutex_exit(&bufcache_lock);
 	return;
+}
 int
 lfs_wait_pages(void)
+{
 	int active, inactive;
 	uvm_estimatepageable(&active, &inactive);
 	return LFS_WAIT_RESOURCE(active + inactive + uvmexp.free, 1);
+}
 int
 lfs_max_pages(void)
+{
 	int active, inactive;
 	uvm_estimatepageable(&active, &inactive);
 	return LFS_MAX_RESOURCE(active + inactive + uvmexp.free, 1);
+}

 @@ -1,893 +1,893 @@
-/*	$NetBSD: lfs_pages.c,v 1.3 2015/07/24 06:59:32 dholland Exp $	*/
+/*	$NetBSD: lfs_pages.c,v 1.4 2015/07/25 10:40:35 martin 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
  * 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) 1986, 1989, 1991, 1993, 1995
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    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.
+ *
  *	@(#)lfs_vnops.c	8.13 (Berkeley) 6/10/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_pages.c,v 1.3 2015/07/24 06:59:32 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_pages.c,v 1.4 2015/07/25 10:40:35 martin Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_compat_netbsd.h"
 #include "opt_uvm_page_trkown.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/resourcevar.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/buf.h>
 #include <sys/proc.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <sys/pool.h>
 #include <sys/signalvar.h>
 #include <sys/kauth.h>
 #include <sys/syslog.h>
 #include <sys/fstrans.h>
 #include <miscfs/fifofs/fifo.h>
 #include <miscfs/genfs/genfs.h>
 #include <miscfs/specfs/specdev.h>
 #include <ufs/lfs/ulfs_inode.h>
 #include <ufs/lfs/ulfsmount.h>
 #include <ufs/lfs/ulfs_bswap.h>
 #include <ufs/lfs/ulfs_extern.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_pmap.h>
 #include <uvm/uvm_stat.h>
 #include <uvm/uvm_pager.h>
 #include <ufs/lfs/lfs.h>
 #include <ufs/lfs/lfs_kernel.h>
 #include <ufs/lfs/lfs_extern.h>
 extern pid_t lfs_writer_daemon;
 static int check_dirty(struct lfs *, struct vnode *, off_t, off_t, off_t, int, int, struct vm_page **);
 int
 lfs_getpages(void *v)
+{
 	struct vop_getpages_args /* {
 		struct vnode *a_vp;
 		voff_t a_offset;
 		struct vm_page **a_m;
 		int *a_count;
 		int a_centeridx;
 		vm_prot_t a_access_type;
 		int a_advice;
 		int a_flags;
 	} */ *ap = v;
 	if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM &&
 	    (ap->a_access_type & VM_PROT_WRITE) != 0) {
 		return EPERM;
+	}
 	if ((ap->a_access_type & VM_PROT_WRITE) != 0) {
 		mutex_enter(&lfs_lock);
 		LFS_SET_UINO(VTOI(ap->a_vp), IN_MODIFIED);
 		mutex_exit(&lfs_lock);
+	}
 	/*
 	 * we're relying on the fact that genfs_getpages() always read in
 	 * entire filesystem blocks.
 	 */
 	return genfs_getpages(v);
+}
 /*
  * Wait for a page to become unbusy, possibly printing diagnostic messages
  * as well.
+ *
  * Called with vp->v_interlock held; return with it held.
  */
 static void
 wait_for_page(struct vnode *vp, struct vm_page *pg, const char *label)
+{
 	KASSERT(mutex_owned(vp->v_interlock));
 	if ((pg->flags & PG_BUSY) == 0)
 		return;		/* Nothing to wait for! */
 #if defined(DEBUG) && defined(UVM_PAGE_TRKOWN)
 	static struct vm_page *lastpg;
 	if (label != NULL && pg != lastpg) {
 		if (pg->owner_tag) {
 			printf("lfs_putpages[%d.%d]: %s: page %p owner %d.%d [%s]\n",
 			       curproc->p_pid, curlwp->l_lid, label,
 			       pg, pg->owner, pg->lowner, pg->owner_tag);
 		} else {
 			printf("lfs_putpages[%d.%d]: %s: page %p unowned?!\n",
 			       curproc->p_pid, curlwp->l_lid, label, pg);
+		}
+	}
 	lastpg = pg;
 #endif
 	pg->flags |= PG_WANTED;
 	UVM_UNLOCK_AND_WAIT(pg, vp->v_interlock, 0, "lfsput", 0);
 	mutex_enter(vp->v_interlock);
+}
 /*
  * This routine is called by lfs_putpages() when it can't complete the
  * write because a page is busy.  This means that either (1) someone,
  * possibly the pagedaemon, is looking at this page, and will give it up
  * presently; or (2) we ourselves are holding the page busy in the
  * process of being written (either gathered or actually on its way to
  * disk).  We don't need to give up the segment lock, but we might need
  * to call lfs_writeseg() to expedite the page's journey to disk.
+ *
  * Called with vp->v_interlock held; return with it held.
  */
 /* #define BUSYWAIT */
 static void
 write_and_wait(struct lfs *fs, struct vnode *vp, struct vm_page *pg,
 	       int seglocked, const char *label)
+{
 	KASSERT(mutex_owned(vp->v_interlock));
 #ifndef BUSYWAIT
 	struct inode *ip = VTOI(vp);
 	struct segment *sp = fs->lfs_sp;
 	int count = 0;
 	if (pg == NULL)
 		return;
 	while (pg->flags & PG_BUSY &&
 	    pg->uobject == &vp->v_uobj) {
 		mutex_exit(vp->v_interlock);
 		if (sp->cbpp - sp->bpp > 1) {
 			/* Write gathered pages */
 			lfs_updatemeta(sp);
 			lfs_release_finfo(fs);
 			(void) lfs_writeseg(fs, sp);
 			/*
 			 * Reinitialize FIP
 			 */
 			KASSERT(sp->vp == vp);
 			lfs_acquire_finfo(fs, ip->i_number,
 					  ip->i_gen);
+		}
 		++count;
 		mutex_enter(vp->v_interlock);
 		wait_for_page(vp, pg, label);
+	}
 	if (label != NULL && count > 1) {
 		DLOG((DLOG_PAGE, "lfs_putpages[%d]: %s: %sn = %d\n",
 		      curproc->p_pid, label, (count > 0 ? "looping, " : ""),
 		      count));
+	}
 #else
 	preempt(1);
 #endif
 	KASSERT(mutex_owned(vp->v_interlock));
+}
 /*
  * Make sure that for all pages in every block in the given range,
  * either all are dirty or all are clean.  If any of the pages
  * we've seen so far are dirty, put the vnode on the paging chain,
  * and mark it IN_PAGING.
+ *
  * If checkfirst != 0, don't check all the pages but return at the
  * first dirty page.
  */
 static int
 check_dirty(struct lfs *fs, struct vnode *vp,
 	    off_t startoffset, off_t endoffset, off_t blkeof,
 	    int flags, int checkfirst, struct vm_page **pgp)
+{
 	int by_list;
 	struct vm_page *curpg = NULL; /* XXX: gcc */
 	struct vm_page *pgs[MAXBSIZE / PAGE_SIZE], *pg;
 	off_t soff = 0; /* XXX: gcc */
 	voff_t off;
 	int i;
 	int nonexistent;
 	int any_dirty;	/* number of dirty pages */
 	int dirty;	/* number of dirty pages in a block */
 	int tdirty;
 	int pages_per_block = lfs_sb_getbsize(fs) >> PAGE_SHIFT;
 	int pagedaemon = (curlwp == uvm.pagedaemon_lwp);
 	KASSERT(mutex_owned(vp->v_interlock));
 	ASSERT_MAYBE_SEGLOCK(fs);
   top:
 	by_list = (vp->v_uobj.uo_npages <=
 		   ((endoffset - startoffset) >> PAGE_SHIFT) *
 		   UVM_PAGE_TREE_PENALTY);
 	any_dirty = 0;
 	if (by_list) {
 		curpg = TAILQ_FIRST(&vp->v_uobj.memq);
 	} else {
 		soff = startoffset;
+	}
 	while (by_list || soff < MIN(blkeof, endoffset)) {
 		if (by_list) {
 			/*
 			 * Find the first page in a block.  Skip
 			 * blocks outside our area of interest or beyond
 			 * the end of file.
 			 */
 			KASSERT(curpg == NULL
 			    || (curpg->flags & PG_MARKER) == 0);
 			if (pages_per_block > 1) {
 				while (curpg &&
 				    ((curpg->offset & lfs_sb_getbmask(fs)) ||
 				    curpg->offset >= vp->v_size ||
 				    curpg->offset >= endoffset)) {
 					curpg = TAILQ_NEXT(curpg, listq.queue);
 					KASSERT(curpg == NULL ||
 					    (curpg->flags & PG_MARKER) == 0);
+				}
+			}
 			if (curpg == NULL)
 				break;
 			soff = curpg->offset;
+		}
 		/*
 		 * Mark all pages in extended range busy; find out if any
 		 * of them are dirty.
 		 */
 		nonexistent = dirty = 0;
 		for (i = 0; i == 0 || i < pages_per_block; i++) {
 			KASSERT(mutex_owned(vp->v_interlock));
 			if (by_list && pages_per_block <= 1) {
 				pgs[i] = pg = curpg;
 			} else {
 				off = soff + (i << PAGE_SHIFT);
 				pgs[i] = pg = uvm_pagelookup(&vp->v_uobj, off);
 				if (pg == NULL) {
 					++nonexistent;
 					continue;
+				}
+			}
 			KASSERT(pg != NULL);
 			/*
 			 * If we're holding the segment lock, we can deadlock
 			 * against a process that has our page and is waiting
 			 * for the cleaner, while the cleaner waits for the
 			 * segment lock.  Just bail in that case.
 			 */
 			if ((pg->flags & PG_BUSY) &&
 			    (pagedaemon || LFS_SEGLOCK_HELD(fs))) {
 				if (i > 0)
 					uvm_page_unbusy(pgs, i);
 				DLOG((DLOG_PAGE, "lfs_putpages: avoiding 3-way or pagedaemon deadlock\n"));
 				if (pgp)
 					*pgp = pg;
 				KASSERT(mutex_owned(vp->v_interlock));
 				return -1;
+			}
 			while (pg->flags & PG_BUSY) {
 				wait_for_page(vp, pg, NULL);
 				KASSERT(mutex_owned(vp->v_interlock));
 				if (i > 0)
 					uvm_page_unbusy(pgs, i);
 				KASSERT(mutex_owned(vp->v_interlock));
 				goto top;
+			}
 			pg->flags |= PG_BUSY;
 			UVM_PAGE_OWN(pg, "lfs_putpages");
 			pmap_page_protect(pg, VM_PROT_NONE);
 			tdirty = (pmap_clear_modify(pg) ||
 				  (pg->flags & PG_CLEAN) == 0);
 			dirty += tdirty;
+		}
 		if (pages_per_block > 0 && nonexistent >= pages_per_block) {
 			if (by_list) {
 				curpg = TAILQ_NEXT(curpg, listq.queue);
 			} else {
 				soff += lfs_sb_getbsize(fs);
+			}
 			continue;
+		}
 		any_dirty += dirty;
 		KASSERT(nonexistent == 0);
 		KASSERT(mutex_owned(vp->v_interlock));
 		/*
 		 * If any are dirty make all dirty; unbusy them,
 		 * but if we were asked to clean, wire them so that
 		 * the pagedaemon doesn't bother us about them while
 		 * they're on their way to disk.
 		 */
 		for (i = 0; i == 0 || i < pages_per_block; i++) {
 			KASSERT(mutex_owned(vp->v_interlock));
 			pg = pgs[i];
 			KASSERT(!((pg->flags & PG_CLEAN) && (pg->flags & PG_DELWRI)));
 			KASSERT(pg->flags & PG_BUSY);
 			if (dirty) {
 				pg->flags &= ~PG_CLEAN;
 				if (flags & PGO_FREE) {
 					/*
 					 * Wire the page so that
 					 * pdaemon doesn't see it again.
 					 */
 					mutex_enter(&uvm_pageqlock);
 					uvm_pagewire(pg);
 					mutex_exit(&uvm_pageqlock);
 					/* Suspended write flag */
 					pg->flags |= PG_DELWRI;
+				}
+			}
 			if (pg->flags & PG_WANTED)
 				wakeup(pg);
 			pg->flags &= ~(PG_WANTED|PG_BUSY);
 			UVM_PAGE_OWN(pg, NULL);
+		}
 		if (checkfirst && any_dirty)
 			break;
 		if (by_list) {
 			curpg = TAILQ_NEXT(curpg, listq.queue);
 		} else {
 			soff += MAX(PAGE_SIZE, lfs_sb_getbsize(fs));
+		}
+	}
 	KASSERT(mutex_owned(vp->v_interlock));
 	return any_dirty;
+}
 /*
  * lfs_putpages functions like genfs_putpages except that
+ *
  * (1) It needs to bounds-check the incoming requests to ensure that
  *     they are block-aligned; if they are not, expand the range and
  *     do the right thing in case, e.g., the requested range is clean
  *     but the expanded range is dirty.
+ *
  * (2) It needs to explicitly send blocks to be written when it is done.
  *     If VOP_PUTPAGES is called without the seglock held, we simply take
  *     the seglock and let lfs_segunlock wait for us.
  *     XXX There might be a bad situation if we have to flush a vnode while
  *     XXX lfs_markv is in operation.  As of this writing we panic in this
  *     XXX case.
+ *
  * Assumptions:
+ *
  * (1) The caller does not hold any pages in this vnode busy.  If it does,
  *     there is a danger that when we expand the page range and busy the
  *     pages we will deadlock.
+ *
  * (2) We are called with vp->v_interlock held; we must return with it
  *     released.
+ *
  * (3) We don't absolutely have to free pages right away, provided that
  *     the request does not have PGO_SYNCIO.  When the pagedaemon gives
  *     us a request with PGO_FREE, we take the pages out of the paging
  *     queue and wake up the writer, which will handle freeing them for us.
+ *
  *     We ensure that for any filesystem block, all pages for that
  *     block are either resident or not, even if those pages are higher
  *     than EOF; that means that we will be getting requests to free
  *     "unused" pages above EOF all the time, and should ignore them.
+ *
  * (4) If we are called with PGO_LOCKED, the finfo array we are to write
  *     into has been set up for us by lfs_writefile.  If not, we will
  *     have to handle allocating and/or freeing an finfo entry.
+ *
  * XXX note that we're (ab)using PGO_LOCKED as "seglock held".
  */
 /* How many times to loop before we should start to worry */
 #define TOOMANY 4
 int
 lfs_putpages(void *v)
+{
 	int error;
 	struct vop_putpages_args /* {
 		struct vnode *a_vp;
 		voff_t a_offlo;
 		voff_t a_offhi;
 		int a_flags;
 	} */ *ap = v;
 	struct vnode *vp;
 	struct inode *ip;
 	struct lfs *fs;
 	struct segment *sp;
 	off_t origoffset, startoffset, endoffset, origendoffset, blkeof;
 	off_t off, max_endoffset;
 	bool seglocked, sync, pagedaemon, reclaim;
 	struct vm_page *pg, *busypg;
 	UVMHIST_FUNC("lfs_putpages"); UVMHIST_CALLED(ubchist);
 	int oreclaim = 0;
 	int donewriting = 0;
 #ifdef DEBUG
 	int debug_n_again, debug_n_dirtyclean;
 #endif
 	vp = ap->a_vp;
 	ip = VTOI(vp);
 	fs = ip->i_lfs;
 	sync = (ap->a_flags & PGO_SYNCIO) != 0;
 	reclaim = (ap->a_flags & PGO_RECLAIM) != 0;
 	pagedaemon = (curlwp == uvm.pagedaemon_lwp);
 	KASSERT(mutex_owned(vp->v_interlock));
 	/* Putpages does nothing for metadata. */
 	if (vp == fs->lfs_ivnode || vp->v_type != VREG) {
 		mutex_exit(vp->v_interlock);
 		return 0;
+	}
 	/*
 	 * If there are no pages, don't do anything.
 	 */
 	if (vp->v_uobj.uo_npages == 0) {
 		if (TAILQ_EMPTY(&vp->v_uobj.memq) &&
 		    (vp->v_iflag & VI_ONWORKLST) &&
 		    LIST_FIRST(&vp->v_dirtyblkhd) == NULL) {
 			vp->v_iflag &= ~VI_WRMAPDIRTY;
 			vn_syncer_remove_from_worklist(vp);
+		}
 		mutex_exit(vp->v_interlock);
 		/* Remove us from paging queue, if we were on it */
 		mutex_enter(&lfs_lock);
 		if (ip->i_flags & IN_PAGING) {
 			ip->i_flags &= ~IN_PAGING;
 			TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);
+		}
 		mutex_exit(&lfs_lock);
 		KASSERT(!mutex_owned(vp->v_interlock));
 		return 0;
+	}
 	blkeof = lfs_blkroundup(fs, ip->i_size);
 	/*
 	 * Ignore requests to free pages past EOF but in the same block
 	 * as EOF, unless the vnode is being reclaimed or the request
 	 * is synchronous.  (If the request is sync, it comes from
 	 * lfs_truncate.)
+	 *
 	 * To avoid being flooded with this request, make these pages
 	 * look "active".
 	 */
 	if (!sync && !reclaim &&
 	    ap->a_offlo >= ip->i_size && ap->a_offlo < blkeof) {
 		origoffset = ap->a_offlo;
 		for (off = origoffset; off < blkeof; off += lfs_sb_getbsize(fs)) {
 			pg = uvm_pagelookup(&vp->v_uobj, off);
 			KASSERT(pg != NULL);
 			while (pg->flags & PG_BUSY) {
 				pg->flags |= PG_WANTED;
 				UVM_UNLOCK_AND_WAIT(pg, vp->v_interlock, 0,
 						    "lfsput2", 0);
 				mutex_enter(vp->v_interlock);
+			}
 			mutex_enter(&uvm_pageqlock);
 			uvm_pageactivate(pg);
 			mutex_exit(&uvm_pageqlock);
+		}
 		ap->a_offlo = blkeof;
 		if (ap->a_offhi > 0 && ap->a_offhi <= ap->a_offlo) {
 			mutex_exit(vp->v_interlock);
 			return 0;
+		}
+	}
 	/*
 	 * Extend page range to start and end at block boundaries.
 	 * (For the purposes of VOP_PUTPAGES, fragments don't exist.)
 	 */
 	origoffset = ap->a_offlo;
 	origendoffset = ap->a_offhi;
 	startoffset = origoffset & ~(lfs_sb_getbmask(fs));
 	max_endoffset = (trunc_page(LLONG_MAX) >> lfs_sb_getbshift(fs))
 					       << lfs_sb_getbshift(fs);
 	if (origendoffset == 0 || ap->a_flags & PGO_ALLPAGES) {
 		endoffset = max_endoffset;
 		origendoffset = endoffset;
 	} else {
 		origendoffset = round_page(ap->a_offhi);
 		endoffset = round_page(lfs_blkroundup(fs, origendoffset));
+	}
 	KASSERT(startoffset > 0 || endoffset >= startoffset);
 	if (startoffset == endoffset) {
 		/* Nothing to do, why were we called? */
 		mutex_exit(vp->v_interlock);
 		DLOG((DLOG_PAGE, "lfs_putpages: startoffset = endoffset = %"
 		      PRId64 "\n", startoffset));
 		return 0;
+	}
 	ap->a_offlo = startoffset;
 	ap->a_offhi = endoffset;
 	/*
 	 * If not cleaning, just send the pages through genfs_putpages
 	 * to be returned to the pool.
 	 */
 	if (!(ap->a_flags & PGO_CLEANIT)) {
 		DLOG((DLOG_PAGE, "lfs_putpages: no cleanit vn %p ino %d (flags %x)\n",
 		      vp, (int)ip->i_number, ap->a_flags));
 		int r = genfs_putpages(v);
 		KASSERT(!mutex_owned(vp->v_interlock));
 		return r;
+	}
 	/* Set PGO_BUSYFAIL to avoid deadlocks */
 	ap->a_flags |= PGO_BUSYFAIL;
 	/*
 	 * Likewise, if we are asked to clean but the pages are not
 	 * dirty, we can just free them using genfs_putpages.
 	 */
 #ifdef DEBUG
 	debug_n_dirtyclean = 0;
 #endif
 	do {
 		int r;
 		KASSERT(mutex_owned(vp->v_interlock));
 		/* Count the number of dirty pages */
 		r = check_dirty(fs, vp, startoffset, endoffset, blkeof,
 				ap->a_flags, 1, NULL);
 		if (r < 0) {
 			/* Pages are busy with another process */
 			mutex_exit(vp->v_interlock);
 			return EDEADLK;
+		}
 		if (r > 0) /* Some pages are dirty */
 			break;
 		/*
 		 * Sometimes pages are dirtied between the time that
 		 * we check and the time we try to clean them.
 		 * Instruct lfs_gop_write to return EDEADLK in this case
 		 * so we can write them properly.
 		 */
 		ip->i_lfs_iflags |= LFSI_NO_GOP_WRITE;
 		r = genfs_do_putpages(vp, startoffset, endoffset,
 				       ap->a_flags & ~PGO_SYNCIO, &busypg);
 		ip->i_lfs_iflags &= ~LFSI_NO_GOP_WRITE;
 		if (r != EDEADLK) {
 			KASSERT(!mutex_owned(vp->v_interlock));
  			return r;
+		}
 		/* One of the pages was busy.  Start over. */
 		mutex_enter(vp->v_interlock);
 		wait_for_page(vp, busypg, "dirtyclean");
 #ifdef DEBUG
 		++debug_n_dirtyclean;
 #endif
 	} while(1);
 #ifdef DEBUG
 	if (debug_n_dirtyclean > TOOMANY)
 		DLOG((DLOG_PAGE, "lfs_putpages: dirtyclean: looping, n = %d\n",
 		      debug_n_dirtyclean));
 #endif
 	/*
 	 * Dirty and asked to clean.
+	 *
 	 * Pagedaemon can't actually write LFS pages; wake up
 	 * the writer to take care of that.  The writer will
 	 * notice the pager inode queue and act on that.
+	 *
 	 * XXX We must drop the vp->interlock before taking the lfs_lock or we
 	 * get a nasty deadlock with lfs_flush_pchain().
 	 */
 	if (pagedaemon) {
 		mutex_exit(vp->v_interlock);
 		mutex_enter(&lfs_lock);
 		if (!(ip->i_flags & IN_PAGING)) {
 			ip->i_flags |= IN_PAGING;
 			TAILQ_INSERT_TAIL(&fs->lfs_pchainhd, ip, i_lfs_pchain);
+		}
 		wakeup(&lfs_writer_daemon);
 		mutex_exit(&lfs_lock);
 		preempt();
 		KASSERT(!mutex_owned(vp->v_interlock));
 		return EWOULDBLOCK;
+	}
 	/*
 	 * If this is a file created in a recent dirop, we can't flush its
 	 * inode until the dirop is complete.  Drain dirops, then flush the
 	 * filesystem (taking care of any other pending dirops while we're
 	 * at it).
 	 */
 	if ((ap->a_flags & (PGO_CLEANIT|PGO_LOCKED)) == PGO_CLEANIT &&
 	    (vp->v_uflag & VU_DIROP)) {
 		DLOG((DLOG_PAGE, "lfs_putpages: flushing VU_DIROP\n"));
  		lfs_writer_enter(fs, "ppdirop");
 		/* Note if we hold the vnode locked */
 		if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE)
+		{
 		    DLOG((DLOG_PAGE, "lfs_putpages: dirop inode already locked\n"));
 		} else {
 		    DLOG((DLOG_PAGE, "lfs_putpages: dirop inode not locked\n"));
+		}
 		mutex_exit(vp->v_interlock);
 		mutex_enter(&lfs_lock);
 		lfs_flush_fs(fs, sync ? SEGM_SYNC : 0);
 		mutex_exit(&lfs_lock);
 		mutex_enter(vp->v_interlock);
 		lfs_writer_leave(fs);
 		/* The flush will have cleaned out this vnode as well,
 		   no need to do more to it. */
+	}
 	/*
 	 * This is it.	We are going to write some pages.  From here on
 	 * down it's all just mechanics.
+	 *
 	 * Don't let genfs_putpages wait; lfs_segunlock will wait for us.
 	 */
 	ap->a_flags &= ~PGO_SYNCIO;
 	/*
 	 * If we've already got the seglock, flush the node and return.
 	 * The FIP has already been set up for us by lfs_writefile,
 	 * and FIP cleanup and lfs_updatemeta will also be done there,
 	 * unless genfs_putpages returns EDEADLK; then we must flush
 	 * what we have, and correct FIP and segment header accounting.
 	 */
   get_seglock:
 	/*
 	 * If we are not called with the segment locked, lock it.
 	 * Account for a new FIP in the segment header, and set sp->vp.
 	 * (This should duplicate the setup at the top of lfs_writefile().)
 	 */
 	seglocked = (ap->a_flags & PGO_LOCKED) != 0;
 	if (!seglocked) {
 		mutex_exit(vp->v_interlock);
 		error = lfs_seglock(fs, SEGM_PROT | (sync ? SEGM_SYNC : 0));
 		if (error != 0) {
 			KASSERT(!mutex_owned(vp->v_interlock));
  			return error;
+		}
 		mutex_enter(vp->v_interlock);
 		lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);
+	}
 	sp = fs->lfs_sp;
 	KASSERT(sp->vp == NULL);
 	sp->vp = vp;
 	/* Note segments written by reclaim; only for debugging */
 	if (vdead_check(vp, VDEAD_NOWAIT) != 0) {
 		sp->seg_flags |= SEGM_RECLAIM;
 		fs->lfs_reclino = ip->i_number;
+	}
 	/*
 	 * Ensure that the partial segment is marked SS_DIROP if this
 	 * vnode is a DIROP.
 	 */
 	if (!seglocked && vp->v_uflag & VU_DIROP)
 		((SEGSUM *)(sp->segsum))->ss_flags |= (SS_DIROP|SS_CONT);
 	/*
 	 * Loop over genfs_putpages until all pages are gathered.
 	 * genfs_putpages() drops the interlock, so reacquire it if necessary.
 	 * Whenever we lose the interlock we have to rerun check_dirty, as
 	 * well, since more pages might have been dirtied in our absence.
 	 */
 #ifdef DEBUG
 	debug_n_again = 0;
 #endif
 	do {
 		busypg = NULL;
 		KASSERT(mutex_owned(vp->v_interlock));
 		if (check_dirty(fs, vp, startoffset, endoffset, blkeof,
 				ap->a_flags, 0, &busypg) < 0) {
 			mutex_exit(vp->v_interlock);
 			/* XXX why? --ks */
 			mutex_enter(vp->v_interlock);
 			write_and_wait(fs, vp, busypg, seglocked, NULL);
 			if (!seglocked) {
 				mutex_exit(vp->v_interlock);
 				lfs_release_finfo(fs);
 				lfs_segunlock(fs);
 				mutex_enter(vp->v_interlock);
+			}
 			sp->vp = NULL;
 			goto get_seglock;
+		}
 		busypg = NULL;
 		KASSERT(!mutex_owned(&uvm_pageqlock));
 		oreclaim = (ap->a_flags & PGO_RECLAIM);
 		ap->a_flags &= ~PGO_RECLAIM;
 		error = genfs_do_putpages(vp, startoffset, endoffset,
 					   ap->a_flags, &busypg);
 		ap->a_flags |= oreclaim;
 		if (error == EDEADLK || error == EAGAIN) {
 			DLOG((DLOG_PAGE, "lfs_putpages: genfs_putpages returned"
 			      " %d ino %d off %x (seg %d)\n", error,
-			      ip->i_number, fs->lfs_offset,
+			      ip->i_number, lfs_sb_getoffset(fs),
-			      lfs_dtosn(fs, fs->lfs_offset)));
+			      lfs_dtosn(fs, lfs_sb_getoffset(fs))));
 			if (oreclaim) {
 				mutex_enter(vp->v_interlock);
 				write_and_wait(fs, vp, busypg, seglocked, "again");
 				mutex_exit(vp->v_interlock);
 			} else {
 				if ((sp->seg_flags & SEGM_SINGLE) &&
 				    lfs_sb_getcurseg(fs) != fs->lfs_startseg)
 					donewriting = 1;
+			}
 		} else if (error) {
 			DLOG((DLOG_PAGE, "lfs_putpages: genfs_putpages returned"
 			      " %d ino %d off %x (seg %d)\n", error,
-			      (int)ip->i_number, fs->lfs_offset,
+			      (int)ip->i_number, lfs_sb_getoffset(fs),
-			      lfs_dtosn(fs, fs->lfs_offset)));
+			      lfs_dtosn(fs, lfs_sb_getoffset(fs))));
+		}
 		/* genfs_do_putpages loses the interlock */
 #ifdef DEBUG
 		++debug_n_again;
 #endif
 		if (oreclaim && error == EAGAIN) {
 			DLOG((DLOG_PAGE, "vp %p ino %d vi_flags %x a_flags %x avoiding vclean panic\n",
 			      vp, (int)ip->i_number, vp->v_iflag, ap->a_flags));
 			mutex_enter(vp->v_interlock);
+		}
 		if (error == EDEADLK)
 			mutex_enter(vp->v_interlock);
 	} while (error == EDEADLK || (oreclaim && error == EAGAIN));
 #ifdef DEBUG
 	if (debug_n_again > TOOMANY)
 		DLOG((DLOG_PAGE, "lfs_putpages: again: looping, n = %d\n", debug_n_again));
 #endif
 	KASSERT(sp != NULL && sp->vp == vp);
 	if (!seglocked && !donewriting) {
 		sp->vp = NULL;
 		/* Write indirect blocks as well */
 		lfs_gather(fs, fs->lfs_sp, vp, lfs_match_indir);
 		lfs_gather(fs, fs->lfs_sp, vp, lfs_match_dindir);
 		lfs_gather(fs, fs->lfs_sp, vp, lfs_match_tindir);
 		KASSERT(sp->vp == NULL);
 		sp->vp = vp;
+	}
 	/*
 	 * Blocks are now gathered into a segment waiting to be written.
 	 * All that's left to do is update metadata, and write them.
 	 */
 	lfs_updatemeta(sp);
 	KASSERT(sp->vp == vp);
 	sp->vp = NULL;
 	/*
 	 * If we were called from lfs_writefile, we don't need to clean up
 	 * the FIP or unlock the segment lock.	We're done.
 	 */
 	if (seglocked) {
 		KASSERT(!mutex_owned(vp->v_interlock));
 		return error;
+	}
 	/* Clean up FIP and send it to disk. */
 	lfs_release_finfo(fs);
 	lfs_writeseg(fs, fs->lfs_sp);
 	/*
 	 * Remove us from paging queue if we wrote all our pages.
 	 */
 	if (origendoffset == 0 || ap->a_flags & PGO_ALLPAGES) {
 		mutex_enter(&lfs_lock);
 		if (ip->i_flags & IN_PAGING) {
 			ip->i_flags &= ~IN_PAGING;
 			TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);
+		}
 		mutex_exit(&lfs_lock);
+	}
 	/*
 	 * XXX - with the malloc/copy writeseg, the pages are freed by now
 	 * even if we don't wait (e.g. if we hold a nested lock).  This
 	 * will not be true if we stop using malloc/copy.
 	 */
 	KASSERT(fs->lfs_sp->seg_flags & SEGM_PROT);
 	lfs_segunlock(fs);
 	/*
 	 * Wait for v_numoutput to drop to zero.  The seglock should
 	 * take care of this, but there is a slight possibility that
 	 * aiodoned might not have got around to our buffers yet.
 	 */
 	if (sync) {
 		mutex_enter(vp->v_interlock);
 		while (vp->v_numoutput > 0) {
 			DLOG((DLOG_PAGE, "lfs_putpages: ino %d sleeping on"
 			      " num %d\n", ip->i_number, vp->v_numoutput));
 			cv_wait(&vp->v_cv, vp->v_interlock);
+		}
 		mutex_exit(vp->v_interlock);
+	}
 	KASSERT(!mutex_owned(vp->v_interlock));
 	return error;
+}

 @@ -1,1062 +1,1062 @@
-/*	$NetBSD: lfs_segment.c,v 1.243 2015/07/24 06:59:32 dholland Exp $	*/
+/*	$NetBSD: lfs_segment.c,v 1.244 2015/07/25 10:40:35 martin 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
  * 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) 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.
+ *
  *	@(#)lfs_segment.c	8.10 (Berkeley) 6/10/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_segment.c,v 1.243 2015/07/24 06:59:32 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_segment.c,v 1.244 2015/07/25 10:40:35 martin Exp $");
 #define _VFS_VNODE_PRIVATE	/* XXX: check for VI_MARKER, this has to go */
 #ifdef DEBUG
 # define vndebug(vp, str) do {						\
 	if (VTOI(vp)->i_flag & IN_CLEANING)				\
 		DLOG((DLOG_WVNODE, "not writing ino %d because %s (op %d)\n", \
 		     VTOI(vp)->i_number, (str), op));			\
 } while(0)
 #else
 # define vndebug(vp, str)
 #endif
 #define ivndebug(vp, str) \
 	DLOG((DLOG_WVNODE, "ino %d: %s\n", VTOI(vp)->i_number, (str)))
 #if defined(_KERNEL_OPT)
 #include "opt_ddb.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/kernel.h>
 #include <sys/resourcevar.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/buf.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/kauth.h>
 #include <sys/syslog.h>
 #include <miscfs/specfs/specdev.h>
 #include <miscfs/fifofs/fifo.h>
 #include <ufs/lfs/ulfs_inode.h>
 #include <ufs/lfs/ulfsmount.h>
 #include <ufs/lfs/ulfs_extern.h>
 #include <ufs/lfs/lfs.h>
 #include <ufs/lfs/lfs_kernel.h>
 #include <ufs/lfs/lfs_extern.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_extern.h>
 MALLOC_JUSTDEFINE(M_SEGMENT, "LFS segment", "Segment for LFS");
 static void lfs_generic_callback(struct buf *, void (*)(struct buf *));
 static void lfs_free_aiodone(struct buf *);
 static void lfs_super_aiodone(struct buf *);
 static void lfs_cluster_aiodone(struct buf *);
 static void lfs_cluster_callback(struct buf *);
 /*
  * Determine if it's OK to start a partial in this segment, or if we need
  * to go on to a new segment.
  */
 #define	LFS_PARTIAL_FITS(fs) \
 	(lfs_sb_getfsbpseg(fs) - \
 	    (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)) > \
 	lfs_sb_getfrag(fs))
 /*
  * Figure out whether we should do a checkpoint write or go ahead with
  * an ordinary write.
  */
 #define LFS_SHOULD_CHECKPOINT(fs, flags) \
         ((flags & SEGM_CLEAN) == 0 &&					\
 	  ((fs->lfs_nactive > LFS_MAX_ACTIVE ||				\
 	    (flags & SEGM_CKP) ||					\
 	    lfs_sb_getnclean(fs) < LFS_MAX_ACTIVE)))
 int	 lfs_match_fake(struct lfs *, struct buf *);
 void	 lfs_newseg(struct lfs *);
 /* XXX ondisk32 */
 void	 lfs_shellsort(struct buf **, int32_t *, int, int);
 void	 lfs_supercallback(struct buf *);
 void	 lfs_updatemeta(struct segment *);
 void	 lfs_writesuper(struct lfs *, daddr_t);
 int	 lfs_writevnodes(struct lfs *fs, struct mount *mp,
 	    struct segment *sp, int dirops);
 int	lfs_allclean_wakeup;		/* Cleaner wakeup address. */
 int	lfs_writeindir = 1;		/* whether to flush indir on non-ckp */
 int	lfs_clean_vnhead = 0;		/* Allow freeing to head of vn list */
 int	lfs_dirvcount = 0;		/* # active dirops */
 /* Statistics Counters */
 int lfs_dostats = 1;
 struct lfs_stats lfs_stats;
 /* op values to lfs_writevnodes */
 #define	VN_REG		0
 #define	VN_DIROP	1
 #define	VN_EMPTY	2
 #define VN_CLEAN	3
 /*
  * XXX KS - Set modification time on the Ifile, so the cleaner can
  * read the fs mod time off of it.  We don't set IN_UPDATE here,
  * since we don't really need this to be flushed to disk (and in any
  * case that wouldn't happen to the Ifile until we checkpoint).
  */
 void
 lfs_imtime(struct lfs *fs)
+{
 	struct timespec ts;
 	struct inode *ip;
 	ASSERT_MAYBE_SEGLOCK(fs);
 	vfs_timestamp(&ts);
 	ip = VTOI(fs->lfs_ivnode);
 	ip->i_ffs1_mtime = ts.tv_sec;
 	ip->i_ffs1_mtimensec = ts.tv_nsec;
+}
 /*
  * Ifile and meta data blocks are not marked busy, so segment writes MUST be
  * single threaded.  Currently, there are two paths into lfs_segwrite, sync()
  * and getnewbuf().  They both mark the file system busy.  Lfs_vflush()
  * explicitly marks the file system busy.  So lfs_segwrite is safe.  I think.
  */
 #define IS_FLUSHING(fs,vp)  ((fs)->lfs_flushvp == (vp))
 int
 lfs_vflush(struct vnode *vp)
+{
 	struct inode *ip;
 	struct lfs *fs;
 	struct segment *sp;
 	struct buf *bp, *nbp, *tbp, *tnbp;
 	int error;
 	int flushed;
 	int relock;
 	ip = VTOI(vp);
 	fs = VFSTOULFS(vp->v_mount)->um_lfs;
 	relock = 0;
     top:
 	KASSERT(mutex_owned(vp->v_interlock) == false);
 	KASSERT(mutex_owned(&lfs_lock) == false);
 	KASSERT(mutex_owned(&bufcache_lock) == false);
 	ASSERT_NO_SEGLOCK(fs);
 	if (ip->i_flag & IN_CLEANING) {
 		ivndebug(vp,"vflush/in_cleaning");
 		mutex_enter(&lfs_lock);
 		LFS_CLR_UINO(ip, IN_CLEANING);
 		LFS_SET_UINO(ip, IN_MODIFIED);
 		mutex_exit(&lfs_lock);
 		/*
 		 * Toss any cleaning buffers that have real counterparts
 		 * to avoid losing new data.
 		 */
 		mutex_enter(vp->v_interlock);
 		for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
 			nbp = LIST_NEXT(bp, b_vnbufs);
 			if (!LFS_IS_MALLOC_BUF(bp))
 				continue;
 			/*
 			 * Look for pages matching the range covered
 			 * by cleaning blocks.  It's okay if more dirty
 			 * pages appear, so long as none disappear out
 			 * from under us.
 			 */
 			if (bp->b_lblkno > 0 && vp->v_type == VREG &&
 			    vp != fs->lfs_ivnode) {
 				struct vm_page *pg;
 				voff_t off;
 				for (off = lfs_lblktosize(fs, bp->b_lblkno);
 				     off < lfs_lblktosize(fs, bp->b_lblkno + 1);
 				     off += PAGE_SIZE) {
 					pg = uvm_pagelookup(&vp->v_uobj, off);
 					if (pg == NULL)
 						continue;
 					if ((pg->flags & PG_CLEAN) == 0 ||
 					    pmap_is_modified(pg)) {
 						lfs_sb_addavail(fs,
 							lfs_btofsb(fs,
 								bp->b_bcount));
 						wakeup(&fs->lfs_availsleep);
 						mutex_exit(vp->v_interlock);
 						lfs_freebuf(fs, bp);
 						mutex_enter(vp->v_interlock);
 						bp = NULL;
 						break;
+					}
+				}
+			}
 			for (tbp = LIST_FIRST(&vp->v_dirtyblkhd); tbp;
 			    tbp = tnbp)
+			{
 				tnbp = LIST_NEXT(tbp, b_vnbufs);
 				if (tbp->b_vp == bp->b_vp
 				   && tbp->b_lblkno == bp->b_lblkno
 				   && tbp != bp)
+				{
 					lfs_sb_addavail(fs, lfs_btofsb(fs,
 						bp->b_bcount));
 					wakeup(&fs->lfs_availsleep);
 					mutex_exit(vp->v_interlock);
 					lfs_freebuf(fs, bp);
 					mutex_enter(vp->v_interlock);
 					bp = NULL;
 					break;
+				}
+			}
+		}
 	} else {
 		mutex_enter(vp->v_interlock);
+	}
 	/* If the node is being written, wait until that is done */
 	while (WRITEINPROG(vp)) {
 		ivndebug(vp,"vflush/writeinprog");
 		cv_wait(&vp->v_cv, vp->v_interlock);
+	}
 	error = vdead_check(vp, VDEAD_NOWAIT);
 	mutex_exit(vp->v_interlock);
 	/* Protect against deadlock in vinvalbuf() */
 	lfs_seglock(fs, SEGM_SYNC | ((error != 0) ? SEGM_RECLAIM : 0));
 	if (error != 0) {
 		fs->lfs_reclino = ip->i_number;
+	}
 	/* If we're supposed to flush a freed inode, just toss it */
 	if (ip->i_lfs_iflags & LFSI_DELETED) {
 		DLOG((DLOG_VNODE, "lfs_vflush: ino %d freed, not flushing\n",
 		      ip->i_number));
 		/* Drain v_numoutput */
 		mutex_enter(vp->v_interlock);
 		while (vp->v_numoutput > 0) {
 			cv_wait(&vp->v_cv, vp->v_interlock);
+		}
 		KASSERT(vp->v_numoutput == 0);
 		mutex_exit(vp->v_interlock);
 		mutex_enter(&bufcache_lock);
 		for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
 			nbp = LIST_NEXT(bp, b_vnbufs);
 			KASSERT((bp->b_flags & B_GATHERED) == 0);
 			if (bp->b_oflags & BO_DELWRI) { /* XXX always true? */
 				lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));
 				wakeup(&fs->lfs_availsleep);
+			}
 			/* Copied from lfs_writeseg */
 			if (bp->b_iodone != NULL) {
 				mutex_exit(&bufcache_lock);
 				biodone(bp);
 				mutex_enter(&bufcache_lock);
 			} else {
 				bremfree(bp);
 				LFS_UNLOCK_BUF(bp);
 				mutex_enter(vp->v_interlock);
 				bp->b_flags &= ~(B_READ | B_GATHERED);
 				bp->b_oflags = (bp->b_oflags & ~BO_DELWRI) | BO_DONE;
 				bp->b_error = 0;
 				reassignbuf(bp, vp);
 				mutex_exit(vp->v_interlock);
 				brelse(bp, 0);
+			}
+		}
 		mutex_exit(&bufcache_lock);
 		LFS_CLR_UINO(ip, IN_CLEANING);
 		LFS_CLR_UINO(ip, IN_MODIFIED | IN_ACCESSED);
 		ip->i_flag &= ~IN_ALLMOD;
 		DLOG((DLOG_VNODE, "lfs_vflush: done not flushing ino %d\n",
 		      ip->i_number));
 		lfs_segunlock(fs);
 		KASSERT(LIST_FIRST(&vp->v_dirtyblkhd) == NULL);
 		return 0;
+	}
 	fs->lfs_flushvp = vp;
 	if (LFS_SHOULD_CHECKPOINT(fs, fs->lfs_sp->seg_flags)) {
 		error = lfs_segwrite(vp->v_mount, SEGM_CKP | SEGM_SYNC);
 		fs->lfs_flushvp = NULL;
 		KASSERT(fs->lfs_flushvp_fakevref == 0);
 		lfs_segunlock(fs);
 		/* Make sure that any pending buffers get written */
 		mutex_enter(vp->v_interlock);
 		while (vp->v_numoutput > 0) {
 			cv_wait(&vp->v_cv, vp->v_interlock);
+		}
 		KASSERT(LIST_FIRST(&vp->v_dirtyblkhd) == NULL);
 		KASSERT(vp->v_numoutput == 0);
 		mutex_exit(vp->v_interlock);
 		return error;
+	}
 	sp = fs->lfs_sp;
 	flushed = 0;
 	if (VPISEMPTY(vp)) {
 		lfs_writevnodes(fs, vp->v_mount, sp, VN_EMPTY);
 		++flushed;
 	} else if ((ip->i_flag & IN_CLEANING) &&
 		  (fs->lfs_sp->seg_flags & SEGM_CLEAN)) {
 		ivndebug(vp,"vflush/clean");
 		lfs_writevnodes(fs, vp->v_mount, sp, VN_CLEAN);
 		++flushed;
 	} else if (lfs_dostats) {
 		if (!VPISEMPTY(vp) || (VTOI(vp)->i_flag & IN_ALLMOD))
 			++lfs_stats.vflush_invoked;
 		ivndebug(vp,"vflush");
+	}
 #ifdef DIAGNOSTIC
 	if (vp->v_uflag & VU_DIROP) {
 		DLOG((DLOG_VNODE, "lfs_vflush: flushing VU_DIROP\n"));
 		/* panic("lfs_vflush: VU_DIROP being flushed...this can\'t happen"); */
+	}
 #endif
 	do {
 #ifdef DEBUG
 		int loopcount = 0;
 #endif
 		do {
 			if (LIST_FIRST(&vp->v_dirtyblkhd) != NULL) {
 				relock = lfs_writefile(fs, sp, vp);
 				if (relock && vp != fs->lfs_ivnode) {
 					/*
 					 * Might have to wait for the
 					 * cleaner to run; but we're
 					 * still not done with this vnode.
 					 * XXX we can do better than this.
 					 */
 					KDASSERT(ip->i_number != LFS_IFILE_INUM);
 					lfs_writeinode(fs, sp, ip);
 					mutex_enter(&lfs_lock);
 					LFS_SET_UINO(ip, IN_MODIFIED);
 					mutex_exit(&lfs_lock);
 					lfs_writeseg(fs, sp);
 					lfs_segunlock(fs);
 					lfs_segunlock_relock(fs);
 					goto top;
+				}
+			}
 			/*
 			 * If we begin a new segment in the middle of writing
 			 * the Ifile, it creates an inconsistent checkpoint,
 			 * since the Ifile information for the new segment
 			 * is not up-to-date.  Take care of this here by
 			 * sending the Ifile through again in case there
 			 * are newly dirtied blocks.  But wait, there's more!
 			 * This second Ifile write could *also* cross a segment
 			 * boundary, if the first one was large.  The second
 			 * one is guaranteed to be no more than 8 blocks,
 			 * though (two segment blocks and supporting indirects)
 			 * so the third write *will not* cross the boundary.
 			 */
 			if (vp == fs->lfs_ivnode) {
 				lfs_writefile(fs, sp, vp);
 				lfs_writefile(fs, sp, vp);
+			}
 #ifdef DEBUG
 			if (++loopcount > 2)
 				log(LOG_NOTICE, "lfs_vflush: looping count=%d\n", loopcount);
 #endif
 		} while (lfs_writeinode(fs, sp, ip));
 	} while (lfs_writeseg(fs, sp) && ip->i_number == LFS_IFILE_INUM);
 	if (lfs_dostats) {
 		++lfs_stats.nwrites;
 		if (sp->seg_flags & SEGM_SYNC)
 			++lfs_stats.nsync_writes;
 		if (sp->seg_flags & SEGM_CKP)
 			++lfs_stats.ncheckpoints;
+	}
 	/*
 	 * If we were called from somewhere that has already held the seglock
 	 * (e.g., lfs_markv()), the lfs_segunlock will not wait for
 	 * the write to complete because we are still locked.
 	 * Since lfs_vflush() must return the vnode with no dirty buffers,
 	 * we must explicitly wait, if that is the case.
+	 *
 	 * We compare the iocount against 1, not 0, because it is
 	 * artificially incremented by lfs_seglock().
 	 */
 	mutex_enter(&lfs_lock);
 	if (fs->lfs_seglock > 1) {
 		while (fs->lfs_iocount > 1)
 			(void)mtsleep(&fs->lfs_iocount, PRIBIO + 1,
 				     "lfs_vflush", 0, &lfs_lock);
+	}
 	mutex_exit(&lfs_lock);
 	lfs_segunlock(fs);
 	/* Wait for these buffers to be recovered by aiodoned */
 	mutex_enter(vp->v_interlock);
 	while (vp->v_numoutput > 0) {
 		cv_wait(&vp->v_cv, vp->v_interlock);
+	}
 	KASSERT(LIST_FIRST(&vp->v_dirtyblkhd) == NULL);
 	KASSERT(vp->v_numoutput == 0);
 	mutex_exit(vp->v_interlock);
 	fs->lfs_flushvp = NULL;
 	KASSERT(fs->lfs_flushvp_fakevref == 0);
 	return (0);
+}
 int
 lfs_writevnodes(struct lfs *fs, struct mount *mp, struct segment *sp, int op)
+{
 	struct inode *ip;
 	struct vnode *vp;
 	int inodes_written = 0;
 	int error = 0;
 	ASSERT_SEGLOCK(fs);
  loop:
 	/* start at last (newest) vnode. */
 	mutex_enter(&mntvnode_lock);
 	TAILQ_FOREACH_REVERSE(vp, &mp->mnt_vnodelist, vnodelst, v_mntvnodes) {
 		/*
 		 * If the vnode that we are about to sync is no longer
 		 * associated with this mount point, start over.
 		 */
 		if (vp->v_mount != mp) {
 			DLOG((DLOG_VNODE, "lfs_writevnodes: starting over\n"));
 			/*
 			 * After this, pages might be busy
 			 * due to our own previous putpages.
 			 * Start actual segment write here to avoid deadlock.
 			 * If we were just writing one segment and we've done
 			 * that, break out.
 			 */
 			mutex_exit(&mntvnode_lock);
 			if (lfs_writeseg(fs, sp) &&
 			    (sp->seg_flags & SEGM_SINGLE) &&
 			    lfs_sb_getcurseg(fs) != fs->lfs_startseg) {
 				DLOG((DLOG_VNODE, "lfs_writevnodes: breaking out of segment write at daddr 0x%jx\n", (uintmax_t)lfs_sb_getoffset(fs)));
 				break;
+			}
 			goto loop;
+		}
 		mutex_enter(vp->v_interlock);
 		if (vp->v_type == VNON || (vp->v_iflag & VI_MARKER) ||
 		    vdead_check(vp, VDEAD_NOWAIT) != 0) {
 			mutex_exit(vp->v_interlock);
 			continue;
+		}
 		ip = VTOI(vp);
 		if ((op == VN_DIROP && !(vp->v_uflag & VU_DIROP)) ||
 		    (op != VN_DIROP && op != VN_CLEAN &&
 		    (vp->v_uflag & VU_DIROP))) {
 			mutex_exit(vp->v_interlock);
 			vndebug(vp,"dirop");
 			continue;
+		}
 		if (op == VN_EMPTY && !VPISEMPTY(vp)) {
 			mutex_exit(vp->v_interlock);
 			vndebug(vp,"empty");
 			continue;
+		}
 		if (op == VN_CLEAN && ip->i_number != LFS_IFILE_INUM
 		   && vp != fs->lfs_flushvp
 		   && !(ip->i_flag & IN_CLEANING)) {
 			mutex_exit(vp->v_interlock);
 			vndebug(vp,"cleaning");
 			continue;
+		}
 		mutex_exit(&mntvnode_lock);
 		if (vget(vp, LK_NOWAIT, false /* !wait */)) {
 			vndebug(vp,"vget");
 			mutex_enter(&mntvnode_lock);
 			continue;
+		}
 		/*
 		 * Write the inode/file if dirty and it's not the IFILE.
 		 */
 		if ((ip->i_flag & IN_ALLMOD) || !VPISEMPTY(vp)) {
 			if (ip->i_number != LFS_IFILE_INUM) {
 				error = lfs_writefile(fs, sp, vp);
 				if (error) {
 					vrele(vp);
 					if (error == EAGAIN) {
 						/*
 						 * This error from lfs_putpages
 						 * indicates we need to drop
 						 * the segment lock and start
 						 * over after the cleaner has
 						 * had a chance to run.
 						 */
 						lfs_writeinode(fs, sp, ip);
 						lfs_writeseg(fs, sp);
 						if (!VPISEMPTY(vp) &&
 						    !WRITEINPROG(vp) &&
 						    !(ip->i_flag & IN_ALLMOD)) {
 							mutex_enter(&lfs_lock);
 							LFS_SET_UINO(ip, IN_MODIFIED);
 							mutex_exit(&lfs_lock);
+						}
 						mutex_enter(&mntvnode_lock);
 						break;
+					}
 					error = 0; /* XXX not quite right */
 					mutex_enter(&mntvnode_lock);
 					continue;
+				}
 				if (!VPISEMPTY(vp)) {
 					if (WRITEINPROG(vp)) {
 						ivndebug(vp,"writevnodes/write2");
 					} else if (!(ip->i_flag & IN_ALLMOD)) {
 						mutex_enter(&lfs_lock);
 						LFS_SET_UINO(ip, IN_MODIFIED);
 						mutex_exit(&lfs_lock);
+					}
+				}
 				(void) lfs_writeinode(fs, sp, ip);
 				inodes_written++;
+			}
+		}
 		vrele(vp);
 		mutex_enter(&mntvnode_lock);
+	}
 	mutex_exit(&mntvnode_lock);
 	return error;
+}
 /*
  * Do a checkpoint.
  */
 int
 lfs_segwrite(struct mount *mp, int flags)
+{
 	struct buf *bp;
 	struct inode *ip;
 	struct lfs *fs;
 	struct segment *sp;
 	struct vnode *vp;
 	SEGUSE *segusep;
 	int do_ckp, did_ckp, error;
 	unsigned n, segleft, maxseg, sn, i, curseg;
 	int writer_set = 0;
 	int dirty;
 	int redo;
 	int um_error;
 	fs = VFSTOULFS(mp)->um_lfs;
 	ASSERT_MAYBE_SEGLOCK(fs);
 	if (fs->lfs_ronly)
 		return EROFS;
 	lfs_imtime(fs);
 	/*
 	 * Allocate a segment structure and enough space to hold pointers to
 	 * the maximum possible number of buffers which can be described in a
 	 * single summary block.
 	 */
 	do_ckp = LFS_SHOULD_CHECKPOINT(fs, flags);
 	/* We can't do a partial write and checkpoint at the same time. */
 	if (do_ckp)
 		flags &= ~SEGM_SINGLE;
 	lfs_seglock(fs, flags | (do_ckp ? SEGM_CKP : 0));
 	sp = fs->lfs_sp;
 	if (sp->seg_flags & (SEGM_CLEAN | SEGM_CKP))
 		do_ckp = 1;
 	/*
 	 * If lfs_flushvp is non-NULL, we are called from lfs_vflush,
 	 * in which case we have to flush *all* buffers off of this vnode.
 	 * We don't care about other nodes, but write any non-dirop nodes
 	 * anyway in anticipation of another getnewvnode().
+	 *
 	 * If we're cleaning we only write cleaning and ifile blocks, and
 	 * no dirops, since otherwise we'd risk corruption in a crash.
 	 */
 	if (sp->seg_flags & SEGM_CLEAN)
 		lfs_writevnodes(fs, mp, sp, VN_CLEAN);
 	else if (!(sp->seg_flags & SEGM_FORCE_CKP)) {
 		do {
 			um_error = lfs_writevnodes(fs, mp, sp, VN_REG);
 			if ((sp->seg_flags & SEGM_SINGLE) &&
 			    lfs_sb_getcurseg(fs) != fs->lfs_startseg) {
 				DLOG((DLOG_SEG, "lfs_segwrite: breaking out of segment write at daddr 0x%jx\n", (uintmax_t)lfs_sb_getoffset(fs)));
 				break;
+			}
 			if (do_ckp || fs->lfs_dirops == 0) {
 				if (!writer_set) {
 					lfs_writer_enter(fs, "lfs writer");
 					writer_set = 1;
+				}
 				error = lfs_writevnodes(fs, mp, sp, VN_DIROP);
 				if (um_error == 0)
 					um_error = error;
 				/* In case writevnodes errored out */
 				lfs_flush_dirops(fs);
 				((SEGSUM *)(sp->segsum))->ss_flags &= ~(SS_CONT);
 				lfs_finalize_fs_seguse(fs);
+			}
 			if (do_ckp && um_error) {
 				lfs_segunlock_relock(fs);
 				sp = fs->lfs_sp;
+			}
 		} while (do_ckp && um_error != 0);
+	}
 	/*
 	 * If we are doing a checkpoint, mark everything since the
 	 * last checkpoint as no longer ACTIVE.
 	 */
 	if (do_ckp || fs->lfs_doifile) {
 		segleft = lfs_sb_getnseg(fs);
 		curseg = 0;
 		for (n = 0; n < lfs_sb_getsegtabsz(fs); n++) {
 			dirty = 0;
 			if (bread(fs->lfs_ivnode, lfs_sb_getcleansz(fs) + n,
 			    lfs_sb_getbsize(fs), B_MODIFY, &bp))
 				panic("lfs_segwrite: ifile read");
 			segusep = (SEGUSE *)bp->b_data;
 			maxseg = min(segleft, lfs_sb_getsepb(fs));
 			for (i = 0; i < maxseg; i++) {
 				sn = curseg + i;
 				if (sn != lfs_dtosn(fs, lfs_sb_getcurseg(fs)) &&
 				    segusep->su_flags & SEGUSE_ACTIVE) {
 					segusep->su_flags &= ~SEGUSE_ACTIVE;
 					--fs->lfs_nactive;
 					++dirty;
+				}
 				fs->lfs_suflags[fs->lfs_activesb][sn] =
 					segusep->su_flags;
 				if (fs->lfs_version > 1)
 					++segusep;
 				else
 					segusep = (SEGUSE *)
 						((SEGUSE_V1 *)segusep + 1);
+			}
 			if (dirty)
 				error = LFS_BWRITE_LOG(bp); /* Ifile */
 			else
 				brelse(bp, 0);
 			segleft -= lfs_sb_getsepb(fs);
 			curseg += lfs_sb_getsepb(fs);
+		}
+	}
 	KASSERT(LFS_SEGLOCK_HELD(fs));
 	did_ckp = 0;
 	if (do_ckp || fs->lfs_doifile) {
 		vp = fs->lfs_ivnode;
 #ifdef DEBUG
 		int loopcount = 0;
 #endif
 		do {
 #ifdef DEBUG
 			LFS_ENTER_LOG("pretend", __FILE__, __LINE__, 0, 0, curproc->p_pid);
 #endif
 			mutex_enter(&lfs_lock);
 			fs->lfs_flags &= ~LFS_IFDIRTY;
 			mutex_exit(&lfs_lock);
 			ip = VTOI(vp);
 			if (LIST_FIRST(&vp->v_dirtyblkhd) != NULL) {
 				/*
 				 * Ifile has no pages, so we don't need
 				 * to check error return here.
 				 */
 				lfs_writefile(fs, sp, vp);
 				/*
 				 * Ensure the Ifile takes the current segment
 				 * into account.  See comment in lfs_vflush.
 				 */
 				lfs_writefile(fs, sp, vp);
 				lfs_writefile(fs, sp, vp);
+			}
 			if (ip->i_flag & IN_ALLMOD)
 				++did_ckp;
 #if 0
 			redo = (do_ckp ? lfs_writeinode(fs, sp, ip) : 0);
 #else
 			redo = lfs_writeinode(fs, sp, ip);
 #endif
 			redo += lfs_writeseg(fs, sp);
 			mutex_enter(&lfs_lock);
 			redo += (fs->lfs_flags & LFS_IFDIRTY);
 			mutex_exit(&lfs_lock);
 #ifdef DEBUG
 			if (++loopcount > 2)
 				log(LOG_NOTICE, "lfs_segwrite: looping count=%d\n",
 					loopcount);
 #endif
 		} while (redo && do_ckp);
 		/*
 		 * Unless we are unmounting, the Ifile may continue to have
 		 * dirty blocks even after a checkpoint, due to changes to
 		 * inodes' atime.  If we're checkpointing, it's "impossible"
 		 * for other parts of the Ifile to be dirty after the loop
 		 * above, since we hold the segment lock.
 		 */
 		mutex_enter(vp->v_interlock);
 		if (LIST_EMPTY(&vp->v_dirtyblkhd)) {
 			LFS_CLR_UINO(ip, IN_ALLMOD);
+		}
 #ifdef DIAGNOSTIC
 		else if (do_ckp) {
 			int do_panic = 0;
 			LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {
 				if (bp->b_lblkno < lfs_sb_getcleansz(fs) +
 				    lfs_sb_getsegtabsz(fs) &&
 				    !(bp->b_flags & B_GATHERED)) {
 					printf("ifile lbn %ld still dirty (flags %lx)\n",
 						(long)bp->b_lblkno,
 						(long)bp->b_flags);
 					++do_panic;
+				}
+			}
 			if (do_panic)
 				panic("dirty blocks");
+		}
 #endif
 		mutex_exit(vp->v_interlock);
 	} else {
 		(void) lfs_writeseg(fs, sp);
+	}
 	/* Note Ifile no longer needs to be written */
 	fs->lfs_doifile = 0;
 	if (writer_set)
 		lfs_writer_leave(fs);
 	/*
 	 * If we didn't write the Ifile, we didn't really do anything.
 	 * That means that (1) there is a checkpoint on disk and (2)
 	 * nothing has changed since it was written.
+	 *
 	 * Take the flags off of the segment so that lfs_segunlock
 	 * doesn't have to write the superblock either.
 	 */
 	if (do_ckp && !did_ckp) {
 		sp->seg_flags &= ~SEGM_CKP;
+	}
 	if (lfs_dostats) {
 		++lfs_stats.nwrites;
 		if (sp->seg_flags & SEGM_SYNC)
 			++lfs_stats.nsync_writes;
 		if (sp->seg_flags & SEGM_CKP)
 			++lfs_stats.ncheckpoints;
+	}
 	lfs_segunlock(fs);
 	return (0);
+}
 /*
  * Write the dirty blocks associated with a vnode.
  */
 int
 lfs_writefile(struct lfs *fs, struct segment *sp, struct vnode *vp)
+{
 	struct inode *ip;
 	int i, frag;
 	int error;
 	ASSERT_SEGLOCK(fs);
 	error = 0;
 	ip = VTOI(vp);
 	lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);
 	if (vp->v_uflag & VU_DIROP)
 		((SEGSUM *)(sp->segsum))->ss_flags |= (SS_DIROP|SS_CONT);
 	if (sp->seg_flags & SEGM_CLEAN) {
 		lfs_gather(fs, sp, vp, lfs_match_fake);
 		/*
 		 * For a file being flushed, we need to write *all* blocks.
 		 * This means writing the cleaning blocks first, and then
 		 * immediately following with any non-cleaning blocks.
 		 * The same is true of the Ifile since checkpoints assume
 		 * that all valid Ifile blocks are written.
 		 */
 		if (IS_FLUSHING(fs, vp) || vp == fs->lfs_ivnode) {
 			lfs_gather(fs, sp, vp, lfs_match_data);
 			/*
 			 * Don't call VOP_PUTPAGES: if we're flushing,
 			 * we've already done it, and the Ifile doesn't
 			 * use the page cache.
 			 */
+		}
 	} else {
 		lfs_gather(fs, sp, vp, lfs_match_data);
 		/*
 		 * If we're flushing, we've already called VOP_PUTPAGES
 		 * so don't do it again.  Otherwise, we want to write
 		 * everything we've got.
 		 */
 		if (!IS_FLUSHING(fs, vp)) {
 			mutex_enter(vp->v_interlock);
 			error = VOP_PUTPAGES(vp, 0, 0,
 				PGO_CLEANIT | PGO_ALLPAGES | PGO_LOCKED);
+		}
+	}
 	/*
 	 * It may not be necessary to write the meta-data blocks at this point,
 	 * as the roll-forward recovery code should be able to reconstruct the
 	 * list.
+	 *
 	 * We have to write them anyway, though, under two conditions: (1) the
 	 * vnode is being flushed (for reuse by vinvalbuf); or (2) we are
 	 * checkpointing.
+	 *
 	 * BUT if we are cleaning, we might have indirect blocks that refer to
 	 * new blocks not being written yet, in addition to fragments being
 	 * moved out of a cleaned segment.  If that is the case, don't
 	 * write the indirect blocks, or the finfo will have a small block
 	 * in the middle of it!
 	 * XXX in this case isn't the inode size wrong too?
 	 */
 	frag = 0;
 	if (sp->seg_flags & SEGM_CLEAN) {
 		for (i = 0; i < ULFS_NDADDR; i++)
 			if (ip->i_lfs_fragsize[i] > 0 &&
 			    ip->i_lfs_fragsize[i] < lfs_sb_getbsize(fs))
 				++frag;
+	}
 #ifdef DIAGNOSTIC
 	if (frag > 1)
 		panic("lfs_writefile: more than one fragment!");
 #endif
 	if (IS_FLUSHING(fs, vp) ||
 	    (frag == 0 && (lfs_writeindir || (sp->seg_flags & SEGM_CKP)))) {
 		lfs_gather(fs, sp, vp, lfs_match_indir);
 		lfs_gather(fs, sp, vp, lfs_match_dindir);
 		lfs_gather(fs, sp, vp, lfs_match_tindir);
+	}
 	lfs_release_finfo(fs);
 	return error;
+}
 /*
  * Update segment accounting to reflect this inode's change of address.
  */
 static int
 lfs_update_iaddr(struct lfs *fs, struct segment *sp, struct inode *ip, daddr_t ndaddr)
+{
 	struct buf *bp;
 	daddr_t daddr;
 	IFILE *ifp;
 	SEGUSE *sup;
 	ino_t ino;
 	int redo_ifile;
 	u_int32_t sn;
 	redo_ifile = 0;
 	/*
 	 * If updating the ifile, update the super-block.  Update the disk
 	 * address and access times for this inode in the ifile.
 	 */
 	ino = ip->i_number;
 	if (ino == LFS_IFILE_INUM) {
 		daddr = lfs_sb_getidaddr(fs);
 		lfs_sb_setidaddr(fs, LFS_DBTOFSB(fs, ndaddr));
 	} else {
 		LFS_IENTRY(ifp, fs, ino, bp);
 		daddr = ifp->if_daddr;
 		ifp->if_daddr = LFS_DBTOFSB(fs, ndaddr);
 		(void)LFS_BWRITE_LOG(bp); /* Ifile */
+	}
 	/*
 	 * If this is the Ifile and lfs_offset is set to the first block
 	 * in the segment, dirty the new segment's accounting block
 	 * (XXX should already be dirty?) and tell the caller to do it again.
 	 */
 	if (ip->i_number == LFS_IFILE_INUM) {
 		sn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
 		if (lfs_sntod(fs, sn) + lfs_btofsb(fs, lfs_sb_getsumsize(fs)) ==
 		    lfs_sb_getoffset(fs)) {
 			LFS_SEGENTRY(sup, fs, sn, bp);
 			KASSERT(bp->b_oflags & BO_DELWRI);
 			LFS_WRITESEGENTRY(sup, fs, sn, bp);
 			/* fs->lfs_flags |= LFS_IFDIRTY; */
 			redo_ifile |= 1;
+		}
+	}
 	/*
 	 * The inode's last address should not be in the current partial
 	 * segment, except under exceptional circumstances (lfs_writevnodes
 	 * had to start over, and in the meantime more blocks were written
 	 * to a vnode).	 Both inodes will be accounted to this segment
 	 * in lfs_writeseg so we need to subtract the earlier version
 	 * here anyway.	 The segment count can temporarily dip below
 	 * zero here; keep track of how many duplicates we have in
 	 * "dupino" so we don't panic below.
 	 */
 	if (daddr >= lfs_sb_getlastpseg(fs) && daddr <= lfs_sb_getoffset(fs)) {
 		++sp->ndupino;
 		DLOG((DLOG_SEG, "lfs_writeinode: last inode addr in current pseg "
 		      "(ino %d daddr 0x%llx) ndupino=%d\n", ino,
 		      (long long)daddr, sp->ndupino));
+	}
 	/*
 	 * Account the inode: it no longer belongs to its former segment,
 	 * though it will not belong to the new segment until that segment
 	 * is actually written.
 	 */
 	if (daddr != LFS_UNUSED_DADDR) {
 		u_int32_t oldsn = lfs_dtosn(fs, daddr);
 #ifdef DIAGNOSTIC
 		int ndupino = (sp->seg_number == oldsn) ? sp->ndupino : 0;
 #endif
 		LFS_SEGENTRY(sup, fs, oldsn, bp);
 #ifdef DIAGNOSTIC
 		if (sup->su_nbytes +
 		    sizeof (struct ulfs1_dinode) * ndupino
 		      < sizeof (struct ulfs1_dinode)) {
 			printf("lfs_writeinode: negative bytes "
 			       "(segment %" PRIu32 " short by %d, "
 			       "oldsn=%" PRIu32 ", cursn=%" PRIu32
 			       ", daddr=%" PRId64 ", su_nbytes=%u, "
 			       "ndupino=%d)\n",
 			       lfs_dtosn(fs, daddr),
 			       (int)sizeof (struct ulfs1_dinode) *
 				   (1 - sp->ndupino) - sup->su_nbytes,
 			       oldsn, sp->seg_number, daddr,
 			       (unsigned int)sup->su_nbytes,
 			       sp->ndupino);
 			panic("lfs_writeinode: negative bytes");
 			sup->su_nbytes = sizeof (struct ulfs1_dinode);
+		}
 #endif
 		DLOG((DLOG_SU, "seg %d -= %d for ino %d inode\n",
 		      lfs_dtosn(fs, daddr), sizeof (struct ulfs1_dinode), ino));
 		sup->su_nbytes -= sizeof (struct ulfs1_dinode);
 		redo_ifile |=
 			(ino == LFS_IFILE_INUM && !(bp->b_flags & B_GATHERED));
 		if (redo_ifile) {
 			mutex_enter(&lfs_lock);
 			fs->lfs_flags |= LFS_IFDIRTY;
 			mutex_exit(&lfs_lock);
 			/* Don't double-account */
 			lfs_sb_setidaddr(fs, 0x0);
+		}
 		LFS_WRITESEGENTRY(sup, fs, oldsn, bp); /* Ifile */
+	}
 	return redo_ifile;
+}
 int
 lfs_writeinode(struct lfs *fs, struct segment *sp, struct inode *ip)
+{
 	struct buf *bp;
 	struct ulfs1_dinode *cdp;
 	struct vnode *vp = ITOV(ip);
 	daddr_t daddr;
 	int32_t *daddrp;	/* XXX ondisk32 */
 	int i, ndx;
 	int redo_ifile = 0;
 	int gotblk = 0;
 	int count;
 	ASSERT_SEGLOCK(fs);
 	if (!(ip->i_flag & IN_ALLMOD) && !(vp->v_uflag & VU_DIROP))
 		return (0);
 	/* Can't write ifile when writer is not set */
 	KASSERT(ip->i_number != LFS_IFILE_INUM || fs->lfs_writer > 0 ||
 		(sp->seg_flags & SEGM_CLEAN));
 	/*
 @@ -1251,1543 +1251,1543 @@ lfs_writeinode(struct lfs *fs, struct se
 		LFS_CLR_UINO(ip, IN_CLEANING);
 	else {
 		/* XXX IN_ALLMOD */
 		LFS_CLR_UINO(ip, IN_ACCESSED | IN_ACCESS | IN_CHANGE |
 			     IN_UPDATE | IN_MODIFY);
 		if (ip->i_lfs_effnblks == ip->i_ffs1_blocks)
 			LFS_CLR_UINO(ip, IN_MODIFIED);
 		else {
 			DLOG((DLOG_VNODE, "lfs_writeinode: ino %d: real "
 			    "blks=%d, eff=%d\n", ip->i_number,
 			    ip->i_ffs1_blocks, ip->i_lfs_effnblks));
+		}
+	}
 	if (ip->i_number == LFS_IFILE_INUM) {
 		/* We know sp->idp == NULL */
 		sp->idp = ((struct ulfs1_dinode *)bp->b_data) +
 			(sp->ninodes % LFS_INOPB(fs));
 		/* Not dirty any more */
 		mutex_enter(&lfs_lock);
 		fs->lfs_flags &= ~LFS_IFDIRTY;
 		mutex_exit(&lfs_lock);
+	}
 	if (gotblk) {
 		mutex_enter(&bufcache_lock);
 		LFS_LOCK_BUF(bp);
 		brelsel(bp, 0);
 		mutex_exit(&bufcache_lock);
+	}
 	/* Increment inode count in segment summary block. */
 	++((SEGSUM *)(sp->segsum))->ss_ninos;
 	/* If this page is full, set flag to allocate a new page. */
 	if (++sp->ninodes % LFS_INOPB(fs) == 0)
 		sp->ibp = NULL;
 	redo_ifile = lfs_update_iaddr(fs, sp, ip, bp->b_blkno);
 	KASSERT(redo_ifile == 0);
 	return (redo_ifile);
+}
 int
 lfs_gatherblock(struct segment *sp, struct buf *bp, kmutex_t *mptr)
+{
 	struct lfs *fs;
 	int vers;
 	int j, blksinblk;
 	ASSERT_SEGLOCK(sp->fs);
 	/*
 	 * If full, finish this segment.  We may be doing I/O, so
 	 * release and reacquire the splbio().
 	 */
 #ifdef DIAGNOSTIC
 	if (sp->vp == NULL)
 		panic ("lfs_gatherblock: Null vp in segment");
 #endif
 	fs = sp->fs;
 	blksinblk = howmany(bp->b_bcount, lfs_sb_getbsize(fs));
 	if (sp->sum_bytes_left < sizeof(int32_t) * blksinblk ||
 	    sp->seg_bytes_left < bp->b_bcount) {
 		if (mptr)
 			mutex_exit(mptr);
 		lfs_updatemeta(sp);
 		vers = sp->fip->fi_version;
 		(void) lfs_writeseg(fs, sp);
 		/* Add the current file to the segment summary. */
 		lfs_acquire_finfo(fs, VTOI(sp->vp)->i_number, vers);
 		if (mptr)
 			mutex_enter(mptr);
 		return (1);
+	}
 	if (bp->b_flags & B_GATHERED) {
 		DLOG((DLOG_SEG, "lfs_gatherblock: already gathered! Ino %d,"
 		      " lbn %" PRId64 "\n",
 		      sp->fip->fi_ino, bp->b_lblkno));
 		return (0);
+	}
 	/* Insert into the buffer list, update the FINFO block. */
 	bp->b_flags |= B_GATHERED;
 	*sp->cbpp++ = bp;
 	for (j = 0; j < blksinblk; j++) {
 		sp->fip->fi_blocks[sp->fip->fi_nblocks++] = bp->b_lblkno + j;
 		/* This block's accounting moves from lfs_favail to lfs_avail */
 		lfs_deregister_block(sp->vp, bp->b_lblkno + j);
+	}
 	sp->sum_bytes_left -= sizeof(int32_t) * blksinblk;
 	sp->seg_bytes_left -= bp->b_bcount;
 	return (0);
+}
 int
 lfs_gather(struct lfs *fs, struct segment *sp, struct vnode *vp,
     int (*match)(struct lfs *, struct buf *))
+{
 	struct buf *bp, *nbp;
 	int count = 0;
 	ASSERT_SEGLOCK(fs);
 	if (vp->v_type == VBLK)
 		return 0;
 	KASSERT(sp->vp == NULL);
 	sp->vp = vp;
 	mutex_enter(&bufcache_lock);
 #ifndef LFS_NO_BACKBUF_HACK
 /* This is a hack to see if ordering the blocks in LFS makes a difference. */
 # define	BUF_OFFSET	\
 	(((char *)&LIST_NEXT(bp, b_vnbufs)) - (char *)bp)
 # define	BACK_BUF(BP)	\
 	((struct buf *)(((char *)(BP)->b_vnbufs.le_prev) - BUF_OFFSET))
 # define	BEG_OF_LIST	\
 	((struct buf *)(((char *)&LIST_FIRST(&vp->v_dirtyblkhd)) - BUF_OFFSET))
 loop:
 	/* Find last buffer. */
 	for (bp = LIST_FIRST(&vp->v_dirtyblkhd);
 	     bp && LIST_NEXT(bp, b_vnbufs) != NULL;
 	     bp = LIST_NEXT(bp, b_vnbufs))
 		/* nothing */;
 	for (; bp && bp != BEG_OF_LIST; bp = nbp) {
 		nbp = BACK_BUF(bp);
 #else /* LFS_NO_BACKBUF_HACK */
 loop:
 	for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
 		nbp = LIST_NEXT(bp, b_vnbufs);
 #endif /* LFS_NO_BACKBUF_HACK */
 		if ((bp->b_cflags & BC_BUSY) != 0 ||
 		    (bp->b_flags & B_GATHERED) != 0 || !match(fs, bp)) {
 #ifdef DEBUG
 			if (vp == fs->lfs_ivnode &&
 			    (bp->b_cflags & BC_BUSY) != 0 &&
 			    (bp->b_flags & B_GATHERED) == 0)
 				log(LOG_NOTICE, "lfs_gather: ifile lbn %"
 				      PRId64 " busy (%x) at 0x%jx",
 				      bp->b_lblkno, bp->b_flags,
 				      (uintmax_t)lfs_sb_getoffset(fs));
 #endif
 			continue;
+		}
 #ifdef DIAGNOSTIC
 # ifdef LFS_USE_B_INVAL
 		if ((bp->b_flags & BC_INVAL) != 0 && bp->b_iodone == NULL) {
 			DLOG((DLOG_SEG, "lfs_gather: lbn %" PRId64
 			      " is BC_INVAL\n", bp->b_lblkno));
 			VOP_PRINT(bp->b_vp);
+		}
 # endif /* LFS_USE_B_INVAL */
 		if (!(bp->b_oflags & BO_DELWRI))
 			panic("lfs_gather: bp not BO_DELWRI");
 		if (!(bp->b_flags & B_LOCKED)) {
 			DLOG((DLOG_SEG, "lfs_gather: lbn %" PRId64
 			      " blk %" PRId64 " not B_LOCKED\n",
 			      bp->b_lblkno,
 			      LFS_DBTOFSB(fs, bp->b_blkno)));
 			VOP_PRINT(bp->b_vp);
 			panic("lfs_gather: bp not B_LOCKED");
+		}
 #endif
 		if (lfs_gatherblock(sp, bp, &bufcache_lock)) {
 			goto loop;
+		}
 		count++;
+	}
 	mutex_exit(&bufcache_lock);
 	lfs_updatemeta(sp);
 	KASSERT(sp->vp == vp);
 	sp->vp = NULL;
 	return count;
+}
 #if DEBUG
 # define DEBUG_OOFF(n) do {						\
 	if (ooff == 0) {						\
 		DLOG((DLOG_SEG, "lfs_updatemeta[%d]: warning: writing " \
 			"ino %d lbn %" PRId64 " at 0x%" PRIx32		\
 			", was 0x0 (or %" PRId64 ")\n",			\
 			(n), ip->i_number, lbn, ndaddr, daddr));	\
 	}								\
 } while (0)
 #else
 # define DEBUG_OOFF(n)
 #endif
 /*
  * Change the given block's address to ndaddr, finding its previous
  * location using ulfs_bmaparray().
+ *
  * Account for this change in the segment table.
+ *
  * called with sp == NULL by roll-forwarding code.
  */
 void
 lfs_update_single(struct lfs *fs, struct segment *sp,
     struct vnode *vp, daddr_t lbn, int32_t ndaddr, int size)
+{
 	SEGUSE *sup;
 	struct buf *bp;
 	struct indir a[ULFS_NIADDR + 2], *ap;
 	struct inode *ip;
 	daddr_t daddr, ooff;
 	int num, error;
 	int bb, osize, obb;
 	ASSERT_SEGLOCK(fs);
 	KASSERT(sp == NULL || sp->vp == vp);
 	ip = VTOI(vp);
 	error = ulfs_bmaparray(vp, lbn, &daddr, a, &num, NULL, NULL);
 	if (error)
 		panic("lfs_updatemeta: ulfs_bmaparray returned %d", error);
 	daddr = (daddr_t)((int32_t)daddr); /* XXX ondisk32 */
 	KASSERT(daddr <= LFS_MAX_DADDR);
 	if (daddr > 0)
 		daddr = LFS_DBTOFSB(fs, daddr);
 	bb = lfs_numfrags(fs, size);
 	switch (num) {
 	    case 0:
 		    ooff = ip->i_ffs1_db[lbn];
 		    DEBUG_OOFF(0);
 		    if (ooff == UNWRITTEN)
 			    ip->i_ffs1_blocks += bb;
 		    else {
 			    /* possible fragment truncation or extension */
 			    obb = lfs_btofsb(fs, ip->i_lfs_fragsize[lbn]);
 			    ip->i_ffs1_blocks += (bb - obb);
+		    }
 		    ip->i_ffs1_db[lbn] = ndaddr;
 		    break;
 	    case 1:
 		    ooff = ip->i_ffs1_ib[a[0].in_off];
 		    DEBUG_OOFF(1);
 		    if (ooff == UNWRITTEN)
 			    ip->i_ffs1_blocks += bb;
 		    ip->i_ffs1_ib[a[0].in_off] = ndaddr;
 		    break;
 	    default:
 		    ap = &a[num - 1];
 		    if (bread(vp, ap->in_lbn, lfs_sb_getbsize(fs),
 			B_MODIFY, &bp))
 			    panic("lfs_updatemeta: bread bno %" PRId64,
 				  ap->in_lbn);
 		    /* XXX ondisk32 */
 		    ooff = ((int32_t *)bp->b_data)[ap->in_off];
 		    DEBUG_OOFF(num);
 		    if (ooff == UNWRITTEN)
 			    ip->i_ffs1_blocks += bb;
 		    /* XXX ondisk32 */
 		    ((int32_t *)bp->b_data)[ap->in_off] = ndaddr;
 		    (void) VOP_BWRITE(bp->b_vp, bp);
+	}
 	KASSERT(ooff == 0 || ooff == UNWRITTEN || ooff == daddr);
 	/* Update hiblk when extending the file */
 	if (lbn > ip->i_lfs_hiblk)
 		ip->i_lfs_hiblk = lbn;
 	/*
 	 * Though we'd rather it couldn't, this *can* happen right now
 	 * if cleaning blocks and regular blocks coexist.
 	 */
 	/* KASSERT(daddr < fs->lfs_lastpseg || daddr > ndaddr); */
 	/*
 	 * Update segment usage information, based on old size
 	 * and location.
 	 */
 	if (daddr > 0) {
 		u_int32_t oldsn = lfs_dtosn(fs, daddr);
 #ifdef DIAGNOSTIC
 		int ndupino;
 		if (sp && sp->seg_number == oldsn) {
 			ndupino = sp->ndupino;
 		} else {
 			ndupino = 0;
+		}
 #endif
 		KASSERT(oldsn < lfs_sb_getnseg(fs));
 		if (lbn >= 0 && lbn < ULFS_NDADDR)
 			osize = ip->i_lfs_fragsize[lbn];
 		else
 			osize = lfs_sb_getbsize(fs);
 		LFS_SEGENTRY(sup, fs, oldsn, bp);
 #ifdef DIAGNOSTIC
 		if (sup->su_nbytes + sizeof (struct ulfs1_dinode) * ndupino
 		    < osize) {
 			printf("lfs_updatemeta: negative bytes "
 			       "(segment %" PRIu32 " short by %" PRId64
 			       ")\n", lfs_dtosn(fs, daddr),
 			       (int64_t)osize -
 			       (sizeof (struct ulfs1_dinode) * ndupino +
 				sup->su_nbytes));
 			printf("lfs_updatemeta: ino %llu, lbn %" PRId64
 			       ", addr = 0x%" PRIx64 "\n",
 			       (unsigned long long)ip->i_number, lbn, daddr);
 			printf("lfs_updatemeta: ndupino=%d\n", ndupino);
 			panic("lfs_updatemeta: negative bytes");
 			sup->su_nbytes = osize -
 			    sizeof (struct ulfs1_dinode) * ndupino;
+		}
 #endif
 		DLOG((DLOG_SU, "seg %" PRIu32 " -= %d for ino %d lbn %" PRId64
 		      " db 0x%" PRIx64 "\n",
 		      lfs_dtosn(fs, daddr), osize,
 		      ip->i_number, lbn, daddr));
 		sup->su_nbytes -= osize;
 		if (!(bp->b_flags & B_GATHERED)) {
 			mutex_enter(&lfs_lock);
 			fs->lfs_flags |= LFS_IFDIRTY;
 			mutex_exit(&lfs_lock);
+		}
 		LFS_WRITESEGENTRY(sup, fs, oldsn, bp);
+	}
 	/*
 	 * Now that this block has a new address, and its old
 	 * segment no longer owns it, we can forget about its
 	 * old size.
 	 */
 	if (lbn >= 0 && lbn < ULFS_NDADDR)
 		ip->i_lfs_fragsize[lbn] = size;
+}
 /*
  * Update the metadata that points to the blocks listed in the FINFO
  * array.
  */
 void
 lfs_updatemeta(struct segment *sp)
+{
 	struct buf *sbp;
 	struct lfs *fs;
 	struct vnode *vp;
 	daddr_t lbn;
 	int i, nblocks, num;
 	int bb;
 	int bytesleft, size;
 	ASSERT_SEGLOCK(sp->fs);
 	vp = sp->vp;
 	nblocks = &sp->fip->fi_blocks[sp->fip->fi_nblocks] - sp->start_lbp;
 	KASSERT(nblocks >= 0);
 	KASSERT(vp != NULL);
 	if (nblocks == 0)
 		return;
 	/*
 	 * This count may be high due to oversize blocks from lfs_gop_write.
 	 * Correct for this. (XXX we should be able to keep track of these.)
 	 */
 	fs = sp->fs;
 	for (i = 0; i < nblocks; i++) {
 		if (sp->start_bpp[i] == NULL) {
 			DLOG((DLOG_SEG, "lfs_updatemeta: nblocks = %d, not %d\n", i, nblocks));
 			nblocks = i;
 			break;
+		}
 		num = howmany(sp->start_bpp[i]->b_bcount, lfs_sb_getbsize(fs));
 		KASSERT(sp->start_bpp[i]->b_lblkno >= 0 || num == 1);
 		nblocks -= num - 1;
+	}
 	KASSERT(vp->v_type == VREG ||
 	   nblocks == &sp->fip->fi_blocks[sp->fip->fi_nblocks] - sp->start_lbp);
 	KASSERT(nblocks == sp->cbpp - sp->start_bpp);
 	/*
 	 * Sort the blocks.
+	 *
 	 * We have to sort even if the blocks come from the
 	 * cleaner, because there might be other pending blocks on the
 	 * same inode...and if we don't sort, and there are fragments
 	 * present, blocks may be written in the wrong place.
 	 */
 	lfs_shellsort(sp->start_bpp, sp->start_lbp, nblocks, lfs_sb_getbsize(fs));
 	/*
 	 * Record the length of the last block in case it's a fragment.
 	 * If there are indirect blocks present, they sort last.  An
 	 * indirect block will be lfs_bsize and its presence indicates
 	 * that you cannot have fragments.
+	 *
 	 * XXX This last is a lie.  A cleaned fragment can coexist with
 	 * XXX a later indirect block.	This will continue to be
 	 * XXX true until lfs_markv is fixed to do everything with
 	 * XXX fake blocks (including fake inodes and fake indirect blocks).
 	 */
 	sp->fip->fi_lastlength = ((sp->start_bpp[nblocks - 1]->b_bcount - 1) &
 		lfs_sb_getbmask(fs)) + 1;
 	/*
 	 * Assign disk addresses, and update references to the logical
 	 * block and the segment usage information.
 	 */
 	for (i = nblocks; i--; ++sp->start_bpp) {
 		sbp = *sp->start_bpp;
 		lbn = *sp->start_lbp;
 		KASSERT(sbp->b_lblkno == lbn);
 		sbp->b_blkno = LFS_FSBTODB(fs, lfs_sb_getoffset(fs));
 		/*
 		 * If we write a frag in the wrong place, the cleaner won't
 		 * be able to correctly identify its size later, and the
 		 * segment will be uncleanable.	 (Even worse, it will assume
 		 * that the indirect block that actually ends the list
 		 * is of a smaller size!)
 		 */
 		if ((sbp->b_bcount & lfs_sb_getbmask(fs)) && i != 0)
 			panic("lfs_updatemeta: fragment is not last block");
 		/*
 		 * For each subblock in this possibly oversized block,
 		 * update its address on disk.
 		 */
 		KASSERT(lbn >= 0 || sbp->b_bcount == lfs_sb_getbsize(fs));
 		KASSERT(vp == sbp->b_vp);
 		for (bytesleft = sbp->b_bcount; bytesleft > 0;
 		     bytesleft -= lfs_sb_getbsize(fs)) {
 			size = MIN(bytesleft, lfs_sb_getbsize(fs));
 			bb = lfs_numfrags(fs, size);
 			lbn = *sp->start_lbp++;
 			lfs_update_single(fs, sp, sp->vp, lbn, lfs_sb_getoffset(fs),
 			    size);
 			lfs_sb_addoffset(fs, bb);
+		}
+	}
 	/* This inode has been modified */
 	LFS_SET_UINO(VTOI(vp), IN_MODIFIED);
+}
 /*
  * Move lfs_offset to a segment earlier than sn.
  */
 int
 lfs_rewind(struct lfs *fs, int newsn)
+{
 	int sn, osn, isdirty;
 	struct buf *bp;
 	SEGUSE *sup;
 	ASSERT_SEGLOCK(fs);
 	osn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
 	if (osn < newsn)
 		return 0;
 	/* lfs_avail eats the remaining space in this segment */
 	lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
 	/* Find a low-numbered segment */
 	for (sn = 0; sn < lfs_sb_getnseg(fs); ++sn) {
 		LFS_SEGENTRY(sup, fs, sn, bp);
 		isdirty = sup->su_flags & SEGUSE_DIRTY;
 		brelse(bp, 0);
 		if (!isdirty)
 			break;
+	}
 	if (sn == lfs_sb_getnseg(fs))
 		panic("lfs_rewind: no clean segments");
 	if (newsn >= 0 && sn >= newsn)
 		return ENOENT;
 	lfs_sb_setnextseg(fs, sn);
 	lfs_newseg(fs);
 	lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
 	return 0;
+}
 /*
  * Start a new partial segment.
+ *
  * Return 1 when we entered to a new segment.
  * Otherwise, return 0.
  */
 int
 lfs_initseg(struct lfs *fs)
+{
 	struct segment *sp = fs->lfs_sp;
 	SEGSUM *ssp;
 	struct buf *sbp;	/* buffer for SEGSUM */
 	int repeat = 0;		/* return value */
 	ASSERT_SEGLOCK(fs);
 	/* Advance to the next segment. */
 	if (!LFS_PARTIAL_FITS(fs)) {
 		SEGUSE *sup;
 		struct buf *bp;
 		/* lfs_avail eats the remaining space */
 		lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) -
 						   lfs_sb_getcurseg(fs)));
 		/* Wake up any cleaning procs waiting on this file system. */
 		lfs_wakeup_cleaner(fs);
 		lfs_newseg(fs);
 		repeat = 1;
 		lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
 		sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
 		sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs));
 		/*
 		 * If the segment contains a superblock, update the offset
 		 * and summary address to skip over it.
 		 */
 		LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
 		if (sup->su_flags & SEGUSE_SUPERBLOCK) {
 			lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_SBPAD));
 			sp->seg_bytes_left -= LFS_SBPAD;
+		}
 		brelse(bp, 0);
 		/* Segment zero could also contain the labelpad */
 		if (fs->lfs_version > 1 && sp->seg_number == 0 &&
 		    lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD)) {
 			lfs_sb_addoffset(fs,
 			    lfs_btofsb(fs, LFS_LABELPAD) - lfs_sb_gets0addr(fs));
 			sp->seg_bytes_left -=
 			    LFS_LABELPAD - lfs_fsbtob(fs, lfs_sb_gets0addr(fs));
+		}
 	} else {
 		sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
 		sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs) -
 				      (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
+	}
 	lfs_sb_setlastpseg(fs, lfs_sb_getoffset(fs));
 	/* Record first address of this partial segment */
 	if (sp->seg_flags & SEGM_CLEAN) {
 		fs->lfs_cleanint[fs->lfs_cleanind] = lfs_sb_getoffset(fs);
 		if (++fs->lfs_cleanind >= LFS_MAX_CLEANIND) {
 			/* "1" is the artificial inc in lfs_seglock */
 			mutex_enter(&lfs_lock);
 			while (fs->lfs_iocount > 1) {
 				mtsleep(&fs->lfs_iocount, PRIBIO + 1,
 				    "lfs_initseg", 0, &lfs_lock);
+			}
 			mutex_exit(&lfs_lock);
 			fs->lfs_cleanind = 0;
+		}
+	}
 	sp->fs = fs;
 	sp->ibp = NULL;
 	sp->idp = NULL;
 	sp->ninodes = 0;
 	sp->ndupino = 0;
 	sp->cbpp = sp->bpp;
 	/* Get a new buffer for SEGSUM */
 	sbp = lfs_newbuf(fs, VTOI(fs->lfs_ivnode)->i_devvp,
 	    LFS_FSBTODB(fs, lfs_sb_getoffset(fs)), lfs_sb_getsumsize(fs), LFS_NB_SUMMARY);
 	/* ... and enter it into the buffer list. */
 	*sp->cbpp = sbp;
 	sp->cbpp++;
 	lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
 	sp->start_bpp = sp->cbpp;
 	/* Set point to SEGSUM, initialize it. */
 	ssp = sp->segsum = sbp->b_data;
 	memset(ssp, 0, lfs_sb_getsumsize(fs));
 	ssp->ss_next = lfs_sb_getnextseg(fs);
 	ssp->ss_nfinfo = ssp->ss_ninos = 0;
 	ssp->ss_magic = SS_MAGIC;
 	/* Set pointer to first FINFO, initialize it. */
 	sp->fip = (struct finfo *)((char *)sp->segsum + SEGSUM_SIZE(fs));
 	sp->fip->fi_nblocks = 0;
 	sp->start_lbp = &sp->fip->fi_blocks[0];
 	sp->fip->fi_lastlength = 0;
 	sp->seg_bytes_left -= lfs_sb_getsumsize(fs);
 	sp->sum_bytes_left = lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs);
 	return (repeat);
+}
 /*
  * Remove SEGUSE_INVAL from all segments.
  */
 void
 lfs_unset_inval_all(struct lfs *fs)
+{
 	SEGUSE *sup;
 	struct buf *bp;
 	int i;
 	for (i = 0; i < lfs_sb_getnseg(fs); i++) {
 		LFS_SEGENTRY(sup, fs, i, bp);
 		if (sup->su_flags & SEGUSE_INVAL) {
 			sup->su_flags &= ~SEGUSE_INVAL;
 			LFS_WRITESEGENTRY(sup, fs, i, bp);
 		} else
 			brelse(bp, 0);
+	}
+}
 /*
  * Return the next segment to write.
  */
 void
 lfs_newseg(struct lfs *fs)
+{
 	CLEANERINFO *cip;
 	SEGUSE *sup;
 	struct buf *bp;
 	int curseg, isdirty, sn, skip_inval;
 	ASSERT_SEGLOCK(fs);
 	/* Honor LFCNWRAPSTOP */
 	mutex_enter(&lfs_lock);
 	while (lfs_sb_getnextseg(fs) < lfs_sb_getcurseg(fs) && fs->lfs_nowrap) {
 		if (fs->lfs_wrappass) {
 			log(LOG_NOTICE, "%s: wrappass=%d\n",
 				lfs_sb_getfsmnt(fs), fs->lfs_wrappass);
 			fs->lfs_wrappass = 0;
 			break;
+		}
 		fs->lfs_wrapstatus = LFS_WRAP_WAITING;
 		wakeup(&fs->lfs_nowrap);
 		log(LOG_NOTICE, "%s: waiting at log wrap\n", lfs_sb_getfsmnt(fs));
 		mtsleep(&fs->lfs_wrappass, PVFS, "newseg", 10 * hz,
 			&lfs_lock);
+	}
 	fs->lfs_wrapstatus = LFS_WRAP_GOING;
 	mutex_exit(&lfs_lock);
 	LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
 	DLOG((DLOG_SU, "lfs_newseg: seg %d := 0 in newseg\n",
 	      lfs_dtosn(fs, lfs_sb_getnextseg(fs))));
 	sup->su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE;
 	sup->su_nbytes = 0;
 	sup->su_nsums = 0;
 	sup->su_ninos = 0;
 	LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
 	LFS_CLEANERINFO(cip, fs, bp);
 	--cip->clean;
 	++cip->dirty;
 	lfs_sb_setnclean(fs, cip->clean);
 	LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
 	lfs_sb_setlastseg(fs, lfs_sb_getcurseg(fs));
 	lfs_sb_setcurseg(fs, lfs_sb_getnextseg(fs));
 	skip_inval = 1;
 	for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + lfs_sb_getinterleave(fs);;) {
 		sn = (sn + 1) % lfs_sb_getnseg(fs);
 		if (sn == curseg) {
 			if (skip_inval)
 				skip_inval = 0;
 			else
 				panic("lfs_nextseg: no clean segments");
+		}
 		LFS_SEGENTRY(sup, fs, sn, bp);
 		isdirty = sup->su_flags & (SEGUSE_DIRTY | (skip_inval ? SEGUSE_INVAL : 0));
 		/* Check SEGUSE_EMPTY as we go along */
 		if (isdirty && sup->su_nbytes == 0 &&
 		    !(sup->su_flags & SEGUSE_EMPTY))
 			LFS_WRITESEGENTRY(sup, fs, sn, bp);
 		else
 			brelse(bp, 0);
 		if (!isdirty)
 			break;
+	}
 	if (skip_inval == 0)
 		lfs_unset_inval_all(fs);
 	++fs->lfs_nactive;
 	lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
 	if (lfs_dostats) {
 		++lfs_stats.segsused;
+	}
+}
 static struct buf *
 lfs_newclusterbuf(struct lfs *fs, struct vnode *vp, daddr_t addr,
     int n)
+{
 	struct lfs_cluster *cl;
 	struct buf **bpp, *bp;
 	ASSERT_SEGLOCK(fs);
 	cl = (struct lfs_cluster *)pool_get(&fs->lfs_clpool, PR_WAITOK);
 	bpp = (struct buf **)pool_get(&fs->lfs_bpppool, PR_WAITOK);
 	memset(cl, 0, sizeof(*cl));
 	cl->fs = fs;
 	cl->bpp = bpp;
 	cl->bufcount = 0;
 	cl->bufsize = 0;
 	/* If this segment is being written synchronously, note that */
 	if (fs->lfs_sp->seg_flags & SEGM_SYNC) {
 		cl->flags |= LFS_CL_SYNC;
 		cl->seg = fs->lfs_sp;
 		++cl->seg->seg_iocount;
+	}
 	/* Get an empty buffer header, or maybe one with something on it */
 	bp = getiobuf(vp, true);
 	bp->b_dev = NODEV;
 	bp->b_blkno = bp->b_lblkno = addr;
 	bp->b_iodone = lfs_cluster_callback;
 	bp->b_private = cl;
 	return bp;
+}
 int
 lfs_writeseg(struct lfs *fs, struct segment *sp)
+{
 	struct buf **bpp, *bp, *cbp, *newbp, *unbusybp;
 	SEGUSE *sup;
 	SEGSUM *ssp;
 	int i;
 	int do_again, nblocks, byteoffset;
 	size_t el_size;
 	struct lfs_cluster *cl;
 	u_short ninos;
 	struct vnode *devvp;
 	char *p = NULL;
 	struct vnode *vp;
 	int32_t *daddrp;	/* XXX ondisk32 */
 	int changed;
 	u_int32_t sum;
 #ifdef DEBUG
 	FINFO *fip;
 	int findex;
 #endif
 	ASSERT_SEGLOCK(fs);
 	ssp = (SEGSUM *)sp->segsum;
 	/*
 	 * If there are no buffers other than the segment summary to write,
 	 * don't do anything.  If we are the end of a dirop sequence, however,
 	 * write the empty segment summary anyway, to help out the
 	 * roll-forward agent.
 	 */
 	if ((nblocks = sp->cbpp - sp->bpp) == 1) {
 		if ((ssp->ss_flags & (SS_DIROP | SS_CONT)) != SS_DIROP)
 			return 0;
+	}
 	/* Note if partial segment is being written by the cleaner */
 	if (sp->seg_flags & SEGM_CLEAN)
 		ssp->ss_flags |= SS_CLEAN;
 	/* Note if we are writing to reclaim */
 	if (sp->seg_flags & SEGM_RECLAIM) {
 		ssp->ss_flags |= SS_RECLAIM;
 		ssp->ss_reclino = fs->lfs_reclino;
+	}
 	devvp = VTOI(fs->lfs_ivnode)->i_devvp;
 	/* Update the segment usage information. */
 	LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
 	/* Loop through all blocks, except the segment summary. */
 	for (bpp = sp->bpp; ++bpp < sp->cbpp; ) {
 		if ((*bpp)->b_vp != devvp) {
 			sup->su_nbytes += (*bpp)->b_bcount;
 			DLOG((DLOG_SU, "seg %" PRIu32 " += %ld for ino %d"
 			      " lbn %" PRId64 " db 0x%" PRIx64 "\n",
 			      sp->seg_number, (*bpp)->b_bcount,
 			      VTOI((*bpp)->b_vp)->i_number, (*bpp)->b_lblkno,
 			      (*bpp)->b_blkno));
+		}
+	}
 #ifdef DEBUG
 	/* Check for zero-length and zero-version FINFO entries. */
 	fip = (struct finfo *)((char *)ssp + SEGSUM_SIZE(fs));
 	for (findex = 0; findex < ssp->ss_nfinfo; findex++) {
 		KDASSERT(fip->fi_nblocks > 0);
 		KDASSERT(fip->fi_version > 0);
 		fip = (FINFO *)((char *)fip + FINFOSIZE +
 			sizeof(int32_t) * fip->fi_nblocks);
+	}
 #endif /* DEBUG */
 	ninos = (ssp->ss_ninos + LFS_INOPB(fs) - 1) / LFS_INOPB(fs);
 	DLOG((DLOG_SU, "seg %d += %d for %d inodes\n",
 	      sp->seg_number, ssp->ss_ninos * sizeof (struct ulfs1_dinode),
 	      ssp->ss_ninos));
 	sup->su_nbytes += ssp->ss_ninos * sizeof (struct ulfs1_dinode);
 	/* sup->su_nbytes += lfs_sb_getsumsize(fs); */
 	if (fs->lfs_version == 1)
 		sup->su_olastmod = time_second;
 	else
 		sup->su_lastmod = time_second;
 	sup->su_ninos += ninos;
 	++sup->su_nsums;
 	lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
 	do_again = !(bp->b_flags & B_GATHERED);
 	LFS_WRITESEGENTRY(sup, fs, sp->seg_number, bp); /* Ifile */
 	/*
 	 * Mark blocks B_BUSY, to prevent then from being changed between
 	 * the checksum computation and the actual write.
+	 *
 	 * If we are cleaning, check indirect blocks for UNWRITTEN, and if
 	 * there are any, replace them with copies that have UNASSIGNED
 	 * instead.
 	 */
 	mutex_enter(&bufcache_lock);
 	for (bpp = sp->bpp, i = nblocks - 1; i--;) {
 		++bpp;
 		bp = *bpp;
 		if (bp->b_iodone != NULL) {	 /* UBC or malloced buffer */
 			bp->b_cflags |= BC_BUSY;
 			continue;
+		}
 		while (bp->b_cflags & BC_BUSY) {
 			DLOG((DLOG_SEG, "lfs_writeseg: avoiding potential"
 			      " data summary corruption for ino %d, lbn %"
 			      PRId64 "\n",
 			      VTOI(bp->b_vp)->i_number, bp->b_lblkno));
 			bp->b_cflags |= BC_WANTED;
 			cv_wait(&bp->b_busy, &bufcache_lock);
+		}
 		bp->b_cflags |= BC_BUSY;
 		mutex_exit(&bufcache_lock);
 		unbusybp = NULL;
 		/*
 		 * Check and replace indirect block UNWRITTEN bogosity.
 		 * XXX See comment in lfs_writefile.
 		 */
 		if (bp->b_lblkno < 0 && bp->b_vp != devvp && bp->b_vp &&
 		   VTOI(bp->b_vp)->i_ffs1_blocks !=
 		   VTOI(bp->b_vp)->i_lfs_effnblks) {
 			DLOG((DLOG_VNODE, "lfs_writeseg: cleansing ino %d (%d != %d)\n",
 			      VTOI(bp->b_vp)->i_number,
 			      VTOI(bp->b_vp)->i_lfs_effnblks,
 			      VTOI(bp->b_vp)->i_ffs1_blocks));
 			/* Make a copy we'll make changes to */
 			newbp = lfs_newbuf(fs, bp->b_vp, bp->b_lblkno,
 					   bp->b_bcount, LFS_NB_IBLOCK);
 			newbp->b_blkno = bp->b_blkno;
 			memcpy(newbp->b_data, bp->b_data,
 			       newbp->b_bcount);
 			changed = 0;
 			/* XXX ondisk32 */
 			for (daddrp = (int32_t *)(newbp->b_data);
 			     daddrp < (int32_t *)((char *)newbp->b_data +
 						  newbp->b_bcount); daddrp++) {
 				if (*daddrp == UNWRITTEN) {
 					++changed;
 					*daddrp = 0;
+				}
+			}
 			/*
 			 * Get rid of the old buffer.  Don't mark it clean,
 			 * though, if it still has dirty data on it.
 			 */
 			if (changed) {
 				DLOG((DLOG_SEG, "lfs_writeseg: replacing UNWRITTEN(%d):"
 				      " bp = %p newbp = %p\n", changed, bp,
 				      newbp));
 				*bpp = newbp;
 				bp->b_flags &= ~B_GATHERED;
 				bp->b_error = 0;
 				if (bp->b_iodone != NULL) {
 					DLOG((DLOG_SEG, "lfs_writeseg: "
 					      "indir bp should not be B_CALL\n"));
 					biodone(bp);
 					bp = NULL;
 				} else {
 					/* Still on free list, leave it there */
 					unbusybp = bp;
 					/*
 					 * We have to re-decrement lfs_avail
 					 * since this block is going to come
 					 * back around to us in the next
 					 * segment.
 					 */
 					lfs_sb_subavail(fs,
 					    lfs_btofsb(fs, bp->b_bcount));
+				}
 			} else {
 				lfs_freebuf(fs, newbp);
+			}
+		}
 		mutex_enter(&bufcache_lock);
 		if (unbusybp != NULL) {
 			unbusybp->b_cflags &= ~BC_BUSY;
 			if (unbusybp->b_cflags & BC_WANTED)
 				cv_broadcast(&bp->b_busy);
+		}
+	}
 	mutex_exit(&bufcache_lock);
 	/*
 	 * Compute checksum across data and then across summary; the first
 	 * block (the summary block) is skipped.  Set the create time here
 	 * so that it's guaranteed to be later than the inode mod times.
 	 */
 	sum = 0;
 	if (fs->lfs_version == 1)
 		el_size = sizeof(u_long);
 	else
 		el_size = sizeof(u_int32_t);
 	for (bpp = sp->bpp, i = nblocks - 1; i--; ) {
 		++bpp;
 		/* Loop through gop_write cluster blocks */
 		for (byteoffset = 0; byteoffset < (*bpp)->b_bcount;
 		     byteoffset += lfs_sb_getbsize(fs)) {
 #ifdef LFS_USE_B_INVAL
 			if (((*bpp)->b_cflags & BC_INVAL) != 0 &&
 			    (*bpp)->b_iodone != NULL) {
 				if (copyin((void *)(*bpp)->b_saveaddr +
 					   byteoffset, dp, el_size)) {
 					panic("lfs_writeseg: copyin failed [1]:"
 						" ino %d blk %" PRId64,
 						VTOI((*bpp)->b_vp)->i_number,
 						(*bpp)->b_lblkno);
+				}
 			} else
 #endif /* LFS_USE_B_INVAL */
+			{
 				sum = lfs_cksum_part((char *)
 				    (*bpp)->b_data + byteoffset, el_size, sum);
+			}
+		}
+	}
 	if (fs->lfs_version == 1)
 		ssp->ss_ocreate = time_second;
 	else {
 		ssp->ss_create = time_second;
 		lfs_sb_addserial(fs, 1);
 		ssp->ss_serial = lfs_sb_getserial(fs);
 		ssp->ss_ident  = lfs_sb_getident(fs);
+	}
 	ssp->ss_datasum = lfs_cksum_fold(sum);
 	ssp->ss_sumsum = cksum(&ssp->ss_datasum,
 	    lfs_sb_getsumsize(fs) - sizeof(ssp->ss_sumsum));
 	mutex_enter(&lfs_lock);
 	lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
 			  lfs_btofsb(fs, lfs_sb_getsumsize(fs))));
 	lfs_sb_adddmeta(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
 			  lfs_btofsb(fs, lfs_sb_getsumsize(fs))));
 	mutex_exit(&lfs_lock);
 	/*
 	 * When we simply write the blocks we lose a rotation for every block
 	 * written.  To avoid this problem, we cluster the buffers into a
 	 * chunk and write the chunk.  MAXPHYS is the largest size I/O
 	 * devices can handle, use that for the size of the chunks.
+	 *
 	 * Blocks that are already clusters (from GOP_WRITE), however, we
 	 * don't bother to copy into other clusters.
 	 */
 #define CHUNKSIZE MAXPHYS
 	if (devvp == NULL)
 		panic("devvp is NULL");
 	for (bpp = sp->bpp, i = nblocks; i;) {
 		cbp = lfs_newclusterbuf(fs, devvp, (*bpp)->b_blkno, i);
 		cl = cbp->b_private;
 		cbp->b_flags |= B_ASYNC;
 		cbp->b_cflags |= BC_BUSY;
 		cbp->b_bcount = 0;
 #if defined(DEBUG) && defined(DIAGNOSTIC)
 		if (bpp - sp->bpp > (lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs))
 		    / sizeof(int32_t)) {
 			panic("lfs_writeseg: real bpp overwrite");
+		}
-		if (bpp - sp->bpp > lfs_segsize(fs) / fs->lfs_fsize) {
+		if (bpp - sp->bpp > lfs_segsize(fs) / lfs_sb_getfsize(fs)) {
 			panic("lfs_writeseg: theoretical bpp overwrite");
+		}
 #endif
 		/*
 		 * Construct the cluster.
 		 */
 		mutex_enter(&lfs_lock);
 		++fs->lfs_iocount;
 		mutex_exit(&lfs_lock);
 		while (i && cbp->b_bcount < CHUNKSIZE) {
 			bp = *bpp;
 			if (bp->b_bcount > (CHUNKSIZE - cbp->b_bcount))
 				break;
 			if (cbp->b_bcount > 0 && !(cl->flags & LFS_CL_MALLOC))
 				break;
 			/* Clusters from GOP_WRITE are expedited */
 			if (bp->b_bcount > lfs_sb_getbsize(fs)) {
 				if (cbp->b_bcount > 0)
 					/* Put in its own buffer */
 					break;
 				else {
 					cbp->b_data = bp->b_data;
+				}
 			} else if (cbp->b_bcount == 0) {
 				p = cbp->b_data = lfs_malloc(fs, CHUNKSIZE,
 							     LFS_NB_CLUSTER);
 				cl->flags |= LFS_CL_MALLOC;
+			}
 #ifdef DIAGNOSTIC
 			if (lfs_dtosn(fs, LFS_DBTOFSB(fs, bp->b_blkno +
 					      btodb(bp->b_bcount - 1))) !=
 			    sp->seg_number) {
 				printf("blk size %d daddr %" PRIx64
 				    " not in seg %d\n",
 				    bp->b_bcount, bp->b_blkno,
 				    sp->seg_number);
 				panic("segment overwrite");
+			}
 #endif
 #ifdef LFS_USE_B_INVAL
 			/*
 			 * Fake buffers from the cleaner are marked as B_INVAL.
 			 * We need to copy the data from user space rather than
 			 * from the buffer indicated.
 			 * XXX == what do I do on an error?
 			 */
 			if ((bp->b_cflags & BC_INVAL) != 0 &&
 			    bp->b_iodone != NULL) {
 				if (copyin(bp->b_saveaddr, p, bp->b_bcount))
 					panic("lfs_writeseg: "
 					    "copyin failed [2]");
 			} else
 #endif /* LFS_USE_B_INVAL */
 			if (cl->flags & LFS_CL_MALLOC) {
 				/* copy data into our cluster. */
 				memcpy(p, bp->b_data, bp->b_bcount);
 				p += bp->b_bcount;
+			}
 			cbp->b_bcount += bp->b_bcount;
 			cl->bufsize += bp->b_bcount;
 			bp->b_flags &= ~B_READ;
 			bp->b_error = 0;
 			cl->bpp[cl->bufcount++] = bp;
 			vp = bp->b_vp;
 			mutex_enter(&bufcache_lock);
 			mutex_enter(vp->v_interlock);
 			bp->b_oflags &= ~(BO_DELWRI | BO_DONE);
 			reassignbuf(bp, vp);
 			vp->v_numoutput++;
 			mutex_exit(vp->v_interlock);
 			mutex_exit(&bufcache_lock);
 			bpp++;
 			i--;
+		}
 		if (fs->lfs_sp->seg_flags & SEGM_SYNC)
 			BIO_SETPRIO(cbp, BPRIO_TIMECRITICAL);
 		else
 			BIO_SETPRIO(cbp, BPRIO_TIMELIMITED);
 		mutex_enter(devvp->v_interlock);
 		devvp->v_numoutput++;
 		mutex_exit(devvp->v_interlock);
 		VOP_STRATEGY(devvp, cbp);
 		curlwp->l_ru.ru_oublock++;
+	}
 	if (lfs_dostats) {
 		++lfs_stats.psegwrites;
 		lfs_stats.blocktot += nblocks - 1;
 		if (fs->lfs_sp->seg_flags & SEGM_SYNC)
 			++lfs_stats.psyncwrites;
 		if (fs->lfs_sp->seg_flags & SEGM_CLEAN) {
 			++lfs_stats.pcleanwrites;
 			lfs_stats.cleanblocks += nblocks - 1;
+		}
+	}
 	return (lfs_initseg(fs) || do_again);
+}
 void
 lfs_writesuper(struct lfs *fs, daddr_t daddr)
+{
 	struct buf *bp;
 	struct vnode *devvp = VTOI(fs->lfs_ivnode)->i_devvp;
 	int s;
 	ASSERT_MAYBE_SEGLOCK(fs);
 #ifdef DIAGNOSTIC
 	KASSERT(fs->lfs_magic == LFS_MAGIC);
 #endif
 	/*
 	 * If we can write one superblock while another is in
 	 * progress, we risk not having a complete checkpoint if we crash.
 	 * So, block here if a superblock write is in progress.
 	 */
 	mutex_enter(&lfs_lock);
 	s = splbio();
 	while (fs->lfs_sbactive) {
 		mtsleep(&fs->lfs_sbactive, PRIBIO+1, "lfs sb", 0,
 			&lfs_lock);
+	}
 	fs->lfs_sbactive = daddr;
 	splx(s);
 	mutex_exit(&lfs_lock);
 	/* Set timestamp of this version of the superblock */
 	if (fs->lfs_version == 1)
 		lfs_sb_setotstamp(fs, time_second);
 	lfs_sb_settstamp(fs, time_second);
 	/* Checksum the superblock and copy it into a buffer. */
 	lfs_sb_setcksum(fs, lfs_sb_cksum(&(fs->lfs_dlfs)));
 	bp = lfs_newbuf(fs, devvp,
 	    LFS_FSBTODB(fs, daddr), LFS_SBPAD, LFS_NB_SBLOCK);
 	memset((char *)bp->b_data + sizeof(struct dlfs), 0,
 	    LFS_SBPAD - sizeof(struct dlfs));
 	*(struct dlfs *)bp->b_data = fs->lfs_dlfs;
 	bp->b_cflags |= BC_BUSY;
 	bp->b_flags = (bp->b_flags & ~B_READ) | B_ASYNC;
 	bp->b_oflags &= ~(BO_DONE | BO_DELWRI);
 	bp->b_error = 0;
 	bp->b_iodone = lfs_supercallback;
 	if (fs->lfs_sp != NULL && fs->lfs_sp->seg_flags & SEGM_SYNC)
 		BIO_SETPRIO(bp, BPRIO_TIMECRITICAL);
 	else
 		BIO_SETPRIO(bp, BPRIO_TIMELIMITED);
 	curlwp->l_ru.ru_oublock++;
 	mutex_enter(devvp->v_interlock);
 	devvp->v_numoutput++;
 	mutex_exit(devvp->v_interlock);
 	mutex_enter(&lfs_lock);
 	++fs->lfs_iocount;
 	mutex_exit(&lfs_lock);
 	VOP_STRATEGY(devvp, bp);
+}
 /*
  * Logical block number match routines used when traversing the dirty block
  * chain.
  */
 int
 lfs_match_fake(struct lfs *fs, struct buf *bp)
+{
 	ASSERT_SEGLOCK(fs);
 	return LFS_IS_MALLOC_BUF(bp);
+}
 #if 0
 int
 lfs_match_real(struct lfs *fs, struct buf *bp)
+{
 	ASSERT_SEGLOCK(fs);
 	return (lfs_match_data(fs, bp) && !lfs_match_fake(fs, bp));
+}
 #endif
 int
 lfs_match_data(struct lfs *fs, struct buf *bp)
+{
 	ASSERT_SEGLOCK(fs);
 	return (bp->b_lblkno >= 0);
+}
 int
 lfs_match_indir(struct lfs *fs, struct buf *bp)
+{
 	daddr_t lbn;
 	ASSERT_SEGLOCK(fs);
 	lbn = bp->b_lblkno;
 	return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 0);
+}
 int
 lfs_match_dindir(struct lfs *fs, struct buf *bp)
+{
 	daddr_t lbn;
 	ASSERT_SEGLOCK(fs);
 	lbn = bp->b_lblkno;
 	return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 1);
+}
 int
 lfs_match_tindir(struct lfs *fs, struct buf *bp)
+{
 	daddr_t lbn;
 	ASSERT_SEGLOCK(fs);
 	lbn = bp->b_lblkno;
 	return (lbn < 0 && (-lbn - ULFS_NDADDR) % LFS_NINDIR(fs) == 2);
+}
 static void
 lfs_free_aiodone(struct buf *bp)
+{
 	struct lfs *fs;
 	KERNEL_LOCK(1, curlwp);
 	fs = bp->b_private;
 	ASSERT_NO_SEGLOCK(fs);
 	lfs_freebuf(fs, bp);
 	KERNEL_UNLOCK_LAST(curlwp);
+}
 static void
 lfs_super_aiodone(struct buf *bp)
+{
 	struct lfs *fs;
 	KERNEL_LOCK(1, curlwp);
 	fs = bp->b_private;
 	ASSERT_NO_SEGLOCK(fs);
 	mutex_enter(&lfs_lock);
 	fs->lfs_sbactive = 0;
 	if (--fs->lfs_iocount <= 1)
 		wakeup(&fs->lfs_iocount);
 	wakeup(&fs->lfs_sbactive);
 	mutex_exit(&lfs_lock);
 	lfs_freebuf(fs, bp);
 	KERNEL_UNLOCK_LAST(curlwp);
+}
 static void
 lfs_cluster_aiodone(struct buf *bp)
+{
 	struct lfs_cluster *cl;
 	struct lfs *fs;
 	struct buf *tbp, *fbp;
 	struct vnode *vp, *devvp, *ovp;
 	struct inode *ip;
 	int error;
 	KERNEL_LOCK(1, curlwp);
 	error = bp->b_error;
 	cl = bp->b_private;
 	fs = cl->fs;
 	devvp = VTOI(fs->lfs_ivnode)->i_devvp;
 	ASSERT_NO_SEGLOCK(fs);
 	/* Put the pages back, and release the buffer */
 	while (cl->bufcount--) {
 		tbp = cl->bpp[cl->bufcount];
 		KASSERT(tbp->b_cflags & BC_BUSY);
 		if (error) {
 			tbp->b_error = error;
+		}
 		/*
 		 * We're done with tbp.	 If it has not been re-dirtied since
 		 * the cluster was written, free it.  Otherwise, keep it on
 		 * the locked list to be written again.
 		 */
 		vp = tbp->b_vp;
 		tbp->b_flags &= ~B_GATHERED;
 		LFS_BCLEAN_LOG(fs, tbp);
 		mutex_enter(&bufcache_lock);
 		if (tbp->b_iodone == NULL) {
 			KASSERT(tbp->b_flags & B_LOCKED);
 			bremfree(tbp);
 			if (vp) {
 				mutex_enter(vp->v_interlock);
 				reassignbuf(tbp, vp);
 				mutex_exit(vp->v_interlock);
+			}
 			tbp->b_flags |= B_ASYNC; /* for biodone */
+		}
 		if (((tbp->b_flags | tbp->b_oflags) &
 		    (B_LOCKED | BO_DELWRI)) == B_LOCKED)
 			LFS_UNLOCK_BUF(tbp);
 		if (tbp->b_oflags & BO_DONE) {
 			DLOG((DLOG_SEG, "blk %d biodone already (flags %lx)\n",
 				cl->bufcount, (long)tbp->b_flags));
+		}
 		if (tbp->b_iodone != NULL && !LFS_IS_MALLOC_BUF(tbp)) {
 			/*
 			 * A buffer from the page daemon.
 			 * We use the same iodone as it does,
 			 * so we must manually disassociate its
 			 * buffers from the vp.
 			 */
 			if ((ovp = tbp->b_vp) != NULL) {
 				/* This is just silly */
 				mutex_enter(ovp->v_interlock);
 				brelvp(tbp);
 				mutex_exit(ovp->v_interlock);
 				tbp->b_vp = vp;
 				tbp->b_objlock = vp->v_interlock;
+			}
 			/* Put it back the way it was */
 			tbp->b_flags |= B_ASYNC;
 			/* Master buffers have BC_AGE */
 			if (tbp->b_private == tbp)
 				tbp->b_cflags |= BC_AGE;
+		}
 		mutex_exit(&bufcache_lock);
 		biodone(tbp);
 		/*
 		 * If this is the last block for this vnode, but
 		 * there are other blocks on its dirty list,
 		 * set IN_MODIFIED/IN_CLEANING depending on what
 		 * sort of block.  Only do this for our mount point,
 		 * not for, e.g., inode blocks that are attached to
 		 * the devvp.
 		 * XXX KS - Shouldn't we set *both* if both types
 		 * of blocks are present (traverse the dirty list?)
 		 */
 		mutex_enter(vp->v_interlock);
 		mutex_enter(&lfs_lock);
 		if (vp != devvp && vp->v_numoutput == 0 &&
 		    (fbp = LIST_FIRST(&vp->v_dirtyblkhd)) != NULL) {
 			ip = VTOI(vp);
 			DLOG((DLOG_SEG, "lfs_cluster_aiodone: mark ino %d\n",
 			       ip->i_number));
 			if (LFS_IS_MALLOC_BUF(fbp))
 				LFS_SET_UINO(ip, IN_CLEANING);
 			else
 				LFS_SET_UINO(ip, IN_MODIFIED);
+		}
 		cv_broadcast(&vp->v_cv);
 		mutex_exit(&lfs_lock);
 		mutex_exit(vp->v_interlock);
+	}
 	/* Fix up the cluster buffer, and release it */
 	if (cl->flags & LFS_CL_MALLOC)
 		lfs_free(fs, bp->b_data, LFS_NB_CLUSTER);
 	putiobuf(bp);
 	/* Note i/o done */
 	if (cl->flags & LFS_CL_SYNC) {
 		if (--cl->seg->seg_iocount == 0)
 			wakeup(&cl->seg->seg_iocount);
+	}
 	mutex_enter(&lfs_lock);
 #ifdef DIAGNOSTIC
 	if (fs->lfs_iocount == 0)
 		panic("lfs_cluster_aiodone: zero iocount");
 #endif
 	if (--fs->lfs_iocount <= 1)
 		wakeup(&fs->lfs_iocount);
 	mutex_exit(&lfs_lock);
 	KERNEL_UNLOCK_LAST(curlwp);
 	pool_put(&fs->lfs_bpppool, cl->bpp);
 	cl->bpp = NULL;
 	pool_put(&fs->lfs_clpool, cl);
+}
 static void
 lfs_generic_callback(struct buf *bp, void (*aiodone)(struct buf *))
+{
 	/* reset b_iodone for when this is a single-buf i/o. */
 	bp->b_iodone = aiodone;
 	workqueue_enqueue(uvm.aiodone_queue, &bp->b_work, NULL);
+}
 static void
 lfs_cluster_callback(struct buf *bp)
+{
 	lfs_generic_callback(bp, lfs_cluster_aiodone);
+}
 void
 lfs_supercallback(struct buf *bp)
+{
 	lfs_generic_callback(bp, lfs_super_aiodone);
+}
 /*
  * The only buffers that are going to hit these functions are the
  * segment write blocks, or the segment summaries, or the superblocks.
+ *
  * All of the above are created by lfs_newbuf, and so do not need to be
  * released via brelse.
  */
 void
 lfs_callback(struct buf *bp)
+{
 	lfs_generic_callback(bp, lfs_free_aiodone);
+}
 /*
  * Shellsort (diminishing increment sort) from Data Structures and
  * Algorithms, Aho, Hopcraft and Ullman, 1983 Edition, page 290;
  * see also Knuth Vol. 3, page 84.  The increments are selected from
  * formula (8), page 95.  Roughly O(N^3/2).
  */
 /*
  * This is our own private copy of shellsort because we want to sort
  * two parallel arrays (the array of buffer pointers and the array of
  * logical block numbers) simultaneously.  Note that we cast the array
  * of logical block numbers to a unsigned in this routine so that the
  * negative block numbers (meta data blocks) sort AFTER the data blocks.
  */
 void
 lfs_shellsort(struct buf **bp_array, int32_t *lb_array, int nmemb, int size)
+{
 	static int __rsshell_increments[] = { 4, 1, 0 };
 	int incr, *incrp, t1, t2;
 	struct buf *bp_temp;
 #ifdef DEBUG
 	incr = 0;
 	for (t1 = 0; t1 < nmemb; t1++) {
 		for (t2 = 0; t2 * size < bp_array[t1]->b_bcount; t2++) {
 			if (lb_array[incr++] != bp_array[t1]->b_lblkno + t2) {
 				/* dump before panic */
 				printf("lfs_shellsort: nmemb=%d, size=%d\n",
 				    nmemb, size);
 				incr = 0;
 				for (t1 = 0; t1 < nmemb; t1++) {
 					const struct buf *bp = bp_array[t1];
 					printf("bp[%d]: lbn=%" PRIu64 ", size=%"
 					    PRIu64 "\n", t1,
 					    (uint64_t)bp->b_bcount,
 					    (uint64_t)bp->b_lblkno);
 					printf("lbns:");
 					for (t2 = 0; t2 * size < bp->b_bcount;
 					    t2++) {
 						printf(" %" PRId32,
 						    lb_array[incr++]);
+					}
 					printf("\n");
+				}
 				panic("lfs_shellsort: inconsistent input");
+			}
+		}
+	}
 #endif
 	for (incrp = __rsshell_increments; (incr = *incrp++) != 0;)
 		for (t1 = incr; t1 < nmemb; ++t1)
 			for (t2 = t1 - incr; t2 >= 0;)
 				if ((u_int32_t)bp_array[t2]->b_lblkno >
 				    (u_int32_t)bp_array[t2 + incr]->b_lblkno) {
 					bp_temp = bp_array[t2];
 					bp_array[t2] = bp_array[t2 + incr];
 					bp_array[t2 + incr] = bp_temp;
 					t2 -= incr;
 				} else
 					break;
 	/* Reform the list of logical blocks */
 	incr = 0;
 	for (t1 = 0; t1 < nmemb; t1++) {
 		for (t2 = 0; t2 * size < bp_array[t1]->b_bcount; t2++) {
 			lb_array[incr++] = bp_array[t1]->b_lblkno + t2;
+		}
+	}
+}
 /*
  * Set up an FINFO entry for a new file.  The fip pointer is assumed to
  * point at uninitialized space.
  */
 void
 lfs_acquire_finfo(struct lfs *fs, ino_t ino, int vers)
+{
 	struct segment *sp = fs->lfs_sp;
 	KASSERT(vers > 0);
 	if (sp->seg_bytes_left < lfs_sb_getbsize(fs) ||
 	    sp->sum_bytes_left < sizeof(struct finfo))
 		(void) lfs_writeseg(fs, fs->lfs_sp);
 	sp->sum_bytes_left -= FINFOSIZE;
 	++((SEGSUM *)(sp->segsum))->ss_nfinfo;
 	sp->fip->fi_nblocks = 0;
 	sp->fip->fi_ino = ino;
 	sp->fip->fi_version = vers;
+}
 /*
  * Release the FINFO entry, either clearing out an unused entry or
  * advancing us to the next available entry.
  */
 void
 lfs_release_finfo(struct lfs *fs)
+{
 	struct segment *sp = fs->lfs_sp;
 	if (sp->fip->fi_nblocks != 0) {
 		sp->fip = (FINFO*)((char *)sp->fip + FINFOSIZE +
 			sizeof(int32_t) * sp->fip->fi_nblocks);
 		sp->start_lbp = &sp->fip->fi_blocks[0];
 	} else {
 		sp->sum_bytes_left += FINFOSIZE;
 		--((SEGSUM *)(sp->segsum))->ss_nfinfo;
+	}
+}

 @@ -1,2232 +1,2232 @@
-/*	$NetBSD: lfs_vnops.c,v 1.275 2015/07/24 06:59:32 dholland Exp $	*/
+/*	$NetBSD: lfs_vnops.c,v 1.276 2015/07/25 10:40:35 martin 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
  * 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) 1986, 1989, 1991, 1993, 1995
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    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.
+ *
  *	@(#)lfs_vnops.c	8.13 (Berkeley) 6/10/95
  */
 /*  from NetBSD: ufs_vnops.c,v 1.213 2013/06/08 05:47:02 kardel Exp  */
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Wasabi Systems, 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.
+ *
  * 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) 1982, 1986, 1989, 1993, 1995
  *	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_vnops.c	8.28 (Berkeley) 7/31/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.275 2015/07/24 06:59:32 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.276 2015/07/25 10:40:35 martin Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_compat_netbsd.h"
 #include "opt_uvm_page_trkown.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/resourcevar.h>
 #include <sys/kernel.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/buf.h>
 #include <sys/proc.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <sys/pool.h>
 #include <sys/signalvar.h>
 #include <sys/kauth.h>
 #include <sys/syslog.h>
 #include <sys/fstrans.h>
 #include <miscfs/fifofs/fifo.h>
 #include <miscfs/genfs/genfs.h>
 #include <miscfs/specfs/specdev.h>
 #include <ufs/lfs/ulfs_inode.h>
 #include <ufs/lfs/ulfsmount.h>
 #include <ufs/lfs/ulfs_bswap.h>
 #include <ufs/lfs/ulfs_extern.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_pmap.h>
 #include <uvm/uvm_stat.h>
 #include <uvm/uvm_pager.h>
 #include <ufs/lfs/lfs.h>
 #include <ufs/lfs/lfs_kernel.h>
 #include <ufs/lfs/lfs_extern.h>
 extern pid_t lfs_writer_daemon;
 int lfs_ignore_lazy_sync = 1;
 static int lfs_openextattr(void *v);
 static int lfs_closeextattr(void *v);
 static int lfs_getextattr(void *v);
 static int lfs_setextattr(void *v);
 static int lfs_listextattr(void *v);
 static int lfs_deleteextattr(void *v);
 /*
  * A virgin directory (no blushing please).
  */
 static const struct lfs_dirtemplate mastertemplate = {
 ,	12,			LFS_DT_DIR,	1,	".",
 ,	LFS_DIRBLKSIZ - 12,	LFS_DT_DIR,	2,	".."
 };
 /* Global vfs data structures for lfs. */
 int (**lfs_vnodeop_p)(void *);
 const struct vnodeopv_entry_desc lfs_vnodeop_entries[] = {
 	{ &vop_default_desc, vn_default_error },
 	{ &vop_lookup_desc, ulfs_lookup },		/* lookup */
 	{ &vop_create_desc, lfs_create },		/* create */
 	{ &vop_whiteout_desc, ulfs_whiteout },		/* whiteout */
 	{ &vop_mknod_desc, lfs_mknod },			/* mknod */
 	{ &vop_open_desc, ulfs_open },			/* open */
 	{ &vop_close_desc, lfs_close },			/* close */
 	{ &vop_access_desc, ulfs_access },		/* access */
 	{ &vop_getattr_desc, lfs_getattr },		/* getattr */
 	{ &vop_setattr_desc, lfs_setattr },		/* setattr */
 	{ &vop_read_desc, lfs_read },			/* read */
 	{ &vop_write_desc, lfs_write },			/* write */
 	{ &vop_fallocate_desc, genfs_eopnotsupp },	/* fallocate */
 	{ &vop_fdiscard_desc, genfs_eopnotsupp },	/* fdiscard */
 	{ &vop_ioctl_desc, ulfs_ioctl },		/* ioctl */
 	{ &vop_fcntl_desc, lfs_fcntl },			/* fcntl */
 	{ &vop_poll_desc, ulfs_poll },			/* poll */
 	{ &vop_kqfilter_desc, genfs_kqfilter },		/* kqfilter */
 	{ &vop_revoke_desc, ulfs_revoke },		/* revoke */
 	{ &vop_mmap_desc, lfs_mmap },			/* mmap */
 	{ &vop_fsync_desc, lfs_fsync },			/* fsync */
 	{ &vop_seek_desc, ulfs_seek },			/* seek */
 	{ &vop_remove_desc, lfs_remove },		/* remove */
 	{ &vop_link_desc, lfs_link },			/* link */
 	{ &vop_rename_desc, lfs_rename },		/* rename */
 	{ &vop_mkdir_desc, lfs_mkdir },			/* mkdir */
 	{ &vop_rmdir_desc, lfs_rmdir },			/* rmdir */
 	{ &vop_symlink_desc, lfs_symlink },		/* symlink */
 	{ &vop_readdir_desc, ulfs_readdir },		/* readdir */
 	{ &vop_readlink_desc, ulfs_readlink },		/* readlink */
 	{ &vop_abortop_desc, ulfs_abortop },		/* abortop */
 	{ &vop_inactive_desc, lfs_inactive },		/* inactive */
 	{ &vop_reclaim_desc, lfs_reclaim },		/* reclaim */
 	{ &vop_lock_desc, ulfs_lock },			/* lock */
 	{ &vop_unlock_desc, ulfs_unlock },		/* unlock */
 	{ &vop_bmap_desc, ulfs_bmap },			/* bmap */
 	{ &vop_strategy_desc, lfs_strategy },		/* strategy */
 	{ &vop_print_desc, ulfs_print },		/* print */
 	{ &vop_islocked_desc, ulfs_islocked },		/* islocked */
 	{ &vop_pathconf_desc, ulfs_pathconf },		/* pathconf */
 	{ &vop_advlock_desc, ulfs_advlock },		/* advlock */
 	{ &vop_bwrite_desc, lfs_bwrite },		/* bwrite */
 	{ &vop_getpages_desc, lfs_getpages },		/* getpages */
 	{ &vop_putpages_desc, lfs_putpages },		/* putpages */
 	{ &vop_openextattr_desc, lfs_openextattr },	/* openextattr */
 	{ &vop_closeextattr_desc, lfs_closeextattr },	/* closeextattr */
 	{ &vop_getextattr_desc, lfs_getextattr },	/* getextattr */
 	{ &vop_setextattr_desc, lfs_setextattr },	/* setextattr */
 	{ &vop_listextattr_desc, lfs_listextattr },	/* listextattr */
 	{ &vop_deleteextattr_desc, lfs_deleteextattr },	/* deleteextattr */
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc lfs_vnodeop_opv_desc =
 	{ &lfs_vnodeop_p, lfs_vnodeop_entries };
 int (**lfs_specop_p)(void *);
 const struct vnodeopv_entry_desc lfs_specop_entries[] = {
 	{ &vop_default_desc, vn_default_error },
 	{ &vop_lookup_desc, spec_lookup },		/* lookup */
 	{ &vop_create_desc, spec_create },		/* create */
 	{ &vop_mknod_desc, spec_mknod },		/* mknod */
 	{ &vop_open_desc, spec_open },			/* open */
 	{ &vop_close_desc, lfsspec_close },		/* close */
 	{ &vop_access_desc, ulfs_access },		/* access */
 	{ &vop_getattr_desc, lfs_getattr },		/* getattr */
 	{ &vop_setattr_desc, lfs_setattr },		/* setattr */
 	{ &vop_read_desc, ulfsspec_read },		/* read */
 	{ &vop_write_desc, ulfsspec_write },		/* write */
 	{ &vop_fallocate_desc, spec_fallocate },	/* fallocate */
 	{ &vop_fdiscard_desc, spec_fdiscard },		/* fdiscard */
 	{ &vop_ioctl_desc, spec_ioctl },		/* ioctl */
 	{ &vop_fcntl_desc, ulfs_fcntl },		/* fcntl */
 	{ &vop_poll_desc, spec_poll },			/* poll */
 	{ &vop_kqfilter_desc, spec_kqfilter },		/* kqfilter */
 	{ &vop_revoke_desc, spec_revoke },		/* revoke */
 	{ &vop_mmap_desc, spec_mmap },			/* mmap */
 	{ &vop_fsync_desc, spec_fsync },		/* fsync */
 	{ &vop_seek_desc, spec_seek },			/* seek */
 	{ &vop_remove_desc, spec_remove },		/* remove */
 	{ &vop_link_desc, spec_link },			/* link */
 	{ &vop_rename_desc, spec_rename },		/* rename */
 	{ &vop_mkdir_desc, spec_mkdir },		/* mkdir */
 	{ &vop_rmdir_desc, spec_rmdir },		/* rmdir */
 	{ &vop_symlink_desc, spec_symlink },		/* symlink */
 	{ &vop_readdir_desc, spec_readdir },		/* readdir */
 	{ &vop_readlink_desc, spec_readlink },		/* readlink */
 	{ &vop_abortop_desc, spec_abortop },		/* abortop */
 	{ &vop_inactive_desc, lfs_inactive },		/* inactive */
 	{ &vop_reclaim_desc, lfs_reclaim },		/* reclaim */
 	{ &vop_lock_desc, ulfs_lock },			/* lock */
 	{ &vop_unlock_desc, ulfs_unlock },		/* unlock */
 	{ &vop_bmap_desc, spec_bmap },			/* bmap */
 	{ &vop_strategy_desc, spec_strategy },		/* strategy */
 	{ &vop_print_desc, ulfs_print },		/* print */
 	{ &vop_islocked_desc, ulfs_islocked },		/* islocked */
 	{ &vop_pathconf_desc, spec_pathconf },		/* pathconf */
 	{ &vop_advlock_desc, spec_advlock },		/* advlock */
 	{ &vop_bwrite_desc, vn_bwrite },		/* bwrite */
 	{ &vop_getpages_desc, spec_getpages },		/* getpages */
 	{ &vop_putpages_desc, spec_putpages },		/* putpages */
 	{ &vop_openextattr_desc, lfs_openextattr },	/* openextattr */
 	{ &vop_closeextattr_desc, lfs_closeextattr },	/* closeextattr */
 	{ &vop_getextattr_desc, lfs_getextattr },	/* getextattr */
 	{ &vop_setextattr_desc, lfs_setextattr },	/* setextattr */
 	{ &vop_listextattr_desc, lfs_listextattr },	/* listextattr */
 	{ &vop_deleteextattr_desc, lfs_deleteextattr },	/* deleteextattr */
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc lfs_specop_opv_desc =
 	{ &lfs_specop_p, lfs_specop_entries };
 int (**lfs_fifoop_p)(void *);
 const struct vnodeopv_entry_desc lfs_fifoop_entries[] = {
 	{ &vop_default_desc, vn_default_error },
 	{ &vop_lookup_desc, vn_fifo_bypass },		/* lookup */
 	{ &vop_create_desc, vn_fifo_bypass },		/* create */
 	{ &vop_mknod_desc, vn_fifo_bypass },		/* mknod */
 	{ &vop_open_desc, vn_fifo_bypass },		/* open */
 	{ &vop_close_desc, lfsfifo_close },		/* close */
 	{ &vop_access_desc, ulfs_access },		/* access */
 	{ &vop_getattr_desc, lfs_getattr },		/* getattr */
 	{ &vop_setattr_desc, lfs_setattr },		/* setattr */
 	{ &vop_read_desc, ulfsfifo_read },		/* read */
 	{ &vop_write_desc, ulfsfifo_write },		/* write */
 	{ &vop_fallocate_desc, vn_fifo_bypass },	/* fallocate */
 	{ &vop_fdiscard_desc, vn_fifo_bypass },		/* fdiscard */
 	{ &vop_ioctl_desc, vn_fifo_bypass },		/* ioctl */
 	{ &vop_fcntl_desc, ulfs_fcntl },		/* fcntl */
 	{ &vop_poll_desc, vn_fifo_bypass },		/* poll */
 	{ &vop_kqfilter_desc, vn_fifo_bypass },		/* kqfilter */
 	{ &vop_revoke_desc, vn_fifo_bypass },		/* revoke */
 	{ &vop_mmap_desc, vn_fifo_bypass },		/* mmap */
 	{ &vop_fsync_desc, vn_fifo_bypass },		/* fsync */
 	{ &vop_seek_desc, vn_fifo_bypass },		/* seek */
 	{ &vop_remove_desc, vn_fifo_bypass },		/* remove */
 	{ &vop_link_desc, vn_fifo_bypass },		/* link */
 	{ &vop_rename_desc, vn_fifo_bypass },		/* rename */
 	{ &vop_mkdir_desc, vn_fifo_bypass },		/* mkdir */
 	{ &vop_rmdir_desc, vn_fifo_bypass },		/* rmdir */
 	{ &vop_symlink_desc, vn_fifo_bypass },		/* symlink */
 	{ &vop_readdir_desc, vn_fifo_bypass },		/* readdir */
 	{ &vop_readlink_desc, vn_fifo_bypass },		/* readlink */
 	{ &vop_abortop_desc, vn_fifo_bypass },		/* abortop */
 	{ &vop_inactive_desc, lfs_inactive },		/* inactive */
 	{ &vop_reclaim_desc, lfs_reclaim },		/* reclaim */
 	{ &vop_lock_desc, ulfs_lock },			/* lock */
 	{ &vop_unlock_desc, ulfs_unlock },		/* unlock */
 	{ &vop_bmap_desc, vn_fifo_bypass },		/* bmap */
 	{ &vop_strategy_desc, vn_fifo_bypass },		/* strategy */
 	{ &vop_print_desc, ulfs_print },		/* print */
 	{ &vop_islocked_desc, ulfs_islocked },		/* islocked */
 	{ &vop_pathconf_desc, vn_fifo_bypass },		/* pathconf */
 	{ &vop_advlock_desc, vn_fifo_bypass },		/* advlock */
 	{ &vop_bwrite_desc, lfs_bwrite },		/* bwrite */
 	{ &vop_putpages_desc, vn_fifo_bypass },		/* putpages */
 	{ &vop_openextattr_desc, lfs_openextattr },	/* openextattr */
 	{ &vop_closeextattr_desc, lfs_closeextattr },	/* closeextattr */
 	{ &vop_getextattr_desc, lfs_getextattr },	/* getextattr */
 	{ &vop_setextattr_desc, lfs_setextattr },	/* setextattr */
 	{ &vop_listextattr_desc, lfs_listextattr },	/* listextattr */
 	{ &vop_deleteextattr_desc, lfs_deleteextattr },	/* deleteextattr */
 	{ NULL, NULL }
 };
 const struct vnodeopv_desc lfs_fifoop_opv_desc =
 	{ &lfs_fifoop_p, lfs_fifoop_entries };
 #define	LFS_READWRITE
 #include <ufs/lfs/ulfs_readwrite.c>
 #undef	LFS_READWRITE
 /*
  * Synch an open file.
  */
 /* ARGSUSED */
 int
 lfs_fsync(void *v)
+{
 	struct vop_fsync_args /* {
 		struct vnode *a_vp;
 		kauth_cred_t a_cred;
 		int a_flags;
 		off_t offlo;
 		off_t offhi;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	int error, wait;
 	struct inode *ip = VTOI(vp);
 	struct lfs *fs = ip->i_lfs;
 	/* If we're mounted read-only, don't try to sync. */
 	if (fs->lfs_ronly)
 		return 0;
 	/* If a removed vnode is being cleaned, no need to sync here. */
 	if ((ap->a_flags & FSYNC_RECLAIM) != 0 && ip->i_mode == 0)
 		return 0;
 	/*
 	 * Trickle sync simply adds this vnode to the pager list, as if
 	 * the pagedaemon had requested a pageout.
 	 */
 	if (ap->a_flags & FSYNC_LAZY) {
 		if (lfs_ignore_lazy_sync == 0) {
 			mutex_enter(&lfs_lock);
 			if (!(ip->i_flags & IN_PAGING)) {
 				ip->i_flags |= IN_PAGING;
 				TAILQ_INSERT_TAIL(&fs->lfs_pchainhd, ip,
 						  i_lfs_pchain);
+			}
 			wakeup(&lfs_writer_daemon);
 			mutex_exit(&lfs_lock);
+		}
 		return 0;
+	}
 	/*
 	 * If a vnode is bring cleaned, flush it out before we try to
 	 * reuse it.  This prevents the cleaner from writing files twice
 	 * in the same partial segment, causing an accounting underflow.
 	 */
 	if (ap->a_flags & FSYNC_RECLAIM && ip->i_flags & IN_CLEANING) {
 		lfs_vflush(vp);
+	}
 	wait = (ap->a_flags & FSYNC_WAIT);
 	do {
 		mutex_enter(vp->v_interlock);
 		error = VOP_PUTPAGES(vp, trunc_page(ap->a_offlo),
 				     round_page(ap->a_offhi),
 				     PGO_CLEANIT | (wait ? PGO_SYNCIO : 0));
 		if (error == EAGAIN) {
 			mutex_enter(&lfs_lock);
 			mtsleep(&fs->lfs_availsleep, PCATCH | PUSER,
 				"lfs_fsync", hz / 100 + 1, &lfs_lock);
 			mutex_exit(&lfs_lock);
+		}
 	} while (error == EAGAIN);
 	if (error)
 		return error;
 	if ((ap->a_flags & FSYNC_DATAONLY) == 0)
 		error = lfs_update(vp, NULL, NULL, wait ? UPDATE_WAIT : 0);
 	if (error == 0 && ap->a_flags & FSYNC_CACHE) {
 		int l = 0;
 		error = VOP_IOCTL(ip->i_devvp, DIOCCACHESYNC, &l, FWRITE,
 				  curlwp->l_cred);
+	}
 	if (wait && !VPISEMPTY(vp))
 		LFS_SET_UINO(ip, IN_MODIFIED);
 	return error;
+}
 /*
  * Take IN_ADIROP off, then call ulfs_inactive.
  */
 int
 lfs_inactive(void *v)
+{
 	struct vop_inactive_args /* {
 		struct vnode *a_vp;
 	} */ *ap = v;
 	lfs_unmark_vnode(ap->a_vp);
 	/*
 	 * The Ifile is only ever inactivated on unmount.
 	 * Streamline this process by not giving it more dirty blocks.
 	 */
 	if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM) {
 		mutex_enter(&lfs_lock);
 		LFS_CLR_UINO(VTOI(ap->a_vp), IN_ALLMOD);
 		mutex_exit(&lfs_lock);
 		VOP_UNLOCK(ap->a_vp);
 		return 0;
+	}
 #ifdef DEBUG
 	/*
 	 * This might happen on unmount.
 	 * XXX If it happens at any other time, it should be a panic.
 	 */
 	if (ap->a_vp->v_uflag & VU_DIROP) {
 		struct inode *ip = VTOI(ap->a_vp);
 		printf("lfs_inactive: inactivating VU_DIROP? ino = %d\n", (int)ip->i_number);
+	}
 #endif /* DIAGNOSTIC */
 	return ulfs_inactive(v);
+}
 int
 lfs_set_dirop(struct vnode *dvp, struct vnode *vp)
+{
 	struct lfs *fs;
 	int error;
 	KASSERT(VOP_ISLOCKED(dvp));
 	KASSERT(vp == NULL || VOP_ISLOCKED(vp));
 	fs = VTOI(dvp)->i_lfs;
 	ASSERT_NO_SEGLOCK(fs);
 	/*
 	 * LFS_NRESERVE calculates direct and indirect blocks as well
 	 * as an inode block; an overestimate in most cases.
 	 */
 	if ((error = lfs_reserve(fs, dvp, vp, LFS_NRESERVE(fs))) != 0)
 		return (error);
     restart:
 	mutex_enter(&lfs_lock);
 	if (fs->lfs_dirops == 0) {
 		mutex_exit(&lfs_lock);
 		lfs_check(dvp, LFS_UNUSED_LBN, 0);
 		mutex_enter(&lfs_lock);
+	}
 	while (fs->lfs_writer) {
 		error = mtsleep(&fs->lfs_dirops, (PRIBIO + 1) | PCATCH,
 		    "lfs_sdirop", 0, &lfs_lock);
 		if (error == EINTR) {
 			mutex_exit(&lfs_lock);
 			goto unreserve;
+		}
+	}
 	if (lfs_dirvcount > LFS_MAX_DIROP && fs->lfs_dirops == 0) {
 		wakeup(&lfs_writer_daemon);
 		mutex_exit(&lfs_lock);
 		preempt();
 		goto restart;
+	}
 	if (lfs_dirvcount > LFS_MAX_DIROP) {
 		DLOG((DLOG_DIROP, "lfs_set_dirop: sleeping with dirops=%d, "
 		      "dirvcount=%d\n", fs->lfs_dirops, lfs_dirvcount));
 		if ((error = mtsleep(&lfs_dirvcount,
 		    PCATCH | PUSER | PNORELOCK, "lfs_maxdirop", 0,
 		    &lfs_lock)) != 0) {
 			goto unreserve;
+		}
 		goto restart;
+	}
 	++fs->lfs_dirops;
 	/* fs->lfs_doifile = 1; */ /* XXX why? --ks */
 	mutex_exit(&lfs_lock);
 	/* Hold a reference so SET_ENDOP will be happy */
 	vref(dvp);
 	if (vp) {
 		vref(vp);
 		MARK_VNODE(vp);
+	}
 	MARK_VNODE(dvp);
 	return 0;
   unreserve:
 	lfs_reserve(fs, dvp, vp, -LFS_NRESERVE(fs));
 	return error;
+}
 /*
  * Opposite of lfs_set_dirop... mostly. For now at least must call
  * UNMARK_VNODE(dvp) explicitly first. (XXX: clean that up)
  */
 void
 lfs_unset_dirop(struct lfs *fs, struct vnode *dvp, const char *str)
+{
 	mutex_enter(&lfs_lock);
 	--fs->lfs_dirops;
 	if (!fs->lfs_dirops) {
 		if (fs->lfs_nadirop) {
 			panic("lfs_unset_dirop: %s: no dirops but "
 			      " nadirop=%d", str,
 			      fs->lfs_nadirop);
+		}
 		wakeup(&fs->lfs_writer);
 		mutex_exit(&lfs_lock);
 		lfs_check(dvp, LFS_UNUSED_LBN, 0);
 	} else {
 		mutex_exit(&lfs_lock);
+	}
 	lfs_reserve(fs, dvp, NULL, -LFS_NRESERVE(fs));
+}
 void
 lfs_mark_vnode(struct vnode *vp)
+{
 	struct inode *ip = VTOI(vp);
 	struct lfs *fs = ip->i_lfs;
 	mutex_enter(&lfs_lock);
 	if (!(ip->i_flag & IN_ADIROP)) {
 		if (!(vp->v_uflag & VU_DIROP)) {
 			mutex_exit(&lfs_lock);
 			vref(vp);
 			mutex_enter(&lfs_lock);
 			++lfs_dirvcount;
 			++fs->lfs_dirvcount;
 			TAILQ_INSERT_TAIL(&fs->lfs_dchainhd, ip, i_lfs_dchain);
 			vp->v_uflag |= VU_DIROP;
+		}
 		++fs->lfs_nadirop;
 		ip->i_flag &= ~IN_CDIROP;
 		ip->i_flag |= IN_ADIROP;
 	} else
 		KASSERT(vp->v_uflag & VU_DIROP);
 	mutex_exit(&lfs_lock);
+}
 void
 lfs_unmark_vnode(struct vnode *vp)
+{
 	struct inode *ip = VTOI(vp);
 	mutex_enter(&lfs_lock);
 	if (ip && (ip->i_flag & IN_ADIROP)) {
 		KASSERT(vp->v_uflag & VU_DIROP);
 		--ip->i_lfs->lfs_nadirop;
 		ip->i_flag &= ~IN_ADIROP;
+	}
 	mutex_exit(&lfs_lock);
+}
 int
 lfs_symlink(void *v)
+{
 	struct vop_symlink_v3_args /* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 		char *a_target;
 	} */ *ap = v;
 	struct lfs *fs;
 	struct vnode *dvp, **vpp;
 	struct inode *ip;
 	struct ulfs_lookup_results *ulr;
 	ssize_t len; /* XXX should be size_t */
 	int error;
 	dvp = ap->a_dvp;
 	vpp = ap->a_vpp;
 	KASSERT(vpp != NULL);
 	KASSERT(*vpp == NULL);
 	KASSERT(ap->a_vap->va_type == VLNK);
 	/* XXX should handle this material another way */
 	ulr = &VTOI(ap->a_dvp)->i_crap;
 	ULFS_CHECK_CRAPCOUNTER(VTOI(ap->a_dvp));
 	fs = VFSTOULFS(dvp->v_mount)->um_lfs;
 	ASSERT_NO_SEGLOCK(fs);
 	if (fs->lfs_ronly) {
 		return EROFS;
+	}
 	error = lfs_set_dirop(dvp, NULL);
 	if (error)
 		return error;
 	fstrans_start(dvp->v_mount, FSTRANS_SHARED);
 	error = ulfs_makeinode(ap->a_vap, dvp, ulr, vpp, ap->a_cnp);
 	if (error) {
 		goto out;
+	}
 	VN_KNOTE(ap->a_dvp, NOTE_WRITE);
 	ip = VTOI(*vpp);
 	len = strlen(ap->a_target);
 	if (len < ip->i_lfs->um_maxsymlinklen) {
 		memcpy((char *)SHORTLINK(ip), ap->a_target, len);
 		ip->i_size = len;
 		DIP_ASSIGN(ip, size, len);
 		uvm_vnp_setsize(*vpp, ip->i_size);
 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
 		if ((*vpp)->v_mount->mnt_flag & MNT_RELATIME)
 			ip->i_flag |= IN_ACCESS;
 	} else {
 		error = ulfs_bufio(UIO_WRITE, *vpp, ap->a_target, len, (off_t)0,
 		    IO_NODELOCKED | IO_JOURNALLOCKED, ap->a_cnp->cn_cred, NULL,
 		    NULL);
+	}
 	VOP_UNLOCK(*vpp);
 	if (error)
 		vrele(*vpp);
 out:
 	fstrans_done(dvp->v_mount);
 	UNMARK_VNODE(dvp);
 	/* XXX: is it even possible for the symlink to get MARK'd? */
 	UNMARK_VNODE(*vpp);
 	if (!((*vpp)->v_uflag & VU_DIROP)) {
 		KASSERT(error != 0);
 		*vpp = NULL;
+	}
 	else {
 		KASSERT(error == 0);
+	}
 	lfs_unset_dirop(fs, dvp, "symlink");
 	vrele(dvp);
 	return (error);
+}
 int
 lfs_mknod(void *v)
+{
 	struct vop_mknod_v3_args	/* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 	} */ *ap = v;
 	struct lfs *fs;
 	struct vnode *dvp, **vpp;
 	struct vattr *vap;
 	struct inode *ip;
 	int error;
 	ino_t		ino;
 	struct ulfs_lookup_results *ulr;
 	dvp = ap->a_dvp;
 	vpp = ap->a_vpp;
 	vap = ap->a_vap;
 	KASSERT(vpp != NULL);
 	KASSERT(*vpp == NULL);
 	/* XXX should handle this material another way */
 	ulr = &VTOI(dvp)->i_crap;
 	ULFS_CHECK_CRAPCOUNTER(VTOI(dvp));
 	fs = VFSTOULFS(dvp->v_mount)->um_lfs;
 	ASSERT_NO_SEGLOCK(fs);
 	if (fs->lfs_ronly) {
 		return EROFS;
+	}
 	error = lfs_set_dirop(dvp, NULL);
 	if (error)
 		return error;
 	fstrans_start(ap->a_dvp->v_mount, FSTRANS_SHARED);
 	error = ulfs_makeinode(vap, dvp, ulr, vpp, ap->a_cnp);
 	/* Either way we're done with the dirop at this point */
 	UNMARK_VNODE(dvp);
 	UNMARK_VNODE(*vpp);
 	if (!((*vpp)->v_uflag & VU_DIROP)) {
 		KASSERT(error != 0);
 		*vpp = NULL;
+	}
 	else {
 		KASSERT(error == 0);
+	}
 	lfs_unset_dirop(fs, dvp, "mknod");
 	/*
 	 * XXX this is where this used to be (though inside some evil
 	 * macros) but it clearly should be moved further down.
 	 * - dholland 20140515
 	 */
 	vrele(dvp);
 	if (error) {
 		fstrans_done(ap->a_dvp->v_mount);
 		*vpp = NULL;
 		return (error);
+	}
 	VN_KNOTE(dvp, NOTE_WRITE);
 	ip = VTOI(*vpp);
 	ino = ip->i_number;
 	ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
 	/*
 	 * Call fsync to write the vnode so that we don't have to deal with
 	 * flushing it when it's marked VU_DIROP or reclaiming.
+	 *
 	 * XXX KS - If we can't flush we also can't call vgone(), so must
 	 * return.  But, that leaves this vnode in limbo, also not good.
 	 * Can this ever happen (barring hardware failure)?
 	 */
 	if ((error = VOP_FSYNC(*vpp, NOCRED, FSYNC_WAIT, 0, 0)) != 0) {
 		panic("lfs_mknod: couldn't fsync (ino %llu)",
 		      (unsigned long long)ino);
 		/* return (error); */
+	}
 	fstrans_done(ap->a_dvp->v_mount);
 	KASSERT(error == 0);
 	VOP_UNLOCK(*vpp);
 	return (0);
+}
 /*
  * Create a regular file
  */
 int
 lfs_create(void *v)
+{
 	struct vop_create_v3_args	/* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 	} */ *ap = v;
 	struct lfs *fs;
 	struct vnode *dvp, **vpp;
 	struct vattr *vap;
 	struct ulfs_lookup_results *ulr;
 	int error;
 	dvp = ap->a_dvp;
 	vpp = ap->a_vpp;
 	vap = ap->a_vap;
 	KASSERT(vpp != NULL);
 	KASSERT(*vpp == NULL);
 	/* XXX should handle this material another way */
 	ulr = &VTOI(dvp)->i_crap;
 	ULFS_CHECK_CRAPCOUNTER(VTOI(dvp));
 	fs = VFSTOULFS(dvp->v_mount)->um_lfs;
 	ASSERT_NO_SEGLOCK(fs);
 	if (fs->lfs_ronly) {
 		return EROFS;
+	}
 	error = lfs_set_dirop(dvp, NULL);
 	if (error)
 		return error;
 	fstrans_start(dvp->v_mount, FSTRANS_SHARED);
 	error = ulfs_makeinode(vap, dvp, ulr, vpp, ap->a_cnp);
 	if (error) {
 		fstrans_done(dvp->v_mount);
 		goto out;
+	}
 	fstrans_done(dvp->v_mount);
 	VN_KNOTE(dvp, NOTE_WRITE);
 	VOP_UNLOCK(*vpp);
 out:
 	UNMARK_VNODE(dvp);
 	UNMARK_VNODE(*vpp);
 	if (!((*vpp)->v_uflag & VU_DIROP)) {
 		KASSERT(error != 0);
 		*vpp = NULL;
+	}
 	else {
 		KASSERT(error == 0);
+	}
 	lfs_unset_dirop(fs, dvp, "create");
 	vrele(dvp);
 	return (error);
+}
 int
 lfs_mkdir(void *v)
+{
 	struct vop_mkdir_v3_args	/* {
 		struct vnode *a_dvp;
 		struct vnode **a_vpp;
 		struct componentname *a_cnp;
 		struct vattr *a_vap;
 	} */ *ap = v;
 	struct lfs *fs;
 	struct vnode *dvp, *tvp, **vpp;
 	struct inode *dp, *ip;
 	struct componentname *cnp;
 	struct vattr *vap;
 	struct ulfs_lookup_results *ulr;
 	struct buf *bp;
 	struct lfs_dirtemplate dirtemplate;
 	struct lfs_direct *newdir;
 	int dirblksiz;
 	int error;
 	dvp = ap->a_dvp;
 	tvp = NULL;
 	vpp = ap->a_vpp;
 	cnp = ap->a_cnp;
 	vap = ap->a_vap;
 	dp = VTOI(dvp);
 	ip = NULL;
 	KASSERT(vap->va_type == VDIR);
 	KASSERT(vpp != NULL);
 	KASSERT(*vpp == NULL);
 	/* XXX should handle this material another way */
 	ulr = &dp->i_crap;
 	ULFS_CHECK_CRAPCOUNTER(dp);
 	fs = VFSTOULFS(dvp->v_mount)->um_lfs;
 	ASSERT_NO_SEGLOCK(fs);
 	if (fs->lfs_ronly) {
 		return EROFS;
+	}
 	dirblksiz = fs->um_dirblksiz;
 	error = lfs_set_dirop(dvp, NULL);
 	if (error)
 		return error;
 	fstrans_start(dvp->v_mount, FSTRANS_SHARED);
 	if ((nlink_t)dp->i_nlink >= LINK_MAX) {
 		error = EMLINK;
 		goto out;
+	}
 	/*
 	 * Must simulate part of ulfs_makeinode here to acquire the inode,
 	 * but not have it entered in the parent directory. The entry is
 	 * made later after writing "." and ".." entries.
 	 */
 	error = vcache_new(dvp->v_mount, dvp, vap, cnp->cn_cred, ap->a_vpp);
 	if (error)
 		goto out;
 	error = vn_lock(*ap->a_vpp, LK_EXCLUSIVE);
 	if (error) {
 		vrele(*ap->a_vpp);
 		*ap->a_vpp = NULL;
 		goto out;
+	}
 	tvp = *ap->a_vpp;
 	lfs_mark_vnode(tvp);
 	ip = VTOI(tvp);
 	ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
 	ip->i_nlink = 2;
 	DIP_ASSIGN(ip, nlink, 2);
 	if (cnp->cn_flags & ISWHITEOUT) {
 		ip->i_flags |= UF_OPAQUE;
 		DIP_ASSIGN(ip, flags, ip->i_flags);
+	}
 	/*
 	 * Bump link count in parent directory to reflect work done below.
 	 */
 	dp->i_nlink++;
 	DIP_ASSIGN(dp, nlink, dp->i_nlink);
 	dp->i_flag |= IN_CHANGE;
 	if ((error = lfs_update(dvp, NULL, NULL, UPDATE_DIROP)) != 0)
 		goto bad;
 	/*
 	 * Initialize directory with "." and ".." from static template.
 	 */
 	dirtemplate = mastertemplate;
 	dirtemplate.dotdot_reclen = dirblksiz - dirtemplate.dot_reclen;
 	dirtemplate.dot_ino = ulfs_rw32(ip->i_number, ULFS_MPNEEDSWAP(fs));
 	dirtemplate.dotdot_ino = ulfs_rw32(dp->i_number, ULFS_MPNEEDSWAP(fs));
 	dirtemplate.dot_reclen = ulfs_rw16(dirtemplate.dot_reclen,
 	    ULFS_MPNEEDSWAP(fs));
 	dirtemplate.dotdot_reclen = ulfs_rw16(dirtemplate.dotdot_reclen,
 	    ULFS_MPNEEDSWAP(fs));
 	if (fs->um_maxsymlinklen <= 0) {
 #if BYTE_ORDER == LITTLE_ENDIAN
 		if (ULFS_MPNEEDSWAP(fs) == 0)
 #else
 		if (ULFS_MPNEEDSWAP(fs) != 0)
 #endif
+		{
 			dirtemplate.dot_type = dirtemplate.dot_namlen;
 			dirtemplate.dotdot_type = dirtemplate.dotdot_namlen;
 			dirtemplate.dot_namlen = dirtemplate.dotdot_namlen = 0;
 		} else
 			dirtemplate.dot_type = dirtemplate.dotdot_type = 0;
+	}
 	if ((error = lfs_balloc(tvp, (off_t)0, dirblksiz, cnp->cn_cred,
 	    B_CLRBUF, &bp)) != 0)
 		goto bad;
 	ip->i_size = dirblksiz;
 	DIP_ASSIGN(ip, size, dirblksiz);
 	ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
 	uvm_vnp_setsize(tvp, ip->i_size);
 	memcpy((void *)bp->b_data, (void *)&dirtemplate, sizeof dirtemplate);
 	/*
 	 * Directory set up; now install its entry in the parent directory.
 	 */
 	if ((error = VOP_BWRITE(bp->b_vp, bp)) != 0)
 		goto bad;
 	if ((error = lfs_update(tvp, NULL, NULL, UPDATE_DIROP)) != 0) {
 		goto bad;
+	}
 	newdir = pool_cache_get(ulfs_direct_cache, PR_WAITOK);
 	ulfs_makedirentry(ip, cnp, newdir);
 	error = ulfs_direnter(dvp, ulr, tvp, newdir, cnp, bp);
 	pool_cache_put(ulfs_direct_cache, newdir);
  bad:
 	if (error == 0) {
 		VN_KNOTE(dvp, NOTE_WRITE | NOTE_LINK);
 		VOP_UNLOCK(tvp);
 	} else {
 		dp->i_nlink--;
 		DIP_ASSIGN(dp, nlink, dp->i_nlink);
 		dp->i_flag |= IN_CHANGE;
 		/*
 		 * No need to do an explicit lfs_truncate here, vrele will
 		 * do this for us because we set the link count to 0.
 		 */
 		ip->i_nlink = 0;
 		DIP_ASSIGN(ip, nlink, 0);
 		ip->i_flag |= IN_CHANGE;
 		/* If IN_ADIROP, account for it */
 		lfs_unmark_vnode(tvp);
 		vput(tvp);
+	}
 out:
 	fstrans_done(dvp->v_mount);
 	UNMARK_VNODE(dvp);
 	UNMARK_VNODE(*vpp);
 	if (!((*vpp)->v_uflag & VU_DIROP)) {
 		KASSERT(error != 0);
 		*vpp = NULL;
+	}
 	else {
 		KASSERT(error == 0);
+	}
 	lfs_unset_dirop(fs, dvp, "mkdir");
 	vrele(dvp);
 	return (error);
+}
 int
 lfs_remove(void *v)
+{
 	struct vop_remove_args	/* {
 		struct vnode *a_dvp;
 		struct vnode *a_vp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	struct vnode *dvp, *vp;
 	struct inode *ip;
 	int error;
 	dvp = ap->a_dvp;
 	vp = ap->a_vp;
 	ip = VTOI(vp);
 	if ((error = lfs_set_dirop(dvp, vp)) != 0) {
 		if (dvp == vp)
 			vrele(vp);
 		else
 			vput(vp);
 		vput(dvp);
 		return error;
+	}
 	error = ulfs_remove(ap);
 	if (ip->i_nlink == 0)
 		lfs_orphan(ip->i_lfs, ip->i_number);
 	UNMARK_VNODE(dvp);
 	if (ap->a_vp) {
 		UNMARK_VNODE(ap->a_vp);
+	}
 	lfs_unset_dirop(ip->i_lfs, dvp, "remove");
 	vrele(dvp);
 	if (ap->a_vp) {
 		vrele(ap->a_vp);
+	}
 	return (error);
+}
 int
 lfs_rmdir(void *v)
+{
 	struct vop_rmdir_args	/* {
 		struct vnodeop_desc *a_desc;
 		struct vnode *a_dvp;
 		struct vnode *a_vp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	struct vnode *vp;
 	struct inode *ip;
 	int error;
 	vp = ap->a_vp;
 	ip = VTOI(vp);
 	if ((error = lfs_set_dirop(ap->a_dvp, ap->a_vp)) != 0) {
 		if (ap->a_dvp == vp)
 			vrele(ap->a_dvp);
 		else
 			vput(ap->a_dvp);
 		vput(vp);
 		return error;
+	}
 	error = ulfs_rmdir(ap);
 	if (ip->i_nlink == 0)
 		lfs_orphan(ip->i_lfs, ip->i_number);
 	UNMARK_VNODE(ap->a_dvp);
 	if (ap->a_vp) {
 		UNMARK_VNODE(ap->a_vp);
+	}
 	lfs_unset_dirop(ip->i_lfs, ap->a_dvp, "rmdir");
 	vrele(ap->a_dvp);
 	if (ap->a_vp) {
 		vrele(ap->a_vp);
+	}
 	return (error);
+}
 int
 lfs_link(void *v)
+{
 	struct vop_link_v2_args	/* {
 		struct vnode *a_dvp;
 		struct vnode *a_vp;
 		struct componentname *a_cnp;
 	} */ *ap = v;
 	struct lfs *fs;
 	struct vnode *dvp;
 	int error;
 	dvp = ap->a_dvp;
 	fs = VFSTOULFS(dvp->v_mount)->um_lfs;
 	ASSERT_NO_SEGLOCK(fs);
 	if (fs->lfs_ronly) {
 		return EROFS;
+	}
 	error = lfs_set_dirop(dvp, NULL);
 	if (error) {
 		return error;
+	}
 	error = ulfs_link(ap);
 	UNMARK_VNODE(dvp);
 	lfs_unset_dirop(fs, dvp, "link");
 	vrele(dvp);
 	return (error);
+}
 /* XXX hack to avoid calling ITIMES in getattr */
 int
 lfs_getattr(void *v)
+{
 	struct vop_getattr_args /* {
 		struct vnode *a_vp;
 		struct vattr *a_vap;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct inode *ip = VTOI(vp);
 	struct vattr *vap = ap->a_vap;
 	struct lfs *fs = ip->i_lfs;
 	fstrans_start(vp->v_mount, FSTRANS_SHARED);
 	/*
 	 * Copy from inode table
 	 */
 	vap->va_fsid = ip->i_dev;
 	vap->va_fileid = ip->i_number;
 	vap->va_mode = ip->i_mode & ~LFS_IFMT;
 	vap->va_nlink = ip->i_nlink;
 	vap->va_uid = ip->i_uid;
 	vap->va_gid = ip->i_gid;
 	vap->va_rdev = (dev_t)ip->i_ffs1_rdev;
 	vap->va_size = vp->v_size;
 	vap->va_atime.tv_sec = ip->i_ffs1_atime;
 	vap->va_atime.tv_nsec = ip->i_ffs1_atimensec;
 	vap->va_mtime.tv_sec = ip->i_ffs1_mtime;
 	vap->va_mtime.tv_nsec = ip->i_ffs1_mtimensec;
 	vap->va_ctime.tv_sec = ip->i_ffs1_ctime;
 	vap->va_ctime.tv_nsec = ip->i_ffs1_ctimensec;
 	vap->va_flags = ip->i_flags;
 	vap->va_gen = ip->i_gen;
 	/* this doesn't belong here */
 	if (vp->v_type == VBLK)
 		vap->va_blocksize = BLKDEV_IOSIZE;
 	else if (vp->v_type == VCHR)
 		vap->va_blocksize = MAXBSIZE;
 	else
 		vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
 	vap->va_bytes = lfs_fsbtob(fs, (u_quad_t)ip->i_lfs_effnblks);
 	vap->va_type = vp->v_type;
 	vap->va_filerev = ip->i_modrev;
 	fstrans_done(vp->v_mount);
 	return (0);
+}
 /*
  * Check to make sure the inode blocks won't choke the buffer
  * cache, then call ulfs_setattr as usual.
  */
 int
 lfs_setattr(void *v)
+{
 	struct vop_setattr_args /* {
 		struct vnode *a_vp;
 		struct vattr *a_vap;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	lfs_check(vp, LFS_UNUSED_LBN, 0);
 	return ulfs_setattr(v);
+}
 /*
  * Release the block we hold on lfs_newseg wrapping.  Called on file close,
  * or explicitly from LFCNWRAPGO.  Called with the interlock held.
  */
 static int
 lfs_wrapgo(struct lfs *fs, struct inode *ip, int waitfor)
+{
 	if (fs->lfs_stoplwp != curlwp)
 		return EBUSY;
 	fs->lfs_stoplwp = NULL;
 	cv_signal(&fs->lfs_stopcv);
 	KASSERT(fs->lfs_nowrap > 0);
 	if (fs->lfs_nowrap <= 0) {
 		return 0;
+	}
 	if (--fs->lfs_nowrap == 0) {
 		log(LOG_NOTICE, "%s: re-enabled log wrap\n",
 		    lfs_sb_getfsmnt(fs));
 		wakeup(&fs->lfs_wrappass);
 		lfs_wakeup_cleaner(fs);
+	}
 	if (waitfor) {
 		mtsleep(&fs->lfs_nextsegsleep, PCATCH | PUSER, "segment",
 , &lfs_lock);
+	}
 	return 0;
+}
 /*
  * Close called.
+ *
  * Update the times on the inode.
  */
 /* ARGSUSED */
 int
 lfs_close(void *v)
+{
 	struct vop_close_args /* {
 		struct vnode *a_vp;
 		int  a_fflag;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct inode *ip = VTOI(vp);
 	struct lfs *fs = ip->i_lfs;
 	if ((ip->i_number == ULFS_ROOTINO || ip->i_number == LFS_IFILE_INUM) &&
 	    fs->lfs_stoplwp == curlwp) {
 		mutex_enter(&lfs_lock);
 		log(LOG_NOTICE, "lfs_close: releasing log wrap control\n");
 		lfs_wrapgo(fs, ip, 0);
 		mutex_exit(&lfs_lock);
+	}
 	if (vp == ip->i_lfs->lfs_ivnode &&
 	    vp->v_mount->mnt_iflag & IMNT_UNMOUNT)
 		return 0;
 	fstrans_start(vp->v_mount, FSTRANS_SHARED);
 	if (vp->v_usecount > 1 && vp != ip->i_lfs->lfs_ivnode) {
 		LFS_ITIMES(ip, NULL, NULL, NULL);
+	}
 	fstrans_done(vp->v_mount);
 	return (0);
+}
 /*
  * Close wrapper for special devices.
+ *
  * Update the times on the inode then do device close.
  */
 int
 lfsspec_close(void *v)
+{
 	struct vop_close_args /* {
 		struct vnode	*a_vp;
 		int		a_fflag;
 		kauth_cred_t	a_cred;
 	} */ *ap = v;
 	struct vnode	*vp;
 	struct inode	*ip;
 	vp = ap->a_vp;
 	ip = VTOI(vp);
 	if (vp->v_usecount > 1) {
 		LFS_ITIMES(ip, NULL, NULL, NULL);
+	}
 	return (VOCALL (spec_vnodeop_p, VOFFSET(vop_close), ap));
+}
 /*
  * Close wrapper for fifo's.
+ *
  * Update the times on the inode then do device close.
  */
 int
 lfsfifo_close(void *v)
+{
 	struct vop_close_args /* {
 		struct vnode	*a_vp;
 		int		a_fflag;
 		kauth_cred_	a_cred;
 	} */ *ap = v;
 	struct vnode	*vp;
 	struct inode	*ip;
 	vp = ap->a_vp;
 	ip = VTOI(vp);
 	if (ap->a_vp->v_usecount > 1) {
 		LFS_ITIMES(ip, NULL, NULL, NULL);
+	}
 	return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_close), ap));
+}
 /*
  * Reclaim an inode so that it can be used for other purposes.
  */
 int
 lfs_reclaim(void *v)
+{
 	struct vop_reclaim_args /* {
 		struct vnode *a_vp;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct inode *ip = VTOI(vp);
 	struct lfs *fs = ip->i_lfs;
 	int error;
 	/*
 	 * The inode must be freed and updated before being removed
 	 * from its hash chain.  Other threads trying to gain a hold
 	 * or lock on the inode will be stalled.
 	 */
 	if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
 		lfs_vfree(vp, ip->i_number, ip->i_omode);
 	mutex_enter(&lfs_lock);
 	LFS_CLR_UINO(ip, IN_ALLMOD);
 	mutex_exit(&lfs_lock);
 	if ((error = ulfs_reclaim(vp)))
 		return (error);
 	/*
 	 * Take us off the paging and/or dirop queues if we were on them.
 	 * We shouldn't be on them.
 	 */
 	mutex_enter(&lfs_lock);
 	if (ip->i_flags & IN_PAGING) {
 		log(LOG_WARNING, "%s: reclaimed vnode is IN_PAGING\n",
 		    lfs_sb_getfsmnt(fs));
 		ip->i_flags &= ~IN_PAGING;
 		TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);
+	}
 	if (vp->v_uflag & VU_DIROP) {
 		panic("reclaimed vnode is VU_DIROP");
 		vp->v_uflag &= ~VU_DIROP;
 		TAILQ_REMOVE(&fs->lfs_dchainhd, ip, i_lfs_dchain);
+	}
 	mutex_exit(&lfs_lock);
 	pool_put(&lfs_dinode_pool, ip->i_din.ffs1_din);
 	lfs_deregister_all(vp);
 	pool_put(&lfs_inoext_pool, ip->inode_ext.lfs);
 	ip->inode_ext.lfs = NULL;
 	genfs_node_destroy(vp);
 	pool_put(&lfs_inode_pool, vp->v_data);
 	vp->v_data = NULL;
 	return (0);
+}
 /*
  * Read a block from a storage device.
+ *
  * Calculate the logical to physical mapping if not done already,
  * then call the device strategy routine.
+ *
  * In order to avoid reading blocks that are in the process of being
  * written by the cleaner---and hence are not mutexed by the normal
  * buffer cache / page cache mechanisms---check for collisions before
  * reading.
+ *
  * We inline ulfs_strategy to make sure that the VOP_BMAP occurs *before*
  * the active cleaner test.
+ *
  * XXX This code assumes that lfs_markv makes synchronous checkpoints.
  */
 int
 lfs_strategy(void *v)
+{
 	struct vop_strategy_args /* {
 		struct vnode *a_vp;
 		struct buf *a_bp;
 	} */ *ap = v;
 	struct buf	*bp;
 	struct lfs	*fs;
 	struct vnode	*vp;
 	struct inode	*ip;
 	daddr_t		tbn;
 #define MAXLOOP 25
 	int		i, sn, error, slept, loopcount;
 	bp = ap->a_bp;
 	vp = ap->a_vp;
 	ip = VTOI(vp);
 	fs = ip->i_lfs;
 	/* lfs uses its strategy routine only for read */
 	KASSERT(bp->b_flags & B_READ);
 	if (vp->v_type == VBLK || vp->v_type == VCHR)
 		panic("lfs_strategy: spec");
 	KASSERT(bp->b_bcount != 0);
 	if (bp->b_blkno == bp->b_lblkno) {
 		error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno,
 				 NULL);
 		if (error) {
 			bp->b_error = error;
 			bp->b_resid = bp->b_bcount;
 			biodone(bp);
 			return (error);
+		}
 		if ((long)bp->b_blkno == -1) /* no valid data */
 			clrbuf(bp);
+	}
 	if ((long)bp->b_blkno < 0) { /* block is not on disk */
 		bp->b_resid = bp->b_bcount;
 		biodone(bp);
 		return (0);
+	}
 	slept = 1;
 	loopcount = 0;
 	mutex_enter(&lfs_lock);
 	while (slept && fs->lfs_seglock) {
 		mutex_exit(&lfs_lock);
 		/*
 		 * Look through list of intervals.
 		 * There will only be intervals to look through
 		 * if the cleaner holds the seglock.
 		 * Since the cleaner is synchronous, we can trust
 		 * the list of intervals to be current.
 		 */
 		tbn = LFS_DBTOFSB(fs, bp->b_blkno);
 		sn = lfs_dtosn(fs, tbn);
 		slept = 0;
 		for (i = 0; i < fs->lfs_cleanind; i++) {
 			if (sn == lfs_dtosn(fs, fs->lfs_cleanint[i]) &&
 			    tbn >= fs->lfs_cleanint[i]) {
 				DLOG((DLOG_CLEAN,
 				      "lfs_strategy: ino %d lbn %" PRId64
 				      " ind %d sn %d fsb %" PRIx32
 				      " given sn %d fsb %" PRIx64 "\n",
 				      ip->i_number, bp->b_lblkno, i,
 				      lfs_dtosn(fs, fs->lfs_cleanint[i]),
 				      fs->lfs_cleanint[i], sn, tbn));
 				DLOG((DLOG_CLEAN,
 				      "lfs_strategy: sleeping on ino %d lbn %"
 				      PRId64 "\n", ip->i_number, bp->b_lblkno));
 				mutex_enter(&lfs_lock);
 				if (LFS_SEGLOCK_HELD(fs) && fs->lfs_iocount) {
 					/*
 					 * Cleaner can't wait for itself.
 					 * Instead, wait for the blocks
 					 * to be written to disk.
 					 * XXX we need pribio in the test
 					 * XXX here.
 					 */
  					mtsleep(&fs->lfs_iocount,
  						(PRIBIO + 1) | PNORELOCK,
 						"clean2", hz/10 + 1,
  						&lfs_lock);
 					slept = 1;
 					++loopcount;
 					break;
 				} else if (fs->lfs_seglock) {
 					mtsleep(&fs->lfs_seglock,
 						(PRIBIO + 1) | PNORELOCK,
 						"clean1", 0,
 						&lfs_lock);
 					slept = 1;
 					break;
+				}
 				mutex_exit(&lfs_lock);
+			}
+		}
 		mutex_enter(&lfs_lock);
 		if (loopcount > MAXLOOP) {
 			printf("lfs_strategy: breaking out of clean2 loop\n");
 			break;
+		}
+	}
 	mutex_exit(&lfs_lock);
 	vp = ip->i_devvp;
 	return VOP_STRATEGY(vp, bp);
+}
 /*
  * Inline lfs_segwrite/lfs_writevnodes, but just for dirops.
  * Technically this is a checkpoint (the on-disk state is valid)
  * even though we are leaving out all the file data.
  */
 int
 lfs_flush_dirops(struct lfs *fs)
+{
 	struct inode *ip, *nip;
 	struct vnode *vp;
 	extern int lfs_dostats;
 	struct segment *sp;
 	int flags = 0;
 	int error = 0;
 	ASSERT_MAYBE_SEGLOCK(fs);
 	KASSERT(fs->lfs_nadirop == 0);
 	if (fs->lfs_ronly)
 		return EROFS;
 	mutex_enter(&lfs_lock);
 	if (TAILQ_FIRST(&fs->lfs_dchainhd) == NULL) {
 		mutex_exit(&lfs_lock);
 		return 0;
 	} else
 		mutex_exit(&lfs_lock);
 	if (lfs_dostats)
 		++lfs_stats.flush_invoked;
 	lfs_imtime(fs);
 	lfs_seglock(fs, flags);
 	sp = fs->lfs_sp;
 	/*
 	 * lfs_writevnodes, optimized to get dirops out of the way.
 	 * Only write dirops, and don't flush files' pages, only
 	 * blocks from the directories.
+	 *
 	 * We don't need to vref these files because they are
 	 * dirops and so hold an extra reference until the
 	 * segunlock clears them of that status.
+	 *
 	 * We don't need to check for IN_ADIROP because we know that
 	 * no dirops are active.
+	 *
 	 */
 	mutex_enter(&lfs_lock);
 	for (ip = TAILQ_FIRST(&fs->lfs_dchainhd); ip != NULL; ip = nip) {
 		nip = TAILQ_NEXT(ip, i_lfs_dchain);
 		mutex_exit(&lfs_lock);
 		vp = ITOV(ip);
 		mutex_enter(vp->v_interlock);
 		KASSERT((ip->i_flag & IN_ADIROP) == 0);
 		KASSERT(vp->v_uflag & VU_DIROP);
 		KASSERT(vdead_check(vp, VDEAD_NOWAIT) == 0);
 		/*
 		 * All writes to directories come from dirops; all
 		 * writes to files' direct blocks go through the page
 		 * cache, which we're not touching.  Reads to files
 		 * and/or directories will not be affected by writing
 		 * directory blocks inodes and file inodes.  So we don't
 		 * really need to lock.
 		 */
 		if (vdead_check(vp, VDEAD_NOWAIT) != 0) {
 			mutex_exit(vp->v_interlock);
 			mutex_enter(&lfs_lock);
 			continue;
+		}
 		mutex_exit(vp->v_interlock);
 		/* XXX see below
 		 * waslocked = VOP_ISLOCKED(vp);
 		 */
 		if (vp->v_type != VREG &&
 		    ((ip->i_flag & IN_ALLMOD) || !VPISEMPTY(vp))) {
 			error = lfs_writefile(fs, sp, vp);
 			if (!VPISEMPTY(vp) && !WRITEINPROG(vp) &&
 			    !(ip->i_flag & IN_ALLMOD)) {
 			    	mutex_enter(&lfs_lock);
 				LFS_SET_UINO(ip, IN_MODIFIED);
 			    	mutex_exit(&lfs_lock);
+			}
 			if (error && (sp->seg_flags & SEGM_SINGLE)) {
 				mutex_enter(&lfs_lock);
 				error = EAGAIN;
 				break;
+			}
+		}
 		KDASSERT(ip->i_number != LFS_IFILE_INUM);
 		error = lfs_writeinode(fs, sp, ip);
 		mutex_enter(&lfs_lock);
 		if (error && (sp->seg_flags & SEGM_SINGLE)) {
 			error = EAGAIN;
 			break;
+		}
 		/*
 		 * We might need to update these inodes again,
 		 * for example, if they have data blocks to write.
 		 * Make sure that after this flush, they are still
 		 * marked IN_MODIFIED so that we don't forget to
 		 * write them.
 		 */
 		/* XXX only for non-directories? --KS */
 		LFS_SET_UINO(ip, IN_MODIFIED);
+	}
 	mutex_exit(&lfs_lock);
 	/* We've written all the dirops there are */
 	((SEGSUM *)(sp->segsum))->ss_flags &= ~(SS_CONT);
 	lfs_finalize_fs_seguse(fs);
 	(void) lfs_writeseg(fs, sp);
 	lfs_segunlock(fs);
 	return error;
+}
 /*
  * Flush all vnodes for which the pagedaemon has requested pageouts.
  * Skip over any files that are marked VU_DIROP (since lfs_flush_dirop()
  * has just run, this would be an error).  If we have to skip a vnode
  * for any reason, just skip it; if we have to wait for the cleaner,
  * abort.  The writer daemon will call us again later.
  */
 int
 lfs_flush_pchain(struct lfs *fs)
+{
 	struct inode *ip, *nip;
 	struct vnode *vp;
 	extern int lfs_dostats;
 	struct segment *sp;
 	int error, error2;
 	ASSERT_NO_SEGLOCK(fs);
 	if (fs->lfs_ronly)
 		return EROFS;
 	mutex_enter(&lfs_lock);
 	if (TAILQ_FIRST(&fs->lfs_pchainhd) == NULL) {
 		mutex_exit(&lfs_lock);
 		return 0;
 	} else
 		mutex_exit(&lfs_lock);
 	/* Get dirops out of the way */
 	if ((error = lfs_flush_dirops(fs)) != 0)
 		return error;
 	if (lfs_dostats)
 		++lfs_stats.flush_invoked;
 	/*
 	 * Inline lfs_segwrite/lfs_writevnodes, but just for pageouts.
 	 */
 	lfs_imtime(fs);
 	lfs_seglock(fs, 0);
 	sp = fs->lfs_sp;
 	/*
 	 * lfs_writevnodes, optimized to clear pageout requests.
 	 * Only write non-dirop files that are in the pageout queue.
 	 * We're very conservative about what we write; we want to be
 	 * fast and async.
 	 */
 	mutex_enter(&lfs_lock);
     top:
 	for (ip = TAILQ_FIRST(&fs->lfs_pchainhd); ip != NULL; ip = nip) {
 		nip = TAILQ_NEXT(ip, i_lfs_pchain);
 		vp = ITOV(ip);
 		if (!(ip->i_flags & IN_PAGING))
 			goto top;
 		mutex_enter(vp->v_interlock);
 		if (vdead_check(vp, VDEAD_NOWAIT) != 0 ||
 		    (vp->v_uflag & VU_DIROP) != 0) {
 			mutex_exit(vp->v_interlock);
 			continue;
+		}
 		if (vp->v_type != VREG) {
 			mutex_exit(vp->v_interlock);
 			continue;
+		}
 		if (vget(vp, LK_NOWAIT, false /* !wait */))
 			continue;
 		mutex_exit(&lfs_lock);
 		if (vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_RETRY) != 0) {
 			vrele(vp);
 			mutex_enter(&lfs_lock);
 			continue;
+		}
 		error = lfs_writefile(fs, sp, vp);
 		if (!VPISEMPTY(vp) && !WRITEINPROG(vp) &&
 		    !(ip->i_flag & IN_ALLMOD)) {
 		    	mutex_enter(&lfs_lock);
 			LFS_SET_UINO(ip, IN_MODIFIED);
 		    	mutex_exit(&lfs_lock);
+		}
 		KDASSERT(ip->i_number != LFS_IFILE_INUM);
 		error2 = lfs_writeinode(fs, sp, ip);
 		VOP_UNLOCK(vp);
 		vrele(vp);
 		if (error == EAGAIN || error2 == EAGAIN) {
 			lfs_writeseg(fs, sp);
 			mutex_enter(&lfs_lock);
 			break;
+		}
 		mutex_enter(&lfs_lock);
+	}
 	mutex_exit(&lfs_lock);
 	(void) lfs_writeseg(fs, sp);
 	lfs_segunlock(fs);
 	return 0;
+}
 /*
  * Provide a fcntl interface to sys_lfs_{segwait,bmapv,markv}.
  */
 int
 lfs_fcntl(void *v)
+{
 	struct vop_fcntl_args /* {
 		struct vnode *a_vp;
 		u_int a_command;
 		void * a_data;
 		int  a_fflag;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	struct timeval tv;
 	struct timeval *tvp;
 	BLOCK_INFO *blkiov;
 	CLEANERINFO *cip;
 	SEGUSE *sup;
 	int blkcnt, error;
 	size_t fh_size;
 	struct lfs_fcntl_markv blkvp;
 	struct lwp *l;
 	fsid_t *fsidp;
 	struct lfs *fs;
 	struct buf *bp;
 	fhandle_t *fhp;
 	daddr_t off;
 	int oclean;
 	/* Only respect LFS fcntls on fs root or Ifile */
 	if (VTOI(ap->a_vp)->i_number != ULFS_ROOTINO &&
 	    VTOI(ap->a_vp)->i_number != LFS_IFILE_INUM) {
 		return ulfs_fcntl(v);
+	}
 	/* Avoid locking a draining lock */
 	if (ap->a_vp->v_mount->mnt_iflag & IMNT_UNMOUNT) {
 		return ESHUTDOWN;
+	}
 	/* LFS control and monitoring fcntls are available only to root */
 	l = curlwp;
 	if (((ap->a_command & 0xff00) >> 8) == 'L' &&
 	    (error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_LFS,
 	     KAUTH_REQ_SYSTEM_LFS_FCNTL, NULL, NULL, NULL)) != 0)
 		return (error);
 	fs = VTOI(ap->a_vp)->i_lfs;
 	fsidp = &ap->a_vp->v_mount->mnt_stat.f_fsidx;
 	error = 0;
 	switch ((int)ap->a_command) {
 	    case LFCNSEGWAITALL_COMPAT_50:
 	    case LFCNSEGWAITALL_COMPAT:
 		fsidp = NULL;
 		/* FALLSTHROUGH */
 	    case LFCNSEGWAIT_COMPAT_50:
 	    case LFCNSEGWAIT_COMPAT:
+		{
 			struct timeval50 *tvp50
 				= (struct timeval50 *)ap->a_data;
 			timeval50_to_timeval(tvp50, &tv);
 			tvp = &tv;
+		}
 		goto segwait_common;
 	    case LFCNSEGWAITALL:
 		fsidp = NULL;
 		/* FALLSTHROUGH */
 	    case LFCNSEGWAIT:
 		tvp = (struct timeval *)ap->a_data;
 segwait_common:
 		mutex_enter(&lfs_lock);
 		++fs->lfs_sleepers;
 		mutex_exit(&lfs_lock);
 		error = lfs_segwait(fsidp, tvp);
 		mutex_enter(&lfs_lock);
 		if (--fs->lfs_sleepers == 0)
 			wakeup(&fs->lfs_sleepers);
 		mutex_exit(&lfs_lock);
 		return error;
 	    case LFCNBMAPV:
 	    case LFCNMARKV:
 		blkvp = *(struct lfs_fcntl_markv *)ap->a_data;
 		blkcnt = blkvp.blkcnt;
 		if ((u_int) blkcnt > LFS_MARKV_MAXBLKCNT)
 			return (EINVAL);
 		blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV);
 		if ((error = copyin(blkvp.blkiov, blkiov,
 		     blkcnt * sizeof(BLOCK_INFO))) != 0) {
 			lfs_free(fs, blkiov, LFS_NB_BLKIOV);
 			return error;
+		}
 		mutex_enter(&lfs_lock);
 		++fs->lfs_sleepers;
 		mutex_exit(&lfs_lock);
 		if (ap->a_command == LFCNBMAPV)
 			error = lfs_bmapv(l->l_proc, fsidp, blkiov, blkcnt);
 		else /* LFCNMARKV */
 			error = lfs_markv(l->l_proc, fsidp, blkiov, blkcnt);
 		if (error == 0)
 			error = copyout(blkiov, blkvp.blkiov,
 					blkcnt * sizeof(BLOCK_INFO));
 		mutex_enter(&lfs_lock);
 		if (--fs->lfs_sleepers == 0)
 			wakeup(&fs->lfs_sleepers);
 		mutex_exit(&lfs_lock);
 		lfs_free(fs, blkiov, LFS_NB_BLKIOV);
 		return error;
 	    case LFCNRECLAIM:
 		/*
 		 * Flush dirops and write Ifile, allowing empty segments
 		 * to be immediately reclaimed.
 		 */
 		lfs_writer_enter(fs, "pndirop");
 		off = lfs_sb_getoffset(fs);
 		lfs_seglock(fs, SEGM_FORCE_CKP | SEGM_CKP);
 		lfs_flush_dirops(fs);
 		LFS_CLEANERINFO(cip, fs, bp);
 		oclean = cip->clean;
 		LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
 		lfs_segwrite(ap->a_vp->v_mount, SEGM_FORCE_CKP);
 		fs->lfs_sp->seg_flags |= SEGM_PROT;
 		lfs_segunlock(fs);
 		lfs_writer_leave(fs);
 #ifdef DEBUG
 		LFS_CLEANERINFO(cip, fs, bp);
 		DLOG((DLOG_CLEAN, "lfs_fcntl: reclaim wrote %" PRId64
 		      " blocks, cleaned %" PRId32 " segments (activesb %d)\n",
-		      fs->lfs_offset - off, cip->clean - oclean,
+		      lfs_sb_getoffset(fs) - off, cip->clean - oclean,
 		      fs->lfs_activesb));
 		LFS_SYNC_CLEANERINFO(cip, fs, bp, 0);
 #else
 		__USE(oclean);
 		__USE(off);
 #endif
 		return 0;
 	    case LFCNIFILEFH_COMPAT:
 		/* Return the filehandle of the Ifile */
 		if ((error = kauth_authorize_system(l->l_cred,
 		    KAUTH_SYSTEM_FILEHANDLE, 0, NULL, NULL, NULL)) != 0)
 			return (error);
 		fhp = (struct fhandle *)ap->a_data;
 		fhp->fh_fsid = *fsidp;
 		fh_size = 16;	/* former VFS_MAXFIDSIZ */
 		return lfs_vptofh(fs->lfs_ivnode, &(fhp->fh_fid), &fh_size);
 	    case LFCNIFILEFH_COMPAT2:
 	    case LFCNIFILEFH:
 		/* Return the filehandle of the Ifile */
 		fhp = (struct fhandle *)ap->a_data;
 		fhp->fh_fsid = *fsidp;
 		fh_size = sizeof(struct lfs_fhandle) -
 		    offsetof(fhandle_t, fh_fid);
 		return lfs_vptofh(fs->lfs_ivnode, &(fhp->fh_fid), &fh_size);
 	    case LFCNREWIND:
 		/* Move lfs_offset to the lowest-numbered segment */
 		return lfs_rewind(fs, *(int *)ap->a_data);
 	    case LFCNINVAL:
 		/* Mark a segment SEGUSE_INVAL */
 		LFS_SEGENTRY(sup, fs, *(int *)ap->a_data, bp);
 		if (sup->su_nbytes > 0) {
 			brelse(bp, 0);
 			lfs_unset_inval_all(fs);
 			return EBUSY;
+		}
 		sup->su_flags |= SEGUSE_INVAL;
 		VOP_BWRITE(bp->b_vp, bp);
 		return 0;
 	    case LFCNRESIZE:
 		/* Resize the filesystem */
 		return lfs_resize_fs(fs, *(int *)ap->a_data);
 	    case LFCNWRAPSTOP:
 	    case LFCNWRAPSTOP_COMPAT:
 		/*
 		 * Hold lfs_newseg at segment 0; if requested, sleep until
 		 * the filesystem wraps around.  To support external agents
 		 * (dump, fsck-based regression test) that need to look at
 		 * a snapshot of the filesystem, without necessarily
 		 * requiring that all fs activity stops.
 		 */
 		if (fs->lfs_stoplwp == curlwp)
 			return EALREADY;
 		mutex_enter(&lfs_lock);
 		while (fs->lfs_stoplwp != NULL)
 			cv_wait(&fs->lfs_stopcv, &lfs_lock);
 		fs->lfs_stoplwp = curlwp;
 		if (fs->lfs_nowrap == 0)
 			log(LOG_NOTICE, "%s: disabled log wrap\n",
 			    lfs_sb_getfsmnt(fs));
 		++fs->lfs_nowrap;
 		if (*(int *)ap->a_data == 1
 		    || ap->a_command == LFCNWRAPSTOP_COMPAT) {
 			log(LOG_NOTICE, "LFCNSTOPWRAP waiting for log wrap\n");
 			error = mtsleep(&fs->lfs_nowrap, PCATCH | PUSER,
 				"segwrap", 0, &lfs_lock);
 			log(LOG_NOTICE, "LFCNSTOPWRAP done waiting\n");
 			if (error) {
 				lfs_wrapgo(fs, VTOI(ap->a_vp), 0);
+			}
+		}
 		mutex_exit(&lfs_lock);
 		return 0;
 	    case LFCNWRAPGO:
 	    case LFCNWRAPGO_COMPAT:
 		/*
 		 * Having done its work, the agent wakes up the writer.
 		 * If the argument is 1, it sleeps until a new segment
 		 * is selected.
 		 */
 		mutex_enter(&lfs_lock);
 		error = lfs_wrapgo(fs, VTOI(ap->a_vp),
 				   ap->a_command == LFCNWRAPGO_COMPAT ? 1 :
 				    *((int *)ap->a_data));
 		mutex_exit(&lfs_lock);
 		return error;
 	    case LFCNWRAPPASS:
 		if ((VTOI(ap->a_vp)->i_lfs_iflags & LFSI_WRAPWAIT))
 			return EALREADY;
 		mutex_enter(&lfs_lock);
 		if (fs->lfs_stoplwp != curlwp) {
 			mutex_exit(&lfs_lock);
 			return EALREADY;
+		}
 		if (fs->lfs_nowrap == 0) {
 			mutex_exit(&lfs_lock);
 			return EBUSY;
+		}
 		fs->lfs_wrappass = 1;
 		wakeup(&fs->lfs_wrappass);
 		/* Wait for the log to wrap, if asked */
 		if (*(int *)ap->a_data) {
 			vref(ap->a_vp);
 			VTOI(ap->a_vp)->i_lfs_iflags |= LFSI_WRAPWAIT;
 			log(LOG_NOTICE, "LFCNPASS waiting for log wrap\n");
 			error = mtsleep(&fs->lfs_nowrap, PCATCH | PUSER,
 				"segwrap", 0, &lfs_lock);
 			log(LOG_NOTICE, "LFCNPASS done waiting\n");
 			VTOI(ap->a_vp)->i_lfs_iflags &= ~LFSI_WRAPWAIT;
 			vrele(ap->a_vp);
+		}
 		mutex_exit(&lfs_lock);
 		return error;
 	    case LFCNWRAPSTATUS:
 		mutex_enter(&lfs_lock);
 		*(int *)ap->a_data = fs->lfs_wrapstatus;
 		mutex_exit(&lfs_lock);
 		return 0;
 	    default:
 		return ulfs_fcntl(v);
+	}
 	return 0;
+}
 /*
  * Return the last logical file offset that should be written for this file
  * if we're doing a write that ends at "size".	If writing, we need to know
  * about sizes on disk, i.e. fragments if there are any; if reading, we need
  * to know about entire blocks.
  */
 void
 lfs_gop_size(struct vnode *vp, off_t size, off_t *eobp, int flags)
+{
 	struct inode *ip = VTOI(vp);
 	struct lfs *fs = ip->i_lfs;
 	daddr_t olbn, nlbn;
 	olbn = lfs_lblkno(fs, ip->i_size);
 	nlbn = lfs_lblkno(fs, size);
 	if (!(flags & GOP_SIZE_MEM) && nlbn < ULFS_NDADDR && olbn <= nlbn) {
 		*eobp = lfs_fragroundup(fs, size);
 	} else {
 		*eobp = lfs_blkroundup(fs, size);
+	}
+}
 #ifdef DEBUG
 void lfs_dump_vop(void *);
 void
 lfs_dump_vop(void *v)
+{
 	struct vop_putpages_args /* {
 		struct vnode *a_vp;
 		voff_t a_offlo;
 		voff_t a_offhi;
 		int a_flags;
 	} */ *ap = v;
 #ifdef DDB
 	vfs_vnode_print(ap->a_vp, 0, printf);
 #endif
 	lfs_dump_dinode(VTOI(ap->a_vp)->i_din.ffs1_din);
+}
 #endif
 int
 lfs_mmap(void *v)
+{
 	struct vop_mmap_args /* {
 		const struct vnodeop_desc *a_desc;
 		struct vnode *a_vp;
 		vm_prot_t a_prot;
 		kauth_cred_t a_cred;
 	} */ *ap = v;
 	if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM)
 		return EOPNOTSUPP;
 	return ulfs_mmap(v);
+}
 static int
 lfs_openextattr(void *v)
+{
 	struct vop_openextattr_args /* {
 		struct vnode *a_vp;
 		kauth_cred_t a_cred;
 		struct proc *a_p;
 	} */ *ap = v;
 	struct inode *ip = VTOI(ap->a_vp);
 	struct ulfsmount *ump = ip->i_ump;
 	//struct lfs *fs = ip->i_lfs;
 	/* Not supported for ULFS1 file systems. */
 	if (ump->um_fstype == ULFS1)
 		return (EOPNOTSUPP);
 	/* XXX Not implemented for ULFS2 file systems. */
 	return (EOPNOTSUPP);
+}
 static int
 lfs_closeextattr(void *v)
+{
 	struct vop_closeextattr_args /* {
 		struct vnode *a_vp;
 		int a_commit;
 		kauth_cred_t a_cred;
 		struct proc *a_p;
 	} */ *ap = v;
 	struct inode *ip = VTOI(ap->a_vp);
 	struct ulfsmount *ump = ip->i_ump;
 	//struct lfs *fs = ip->i_lfs;
 	/* Not supported for ULFS1 file systems. */
 	if (ump->um_fstype == ULFS1)
 		return (EOPNOTSUPP);
 	/* XXX Not implemented for ULFS2 file systems. */
 	return (EOPNOTSUPP);
+}
 static int
 lfs_getextattr(void *v)
+{
 	struct vop_getextattr_args /* {
 		struct vnode *a_vp;
 		int a_attrnamespace;
 		const char *a_name;
 		struct uio *a_uio;
 		size_t *a_size;
 		kauth_cred_t a_cred;
 		struct proc *a_p;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct inode *ip = VTOI(vp);
 	struct ulfsmount *ump = ip->i_ump;
 	//struct lfs *fs = ip->i_lfs;
 	int error;
 	if (ump->um_fstype == ULFS1) {
 #ifdef LFS_EXTATTR
 		fstrans_start(vp->v_mount, FSTRANS_SHARED);
 		error = ulfs_getextattr(ap);
 		fstrans_done(vp->v_mount);
 #else
 		error = EOPNOTSUPP;
 #endif
 		return error;
+	}
 	/* XXX Not implemented for ULFS2 file systems. */
 	return (EOPNOTSUPP);
+}
 static int
 lfs_setextattr(void *v)
+{
 	struct vop_setextattr_args /* {
 		struct vnode *a_vp;
 		int a_attrnamespace;
 		const char *a_name;
 		struct uio *a_uio;
 		kauth_cred_t a_cred;
 		struct proc *a_p;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct inode *ip = VTOI(vp);
 	struct ulfsmount *ump = ip->i_ump;
 	//struct lfs *fs = ip->i_lfs;
 	int error;
 	if (ump->um_fstype == ULFS1) {
 #ifdef LFS_EXTATTR
 		fstrans_start(vp->v_mount, FSTRANS_SHARED);
 		error = ulfs_setextattr(ap);
 		fstrans_done(vp->v_mount);
 #else
 		error = EOPNOTSUPP;
 #endif
 		return error;
+	}
 	/* XXX Not implemented for ULFS2 file systems. */
 	return (EOPNOTSUPP);
+}
 static int
 lfs_listextattr(void *v)
+{
 	struct vop_listextattr_args /* {
 		struct vnode *a_vp;
 		int a_attrnamespace;
 		struct uio *a_uio;
 		size_t *a_size;
 		kauth_cred_t a_cred;
 		struct proc *a_p;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct inode *ip = VTOI(vp);
 	struct ulfsmount *ump = ip->i_ump;
 	//struct lfs *fs = ip->i_lfs;
 	int error;
 	if (ump->um_fstype == ULFS1) {
 #ifdef LFS_EXTATTR
 		fstrans_start(vp->v_mount, FSTRANS_SHARED);
 		error = ulfs_listextattr(ap);
 		fstrans_done(vp->v_mount);
 #else
 		error = EOPNOTSUPP;
 #endif
 		return error;
+	}
 	/* XXX Not implemented for ULFS2 file systems. */
 	return (EOPNOTSUPP);
+}
 static int
 lfs_deleteextattr(void *v)
+{
 	struct vop_deleteextattr_args /* {
 		struct vnode *a_vp;
 		int a_attrnamespace;
 		kauth_cred_t a_cred;
 		struct proc *a_p;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct inode *ip = VTOI(vp);
 	struct ulfsmount *ump = ip->i_ump;
 	//struct fs *fs = ip->i_lfs;
 	int error;
 	if (ump->um_fstype == ULFS1) {
 #ifdef LFS_EXTATTR
 		fstrans_start(vp->v_mount, FSTRANS_SHARED);
 		error = ulfs_deleteextattr(ap);
 		fstrans_done(vp->v_mount);
 #else
 		error = EOPNOTSUPP;
 #endif
 		return error;
+	}
 	/* XXX Not implemented for ULFS2 file systems. */
 	return (EOPNOTSUPP);
+}