 @@ -1,14 +1,14 @@
-/*      $NetBSD: coalesce.c,v 1.23 2013/06/18 18:18:57 christos Exp $  */
+/*      $NetBSD: coalesce.c,v 1.24 2015/03/29 19:35:58 chopps Exp $  */
 /*-
  * Copyright (c) 2002, 2005 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.
 @@ -108,27 +108,27 @@ get_dinode(struct clfs *fs, ino_t ino)
+{
 	IFILE *ifp;
 	daddr_t daddr;
 	struct ubuf *bp;
 	struct ulfs1_dinode *dip, *r;
 	lfs_ientry(&ifp, fs, ino, &bp);
 	daddr = ifp->if_daddr;
 	brelse(bp, 0);
 	if (daddr == 0x0)
 		return NULL;
-	bread(fs->clfs_devvp, daddr, fs->lfs_ibsize, NOCRED, 0, &bp);
+	bread(fs->clfs_devvp, daddr, fs->lfs_ibsize, 0, &bp);
 	for (dip = (struct ulfs1_dinode *)bp->b_data;
 	     dip < (struct ulfs1_dinode *)(bp->b_data + fs->lfs_ibsize); dip++)
 		if (dip->di_inumber == ino) {
 			r = (struct ulfs1_dinode *)malloc(sizeof(*r));
 			if (r == NULL)
 				break;
 			memcpy(r, dip, sizeof(*r));
 			brelse(bp, 0);
 			return r;
+		}
 	brelse(bp, 0);
 	return NULL;
+}
 @@ -287,27 +287,27 @@ clean_inode(struct clfs *fs, ino_t ino)
+	}
 	if (debug)
 		syslog(LOG_DEBUG, "ino %llu markv %d blocks",
 		    (unsigned long long)ino, nb);
 	/*
 	 * Write in segment-sized chunks.  If at any point we'd write more
 	 * than half of the available segments, sleep until that's not
 	 * true any more.
 	 */
 	bps = lfs_segtod(fs, 1);
 	for (tbip = bip; tbip < bip + nb; tbip += bps) {
 		do {
-			bread(fs->lfs_ivnode, 0, fs->lfs_bsize, NOCRED, 0, &bp);
+			bread(fs->lfs_ivnode, 0, fs->lfs_bsize, 0, &bp);
 			cip = *(CLEANERINFO *)bp->b_data;
 			brelse(bp, B_INVAL);
 			if (cip.clean < 4) /* XXX magic number 4 */
 				kops.ko_fcntl(fs->clfs_ifilefd,
 				    LFCNSEGWAIT, NULL);
 		} while(cip.clean < 4);
 		lim.blkiov = tbip;
 		lim.blkcnt = (tbip + bps < bip + nb ? bps : nb % bps);
 		if (kops.ko_fcntl(fs->clfs_ifilefd, LFCNMARKV, &lim) < 0) {
 			retval = COALESCE_BADMARKV;
 			goto out;

 @@ -1,14 +1,14 @@
-/* $NetBSD: lfs_cleanerd.c,v 1.37 2013/10/19 17:19:30 christos Exp $	 */
+/* $NetBSD: lfs_cleanerd.c,v 1.38 2015/03/29 19:35:58 chopps Exp $	 */
 /*-
  * Copyright (c) 2005 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.
 @@ -321,27 +321,27 @@ reload_ifile(struct clfs *fs)
+}
 /*
  * Get IFILE entry for the given inode, store in ifpp.	The buffer
  * which contains that data is returned in bpp, and must be brelse()d
  * by the caller.
  */
 void
 lfs_ientry(IFILE **ifpp, struct clfs *fs, ino_t ino, struct ubuf **bpp)
+{
 	int error;
 	error = bread(fs->lfs_ivnode, ino / fs->lfs_ifpb + fs->lfs_cleansz +
-		      fs->lfs_segtabsz, fs->lfs_bsize, NOCRED, 0, bpp);
+		      fs->lfs_segtabsz, fs->lfs_bsize, 0, bpp);
 	if (error)
 		syslog(LOG_ERR, "%s: ientry failed for ino %d",
 			fs->lfs_fsmnt, (int)ino);
 	*ifpp = (IFILE *)(*bpp)->b_data + ino % fs->lfs_ifpb;
 	return;
+}
 #ifdef TEST_PATTERN
 /*
  * Check ULFS_ROOTINO for file data.  The assumption is that we are running
  * the "twofiles" test with the rest of the filesystem empty.  Files
  * created by "twofiles" match the test pattern, but ULFS_ROOTINO and the
  * executable itself (assumed to be inode 3) should not match.
 @@ -504,27 +504,27 @@ parse_pseg(struct clfs *fs, daddr_t dadd
 		/*
 		 * If this finfo has nblocks==0, it was written wrong.
 		 * Kernels with this problem always wrote this zero-sized
 		 * finfo last, so just ignore it.
 		 */
 		if (fip->fi_nblocks == 0) {
 #ifdef REPAIR_ZERO_FINFO
 			struct ubuf *nbp;
 			SEGSUM *nssp;
 			syslog(LOG_WARNING, "fixing short FINFO at %x (seg %d)",
 			       odaddr, lfs_dtosn(fs, odaddr));
 			bread(fs->clfs_devvp, odaddr, fs->lfs_fsize,
-			    NOCRED, 0, &nbp);
+, &nbp);
 			nssp = (SEGSUM *)nbp->b_data;
 			--nssp->ss_nfinfo;
 			nssp->ss_sumsum = cksum(&nssp->ss_datasum,
 				fs->lfs_sumsize - sizeof(nssp->ss_sumsum));
 			bwrite(nbp);
 #endif
 			syslog(LOG_WARNING, "zero-length FINFO at %x (seg %d)",
 			       odaddr, lfs_dtosn(fs, odaddr));
 			continue;
+		}
 		/*
 		 * Check currency before adding blocks
 @@ -1004,27 +1004,27 @@ clean_fs(struct clfs *fs, CLEANERINFO *c
 	} */ lim;
 	int mc;
 	BLOCK_INFO *mbip;
 	int inc;
 	off_t nb;
 	off_t goal;
 	off_t extra, if_extra;
 	double util;
 	/* Read the segment table into our private structure */
 	npos = 0;
 	for (i = 0; i < fs->lfs_nseg; i+= fs->lfs_sepb) {
 		bread(fs->lfs_ivnode, fs->lfs_cleansz + i / fs->lfs_sepb,
-		      fs->lfs_bsize, NOCRED, 0, &bp);
+		      fs->lfs_bsize, 0, &bp);
 		for (j = 0; j < fs->lfs_sepb && i + j < fs->lfs_nseg; j++) {
 			sup = ((SEGUSE *)bp->b_data) + j;
 			fs->clfs_segtab[i + j].nbytes  = sup->su_nbytes;
 			fs->clfs_segtab[i + j].nsums = sup->su_nsums;
 			fs->clfs_segtab[i + j].lastmod = sup->su_lastmod;
 			/* Keep error status but renew other flags */
 			fs->clfs_segtab[i + j].flags  &= SEGUSE_ERROR;
 			fs->clfs_segtab[i + j].flags  |= sup->su_flags;
 			/* Compute cost-benefit coefficient */
 			calc_cb(fs, i + j, fs->clfs_segtab + i + j);
 			if (fs->clfs_segtab[i + j].priority > 0)
 				++npos;
 @@ -1204,27 +1204,27 @@ needs_cleaning(struct clfs *fs, CLEANERI
 	daddr_t fsb_per_seg, max_free_segs;
 	time_t now;
 	double loadavg;
 	/* If this fs is "on hold", don't clean it. */
 	if (fs->clfs_onhold)
 		return 0;
 	/*
 	 * Read the cleanerinfo block from the Ifile.  We don't want
 	 * the cached information, so invalidate the buffer before
 	 * handing it back.
 	 */
-	if (bread(fs->lfs_ivnode, 0, fs->lfs_bsize, NOCRED, 0, &bp)) {
+	if (bread(fs->lfs_ivnode, 0, fs->lfs_bsize, 0, &bp)) {
 		syslog(LOG_ERR, "%s: can't read inode", fs->lfs_fsmnt);
 		return -1;
+	}
 	*cip = *(CLEANERINFO *)bp->b_data; /* Structure copy */
 	brelse(bp, B_INVAL);
 	cleaner_stats.bytes_read += fs->lfs_bsize;
 	/*
 	 * If the number of segments changed under us, reinit.
 	 * We don't have to start over from scratch, however,
 	 * since we don't hold any buffers.
 	 */
 	if (fs->lfs_nseg != cip->clean + cip->dirty) {

 @@ -1,14 +1,14 @@
-/* $NetBSD: dir.c,v 1.32 2013/06/18 18:18:58 christos Exp $	 */
+/* $NetBSD: dir.c,v 1.33 2015/03/29 19:35:58 chopps Exp $	 */
 /*
  * Copyright (c) 1980, 1986, 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.
 @@ -145,60 +145,60 @@ dirscan(struct inodesc *idesc)
 	if (chkrange(idesc->id_blkno, idesc->id_numfrags)) {
 		idesc->id_filesize -= blksiz;
 		return (SKIP);
+	}
 	idesc->id_loc = 0;
 	vp = vget(fs, idesc->id_number);
 	for (dp = fsck_readdir(vp, idesc); dp != NULL;
 	    dp = fsck_readdir(vp, idesc)) {
 		dsize = dp->d_reclen;
 		memcpy(dbuf, dp, (size_t) dsize);
 		idesc->id_dirp = (struct lfs_direct *) dbuf;
 		if ((n = (*idesc->id_func) (idesc)) & ALTERED) {
-			bread(vp, idesc->id_lblkno, blksiz, NOCRED, 0, &bp);
+			bread(vp, idesc->id_lblkno, blksiz, 0, &bp);
 			memcpy(bp->b_data + idesc->id_loc - dsize, dbuf,
 			    (size_t) dsize);
 			VOP_BWRITE(bp);
 			sbdirty();
+		}
 		if (n & STOP)
 			return (n);
+	}
 	return (idesc->id_filesize > 0 ? KEEPON : STOP);
+}
 /*
  * get next entry in a directory.
  */
 static struct lfs_direct *
 fsck_readdir(struct uvnode *vp, struct inodesc *idesc)
+{
 	struct lfs_direct *dp, *ndp;
 	struct ubuf *bp;
 	long size, blksiz, fix, dploc;
 	blksiz = idesc->id_numfrags * fs->lfs_fsize;
-	bread(vp, idesc->id_lblkno, blksiz, NOCRED, 0, &bp);
+	bread(vp, idesc->id_lblkno, blksiz, 0, &bp);
 	if (idesc->id_loc % LFS_DIRBLKSIZ == 0 && idesc->id_filesize > 0 &&
 	    idesc->id_loc < blksiz) {
 		dp = (struct lfs_direct *) (bp->b_data + idesc->id_loc);
 		if (dircheck(idesc, dp))
 			goto dpok;
 		brelse(bp, 0);
 		if (idesc->id_fix == IGNORE)
 			return (0);
 		fix = dofix(idesc, "DIRECTORY CORRUPTED");
-		bread(vp, idesc->id_lblkno, blksiz, NOCRED, 0, &bp);
+		bread(vp, idesc->id_lblkno, blksiz, 0, &bp);
 		dp = (struct lfs_direct *) (bp->b_data + idesc->id_loc);
 		dp->d_reclen = LFS_DIRBLKSIZ;
 		dp->d_ino = 0;
 		dp->d_type = 0;
 		dp->d_namlen = 0;
 		dp->d_name[0] = '\0';
 		if (fix)
 			VOP_BWRITE(bp);
 		else
 			brelse(bp, 0);
 		idesc->id_loc += LFS_DIRBLKSIZ;
 		idesc->id_filesize -= LFS_DIRBLKSIZ;
 		return (dp);
 @@ -216,27 +216,27 @@ dpok:
 		brelse(bp, 0);
 		return dp;
+	}
 	ndp = (struct lfs_direct *) (bp->b_data + idesc->id_loc);
 	if (idesc->id_loc < blksiz && idesc->id_filesize > 0 &&
 	    dircheck(idesc, ndp) == 0) {
 		brelse(bp, 0);
 		size = LFS_DIRBLKSIZ - (idesc->id_loc % LFS_DIRBLKSIZ);
 		idesc->id_loc += size;
 		idesc->id_filesize -= size;
 		if (idesc->id_fix == IGNORE)
 			return 0;
 		fix = dofix(idesc, "DIRECTORY CORRUPTED");
-		bread(vp, idesc->id_lblkno, blksiz, NOCRED, 0, &bp);
+		bread(vp, idesc->id_lblkno, blksiz, 0, &bp);
 		dp = (struct lfs_direct *) (bp->b_data + dploc);
 		dp->d_reclen += size;
 		if (fix)
 			VOP_BWRITE(bp);
 		else
 			brelse(bp, 0);
 	} else
 		brelse(bp, 0);
 	return (dp);
+}
 /*
 @@ -563,41 +563,41 @@ expanddir(struct uvnode *vp, struct ulfs
 	struct ubuf *bp;
 	char *cp, firstblk[LFS_DIRBLKSIZ];
 	lastbn = lfs_lblkno(fs, dp->di_size);
 	if (lastbn >= ULFS_NDADDR - 1 || dp->di_db[lastbn] == 0 || dp->di_size == 0)
 		return (0);
 	dp->di_db[lastbn + 1] = dp->di_db[lastbn];
 	dp->di_db[lastbn] = 0;
 	bp = getblk(vp, lastbn, fs->lfs_bsize);
 	VOP_BWRITE(bp);
 	dp->di_size += fs->lfs_bsize;
 	dp->di_blocks += lfs_btofsb(fs, fs->lfs_bsize);
 	bread(vp, dp->di_db[lastbn + 1],
-	    (long) lfs_dblksize(fs, dp, lastbn + 1), NOCRED, 0, &bp);
+	    (long) lfs_dblksize(fs, dp, lastbn + 1), 0, &bp);
 	if (bp->b_flags & B_ERROR)
 		goto bad;
 	memcpy(firstblk, bp->b_data, LFS_DIRBLKSIZ);
-	bread(vp, lastbn, fs->lfs_bsize, NOCRED, 0, &bp);
+	bread(vp, lastbn, fs->lfs_bsize, 0, &bp);
 	if (bp->b_flags & B_ERROR)
 		goto bad;
 	memcpy(bp->b_data, firstblk, LFS_DIRBLKSIZ);
 	for (cp = &bp->b_data[LFS_DIRBLKSIZ];
 	    cp < &bp->b_data[fs->lfs_bsize];
 	    cp += LFS_DIRBLKSIZ)
 		memcpy(cp, &emptydir, sizeof emptydir);
 	VOP_BWRITE(bp);
 	bread(vp, dp->di_db[lastbn + 1],
-	    (long) lfs_dblksize(fs, dp, lastbn + 1), NOCRED, 0, &bp);
+	    (long) lfs_dblksize(fs, dp, lastbn + 1), 0, &bp);
 	if (bp->b_flags & B_ERROR)
 		goto bad;
 	memcpy(bp->b_data, &emptydir, sizeof emptydir);
 	pwarn("NO SPACE LEFT IN %s", name);
 	if (preen)
 		printf(" (EXPANDED)\n");
 	else if (reply("EXPAND") == 0)
 		goto bad;
 	VOP_BWRITE(bp);
 	inodirty(VTOI(vp));
 	return (1);
 bad:
 	dp->di_db[lastbn] = dp->di_db[lastbn + 1];
 @@ -616,27 +616,27 @@ allocdir(ino_t parent, ino_t request, in
 	ino_t ino;
 	char *cp;
 	struct ulfs1_dinode *dp;
 	struct ubuf *bp;
 	struct lfs_dirtemplate *dirp;
 	struct uvnode *vp;
 	ino = allocino(request, LFS_IFDIR | mode);
 	dirp = &dirhead;
 	dirp->dot_ino = ino;
 	dirp->dotdot_ino = parent;
 	vp = vget(fs, ino);
 	dp = VTOD(vp);
-	bread(vp, dp->di_db[0], fs->lfs_fsize, NOCRED, 0, &bp);
+	bread(vp, dp->di_db[0], fs->lfs_fsize, 0, &bp);
 	if (bp->b_flags & B_ERROR) {
 		brelse(bp, 0);
 		freeino(ino);
 		return (0);
+	}
 	memcpy(bp->b_data, dirp, sizeof(struct lfs_dirtemplate));
 	for (cp = &bp->b_data[LFS_DIRBLKSIZ];
 	    cp < &bp->b_data[fs->lfs_fsize];
 	    cp += LFS_DIRBLKSIZ)
 		memcpy(cp, &emptydir, sizeof emptydir);
 	VOP_BWRITE(bp);
 	dp->di_nlink = 2;
 	inodirty(VTOI(vp));

 @@ -1,14 +1,14 @@
-/* $NetBSD: pass6.c,v 1.32 2013/10/19 01:09:58 christos Exp $	 */
+/* $NetBSD: pass6.c,v 1.33 2015/03/29 19:35:58 chopps Exp $	 */
 /*-
  * Copyright (c) 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.
 @@ -110,27 +110,27 @@ rfw_update_single(struct uvnode *vp, dad
 			ofrags = lfs_numfrags(fs, ip->i_lfs_fragsize[lbn]);
 			ip->i_ffs1_blocks += (frags - ofrags);
+		}
 		ip->i_ffs1_db[lbn] = ndaddr;
 		break;
 	case 1:
 		ooff = ip->i_ffs1_ib[a[0].in_off];
 		if (ooff <= 0)
 			ip->i_ffs1_blocks += frags;
 		ip->i_ffs1_ib[a[0].in_off] = ndaddr;
 		break;
 	default:
 		ap = &a[num - 1];
-		if (bread(vp, ap->in_lbn, fs->lfs_bsize, NULL, 0, &bp))
+		if (bread(vp, ap->in_lbn, fs->lfs_bsize, 0, &bp))
 			errx(1, "lfs_updatemeta: bread bno %" PRId64,
 			    ap->in_lbn);
 		ooff = ((ulfs_daddr_t *) bp->b_data)[ap->in_off];
 		if (ooff <= 0)
 			ip->i_ffs1_blocks += frags;
 		((ulfs_daddr_t *) bp->b_data)[ap->in_off] = ndaddr;
 		(void) VOP_BWRITE(bp);
+	}
 	/*
 	 * Update segment usage information, based on old size
 	 * and location.
 @@ -326,34 +326,34 @@ pass6check(struct inodesc * idesc)
+}
 static void
 account_indir(struct uvnode *vp, struct ulfs1_dinode *dp, daddr_t ilbn, daddr_t daddr, int lvl)
+{
 	struct ubuf *bp;
 	int32_t *dap, *odap, *buf, *obuf;
 	daddr_t lbn;
 	if (lvl == 0)
 		lbn = -ilbn;
 	else
 		lbn = ilbn + 1;
-	bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), fs->lfs_bsize, NULL, 0, &bp);
+	bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), fs->lfs_bsize, 0, &bp);
 	buf = emalloc(fs->lfs_bsize);
 	memcpy(buf, bp->b_data, fs->lfs_bsize);
 	brelse(bp, 0);
 	obuf = emalloc(fs->lfs_bsize);
 	if (vp) {
-		bread(vp, ilbn, fs->lfs_bsize, NULL, 0, &bp);
+		bread(vp, ilbn, fs->lfs_bsize, 0, &bp);
 		memcpy(obuf, bp->b_data, fs->lfs_bsize);
 		brelse(bp, 0);
 	} else
 		memset(obuf, 0, fs->lfs_bsize);
 	for (dap = buf, odap = obuf;
 	     dap < (int32_t *)((char *)buf + fs->lfs_bsize);
 	     ++dap, ++odap) {
 		if (*dap > 0 && *dap != *odap) {
 			rfw_update_single(vp, lbn, *dap, lfs_dblksize(fs, dp, lbn));
 			if (lvl > 0)
 				account_indir(vp, dp, lbn, *dap, lvl - 1);
+		}
 @@ -601,27 +601,27 @@ pass6(void)
 				daddr += lfs_btofsb(fs, LFS_LABELPAD);
+			}
 			for (i = 0; i < LFS_MAXNUMSB; i++) {
 				if (daddr == fs->lfs_sboffs[i]) {
 					++hassuper;
 					daddr += lfs_btofsb(fs, LFS_SBPAD);
+				}
 				if (daddr < fs->lfs_sboffs[i])
 					break;
+			}
+		}
 		/* Read in summary block */
-		bread(devvp, LFS_FSBTODB(fs, daddr), fs->lfs_sumsize, NULL, 0, &bp);
+		bread(devvp, LFS_FSBTODB(fs, daddr), fs->lfs_sumsize, 0, &bp);
 		sp = (SEGSUM *)bp->b_data;
 		if (debug)
 			pwarn("sum at 0x%x: ninos=%d nfinfo=%d\n",
 				(unsigned)daddr, (int)sp->ss_ninos,
 				(int)sp->ss_nfinfo);
 		/* We have verified that this is a good summary. */
 		LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), sbp);
 		++sup->su_nsums;
 		VOP_BWRITE(sbp);
 		fs->lfs_bfree -= lfs_btofsb(fs, fs->lfs_sumsize);
 		fs->lfs_dmeta += lfs_btofsb(fs, fs->lfs_sumsize);
 		sbdirty();
 @@ -640,27 +640,27 @@ pass6(void)
 			fs->lfs_dmeta += lfs_btofsb(fs, howmany(sp->ss_ninos,
 							    LFS_INOPB(fs)) *
 						fs->lfs_ibsize);
+		}
 		idaddrp = ((ulfs_daddr_t *)((char *)bp->b_data + fs->lfs_sumsize));
 		for (i = 0; i < howmany(sp->ss_ninos, LFS_INOPB(fs)); i++) {
 			ino_t *inums;
 			inums = ecalloc(LFS_INOPB(fs) + 1, sizeof(*inums));
 			ibdaddr = *--idaddrp;
 			fs->lfs_bfree -= lfs_btofsb(fs, fs->lfs_ibsize);
 			sbdirty();
 			bread(devvp, LFS_FSBTODB(fs, ibdaddr), fs->lfs_ibsize,
-			      NOCRED, 0, &ibp);
+, &ibp);
 			memcpy(ibbuf, ibp->b_data, fs->lfs_ibsize);
 			brelse(ibp, 0);
 			j = 0;
 			for (dp = (struct ulfs1_dinode *)ibbuf;
 			     dp < (struct ulfs1_dinode *)ibbuf + LFS_INOPB(fs);
 			     ++dp) {
 				if (dp->di_inumber == 0 ||
 				    dp->di_inumber == fs->lfs_ifile)
 					continue;
 				/* Basic sanity checks */
 				if (dp->di_nlink < 0
 #if 0
 @@ -827,27 +827,27 @@ pass6(void)
 		if (lfs_sntod(fs, lfs_dtosn(fs, daddr)) == daddr) {
 			if (daddr == fs->lfs_start)
 				daddr += lfs_btofsb(fs, LFS_LABELPAD);
 			for (i = 0; i < LFS_MAXNUMSB; i++) {
 				if (daddr == fs->lfs_sboffs[i]) {
 					daddr += lfs_btofsb(fs, LFS_SBPAD);
+				}
 				if (daddr < fs->lfs_sboffs[i])
 					break;
+			}
+		}
 		/* Read in summary block */
-		bread(devvp, LFS_FSBTODB(fs, daddr), fs->lfs_sumsize, NULL, 0, &bp);
+		bread(devvp, LFS_FSBTODB(fs, daddr), fs->lfs_sumsize, 0, &bp);
 		sp = (SEGSUM *)bp->b_data;
 		bc = check_summary(fs, sp, daddr, debug, devvp, pass6harvest);
 		if (bc == 0) {
 			pwarn("unexpected bad seg ptr [2] at 0x%x with serial=%d\n",
 				(int)daddr, (int)sp->ss_serial);
 			brelse(bp, 0);
 			break;
+		}
 		odaddr = daddr;
 		daddr += lfs_btofsb(fs, fs->lfs_sumsize + bc);
 		fs->lfs_avail -= lfs_btofsb(fs, fs->lfs_sumsize + bc);
 		if (lfs_dtosn(fs, odaddr) != lfs_dtosn(fs, daddr) ||
 		    lfs_dtosn(fs, daddr) != lfs_dtosn(fs, daddr +

 @@ -1,14 +1,14 @@
-/* $NetBSD: inode.c,v 1.52 2014/03/23 05:39:32 dholland Exp $	 */
+/* $NetBSD: inode.c,v 1.53 2015/03/29 19:35:58 chopps Exp $	 */
 /*-
  * Copyright (c) 1997, 1998 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.
 @@ -236,27 +236,27 @@ iblock(struct inodesc *idesc, long ileve
 	if (idesc->id_type == ADDR) {
 		func = idesc->id_func;
 		n = (*func) (idesc);
 		if ((n & KEEPON) == 0)
 			return (n);
 	} else
 		func = dirscan;
 	if (chkrange(idesc->id_blkno, idesc->id_numfrags))
 		return (SKIP);
 	devvp = fs->lfs_devvp;
 	bread(devvp, LFS_FSBTODB(fs, idesc->id_blkno), fs->lfs_bsize,
-	    NOCRED, 0, &bp);
+, &bp);
 	ilevel--;
 	for (sizepb = fs->lfs_bsize, i = 0; i < ilevel; i++)
 		sizepb *= LFS_NINDIR(fs);
 	if (isize > sizepb * LFS_NINDIR(fs))
 		nif = LFS_NINDIR(fs);
 	else
 		nif = howmany(isize, sizepb);
 	if (idesc->id_func == pass1check && nif < LFS_NINDIR(fs)) {
 		aplim = ((ulfs_daddr_t *) bp->b_data) + LFS_NINDIR(fs);
 		for (ap = ((ulfs_daddr_t *) bp->b_data) + nif; ap < aplim; ap++) {
 			if (*ap == 0)
 				continue;
 			(void)snprintf(buf, sizeof(buf),

 @@ -1,14 +1,14 @@
-/* $NetBSD: lfs.c,v 1.43 2014/07/13 02:44:21 dholland Exp $ */
+/* $NetBSD: lfs.c,v 1.44 2015/03/29 19:35:58 chopps Exp $ */
 /*-
  * Copyright (c) 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
 @@ -357,27 +357,27 @@ lfs_raw_vget(struct lfs * fs, ino_t ino,
 	/* Initialize the inode -- from lfs_vcreate. */
 	ip->inode_ext.lfs = ecalloc(1, sizeof(*ip->inode_ext.lfs));
 	vp->v_data = ip;
 	/* ip->i_vnode = vp; */
 	ip->i_number = ino;
 	ip->i_lockf = 0;
 	ip->i_lfs_effnblks = 0;
 	ip->i_flag = 0;
 	/* Load inode block and find inode */
 	if (daddr > 0) {
 		bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), fs->lfs_ibsize,
-		    NULL, 0, &bp);
+, &bp);
 		bp->b_flags |= B_AGE;
 		dip = lfs_ifind(fs, ino, bp);
 		if (dip == NULL) {
 			brelse(bp, 0);
 			free(ip);
 			free(vp);
 			return NULL;
+		}
 		memcpy(ip->i_din.ffs1_din, dip, sizeof(*dip));
 		brelse(bp, 0);
+	}
 	ip->i_number = ino;
 	/* ip->i_devvp = fs->lfs_devvp; */
 @@ -469,38 +469,38 @@ lfs_init(int devfd, daddr_t sblkno, dadd
 			sblkno = LFS_LABELPAD / dev_bsize;
 		fs = ecalloc(1, sizeof(*fs));
 		fs->lfs_devvp = devvp;
 	} else {
 		if (sblkno == 0) {
 			sblkno = LFS_LABELPAD / dev_bsize;
 			tryalt = 1;
 		} else if (debug) {
 			printf("No -b flag given, not attempting to verify checkpoint\n");
+		}
 		dev_bsize = DEV_BSIZE;
-		(void)bread(devvp, sblkno, LFS_SBPAD, NOCRED, 0, &bp);
+		(void)bread(devvp, sblkno, LFS_SBPAD, 0, &bp);
 		fs = ecalloc(1, sizeof(*fs));
 		fs->lfs_dlfs = *((struct dlfs *) bp->b_data);
 		fs->lfs_devvp = devvp;
 		bp->b_flags |= B_INVAL;
 		brelse(bp, 0);
 		dev_bsize = fs->lfs_fsize >> fs->lfs_fsbtodb;
 		if (tryalt) {
 			(void)bread(devvp, LFS_FSBTODB(fs, fs->lfs_sboffs[1]),
-		    	LFS_SBPAD, NOCRED, 0, &bp);
+		    	LFS_SBPAD, 0, &bp);
 			altfs = ecalloc(1, sizeof(*altfs));
 			altfs->lfs_dlfs = *((struct dlfs *) bp->b_data);
 			altfs->lfs_devvp = devvp;
 			bp->b_flags |= B_INVAL;
 			brelse(bp, 0);
 			if (check_sb(fs) || fs->lfs_idaddr <= 0) {
 				if (debug)
 					printf("Primary superblock is no good, using first alternate\n");
 				free(fs);
 				fs = altfs;
 			} else {
 				/* If both superblocks check out, try verification */
 @@ -588,27 +588,27 @@ try_verify(struct lfs *osb, struct uvnod
 		if (lfs_sntod(osb, lfs_dtosn(osb, daddr)) == daddr) {
 			if (daddr == osb->lfs_start)
 				daddr += lfs_btofsb(osb, LFS_LABELPAD);
 			for (i = 0; i < LFS_MAXNUMSB; i++) {
 				if (osb->lfs_sboffs[i] < daddr)
 					break;
 				if (osb->lfs_sboffs[i] == daddr)
 					daddr += lfs_btofsb(osb, LFS_SBPAD);
+			}
+		}
 		/* Read in summary block */
 		bread(devvp, LFS_FSBTODB(osb, daddr), osb->lfs_sumsize,
-		    NULL, 0, &bp);
+, &bp);
 		sp = (SEGSUM *)bp->b_data;
 		/*
 		 * Check for a valid segment summary belonging to our fs.
 		 */
 		if (sp->ss_magic != SS_MAGIC ||
 		    sp->ss_ident != osb->lfs_ident ||
 		    sp->ss_serial < serial ||	/* XXX strengthen this */
 		    sp->ss_sumsum != cksum(&sp->ss_datasum, osb->lfs_sumsize -
 			sizeof(sp->ss_sumsum))) {
 			brelse(bp, 0);
 			if (debug) {
 				if (sp->ss_magic != SS_MAGIC)
 @@ -780,43 +780,43 @@ check_summary(struct lfs *fs, SEGSUM *sp
 	for (i = 0, j = 0;
 	     i < sp->ss_nfinfo || j < howmany(sp->ss_ninos, LFS_INOPB(fs)); i++) {
 		if (i >= sp->ss_nfinfo && *idp != daddr) {
 			pwarn("Not enough inode blocks in pseg at 0x%" PRIx32
 			      ": found %d, wanted %d\n",
 			      pseg_addr, j, howmany(sp->ss_ninos, LFS_INOPB(fs)));
 			if (debug)
 				pwarn("*idp=%x, daddr=%" PRIx32 "\n", *idp,
 				      daddr);
 			break;
+		}
 		while (j < howmany(sp->ss_ninos, LFS_INOPB(fs)) && *idp == daddr) {
 			bread(devvp, LFS_FSBTODB(fs, daddr), fs->lfs_ibsize,
-			    NOCRED, 0, &bp);
+, &bp);
 			datap[datac++] = ((u_int32_t *) (bp->b_data))[0];
 			brelse(bp, 0);
 			++j;
 			daddr += lfs_btofsb(fs, fs->lfs_ibsize);
 			--idp;
+		}
 		if (i < sp->ss_nfinfo) {
 			if (func)
 				func(daddr, fp);
 			for (k = 0; k < fp->fi_nblocks; k++) {
 				len = (k == fp->fi_nblocks - 1 ?
 				       fp->fi_lastlength
 				       : fs->lfs_bsize);
 				bread(devvp, LFS_FSBTODB(fs, daddr), len,
-				    NOCRED, 0, &bp);
+, &bp);
 				datap[datac++] = ((u_int32_t *) (bp->b_data))[0];
 				brelse(bp, 0);
 				daddr += lfs_btofsb(fs, len);
+			}
 			fp = (FINFO *) (fp->fi_blocks + fp->fi_nblocks);
+		}
+	}
 	if (datac != nblocks) {
 		pwarn("Partial segment at 0x%llx expected %d blocks counted %d\n",
 		    (long long) pseg_addr, nblocks, datac);
+	}
 	ccksum = cksum(datap, nblocks * sizeof(u_int32_t));
 @@ -1033,27 +1033,27 @@ lfs_balloc(struct uvnode *vp, off_t star
 			/* Brand new block or fragment */
 			frags = lfs_numfrags(fs, nsize);
 			if (bpp) {
 				*bpp = bp = getblk(vp, lbn, nsize);
 				bp->b_blkno = UNWRITTEN;
+			}
 			ip->i_lfs_effnblks += frags;
 			fs->lfs_bfree -= frags;
 			ip->i_ffs1_db[lbn] = UNWRITTEN;
 		} else {
 			if (nsize <= osize) {
 				/* No need to extend */
 				if (bpp && (error = bread(vp, lbn, osize,
-				    NOCRED, 0, &bp)))
+, &bp)))
 					return error;
 			} else {
 				/* Extend existing block */
 				if ((error =
 				     lfs_fragextend(vp, osize, nsize, lbn,
 						    (bpp ? &bp : NULL))))
 					return error;
+			}
 			if (bpp)
 				*bpp = bp;
+		}
 		return 0;
+	}
 @@ -1139,28 +1139,27 @@ lfs_balloc(struct uvnode *vp, off_t star
 			/* Note the new address */
 			bp->b_blkno = UNWRITTEN;
+		}
 		switch (num) {
 		    case 0:
 			ip->i_ffs1_db[lbn] = UNWRITTEN;
 			break;
 		    case 1:
 			ip->i_ffs1_ib[indirs[0].in_off] = UNWRITTEN;
 			break;
 		    default:
 			idp = &indirs[num - 1];
-			if (bread(vp, idp->in_lbn, fs->lfs_bsize, NOCRED,
+			if (bread(vp, idp->in_lbn, fs->lfs_bsize, 0, &ibp))
 , &ibp))
 				panic("lfs_balloc: bread bno %lld",
 				    (long long)idp->in_lbn);
 			/* XXX ondisk32 */
 			((int32_t *)ibp->b_data)[idp->in_off] = UNWRITTEN;
 			VOP_BWRITE(ibp);
+		}
 	} else if (bpp && !(bp->b_flags & (B_DONE|B_DELWRI))) {
 		/*
 		 * Not a brand new block, also not in the cache;
 		 * read it in from disk.
 		 */
 		if (iosize == fs->lfs_bsize)
 			/* Optimization: I/O is unnecessary. */
 @@ -1190,27 +1189,27 @@ lfs_fragextend(struct uvnode *vp, int os
 	int error;
 	ip = VTOI(vp);
 	fs = ip->i_lfs;
 	frags = (long)lfs_numfrags(fs, nsize - osize);
 	error = 0;
 	/*
 	 * 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.
 	 */
-	if (bpp && (error = bread(vp, lbn, osize, NOCRED, 0, bpp))) {
+	if (bpp && (error = bread(vp, lbn, osize, 0, bpp))) {
 		brelse(*bpp, 0);
 		goto out;
+	}
 	fs->lfs_bfree -= frags;
 	ip->i_lfs_effnblks += frags;
 	ip->i_flag |= IN_CHANGE | IN_UPDATE;
 	if (bpp) {
 		(*bpp)->b_data = erealloc((*bpp)->b_data, nsize);
 		(void)memset((*bpp)->b_data + osize, 0, nsize - osize);
+	}

 @@ -1,14 +1,14 @@
-/* $NetBSD: segwrite.c,v 1.27 2013/10/19 01:09:58 christos Exp $ */
+/* $NetBSD: segwrite.c,v 1.28 2015/03/29 19:35:58 chopps Exp $ */
 /*-
  * Copyright (c) 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
 @@ -462,27 +462,27 @@ lfs_update_single(struct lfs * fs, struc
 			ofrags = lfs_btofsb(fs, ip->i_lfs_fragsize[lbn]);
 			ip->i_ffs1_blocks += (frags - ofrags);
+		}
 		ip->i_ffs1_db[lbn] = ndaddr;
 		break;
 	case 1:
 		ooff = ip->i_ffs1_ib[a[0].in_off];
 		if (ooff == UNWRITTEN)
 			ip->i_ffs1_blocks += frags;
 		ip->i_ffs1_ib[a[0].in_off] = ndaddr;
 		break;
 	default:
 		ap = &a[num - 1];
-		if (bread(vp, ap->in_lbn, fs->lfs_bsize, NULL, 0, &bp))
+		if (bread(vp, ap->in_lbn, fs->lfs_bsize, 0, &bp))
 			errx(1, "lfs_updatemeta: bread bno %" PRId64,
 			    ap->in_lbn);
 		ooff = ((ulfs_daddr_t *) bp->b_data)[ap->in_off];
 		if (ooff == UNWRITTEN)
 			ip->i_ffs1_blocks += frags;
 		((ulfs_daddr_t *) bp->b_data)[ap->in_off] = ndaddr;
 		(void) VOP_BWRITE(bp);
+	}
 	/*
 	 * Update segment usage information, based on old size
 	 * and location.

 @@ -1,14 +1,14 @@
-/* $NetBSD: setup.c,v 1.44 2013/06/18 18:18:58 christos Exp $ */
+/* $NetBSD: setup.c,v 1.45 2015/03/29 19:35:58 chopps Exp $ */
 /*-
  * Copyright (c) 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.
 @@ -246,27 +246,27 @@ setup(const char *dev)
 				if (fs->lfs_sboffs[i] == tdaddr)
 					tdaddr += lfs_btofsb(fs, LFS_SBPAD);
 				if (fs->lfs_sboffs[i] > tdaddr)
 					break;
+			}
+		}
 		fs->lfs_offset = tdaddr;
 		if (debug)
 			pwarn("begin with offset/serial 0x%x/%d\n",
 				(int)fs->lfs_offset, (int)fs->lfs_serial);
 		while (tdaddr < idaddr) {
 			bread(fs->lfs_devvp, LFS_FSBTODB(fs, tdaddr),
 			      fs->lfs_sumsize,
-			      NULL, 0, &bp);
+, &bp);
 			sp = (SEGSUM *)bp->b_data;
 			if (sp->ss_sumsum != cksum(&sp->ss_datasum,
 						   fs->lfs_sumsize -
 						   sizeof(sp->ss_sumsum))) {
 				brelse(bp, 0);
 				if (debug)
 					printf("bad cksum at %x\n",
 					       (unsigned)tdaddr);
 				break;
+			}
 			fp = (FINFO *)(sp + 1);
 			bc = howmany(sp->ss_ninos, LFS_INOPB(fs)) <<
 				(fs->lfs_version > 1 ? fs->lfs_ffshift :
 @@ -401,27 +401,27 @@ setup(const char *dev)
 	/*
 	 * Read in the Ifile; we'll be using it a lot.
 	 * XXX If the Ifile is corrupted we are in bad shape.  We need to
 	 * XXX run through the segment headers of the entire disk to
 	 * XXX reconstruct the inode table, then pretend all segments are
 	 * XXX dirty while we do the rest.
 	 */
 	ivp = fs->lfs_ivnode;
 	maxino = ((VTOI(ivp)->i_ffs1_size - (fs->lfs_cleansz + fs->lfs_segtabsz)
 		* fs->lfs_bsize) / fs->lfs_bsize) * fs->lfs_ifpb;
 	if (debug)
 		pwarn("maxino    = %llu\n", (unsigned long long)maxino);
 	for (i = 0; i < VTOI(ivp)->i_ffs1_size; i += fs->lfs_bsize) {
-		bread(ivp, i >> fs->lfs_bshift, fs->lfs_bsize, NOCRED, 0, &bp);
+		bread(ivp, i >> fs->lfs_bshift, fs->lfs_bsize, 0, &bp);
 		/* XXX check B_ERROR */
 		brelse(bp, 0);
+	}
 	/*
 	 * allocate and initialize the necessary maps
 	 */
 	din_table = ecalloc(maxino, sizeof(*din_table));
 	seg_table = ecalloc(fs->lfs_nseg, sizeof(SEGUSE));
 	/* Get segment flags */
 	for (i = 0; i < fs->lfs_nseg; i++) {
 		LFS_SEGENTRY(sup, fs, i, bp);
 		seg_table[i].su_flags = sup->su_flags & ~SEGUSE_ACTIVE;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: make_lfs.c,v 1.29 2013/10/19 01:09:59 christos Exp $	*/
+/*	$NetBSD: make_lfs.c,v 1.30 2015/03/29 19:35:58 chopps Exp $	*/
 /*-
  * Copyright (c) 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.
 @@ -52,27 +52,27 @@
  * 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.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)lfs.c	8.5 (Berkeley) 5/24/95";
 #else
-__RCSID("$NetBSD: make_lfs.c,v 1.29 2013/10/19 01:09:59 christos Exp $");
+__RCSID("$NetBSD: make_lfs.c,v 1.30 2015/03/29 19:35:58 chopps Exp $");
 #endif
 #endif /* not lint */
 #include <sys/param.h>
 #include <sys/disk.h>
 #include <sys/time.h>
 #include <sys/mount.h>
 #include <sys/stat.h>
 /* Override certain things to make <ufs/lfs/lfs.h> work */
 # undef simple_lock
 # define simple_lock(x)
 # undef simple_unlock
 @@ -679,47 +679,47 @@ make_lfs(int devfd, uint secsize, struct
 	VTOI(vp)->i_lfs_osize = dip->di_size = LFS_DIRBLKSIZ;
 #ifdef MAKE_LF_DIR
 	VTOI(vp)->i_nlink = dip->di_nlink = 3;
 #else
 	VTOI(vp)->i_nlink = dip->di_nlink = 2;
 #endif
         VTOI(vp)->i_lfs_effnblks = dip->di_blocks =
 		lfs_btofsb(fs, roundup(LFS_DIRBLKSIZ,fs->lfs_fsize));
 	for (i = 0; i < ULFS_NDADDR && i < howmany(LFS_DIRBLKSIZ, fs->lfs_bsize); i++)
 		VTOI(vp)->i_lfs_fragsize[i] = fs->lfs_bsize;
 	if (LFS_DIRBLKSIZ < fs->lfs_bsize)
 		VTOI(vp)->i_lfs_fragsize[i - 1] =
 			roundup(LFS_DIRBLKSIZ,fs->lfs_fsize);
-	bread(vp, 0, fs->lfs_fsize, NOCRED, 0, &bp);
+	bread(vp, 0, fs->lfs_fsize, 0, &bp);
 	make_dir(bp->b_data, lfs_root_dir,
 		 sizeof(lfs_root_dir) / sizeof(struct lfs_direct));
 	VOP_BWRITE(bp);
 #ifdef MAKE_LF_DIR
 	/* Initialize lost+found directory */
 	vp = lfs_raw_vget(fs, LOSTFOUNDINO, devfd, 0x0);
 	dip = VTOI(vp)->i_din.ffs1_din;
 	make_dinode(LOSTFOUNDINO, dip, howmany(DIRBLKSIZ,fs->lfs_fsize), fs);
 	dip->di_mode = IFDIR | UMASK;
 	VTOI(vp)->i_lfs_osize = dip->di_size = DIRBLKSIZ;
         VTOI(vp)->i_nlink = dip->di_nlink = 2;
         VTOI(vp)->i_lfs_effnblks = dip->di_blocks =
 		lfs_btofsb(fs, roundup(DIRBLKSIZ,fs->lfs_fsize));
 	for (i = 0; i < ULFS_NDADDR && i < howmany(DIRBLKSIZ, fs->lfs_bsize); i++)
 		VTOI(vp)->i_lfs_fragsize[i] = fs->lfs_bsize;
 	if (DIRBLKSIZ < fs->lfs_bsize)
 		VTOI(vp)->i_lfs_fragsize[i - 1] =
 			roundup(DIRBLKSIZ,fs->lfs_fsize);
-	bread(vp, 0, fs->lfs_fsize, NOCRED, 0, &bp);
+	bread(vp, 0, fs->lfs_fsize, 0, &bp);
 	make_dir(bp->b_data, lfs_lf_dir,
 		 sizeof(lfs_lf_dir) / sizeof(struct lfs_direct));
 	VOP_BWRITE(bp);
 #endif /* MAKE_LF_DIR */
 	/* Set their IFILE entry version numbers to 1 */
 	LFS_IENTRY(ip, fs, 1, bp);
 	if (version == 1) {
 		ip_v1 = (IFILE_V1 *)ip;
 		for (i = LFS_IFILE_INUM; i <= HIGHEST_USED_INO; i++) {
 			ip_v1->if_version = 1;
 			ip_v1->if_daddr = 0x0;
 			ip_v1->if_nextfree = 0;

 @@ -1,14 +1,14 @@
-/* $NetBSD: bufcache.c,v 1.14 2013/10/19 01:09:58 christos Exp $ */
+/* $NetBSD: bufcache.c,v 1.15 2015/03/29 19:35:58 chopps Exp $ */
 /*-
  * Copyright (c) 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
 @@ -329,28 +329,27 @@ brelse(struct ubuf * bp, int set)
 		TAILQ_INSERT_TAIL(&bufqueues[BQ_LRU], bp, b_freelist);
+	}
 	--bp->b_vp->v_usecount;
 	/* Move to the front of the hash chain */
 	if (LIST_FIRST(&bufhash[bp->b_hashval]) != bp) {
 		LIST_REMOVE(bp, b_hash);
 		LIST_INSERT_HEAD(&bufhash[bp->b_hashval], bp, b_hash);
+	}
+}
 /* Read the given block from disk, return it B_BUSY. */
 int
-bread(struct uvnode * vp, daddr_t lbn, int size, void * unused,
+bread(struct uvnode * vp, daddr_t lbn, int size, int flags, struct ubuf ** bpp)
     int flags, struct ubuf ** bpp)
+{
 	struct ubuf *bp;
 	daddr_t daddr;
 	bp = getblk(vp, lbn, size);
 	*bpp = bp;
 	if (bp->b_flags & (B_DELWRI | B_DONE)) {
 		++cachehits;
 		return 0;
+	}
 	++cachemisses;
 	/*

 @@ -1,14 +1,14 @@
-/*	$NetBSD: bufcache.h,v 1.11 2008/05/16 09:21:59 hannken Exp $	*/
+/*	$NetBSD: bufcache.h,v 1.12 2015/03/29 19:35:58 chopps Exp $	*/
 /*-
  * Copyright (c) 1999, 2000 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.
+ *
  * 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
 @@ -110,16 +110,16 @@ LIST_HEAD(bufhash_struct, ubuf);
 #if !defined(NOCRED)
 #define	NOCRED	((void *)-1)	/* dummy; not actually used */
 #endif /* !defined(NOCRED) */
 void bufinit(int);
 void bufrehash(int);
 void bufstats(void);
 void buf_destroy(struct ubuf *);
 void bremfree(struct ubuf *);
 struct ubuf *incore(struct uvnode *, int);
 struct ubuf *getblk(struct uvnode *, daddr_t, int);
 void bwrite(struct ubuf *);
 void brelse(struct ubuf *, int);
-int bread(struct uvnode *, daddr_t, int, void *, int, struct ubuf **);
+int bread(struct uvnode *, daddr_t, int, int, struct ubuf **);
 void reassignbuf(struct ubuf *, struct uvnode *);
 void dump_free_lists(void);