 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_bio.c,v 1.273 2017/05/25 02:28:07 pgoyette Exp $	*/
+/*	$NetBSD: vfs_bio.c,v 1.274 2017/06/08 01:23:01 chs Exp $	*/
 /*-
  * Copyright (c) 2007, 2008, 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran, and 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.
 @@ -113,27 +113,27 @@
  * - bufcache_lock: protects global buffer cache state.
  * - BC_BUSY: a long term per-buffer lock.
  * - buf_t::b_objlock: lock on completion (biowait vs biodone).
+ *
  * For buffers associated with vnodes (a most common case) b_objlock points
  * to the vnode_t::v_interlock.  Otherwise, it points to generic buffer_lock.
+ *
  * Lock order:
  *	bufcache_lock ->
  *		buf_t::b_objlock
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_bio.c,v 1.273 2017/05/25 02:28:07 pgoyette Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_bio.c,v 1.274 2017/06/08 01:23:01 chs Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_bufcache.h"
 #include "opt_dtrace.h"
 #include "opt_biohist.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/buf.h>
 #include <sys/vnode.h>
 @@ -160,29 +160,43 @@ __KERNEL_RCSID(0, "$NetBSD: vfs_bio.c,v
 #ifdef BUFCACHE
 # if (BUFCACHE < 5) || (BUFCACHE > 95)
 #  error BUFCACHE is not between 5 and 95
 # endif
 #else
 # define BUFCACHE 15
 #endif
 u_int	nbuf;			/* desired number of buffer headers */
 u_int	bufpages = BUFPAGES;	/* optional hardwired count */
 u_int	bufcache = BUFCACHE;	/* max % of RAM to use for buffer cache */
-/* Function prototypes */
+/*
-struct bqueue;
+ * Definitions for the buffer free lists.
  */
 #define	BQUEUES		3		/* number of free buffer queues */
 #define	BQ_LOCKED	0		/* super-blocks &c */
 #define	BQ_LRU		1		/* lru, useful buffers */
 #define	BQ_AGE		2		/* rubbish */
 struct bqueue {
 	TAILQ_HEAD(, buf) bq_queue;
 	uint64_t bq_bytes;
 	buf_t *bq_marker;
 };
 static struct bqueue bufqueues[BQUEUES];
 /* Function prototypes */
 static void buf_setwm(void);
 static int buf_trim(void);
 static void *bufpool_page_alloc(struct pool *, int);
 static void bufpool_page_free(struct pool *, void *);
 static buf_t *bio_doread(struct vnode *, daddr_t, int, int);
 static buf_t *getnewbuf(int, int, int);
 static int buf_lotsfree(void);
 static int buf_canrelease(void);
 static u_long buf_mempoolidx(u_long);
 static u_long buf_roundsize(u_long);
 static void *buf_alloc(size_t);
 static void buf_mrelease(void *, size_t);
 static void binsheadfree(buf_t *, struct bqueue *);
 @@ -207,27 +221,26 @@ void
 biohist_init(void)
+{
 	BIOHIST_INIT(biohist, BIOHIST_SIZE);
+}
 /*
  * Definitions for the buffer hash lists.
  */
 #define	BUFHASH(dvp, lbn)	\
 	(&bufhashtbl[(((long)(dvp) >> 8) + (int)(lbn)) & bufhash])
 LIST_HEAD(bufhashhdr, buf) *bufhashtbl, invalhash;
 u_long	bufhash;
 struct bqueue bufqueues[BQUEUES];
 static kcondvar_t needbuffer_cv;
 /*
  * Buffer queue lock.
  */
 kmutex_t bufcache_lock;
 kmutex_t buffer_lock;
 /* Software ISR for completed transfers. */
 static void *biodone_sih;
 /* Buffer pool for I/O buffers. */
 @@ -2126,13 +2139,24 @@ bbusy(buf_t *bp, bool intr, int timo, km
 			    timo);
+		}
 		brele(bp);
 		if (interlock != NULL)
 			mutex_enter(interlock);
 		if (error != 0)
 			return error;
 		return EPASSTHROUGH;
+	}
 	bp->b_cflags |= BC_BUSY;
 	return 0;
+}
 /*
  * Nothing outside this file should really need to know about nbuf,
  * but a few things still want to read it, so give them a way to do that.
  */
 int
 buf_nbuf(void)
