From 95a8d28c27c73a4a11dd64feba21abf2de0b0dbb Mon Sep 17 00:00:00 2001
From: dholland <dholland@NetBSD.org>
Date: Sun, 2 Aug 2015 18:08:12 +0000
Subject: [PATCH] Fix assorted 64 -> 32 truncations in lfs. Also, some minor
 tidyups and corrections in passing.

---
 sbin/fsck_lfs/lfs.c         |  4 +--
 sbin/fsck_lfs/pass5.c       | 18 +++++-----
 sbin/fsck_lfs/pass6.c       |  4 +--
 sbin/newfs_lfs/make_lfs.c   | 15 ++++----
 sbin/scan_ffs/scan_ffs.c    | 12 +++----
 sys/ufs/lfs/lfs.h           |  7 ++--
 sys/ufs/lfs/lfs_accessors.h | 69 +++++++++++++++++++++++++++----------
 sys/ufs/lfs/lfs_balloc.c    | 10 +++---
 sys/ufs/lfs/lfs_bio.c       | 11 +++---
 sys/ufs/lfs/lfs_debug.c     | 16 ++++-----
 sys/ufs/lfs/lfs_inode.c     | 21 ++++++-----
 sys/ufs/lfs/lfs_vfsops.c    | 13 +++++--
 usr.sbin/dumplfs/dumplfs.c  | 18 +++++-----
 13 files changed, 133 insertions(+), 85 deletions(-)

diff --git a/sbin/fsck_lfs/lfs.c b/sbin/fsck_lfs/lfs.c
index fce9678046ce..43e66ff20373 100644
--- a/sbin/fsck_lfs/lfs.c
+++ b/sbin/fsck_lfs/lfs.c
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs.c,v 1.48 2015/07/28 05:09:34 dholland Exp $ */
+/* $NetBSD: lfs.c,v 1.49 2015/08/02 18:08:12 dholland Exp $ */
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
  * All rights reserved.
@@ -72,8 +72,8 @@
 
 #define vnode uvnode
 #include <ufs/lfs/lfs.h>
-#include <ufs/lfs/lfs_accessors.h>
 #include <ufs/lfs/lfs_inode.h>
+#include <ufs/lfs/lfs_accessors.h>
 #undef vnode
 
 #include <assert.h>
diff --git a/sbin/fsck_lfs/pass5.c b/sbin/fsck_lfs/pass5.c
index a85898957d72..6310f327f470 100644
--- a/sbin/fsck_lfs/pass5.c
+++ b/sbin/fsck_lfs/pass5.c
@@ -1,4 +1,4 @@
-/* $NetBSD: pass5.c,v 1.32 2015/07/28 05:09:34 dholland Exp $	 */
+/* $NetBSD: pass5.c,v 1.33 2015/08/02 18:08:12 dholland Exp $	 */
 
 /*-
  * Copyright (c) 2000, 2003 The NetBSD Foundation, Inc.
@@ -60,9 +60,9 @@ pass5(void)
 	SEGUSE *su;
 	struct ubuf *bp;
 	int i;
-	unsigned long bb;	/* total number of used blocks (lower bound) */
-	unsigned long ubb;	/* upper bound number of used blocks */
-	unsigned long avail;	/* blocks available for writing */
+	daddr_t bb;		/* total number of used blocks (lower bound) */
+	daddr_t ubb;		/* upper bound number of used blocks */
+	daddr_t avail;		/* blocks available for writing */
 	unsigned long dmeta;	/* blocks in segsums and inodes */
 	int nclean;		/* clean segments */
 	size_t labelskew;