+{
 	return nbuf;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_wapbl.c,v 1.96 2017/04/10 21:36:05 jdolecek Exp $	*/
+/*	$NetBSD: vfs_wapbl.c,v 1.97 2017/06/08 01:23:01 chs Exp $	*/
 /*-
  * Copyright (c) 2003, 2008, 2009 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.
 @@ -26,27 +26,27 @@
  * 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.
  */
 /*
  * This implements file system independent write ahead filesystem logging.
  */
 #define WAPBL_INTERNAL
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_wapbl.c,v 1.96 2017/04/10 21:36:05 jdolecek Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_wapbl.c,v 1.97 2017/06/08 01:23:01 chs Exp $");
 #include <sys/param.h>
 #include <sys/bitops.h>
 #include <sys/time.h>
 #include <sys/wapbl.h>
 #include <sys/wapbl_replay.h>
 #ifdef _KERNEL
 #include <sys/atomic.h>
 #include <sys/conf.h>
 #include <sys/evcnt.h>
 #include <sys/file.h>
 @@ -602,27 +602,27 @@ wapbl_start(struct wapbl ** wlp, struct
 	/* XXX fix actual number of pages reserved per filesystem. */
 	wl->wl_bufbytes_max = MIN(wl->wl_circ_size, buf_memcalc() / 2);
 	/* Round wl_bufbytes_max to the largest power of two constraint */
 	wl->wl_bufbytes_max >>= PAGE_SHIFT;
 	wl->wl_bufbytes_max <<= PAGE_SHIFT;
 	wl->wl_bufbytes_max >>= wl->wl_log_dev_bshift;
 	wl->wl_bufbytes_max <<= wl->wl_log_dev_bshift;
 	wl->wl_bufbytes_max >>= wl->wl_fs_dev_bshift;
 	wl->wl_bufbytes_max <<= wl->wl_fs_dev_bshift;
 	/* XXX maybe use filesystem fragment size instead of 1024 */
 	/* XXX fix actual number of buffers reserved per filesystem. */
-	wl->wl_bufcount_max = (nbuf / 2) * 1024;
+	wl->wl_bufcount_max = (buf_nbuf() / 2) * 1024;
 	wl->wl_brperjblock = ((1<<wl->wl_log_dev_bshift)
 	    - offsetof(struct wapbl_wc_blocklist, wc_blocks)) /
 	    sizeof(((struct wapbl_wc_blocklist *)0)->wc_blocks[0]);
 	KASSERT(wl->wl_brperjblock > 0);
 	/* XXX tie this into resource estimation */
 	wl->wl_dealloclim = wl->wl_bufbytes_max / mp->mnt_stat.f_bsize / 2;
 	TAILQ_INIT(&wl->wl_dealloclist);
 	wapbl_inodetrk_init(wl, WAPBL_INODETRK_SIZE);
 	wapbl_evcnt_init(wl);

 @@ -1,14 +1,14 @@
-/*     $NetBSD: buf.h,v 1.128 2017/04/10 19:52:38 jdolecek Exp $ */
+/*     $NetBSD: buf.h,v 1.129 2017/06/08 01:23:01 chs Exp $ */
 /*-
  * Copyright (c) 1999, 2000, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, and by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -247,46 +247,26 @@ do {									\
 #ifdef _KERNEL
 #define	BIO_GETPRIO(bp)		((bp)->b_prio)
 #define	BIO_SETPRIO(bp, prio)	(bp)->b_prio = (prio)
 #define	BIO_COPYPRIO(bp1, bp2)	BIO_SETPRIO(bp1, BIO_GETPRIO(bp2))
 #define	BPRIO_NPRIO		3
 #define	BPRIO_TIMECRITICAL	2
 #define	BPRIO_TIMELIMITED	1
 #define	BPRIO_TIMENONCRITICAL	0
 #define	BPRIO_DEFAULT		BPRIO_TIMELIMITED
 extern	u_int nbuf;		/* The number of buffer headers */
 /*
  * Definitions for the buffer free lists.
  */
 #define	BQUEUES		4		/* number of free buffer queues */
 #define	BQ_LOCKED	0		/* super-blocks &c */
 #define	BQ_LRU		1		/* lru, useful buffers */
 #define	BQ_AGE		2		/* rubbish */
 #define	BQ_EMPTY	3		/* buffer headers with no memory */
 struct bqueue {
 	TAILQ_HEAD(, buf) bq_queue;
 	uint64_t bq_bytes;
 	buf_t *bq_marker;
 };
 extern struct bqueue bufqueues[BQUEUES];
 __BEGIN_DECLS
 /*
  * bufferio(9) ops
  */
 void	biodone(buf_t *);
 int	biowait(buf_t *);
 buf_t	*getiobuf(struct vnode *, bool);
 void	putiobuf(buf_t *);
 void	nestiobuf_setup(buf_t *, buf_t *, int, size_t);
 void	nestiobuf_done(buf_t *, int, int);
 void	nestiobuf_iodone(buf_t *);
 int	physio(void (*)(buf_t *), buf_t *, dev_t, int,
 @@ -320,19 +300,20 @@ void	brelvp(buf_t *);
 void	reassignbuf(buf_t *, struct vnode *);
 void	bgetvp(struct vnode *, buf_t *);
 int	buf_syncwait(void);
 u_long	buf_memcalc(void);
 int	buf_drain(int);
 int	buf_setvalimit(vsize_t);
 #if defined(DDB) || defined(DEBUGPRINT)
 void	vfs_buf_print(buf_t *, int, void (*)(const char *, ...)
     __printflike(1, 2));
 #endif
 void	buf_init(buf_t *);
 void	buf_destroy(buf_t *);
 int	bbusy(buf_t *, bool, int, kmutex_t *);
 int	buf_nbuf(void);
 void	biohist_init(void);
 __END_DECLS
 #endif /* _KERNEL */
 #endif /* !_SYS_BUF_H_ */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs_balloc.c,v 1.92 2017/04/06 02:38:08 maya Exp $	*/
+/*	$NetBSD: lfs_balloc.c,v 1.93 2017/06/08 01:23:01 chs 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.
 @@ -50,27 +50,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)lfs_balloc.c	8.4 (Berkeley) 5/8/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_balloc.c,v 1.92 2017/04/06 02:38:08 maya Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_balloc.c,v 1.93 2017/06/08 01:23:01 chs Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_quota.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/buf.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/resourcevar.h>
 #include <sys/tree.h>
 @@ -517,27 +517,26 @@ lfs_fragextend(struct vnode *vp, int osi
 	/*
 	 * Get the seglock so we don't enlarge blocks while a segment
 	 * is being written.  If we're called with bpp==NULL, though,
 	 * we are only pretending to change a buffer, so we don't have to
 	 * lock.
+	 *
 	 * XXX: the above comment is lying, as fs->lfs_fraglock is not
 	 * the segment lock.
 	 */
     top:
 	if (bpp) {
 		rw_enter(&fs->lfs_fraglock, RW_READER);
 		LFS_DEBUG_COUNTLOCKED("frag");
+	}
 	/* check if we actually have enough frags available */
 	if (!ISSPACE(fs, frags, cred)) {
 		error = ENOSPC;
 		goto out;
+	}
 	/*
 	 * If we are not asked to actually return the block, all we need
 	 * to do is allocate space for it.  UBC will handle dirtying the
 	 * appropriate things and making sure it all goes to disk.
 	 * Don't bother to read in that case.

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs_subr.c,v 1.92 2017/04/06 03:21:01 maya Exp $	*/
+/*	$NetBSD: lfs_subr.c,v 1.93 2017/06/08 01:23:01 chs 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.
 @@ -50,27 +50,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)lfs_subr.c	8.4 (Berkeley) 5/8/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_subr.c,v 1.92 2017/04/06 03:21:01 maya Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_subr.c,v 1.93 2017/06/08 01:23:01 chs Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
 #include <sys/buf.h>
 #include <sys/mount.h>
 #include <sys/malloc.h>
 #include <sys/proc.h>
 #include <sys/kauth.h>
 #include <ufs/lfs/ulfs_inode.h>
 #include <ufs/lfs/lfs.h>
 @@ -453,32 +453,30 @@ lfs_segunlock(struct lfs *fs)
 		 * fs->lfs_sp so another process can use it (we have to
 		 * wait but they don't have to wait for us).
 		 */
 		if (!sync)
 			pool_put(&fs->lfs_segpool, sp);
 		fs->lfs_sp = NULL;
 		/*
 		 * If the I/O count is non-zero, sleep until it reaches zero.
 		 * At the moment, the user's process hangs around so we can
 		 * sleep.
 		 */
 		mutex_enter(&lfs_lock);
-		if (--fs->lfs_iocount == 0) {
+		if (--fs->lfs_iocount <= 1)
 			LFS_DEBUG_COUNTLOCKED("lfs_segunlock");
 		if (fs->lfs_iocount <= 1)
 			wakeup(&fs->lfs_iocount);
 		mutex_exit(&lfs_lock);
 		/*
 		 * If we're not checkpointing, we don't have to block
 		 * other processes to wait for a synchronous write
 		 * to complete.
 		 */
 		if (!ckp) {
 			LFS_ENTER_LOG("segunlock_std", __FILE__, __LINE__, 0, 0, curproc->p_pid);
 			mutex_enter(&lfs_lock);
 			--fs->lfs_seglock;
 			fs->lfs_lockpid = 0;
 			fs->lfs_locklwp = 0;
 			mutex_exit(&lfs_lock);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs_bio.c,v 1.139 2017/04/17 08:32:01 hannken Exp $	*/
+/*	$NetBSD: lfs_bio.c,v 1.140 2017/06/08 01:23:01 chs 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.
 @@ -50,27 +50,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)lfs_bio.c	8.10 (Berkeley) 6/10/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.139 2017/04/17 08:32:01 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.140 2017/06/08 01:23:01 chs 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>
 @@ -297,26 +297,40 @@ lfs_reserve(struct lfs *fs, struct vnode
 		return error;
 	/*
 	 * 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);
 	return error;
+}
 int
 lfs_max_bufs(void)
+{
 	return LFS_MAX_RESOURCE(buf_nbuf(), 1);
+}
 int
 lfs_wait_bufs(void)
+{
 	return LFS_WAIT_RESOURCE(buf_nbuf(), 1);
+}
 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;
 	KASSERTMSG((VTOI(bp->b_vp)->i_lfs->lfs_ronly ||
 		!(bp->b_flags & B_ASYNC)),
 	    "bawrite LFS buffer");
 	return lfs_bwrite_ext(bp, 0);
+}
 @@ -546,27 +560,26 @@ lfs_flush(struct lfs *fs, int flags, int
 		locked_fakequeue_count = 0;
 		mountlist_iterator_init(&iter);
 		while ((mp = mountlist_iterator_next(iter)) != NULL) {
 			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);
+			}
+		}
 		mountlist_iterator_destroy(iter);
+	}
 	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) * DINOSIZE(fs))
 /*
 @@ -739,64 +752,26 @@ lfs_freebuf(struct lfs *fs, struct buf *
 		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;
 		KASSERTMSG((n <= nbuf),
 		    "lfs_countlocked: this can't happen: more"
 		    " buffers locked than exist");
 	/*
 	 * 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;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs_extern.h,v 1.111 2016/06/20 03:29:52 dholland Exp $	*/
+/*	$NetBSD: lfs_extern.h,v 1.112 2017/06/08 01:23:01 chs 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.
 @@ -139,26 +139,28 @@ void lfs_deregister_block(struct vnode *
 void lfs_deregister_all(struct vnode *);
 /* lfs_bio.c */
 int lfs_availwait(struct lfs *, int);
 int lfs_bwrite_ext(struct buf *, int);
 int lfs_fits(struct lfs *, int);
 void lfs_flush_fs(struct lfs *, int);
 void lfs_flush(struct lfs *, int, int);
 int lfs_check(struct vnode *, daddr_t, int);
 void lfs_freebuf(struct lfs *, struct buf *);
 struct buf *lfs_newbuf(struct lfs *, struct vnode *, daddr_t, size_t, int);
 void lfs_countlocked(int *, long *, const char *);
 int lfs_reserve(struct lfs *, struct vnode *, struct vnode *, int);
 int lfs_max_bufs(void);
 int lfs_wait_bufs(void);
 /* lfs_debug.c */
 #ifdef DEBUG
 int lfs_bwrite_log(struct buf *, const char *, int);
 void lfs_dumplog(void);
 void lfs_dump_super(struct lfs *);
 void lfs_dump_dinode(struct lfs *, union lfs_dinode *);
 void lfs_check_bpp(struct lfs *, struct segment *, char *, int);
 void lfs_check_segsum(struct lfs *, struct segment *, char *, int);
 void lfs_debug_log(int, const char *, ...);
 #endif /* DEBUG */
 /* lfs_inode.c */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lfs_inode.h,v 1.21 2017/06/05 07:47:32 maya Exp $	*/
+/*	$NetBSD: lfs_inode.h,v 1.22 2017/06/08 01:23:01 chs Exp $	*/
 /*  from NetBSD: ulfs_inode.h,v 1.5 2013/06/06 00:51:50 dholland Exp  */
 /*  from NetBSD: inode.h,v 1.72 2016/06/03 15:36:03 christos Exp  */
 /*
  * Copyright (c) 1982, 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
 @@ -206,37 +206,26 @@ struct lfs_inode_ext {
 #define i_lfs_lbtree		inode_ext.lfs->lfs_lbtree
 #define i_lfs_nbtree		inode_ext.lfs->lfs_nbtree
 #define i_lfs_segdhd		inode_ext.lfs->lfs_segdhd
 #define i_lfs_odnlink		inode_ext.lfs->lfs_odnlink
 /*
  * "struct buf" associated definitions
  */
 #ifdef _KERNEL
 # define LFS_IS_MALLOC_BUF(bp) ((bp)->b_iodone == lfs_callback)
 # ifdef DEBUG
 #  define LFS_DEBUG_COUNTLOCKED(m) do {					\
 	if (lfs_debug_log_subsys[DLOG_LLIST]) {				\
 		lfs_countlocked(&locked_queue_count, &locked_queue_bytes, (m)); \
 		cv_broadcast(&locked_queue_cv);				\
 	}								\
 } while (0)
 # else
 #  define LFS_DEBUG_COUNTLOCKED(m)
 # endif
 /* log for debugging writes to the Ifile */
 # ifdef DEBUG
 struct lfs_log_entry {
 	const char *op;
 	const char *file;
 	int pid;
 	int line;
 	daddr_t block;
 	unsigned long flags;
 };
 extern int lfs_lognum;
 extern struct lfs_log_entry lfs_log[LFS_LOGLENGTH];
 #  define LFS_BWRITE_LOG(bp) lfs_bwrite_log((bp), __FILE__, __LINE__)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ulfs_inode.h,v 1.22 2016/06/21 06:14:40 dholland Exp $	*/
+/*	$NetBSD: ulfs_inode.h,v 1.23 2017/06/08 01:23:01 chs Exp $	*/
 /*  from NetBSD: inode.h,v 1.72 2016/06/03 15:36:03 christos Exp  */
 /*
  * Copyright (c) 1982, 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -59,28 +59,28 @@
 #define	MARK_VNODE(vp)			lfs_mark_vnode(vp)
 #define	UNMARK_VNODE(vp)		lfs_unmark_vnode(vp)
 int lfs_set_dirop(struct vnode *, struct vnode *);
 void lfs_unset_dirop(struct lfs *, struct vnode *, const char *);
 /* Misc. definitions */
 #define BW_CLEAN	1		/* Flag for lfs_bwrite_ext() */
 #define PG_DELWRI	PG_PAGER1	/* Local def for delayed pageout */
 /* Resource limits */
 #define	LFS_MAX_RESOURCE(x, u)	(((x) >> 2) - 10 * (u))
 #define	LFS_WAIT_RESOURCE(x, u)	(((x) >> 1) - ((x) >> 3) - 10 * (u))
 #define	LFS_INVERSE_MAX_RESOURCE(x, u)	(((x) + 10 * (u)) << 2)
-#define LFS_MAX_BUFS	    LFS_MAX_RESOURCE(nbuf, 1)
+#define LFS_MAX_BUFS	    lfs_max_bufs()
-#define LFS_WAIT_BUFS	    LFS_WAIT_RESOURCE(nbuf, 1)
+#define LFS_WAIT_BUFS	    lfs_wait_bufs()
 #define LFS_INVERSE_MAX_BUFS(n)	LFS_INVERSE_MAX_RESOURCE(n, 1)
 #define LFS_MAX_BYTES	    LFS_MAX_RESOURCE(bufmem_lowater, PAGE_SIZE)
 #define LFS_INVERSE_MAX_BYTES(n) LFS_INVERSE_MAX_RESOURCE(n, PAGE_SIZE)
 #define LFS_WAIT_BYTES	    LFS_WAIT_RESOURCE(bufmem_lowater, PAGE_SIZE)
 #define LFS_MAX_DIROP	    ((desiredvnodes >> 2) + (desiredvnodes >> 3))
 #define SIZEOF_DIROP(fs)	(2 * (lfs_sb_getbsize(fs) + DINOSIZE(fs)))
 #define LFS_MAX_FSDIROP(fs)						\
 	(lfs_sb_getnclean(fs) <= lfs_sb_getresvseg(fs) ? 0 :		\
 	 ((lfs_sb_getnclean(fs) - lfs_sb_getresvseg(fs)) * lfs_sb_getssize(fs)) / \
           (2 * SIZEOF_DIROP(fs)))
 #define LFS_MAX_PAGES	lfs_max_pages()
 #define LFS_WAIT_PAGES	lfs_wait_pages()
 #define LFS_BUFWAIT	    2	/* How long to wait if over *_WAIT_* */