@@ -152,8 +152,8 @@ pass5(void)
 		}
 	}
 	if (avail != lfs_sb_getavail(fs)) {
-		pwarn("AVAIL GIVEN AS %d, SHOULD BE %ld\n",
-		      lfs_sb_getavail(fs), avail);
+		pwarn("AVAIL GIVEN AS %jd, SHOULD BE %ld\n",
+		      (intmax_t)lfs_sb_getavail(fs), avail);
 		if (preen || reply("FIX")) {
 			lfs_sb_setavail(fs, avail);
 			sbdirty();
@@ -174,10 +174,10 @@ pass5(void)
 		labelskew = lfs_btofsb(fs, LFS_LABELPAD);
 	if (lfs_sb_getbfree(fs) > lfs_sb_getdsize(fs) - bb - labelskew ||
 	    lfs_sb_getbfree(fs) < lfs_sb_getdsize(fs) - ubb - labelskew) {
-		pwarn("BFREE GIVEN AS %jd, SHOULD BE BETWEEN %ld AND %ld\n",
+		pwarn("BFREE GIVEN AS %jd, SHOULD BE BETWEEN %jd AND %jd\n",
 		    (intmax_t)lfs_sb_getbfree(fs),
-		    lfs_sb_getdsize(fs) - ubb - labelskew,
-		    lfs_sb_getdsize(fs) - bb - labelskew);
+		    (intmax_t)(lfs_sb_getdsize(fs) - ubb - labelskew),
+		    (intmax_t)(lfs_sb_getdsize(fs) - bb - labelskew));
 		if (preen || reply("FIX")) {
 			lfs_sb_setbfree(fs,
 				((lfs_sb_getdsize(fs) - labelskew - ubb) +
diff --git a/sbin/fsck_lfs/pass6.c b/sbin/fsck_lfs/pass6.c
index 58a32e6fb63b..d9d251bbde65 100644
--- a/sbin/fsck_lfs/pass6.c
+++ b/sbin/fsck_lfs/pass6.c
@@ -1,4 +1,4 @@
-/* $NetBSD: pass6.c,v 1.37 2015/07/28 05:09:34 dholland Exp $	 */
+/* $NetBSD: pass6.c,v 1.38 2015/08/02 18:08:12 dholland Exp $	 */
 
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
@@ -78,7 +78,7 @@ static int nnewblocks;
  * Account for this change in the segment table.
  */
 static void
-rfw_update_single(struct uvnode *vp, daddr_t lbn, ulfs_daddr_t ndaddr, int size)
+rfw_update_single(struct uvnode *vp, daddr_t lbn, ulfs_daddr_t ndaddr, size_t size)
 {
 	SEGUSE *sup;
 	struct ubuf *bp;
diff --git a/sbin/newfs_lfs/make_lfs.c b/sbin/newfs_lfs/make_lfs.c
index 29bdb148175a..9b3f4d655265 100644
--- a/sbin/newfs_lfs/make_lfs.c
+++ b/sbin/newfs_lfs/make_lfs.c
@@ -1,4 +1,4 @@
-/*	$NetBSD: make_lfs.c,v 1.34 2015/07/28 05:09:34 dholland Exp $	*/
+/*	$NetBSD: make_lfs.c,v 1.35 2015/08/02 18:08:12 dholland Exp $	*/
 
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
@@ -62,7 +62,7 @@
 #if 0
 static char sccsid[] = "@(#)lfs.c	8.5 (Berkeley) 5/24/95";
 #else
-__RCSID("$NetBSD: make_lfs.c,v 1.34 2015/07/28 05:09:34 dholland Exp $");
+__RCSID("$NetBSD: make_lfs.c,v 1.35 2015/08/02 18:08:12 dholland Exp $");
 #endif
 #endif /* not lint */
 
@@ -320,7 +320,8 @@ make_lfs(int devfd, uint secsize, struct dkwedge_info *dkw, int minfree,
 	char tbuf[BUFSIZ];
 	struct ubuf *bp;
 	struct uvnode *vp, *save_devvp;
-	int bb, ubb, dmeta, labelskew;
+	daddr_t bb, ubb;
+	int dmeta, labelskew;
 	u_int64_t tsepb, tnseg;
 	time_t stamp;
 
@@ -543,8 +544,8 @@ make_lfs(int devfd, uint secsize, struct dkwedge_info *dkw, int minfree,
 	 * and segment usage table, and half a block per segment that can't
 	 * be written due to fragmentation.
 	 */
-	lfs_sb_setdsize(fs, (lfs_sb_getnseg(fs) - lfs_sb_getminfreeseg(fs)) *
-		lfs_segtod(fs, 1));
+	lfs_sb_setdsize(fs,
+		lfs_segtod(fs, lfs_sb_getnseg(fs) - lfs_sb_getminfreeseg(fs)));
 	lfs_sb_setbfree(fs, lfs_sb_getdsize(fs));
 	lfs_sb_subbfree(fs, LFS_DBTOFSB(fs, ((lfs_sb_getnseg(fs) / 2) << 
 		lfs_sb_getblktodb(fs))));
@@ -582,7 +583,7 @@ make_lfs(int devfd, uint secsize, struct dkwedge_info *dkw, int minfree,
 		lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 0));
 	else
 		lfs_sb_sets0addr(fs, LFS_DBTOFSB(fs, start));
-        lfs_sb_setdsize(fs, lfs_sb_getdsize(fs) - sb_fsb);
+        lfs_sb_subdsize(fs, sb_fsb);
 	for (i = 1; i < LFS_MAXNUMSB; i++) {
 		sb_addr = ((i * sb_interval) * lfs_segtod(fs, 1))
 		    + lfs_sb_getsboff(fs, 0);
@@ -593,7 +594,7 @@ make_lfs(int devfd, uint secsize, struct dkwedge_info *dkw, int minfree,
 		    >= LFS_DBTOFSB(fs, dkw->dkw_size))
 			break;
 		lfs_sb_setsboff(fs, i, sb_addr);
-		lfs_sb_setdsize(fs, lfs_sb_getdsize(fs) - sb_fsb);
+		lfs_sb_subdsize(fs, sb_fsb);
 	}
 
 	/* We need >= 2 superblocks */
diff --git a/sbin/scan_ffs/scan_ffs.c b/sbin/scan_ffs/scan_ffs.c
index ccedb3ad2cc0..db4b14aa76c8 100644
--- a/sbin/scan_ffs/scan_ffs.c
+++ b/sbin/scan_ffs/scan_ffs.c
@@ -1,4 +1,4 @@
-/* $NetBSD: scan_ffs.c,v 1.28 2015/07/28 05:09:35 dholland Exp $ */
+/* $NetBSD: scan_ffs.c,v 1.29 2015/08/02 18:08:12 dholland Exp $ */
 
 /*
  * Copyright (c) 2005-2007 Juan Romero Pardines
@@ -33,7 +33,7 @@
  
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: scan_ffs.c,v 1.28 2015/07/28 05:09:35 dholland Exp $");
+__RCSID("$NetBSD: scan_ffs.c,v 1.29 2015/08/02 18:08:12 dholland Exp $");
 #endif /* not lint */
 
 #include <sys/types.h>
@@ -249,14 +249,14 @@ static void
 lfs_printpart(struct sblockinfo *sbi, int flag, int n)
 {
 	if (flags & VERBOSE)
-               	(void)printf("offset: %" PRIu64 " size %" PRIu32
+               	(void)printf("offset: %" PRIu64 " size %" PRIu64
 			" fsid %" PRIx32 "\n", sbi->lfs_off,
 			lfs_sb_getsize(sbi->lfs),
 			lfs_sb_getident(sbi->lfs));
 	switch (flag) {
 	case LABELS:
 		(void)printf("X:  %9" PRIu64,
-               		(uint64_t)(lfs_sb_getsize(sbi->lfs) *
+               		(lfs_sb_getsize(sbi->lfs) *
                		lfs_sb_getfsize(sbi->lfs) / 512));
 		(void)printf(" %9" PRIu64, sbi->lfs_off); 
 		(void)printf(" 4.4LFS %6d %5d %7d # %s [LFSv%d]\n",
@@ -269,14 +269,14 @@ lfs_printpart(struct sblockinfo *sbi, int flag, int n)
 		(void)printf(" sb at %" PRIu64, sbi->lfs_off + btodb(LFS_LABELPAD));
 		(void)printf(" fsid %" PRIx32, lfs_sb_getident(sbi->lfs));
 		(void)printf(" size %" PRIu64 ", last mounted on %s\n",
-			(uint64_t)(lfs_sb_getsize(sbi->lfs) *
+			(lfs_sb_getsize(sbi->lfs) *
 			lfs_sb_getfsize(sbi->lfs) / 512), sbi->lfs_path);
 		break;
 	default:
 		(void)printf("LFSv%d ", sbi->lfs->lfs_version);
 		(void)printf("at %" PRIu64, sbi->lfs_off);
 		(void)printf(" size %" PRIu64 ", last mounted on %s\n",
-			(uint64_t)(lfs_sb_getsize(sbi->lfs) *
+			(lfs_sb_getsize(sbi->lfs) *
 			lfs_sb_getfsize(sbi->lfs) / 512), sbi->lfs_path);
 		break;
 	}
diff --git a/sys/ufs/lfs/lfs.h b/sys/ufs/lfs/lfs.h
index da5f39389560..99c4afb24e04 100644
--- a/sys/ufs/lfs/lfs.h
+++ b/sys/ufs/lfs/lfs.h
@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs.h,v 1.167 2015/07/28 05:13:14 dholland Exp $	*/
+/*	$NetBSD: lfs.h,v 1.168 2015/08/02 18:08:13 dholland Exp $	*/
 
 /*  from NetBSD: dinode.h,v 1.22 2013/01/22 09:39:18 dholland Exp  */
 /*  from NetBSD: dir.h,v 1.21 2009/07/22 04:49:19 dholland Exp  */
@@ -516,6 +516,7 @@ struct ifile_v1 {
 typedef struct _cleanerinfo {
 	u_int32_t clean;		/* number of clean segments */
 	u_int32_t dirty;		/* number of dirty segments */
+	/* XXX64 bfree and avail must -> 64 */
 	int32_t   bfree;		/* disk blocks free */
 	int32_t	  avail;		/* disk blocks available */
 	u_int32_t free_head;		/* head of the inode free list */
@@ -587,7 +588,7 @@ struct dlfs {
 
 /* Checkpoint region. */
 	u_int32_t dlfs_freehd;	  /* 32: start of the free list */
-	int32_t   dlfs_bfree;	  /* 36: number of free disk blocks */
+	int32_t   dlfs_bfree;	  /* 36: number of free frags */
 	u_int32_t dlfs_nfiles;	  /* 40: number of allocated inodes */
 	int32_t	  dlfs_avail;	  /* 44: blocks available for writing */
 	int32_t	  dlfs_uinodes;	  /* 48: inodes in cache not yet on disk */
@@ -605,7 +606,7 @@ struct dlfs {
 
 /* These fields can be computed from the others. */
 	u_int64_t dlfs_maxfilesize; /* 88: maximum representable file size */
-	u_int32_t dlfs_fsbpseg;	    /* 96: fsb per segment */
+	u_int32_t dlfs_fsbpseg;	    /* 96: frags (fsb) per segment */
 	u_int32_t dlfs_inopb;	  /* 100: inodes per block */
 	u_int32_t dlfs_ifpb;	  /* 104: IFILE entries per block */
 	u_int32_t dlfs_sepb;	  /* 108: SEGUSE entries per block */
diff --git a/sys/ufs/lfs/lfs_accessors.h b/sys/ufs/lfs/lfs_accessors.h
index 92b8ad673f6b..87daf1607fc1 100644
--- a/sys/ufs/lfs/lfs_accessors.h
+++ b/sys/ufs/lfs/lfs_accessors.h
@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_accessors.h,v 1.3 2015/08/02 17:57:27 dholland Exp $	*/
+/*	$NetBSD: lfs_accessors.h,v 1.4 2015/08/02 18:08:13 dholland Exp $	*/
 
 /*  from NetBSD: lfs.h,v 1.165 2015/07/24 06:59:32 dholland Exp  */
 /*  from NetBSD: dinode.h,v 1.22 2013/01/22 09:39:18 dholland Exp  */
@@ -418,14 +418,14 @@
 #define lfs_version lfs_dlfs.dlfs_version
 LFS_DEF_SB_ACCESSOR_FULL(u_int64_t, u_int32_t, size);
 LFS_DEF_SB_ACCESSOR(u_int32_t, ssize);
-LFS_DEF_SB_ACCESSOR(u_int32_t, dsize);
+LFS_DEF_SB_ACCESSOR_FULL(u_int64_t, u_int32_t, dsize);
 LFS_DEF_SB_ACCESSOR(u_int32_t, bsize);
 LFS_DEF_SB_ACCESSOR(u_int32_t, fsize);
 LFS_DEF_SB_ACCESSOR(u_int32_t, frag);
 LFS_DEF_SB_ACCESSOR(u_int32_t, freehd);
-LFS_DEF_SB_ACCESSOR(int32_t, bfree);
+LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, bfree);
 LFS_DEF_SB_ACCESSOR(u_int32_t, nfiles);
-LFS_DEF_SB_ACCESSOR(int32_t, avail);
+LFS_DEF_SB_ACCESSOR_FULL(int64_t, int32_t, avail);
 LFS_DEF_SB_ACCESSOR(int32_t, uinodes);
 LFS_DEF_SB_ACCESSOR(int32_t, idaddr);
 LFS_DEF_SB_ACCESSOR(u_int32_t, ifile);
@@ -518,27 +518,47 @@ lfs_sb_getfsmnt(STRUCT_LFS *fs)
 /* LFS_INOPF is the number of inodes in a fragment. */
 #define LFS_INOPF(fs)	(lfs_sb_getinopf(fs))
 
-#define	lfs_blksize(fs, ip, lbn) \
-	(((lbn) >= ULFS_NDADDR || (ip)->i_ffs1_size >= ((lbn) + 1) << lfs_sb_getbshift(fs)) \
-	    ? lfs_sb_getbsize(fs) \
-	    : (lfs_fragroundup(fs, lfs_blkoff(fs, (ip)->i_ffs1_size))))
 #define	lfs_blkoff(fs, loc)	((int)((loc) & lfs_sb_getbmask(fs)))
 #define lfs_fragoff(fs, loc)    /* calculates (loc % fs->lfs_fsize) */ \
     ((int)((loc) & lfs_sb_getffmask(fs)))
 
+/* XXX: lowercase these as they're no longer macros */
+/* Frags to diskblocks */
+static __unused inline uint64_t
+LFS_FSBTODB(STRUCT_LFS *fs, uint64_t b)
+{
 #if defined(_KERNEL)
-#define	LFS_FSBTODB(fs, b)	((b) << (lfs_sb_getffshift(fs) - DEV_BSHIFT))
-#define	LFS_DBTOFSB(fs, b)	((b) >> (lfs_sb_getffshift(fs) - DEV_BSHIFT))
+	return b << (lfs_sb_getffshift(fs) - DEV_BSHIFT);
 #else
-#define	LFS_FSBTODB(fs, b)	((b) << lfs_sb_getfsbtodb(fs))
-#define	LFS_DBTOFSB(fs, b)	((b) >> lfs_sb_getfsbtodb(fs))
+	return b << lfs_sb_getfsbtodb(fs);
 #endif
+}
+/* Diskblocks to frags */
+static __unused inline uint64_t
+LFS_DBTOFSB(STRUCT_LFS *fs, uint64_t b)
+{
+#if defined(_KERNEL)
+	return b >> (lfs_sb_getffshift(fs) - DEV_BSHIFT);
+#else
+	return b >> lfs_sb_getfsbtodb(fs);
+#endif
+}
 
 #define	lfs_lblkno(fs, loc)	((loc) >> lfs_sb_getbshift(fs))
 #define	lfs_lblktosize(fs, blk)	((blk) << lfs_sb_getbshift(fs))
 
-#define lfs_fsbtob(fs, b)	((b) << lfs_sb_getffshift(fs))
-#define lfs_btofsb(fs, b)	((b) >> lfs_sb_getffshift(fs))
+/* Frags to bytes */
+static __unused inline uint64_t
+lfs_fsbtob(STRUCT_LFS *fs, uint64_t b)
+{
+	return b << lfs_sb_getffshift(fs);
+}
+/* Bytes to frags */
+static __unused inline uint64_t
+lfs_btofsb(STRUCT_LFS *fs, uint64_t b)
+{
+	return b >> lfs_sb_getffshift(fs);
+}
 
 #define lfs_numfrags(fs, loc)	/* calculates (loc / fs->lfs_fsize) */	\
 	((loc) >> lfs_sb_getffshift(fs))
@@ -562,14 +582,27 @@ lfs_sb_getfsmnt(STRUCT_LFS *fs)
 #define	lfs_segsize(fs)	((fs)->lfs_version == 1 ?	     		\
 			   lfs_lblktosize((fs), lfs_sb_getssize(fs)) :	\
 			   lfs_sb_getssize(fs))
-#define lfs_segtod(fs, seg) (((fs)->lfs_version == 1     ?	    	\
-			   lfs_sb_getssize(fs) << lfs_sb_getblktodb(fs) : \
-			   lfs_btofsb((fs), lfs_sb_getssize(fs))) * (seg))
+/* XXX segtod produces a result in frags despite the 'd' */
+#define lfs_segtod(fs, seg) (lfs_btofsb(fs, lfs_segsize(fs)) * (seg))
 #define	lfs_dtosn(fs, daddr)	/* block address to segment number */	\
 	((uint32_t)(((daddr) - lfs_sb_gets0addr(fs)) / lfs_segtod((fs), 1)))
 #define lfs_sntod(fs, sn)	/* segment number to disk address */	\
 	((daddr_t)(lfs_segtod((fs), (sn)) + lfs_sb_gets0addr(fs)))
 
+/* XXX, blah. make this appear only if struct inode is defined */
+#ifdef _UFS_LFS_LFS_INODE_H_
+static __unused inline uint32_t
+lfs_blksize(STRUCT_LFS *fs, struct inode *ip, uint64_t lbn)
+{
+	if (lbn >= ULFS_NDADDR || ip->i_ffs1_size >= (lbn + 1) << lfs_sb_getbshift(fs)) {
+		return lfs_sb_getbsize(fs);
+	} else {
+		return lfs_fragroundup(fs, lfs_blkoff(fs, ip->i_ffs1_size));
+	}
+}
+#endif
+
+
 /*
  * Macros for determining free space on the disk, with the variable metadata
  * of segment summaries and inode blocks taken into account.
@@ -607,7 +640,7 @@ lfs_sb_getfsmnt(STRUCT_LFS *fs)
 				   (u_int64_t)lfs_sb_getminfree(F)) /	     \
 				  100)
 
-/* Can credential C write BB blocks */
+/* Can credential C write BB blocks? XXX: kauth_cred_geteuid is abusive */
 #define ISSPACE(F, BB, C)						\
 	((((C) == NOCRED || kauth_cred_geteuid(C) == 0) &&		\
 	  LFS_EST_BFREE(F) >= (BB)) ||					\
diff --git a/sys/ufs/lfs/lfs_balloc.c b/sys/ufs/lfs/lfs_balloc.c
index 4a904edad112..ebff6f607559 100644
--- a/sys/ufs/lfs/lfs_balloc.c
+++ b/sys/ufs/lfs/lfs_balloc.c
@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_balloc.c,v 1.84 2015/07/28 05:09:34 dholland Exp $	*/
+/*	$NetBSD: lfs_balloc.c,v 1.85 2015/08/02 18:08:13 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@@ -60,7 +60,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_balloc.c,v 1.84 2015/07/28 05:09:34 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_balloc.c,v 1.85 2015/08/02 18:08:13 dholland Exp $");
 
 #if defined(_KERNEL_OPT)
 #include "opt_quota.h"
@@ -193,7 +193,7 @@ lfs_balloc(struct vnode *vp, off_t startoffset, int iosize, kauth_cred_t cred,
 			}
 			ip->i_lfs_effnblks += frags;
 			mutex_enter(&lfs_lock);
-			lfs_sb_setbfree(fs, lfs_sb_getbfree(fs) - frags);
+			lfs_sb_subbfree(fs, frags);
 			mutex_exit(&lfs_lock);
 			ip->i_ffs1_db[lbn] = UNWRITTEN;
 		} else {
@@ -238,7 +238,7 @@ lfs_balloc(struct vnode *vp, off_t startoffset, int iosize, kauth_cred_t cred,
 	}
 	if (ISSPACE(fs, bcount, cred)) {
 		mutex_enter(&lfs_lock);
-		lfs_sb_setbfree(fs, lfs_sb_getbfree(fs) - bcount);
+		lfs_sb_subbfree(fs, bcount);
 		mutex_exit(&lfs_lock);
 		ip->i_lfs_effnblks += bcount;
 	} else {
@@ -442,7 +442,7 @@ lfs_fragextend(struct vnode *vp, int osize, int nsize, daddr_t lbn, struct buf *
 	}
 
 	mutex_enter(&lfs_lock);
-	lfs_sb_setbfree(fs, lfs_sb_getbfree(fs) - frags);
+	lfs_sb_subbfree(fs, frags);
 	mutex_exit(&lfs_lock);
 	ip->i_lfs_effnblks += frags;
 	ip->i_flag |= IN_CHANGE | IN_UPDATE;
diff --git a/sys/ufs/lfs/lfs_bio.c b/sys/ufs/lfs/lfs_bio.c
index 8e39dbd71df2..538650a86678 100644
--- a/sys/ufs/lfs/lfs_bio.c
+++ b/sys/ufs/lfs/lfs_bio.c
@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_bio.c,v 1.132 2015/07/28 05:09:34 dholland Exp $	*/
+/*	$NetBSD: lfs_bio.c,v 1.133 2015/08/02 18:08:13 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003, 2008 The NetBSD Foundation, Inc.
@@ -60,7 +60,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.132 2015/07/28 05:09:34 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.133 2015/08/02 18:08:13 dholland Exp $");
 
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -229,10 +229,11 @@ lfs_reserveavail(struct lfs *fs, struct vnode *vp,
 		mutex_exit(&lfs_lock);
 
 		if (!slept) {
-			DLOG((DLOG_AVAIL, "lfs_reserve: waiting for %ld (bfree = %d,"
-			      " est_bfree = %d)\n",
+			DLOG((DLOG_AVAIL, "lfs_reserve: waiting for %ld (bfree = %jd,"
+			      " est_bfree = %jd)\n",
 			      fsb + fs->lfs_ravail + fs->lfs_favail,
-			      lfs_sb_getbfree(fs), LFS_EST_BFREE(fs)));
+			      (intmax_t)lfs_sb_getbfree(fs),
+			      (intmax_t)LFS_EST_BFREE(fs)));
 		}
 		++slept;
 
diff --git a/sys/ufs/lfs/lfs_debug.c b/sys/ufs/lfs/lfs_debug.c
index bfcf8cdc2203..507250b21f91 100644
--- a/sys/ufs/lfs/lfs_debug.c
+++ b/sys/ufs/lfs/lfs_debug.c
@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_debug.c,v 1.46 2015/07/28 05:09:34 dholland Exp $	*/
+/*	$NetBSD: lfs_debug.c,v 1.47 2015/08/02 18:08:13 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@@ -60,7 +60,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_debug.c,v 1.46 2015/07/28 05:09:34 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_debug.c,v 1.47 2015/08/02 18:08:13 dholland Exp $");
 
 #ifdef DEBUG
 
@@ -127,13 +127,13 @@ lfs_dump_super(struct lfs *lfsp)
 {
 	int i;
 
-	printf("%s%x\t%s%x\t%s%d\t%s%d\n",
+	printf("%s%x\t%s%x\t%s%ju\t%s%d\n",
 	       "magic	 ", lfsp->lfs_magic,
 	       "version	 ", lfsp->lfs_version,
-	       "size	 ", lfs_sb_getsize(lfsp),
+	       "size	 ", (uintmax_t)lfs_sb_getsize(lfsp),
 	       "ssize	 ", lfs_sb_getssize(lfsp));
-	printf("%s%d\t%s%d\t%s%d\t%s%d\n",
-	       "dsize	 ", lfs_sb_getdsize(lfsp),
+	printf("%s%ju\t%s%d\t%s%d\t%s%d\n",
+	       "dsize	 ", (uintmax_t)lfs_sb_getdsize(lfsp),
 	       "bsize	 ", lfs_sb_getbsize(lfsp),
 	       "fsize	 ", lfs_sb_getfsize(lfsp),
 	       "frag	 ", lfs_sb_getfrag(lfsp));
@@ -178,8 +178,8 @@ lfs_dump_super(struct lfs *lfsp)
 	       "freehd	 ", lfs_sb_getfreehd(lfsp),
 	       "idaddr	 ", lfs_sb_getidaddr(lfsp),
 	       "ifile	 ", lfs_sb_getifile(lfsp));
-	printf("%s%x\t%s%d\t%s%x\t%s%x\t%s%x\t%s%x\n",
-	       "bfree	 ", lfs_sb_getbfree(lfsp),
+	printf("%s%jx\t%s%d\t%s%x\t%s%x\t%s%x\t%s%x\n",
+	       "bfree	 ", (intmax_t)lfs_sb_getbfree(lfsp),
 	       "nfiles	 ", lfs_sb_getnfiles(lfsp),
 	       "lastseg	 ", lfs_sb_getlastseg(lfsp),
 	       "nextseg	 ", lfs_sb_getnextseg(lfsp),
diff --git a/sys/ufs/lfs/lfs_inode.c b/sys/ufs/lfs/lfs_inode.c
index b9d0458c783d..b18c7df55499 100644
--- a/sys/ufs/lfs/lfs_inode.c
+++ b/sys/ufs/lfs/lfs_inode.c
@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_inode.c,v 1.140 2015/07/28 05:09:34 dholland Exp $	*/
+/*	$NetBSD: lfs_inode.c,v 1.141 2015/08/02 18:08:13 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@@ -60,7 +60,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_inode.c,v 1.140 2015/07/28 05:09:34 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_inode.c,v 1.141 2015/08/02 18:08:13 dholland Exp $");
 
 #if defined(_KERNEL_OPT)
 #include "opt_quota.h"
@@ -90,8 +90,9 @@ __KERNEL_RCSID(0, "$NetBSD: lfs_inode.c,v 1.140 2015/07/28 05:09:34 dholland Exp
 #include <ufs/lfs/lfs_kernel.h>
 
 static int lfs_update_seguse(struct lfs *, struct inode *ip, long, size_t);
-static int lfs_indirtrunc (struct inode *, daddr_t, daddr_t,
-			   daddr_t, int, long *, long *, long *, size_t *);
+static int lfs_indirtrunc(struct inode *, daddr_t, daddr_t,
+			  daddr_t, int, daddr_t *, daddr_t *,
+			  long *, size_t *);
 static int lfs_blkfree (struct lfs *, struct inode *, daddr_t, size_t, long *, size_t *);
 static int lfs_vtruncbuf(struct vnode *, daddr_t, bool, int);
 
@@ -206,7 +207,8 @@ lfs_truncate(struct vnode *ovp, off_t length, int ioflag, kauth_cred_t cred)
 	struct lfs *fs;
 	struct buf *bp;
 	int offset, size, level;
-	long count, rcount, blocksreleased = 0, real_released = 0;
+	long count, rcount;
+	daddr_t blocksreleased = 0, real_released = 0;
 	int i, nblocks;
 	int aflags, error, allerror = 0;
 	off_t osize;
@@ -700,8 +702,8 @@ lfs_finalize_fs_seguse(struct lfs *fs)
  */
 static int
 lfs_indirtrunc(struct inode *ip, daddr_t lbn, daddr_t dbn,
-	       daddr_t lastbn, int level, long *countp,
-	       long *rcountp, long *lastsegp, size_t *bcp)
+	       daddr_t lastbn, int level, daddr_t *countp,
+	       daddr_t *rcountp, long *lastsegp, size_t *bcp)
 {
 	int i;
 	struct buf *bp;
@@ -710,8 +712,9 @@ lfs_indirtrunc(struct inode *ip, daddr_t lbn, daddr_t dbn,
 	struct vnode *vp;
 	daddr_t nb, nlbn, last;
 	int32_t *copy = NULL;	/* XXX ondisk32 */
-	long blkcount, rblkcount, factor;
-	int nblocks, blocksreleased = 0, real_released = 0;
+	daddr_t blkcount, rblkcount, factor;
+	int nblocks;
+	daddr_t blocksreleased = 0, real_released = 0;
 	int error = 0, allerror = 0;
 
 	ASSERT_SEGLOCK(fs);
diff --git a/sys/ufs/lfs/lfs_vfsops.c b/sys/ufs/lfs/lfs_vfsops.c
index 1ab35bda0963..9bf927df7b2a 100644
--- a/sys/ufs/lfs/lfs_vfsops.c
+++ b/sys/ufs/lfs/lfs_vfsops.c
@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_vfsops.c,v 1.329 2015/07/28 05:09:35 dholland Exp $	*/
+/*	$NetBSD: lfs_vfsops.c,v 1.330 2015/08/02 18:08:13 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003, 2007, 2007
@@ -61,7 +61,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_vfsops.c,v 1.329 2015/07/28 05:09:35 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_vfsops.c,v 1.330 2015/08/02 18:08:13 dholland Exp $");
 
 #if defined(_KERNEL_OPT)
 #include "opt_lfs.h"
@@ -1371,6 +1371,14 @@ lfs_statvfs(struct mount *mp, struct statvfs *sbp)
 	sbp->f_blocks = LFS_EST_NONMETA(fs) - VTOI(fs->lfs_ivnode)->i_lfs_effnblks;
 
 	sbp->f_bfree = LFS_EST_BFREE(fs);
+	/*
+	 * XXX this should be lfs_sb_getsize (measured in frags)
+	 * rather than dsize (measured in diskblocks). However,
+	 * getsize needs a format version check (for version 1 it
+	 * needs to be blockstofrags'd) so for the moment I'm going to
+	 * leave this...  it won't fire wrongly as frags are at least
+	 * as big as diskblocks.
+	 */
 	KASSERT(sbp->f_bfree <= lfs_sb_getdsize(fs));
 #if 0
 	if (sbp->f_bfree < 0)
@@ -1383,6 +1391,7 @@ lfs_statvfs(struct mount *mp, struct statvfs *sbp)
 	else
 		sbp->f_bavail = 0;
 
+	/* XXX: huh? - dholland 20150728 */
 	sbp->f_files = lfs_sb_getbfree(fs) / lfs_btofsb(fs, lfs_sb_getibsize(fs))
 	    * LFS_INOPB(fs);
 	sbp->f_ffree = sbp->f_files - lfs_sb_getnfiles(fs);
diff --git a/usr.sbin/dumplfs/dumplfs.c b/usr.sbin/dumplfs/dumplfs.c
index 4f18e247ad82..382017a6f564 100644
--- a/usr.sbin/dumplfs/dumplfs.c
+++ b/usr.sbin/dumplfs/dumplfs.c
@@ -1,4 +1,4 @@
-/*	$NetBSD: dumplfs.c,v 1.45 2015/07/28 05:09:35 dholland Exp $	*/
+/*	$NetBSD: dumplfs.c,v 1.46 2015/08/02 18:08:13 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1991, 1993
@@ -40,7 +40,7 @@ __COPYRIGHT("@(#) Copyright (c) 1991, 1993\
 #if 0
 static char sccsid[] = "@(#)dumplfs.c	8.5 (Berkeley) 5/24/95";
 #else
-__RCSID("$NetBSD: dumplfs.c,v 1.45 2015/07/28 05:09:35 dholland Exp $");
+__RCSID("$NetBSD: dumplfs.c,v 1.46 2015/08/02 18:08:13 dholland Exp $");
 #endif
 #endif /* not lint */
 
@@ -726,13 +726,13 @@ dump_super(struct lfs *lfsp)
 	time_t stamp;
 	int i;
 
- 	(void)printf("    %s0x%-8x  %s0x%-8x  %s%-10d\n",
+ 	(void)printf("    %s0x%-8x  %s0x%-8x  %s%-10ju\n",
  		     "magic    ", lfsp->lfs_magic,
  		     "version  ", lfsp->lfs_version,
- 		     "size     ", lfs_sb_getsize(lfsp));
- 	(void)printf("    %s%-10d  %s%-10d  %s%-10d\n",
+ 		     "size     ", (uintmax_t)lfs_sb_getsize(lfsp));
+ 	(void)printf("    %s%-10d  %s%-10ju  %s%-10d\n",
  		     "ssize    ", lfs_sb_getssize(lfsp),
- 		     "dsize    ", lfs_sb_getdsize(lfsp),
+ 		     "dsize    ", (uintmax_t)lfs_sb_getdsize(lfsp),
  		     "bsize    ", lfs_sb_getbsize(lfsp));
  	(void)printf("    %s%-10d  %s%-10d  %s%-10d\n",
  		     "fsize    ", lfs_sb_getfsize(lfsp),
@@ -789,10 +789,10 @@ dump_super(struct lfs *lfsp)
  		     "freehd   ", lfs_sb_getfreehd(lfsp),
  		     "idaddr   ", lfs_sb_getidaddr(lfsp),
  		     "ifile    ", lfs_sb_getifile(lfsp));
- 	(void)printf("    %s%-10d  %s%-10d  %s%-10d\n",
+ 	(void)printf("    %s%-10d  %s%-10jd  %s%-10jd\n",
  		     "uinodes  ", lfs_sb_getuinodes(lfsp),
- 		     "bfree    ", lfs_sb_getbfree(lfsp),
- 		     "avail    ", lfs_sb_getavail(lfsp));
+ 		     "bfree    ", (intmax_t)lfs_sb_getbfree(lfsp),
+ 		     "avail    ", (intmax_t)lfs_sb_getavail(lfsp));
  	(void)printf("    %s%-10d  %s0x%-8x  %s0x%-8x\n",
  		     "nfiles   ", lfs_sb_getnfiles(lfsp),
  		     "lastseg  ", lfs_sb_getlastseg(lfsp),