@@ -16,7 +16,7 @@
  * The cleaner's view of the superblock data structure.
  */
 struct clfs {
-	struct dlfs lfs_dlfs;	   /* Leverage LFS lfs_* defines here */
+	struct dlfs lfs_dlfs;
 
 	/* Ifile */
 	int clfs_ifilefd;	   /* Ifile file descriptor */
@@ -36,6 +36,47 @@
 	int clfs_nactive;	   /* How many segments' blocks we have */
 	int clfs_onhold;	   /* If cleaning this fs is on hold */
 };
+
+/* ugh... */
+#define CLFS_DEF_SB_ACCESSOR(type, field) \
+	static __unused inline type				\
+	clfs_sb_get##field(struct clfs *fs)			\
+	{							\
+		return fs->lfs_dlfs.dlfs_##field;		\
+	}							\
+	static __unused inline void				\
+	clfs_sb_set##field(struct clfs *fs, type val)		\
+	{							\
+		fs->lfs_dlfs.dlfs_##field = val;		\
+	}							\
+	static __unused inline void				\
+	clfs_sb_add##field(struct clfs *fs, type val)		\
+	{							\
+		fs->lfs_dlfs.dlfs_##field += val;		\
+	}
+
+/* more ugh... */
+CLFS_DEF_SB_ACCESSOR(u_int32_t, ssize);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, bsize);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, fsize);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, frag);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, ifile);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, ifpb);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, sepb);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, nseg);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, cleansz);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, segtabsz);
+
+/* still more ugh... */
+#define lfs_sb_getssize(fs) clfs_sb_getssize(fs)
+#define lfs_sb_getbsize(fs) clfs_sb_getbsize(fs)
+#define lfs_sb_getfsize(fs) clfs_sb_getfsize(fs)
+#define lfs_sb_getfrag(fs) clfs_sb_getfrag(fs)
+#define lfs_sb_getifpb(fs) clfs_sb_getifpb(fs)
+#define lfs_sb_getsepb(fs) clfs_sb_getsepb(fs)
+#define lfs_sb_getnseg(fs) clfs_sb_getnseg(fs)
+#define lfs_sb_getcleansz(fs) clfs_sb_getcleansz(fs)
+#define lfs_sb_getsegtabsz(fs) clfs_sb_getsegtabsz(fs)
 
 /*
  * Fraction of the could-be-clean segments required to be clean.

@@ -1,4 +1,4 @@
-/*      $NetBSD: coalesce.c,v 1.24 2015/03/29 19:35:58 chopps Exp $  */
+/*      $NetBSD: coalesce.c,v 1.25 2015/07/24 06:56:41 dholland Exp $  */
 
 /*-
  * Copyright (c) 2002, 2005 The NetBSD Foundation, Inc.
@@ -215,10 +215,10 @@
 #endif
 	noff = toff = 0;
 	for (i = 1; i < nb; i++) {
-		if (bip[i].bi_daddr != bip[i - 1].bi_daddr + fs->lfs_frag)
+		if (bip[i].bi_daddr != bip[i - 1].bi_daddr + clfs_sb_getfrag(fs))
 			++noff;
 		toff += abs(bip[i].bi_daddr - bip[i - 1].bi_daddr
-		    - fs->lfs_frag) >> fs->lfs_fbshift;
+		    - clfs_sb_getfrag(fs)) >> fs->lfs_fbshift;
 	}
 
 	/*
@@ -297,7 +297,7 @@
 	bps = lfs_segtod(fs, 1);
 	for (tbip = bip; tbip < bip + nb; tbip += bps) {
 		do {
-			bread(fs->lfs_ivnode, 0, fs->lfs_bsize, 0, &bp);
+			bread(fs->lfs_ivnode, 0, clfs_sb_getbsize(fs), 0, &bp);
 			cip = *(CLEANERINFO *)bp->b_data;
 			brelse(bp, B_INVAL);
 
@@ -339,8 +339,8 @@
 	memset(totals, 0, sizeof(totals));
 
 	fstat(fs->clfs_ifilefd, &st);
-	maxino = fs->lfs_ifpb * (st.st_size >> fs->lfs_bshift) -
-		fs->lfs_segtabsz - fs->lfs_cleansz;
+	maxino = lfs_sb_getifpb(fs) * (st.st_size >> fs->lfs_bshift) -
+		lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs);
 
 	for (i = 0; i < maxino; i++) {
 		r = clean_inode(fs, i);

@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_cleanerd.c,v 1.38 2015/03/29 19:35:58 chopps Exp $	 */
+/* $NetBSD: lfs_cleanerd.c,v 1.39 2015/07/24 06:56:41 dholland Exp $	 */
 
 /*-
  * Copyright (c) 2005 The NetBSD Foundation, Inc.
@@ -264,8 +264,8 @@
 	strncpy((char *)fs->lfs_fsmnt, fsname, MNAMELEN);
 
 	/* Set up vnodes for Ifile and raw device */
-	fs->lfs_ivnode = fd_vget(fs->clfs_ifilefd, fs->lfs_bsize, 0, 0);
-	fs->clfs_devvp = fd_vget(fs->clfs_devfd, fs->lfs_fsize, fs->lfs_ssize,
+	fs->lfs_ivnode = fd_vget(fs->clfs_ifilefd, clfs_sb_getbsize(fs), 0, 0);
+	fs->clfs_devvp = fd_vget(fs->clfs_devfd, clfs_sb_getfsize(fs), clfs_sb_getssize(fs),
 				 atatime);
 
 	/* Allocate and clear segtab */
@@ -312,9 +312,9 @@
 
 	/* If Ifile is larger than buffer cache, rehash */
 	fstat(fs->clfs_ifilefd, &st);
-	if (st.st_size / fs->lfs_bsize > hashmax) {
+	if (st.st_size / clfs_sb_getbsize(fs) > hashmax) {
 		ohashmax = hashmax;
-		bufrehash(st.st_size / fs->lfs_bsize);
+		bufrehash(st.st_size / clfs_sb_getbsize(fs));
 		dlog("%s: resized buffer hash from %d to %d",
 		     fs->lfs_fsmnt, ohashmax, hashmax);
 	}
@@ -330,12 +330,13 @@
 {
 	int error;
 
-	error = bread(fs->lfs_ivnode, ino / fs->lfs_ifpb + fs->lfs_cleansz +
-		      fs->lfs_segtabsz, fs->lfs_bsize, 0, bpp);
+	error = bread(fs->lfs_ivnode,
+		      ino / lfs_sb_getifpb(fs) + lfs_sb_getcleansz(fs) +
+		      lfs_sb_getsegtabsz(fs), clfs_sb_getbsize(fs), 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;
+	*ifpp = (IFILE *)(*bpp)->b_data + ino % lfs_sb_getifpb(fs);
 	return;
 }
 
@@ -513,7 +514,7 @@
 
 			syslog(LOG_WARNING, "fixing short FINFO at %x (seg %d)",
 			       odaddr, lfs_dtosn(fs, odaddr));
-			bread(fs->clfs_devvp, odaddr, fs->lfs_fsize,
+			bread(fs->clfs_devvp, odaddr, clfs_sb_getfsize(fs),
 			    0, &nbp);
 			nssp = (SEGSUM *)nbp->b_data;
 			--nssp->ss_nfinfo;
@@ -542,7 +543,7 @@
 			/* Read all the blocks from the data summary */
 			for (i = 0; i < fip->fi_nblocks; i++) {
 				size = (i == fip->fi_nblocks - 1) ?
-					fip->fi_lastlength : fs->lfs_bsize;
+					fip->fi_lastlength : clfs_sb_getbsize(fs);
 				cp = fd_ptrget(fs->clfs_devvp, daddr);
 				ck = lfs_cksum_part(cp, sizeof(u_int32_t), ck);
 				daddr += lfs_btofsb(fs, size);
@@ -568,7 +569,7 @@
 			bip[*bic + i].bi_segcreate = ssp->ss_create;
 			bip[*bic + i].bi_version = fip->fi_version;
 			bip[*bic + i].bi_size = (i == fip->fi_nblocks - 1) ?
-				fip->fi_lastlength : fs->lfs_bsize;
+				fip->fi_lastlength : clfs_sb_getbsize(fs);
 			cp = fd_ptrget(fs->clfs_devvp, daddr);
 			ck = lfs_cksum_part(cp, sizeof(u_int32_t), ck);
 			bip[*bic + i].bi_bp = cp;
@@ -617,7 +618,7 @@
 
         fp = fopen(copylog_filename, "ab");
         if (fp != NULL) {
-                if (fwrite(cp, (size_t)fs->lfs_ssize, 1, fp) != 1) {
+                if (fwrite(cp, (size_t)clfs_sb_getssize(fs), 1, fp) != 1) {
                         perror("writing segment to copy log");
                 }
         }
@@ -653,12 +654,12 @@
 
 	/* Note bytes read for stats */
 	cleaner_stats.segs_cleaned++;
-	cleaner_stats.bytes_read += fs->lfs_ssize;
+	cleaner_stats.bytes_read += clfs_sb_getssize(fs);
 	++fs->clfs_nactive;
 
 	npseg = 0;
 	while(lfs_dtosn(fs, daddr) == sn &&
-	      lfs_dtosn(fs, daddr + lfs_btofsb(fs, fs->lfs_bsize)) == sn) {
+	      lfs_dtosn(fs, daddr + lfs_btofsb(fs, clfs_sb_getbsize(fs))) == sn) {
 		daddr = parse_pseg(fs, daddr, bipp, bic);
 		if (daddr == 0x0) {
 			++cleaner_stats.segs_error;
@@ -702,7 +703,7 @@
 		return;
 	}
 
-	if (t->nbytes > fs->lfs_ssize) {
+	if (t->nbytes > clfs_sb_getssize(fs)) {
 		/* Another type of error */
 		syslog(LOG_WARNING, "segment %d: bad seguse count %d",
 		       sn, t->nbytes);
@@ -719,16 +720,16 @@
 	 * We count the summary headers as "dirty" to avoid cleaning very
 	 * old and very full segments.
 	 */
-	benefit = (int64_t)fs->lfs_ssize - t->nbytes -
-		  (t->nsums + 1) * fs->lfs_fsize;
-	if (fs->lfs_bsize > fs->lfs_fsize) /* fragmentation */
-		benefit -= (fs->lfs_bsize / 2);
+	benefit = (int64_t)clfs_sb_getssize(fs) - t->nbytes -
+		  (t->nsums + 1) * clfs_sb_getfsize(fs);
+	if (clfs_sb_getbsize(fs) > clfs_sb_getfsize(fs)) /* fragmentation */
+		benefit -= (clfs_sb_getbsize(fs) / 2);
 	if (benefit <= 0) {
 		t->priority = 0;
 		return;
 	}
 
-	cost = fs->lfs_ssize + t->nbytes;
+	cost = clfs_sb_getssize(fs) + t->nbytes;
 	t->priority = (256 * benefit * age) / cost;
 
 	return;
@@ -867,7 +868,7 @@
 	/* Record statistics */
 	for (i = nb = 0; i < bic; i++)
 		nb += bip[i].bi_size;
-	util = ((double)nb) / (fs->clfs_nactive * fs->lfs_ssize);
+	util = ((double)nb) / (fs->clfs_nactive * clfs_sb_getssize(fs));
 	cleaner_stats.util_tot += util;
 	cleaner_stats.util_sos += util * util;
 	cleaner_stats.bytes_written += nb;
@@ -964,10 +965,10 @@
 			/*
 			 * Look for IFILE blocks, unless this is the Ifile.
 			 */
-			if (bip[i].bi_inode != fs->lfs_ifile) {
-				lbn = fs->lfs_cleansz + bip[i].bi_inode /
-							fs->lfs_ifpb;
-				*ifc += check_or_add(fs->lfs_ifile, lbn,
+			if (bip[i].bi_inode != clfs_sb_getifile(fs)) {
+				lbn = lfs_sb_getcleansz(fs) + bip[i].bi_inode /
+							lfs_sb_getifpb(fs);
+				*ifc += check_or_add(clfs_sb_getifile(fs), lbn,
 						     bip, bic, &ebip, &ebic);
 			}
 		}
@@ -1012,10 +1013,11 @@
 
 	/* 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, 0, &bp);
-		for (j = 0; j < fs->lfs_sepb && i + j < fs->lfs_nseg; j++) {
+	for (i = 0; i < lfs_sb_getnseg(fs); i+= lfs_sb_getsepb(fs)) {
+		bread(fs->lfs_ivnode,
+		      lfs_sb_getcleansz(fs) + i / lfs_sb_getsepb(fs),
+		      clfs_sb_getbsize(fs), 0, &bp);
+		for (j = 0; j < lfs_sb_getsepb(fs) && i + j < lfs_sb_getnseg(fs); 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;
@@ -1048,10 +1050,10 @@
 	ngood = 0;
 	if (use_bytes) {
 		/* Set attainable goal */
-		goal = fs->lfs_ssize * atatime;
-		if (goal > (cip->clean - 1) * fs->lfs_ssize / 2)
-			goal = MAX((cip->clean - 1) * fs->lfs_ssize,
-				   fs->lfs_ssize) / 2;
+		goal = clfs_sb_getssize(fs) * atatime;
+		if (goal > (cip->clean - 1) * clfs_sb_getssize(fs) / 2)
+			goal = MAX((cip->clean - 1) * clfs_sb_getssize(fs),
+				   clfs_sb_getssize(fs)) / 2;
 
 		dlog("%s: cleaning with goal %" PRId64
 		     " bytes (%d segs clean, %d cleanable)",
@@ -1064,7 +1066,7 @@
 			if (fs->clfs_segtabp[i]->priority == 0)
 				break;
 			/* Upper bound on number of segments at once */
-			if (ngood * fs->lfs_ssize > 4 * goal)
+			if (ngood * clfs_sb_getssize(fs) > 4 * goal)
 				break;
 			sn = (fs->clfs_segtabp[i] - fs->clfs_segtab);
 			dlog("%s: add seg %d prio %" PRIu64
@@ -1115,7 +1117,7 @@
 	/* Record statistics */
 	for (i = nb = 0; i < bic; i++)
 		nb += bip[i].bi_size;
-	util = ((double)nb) / (fs->clfs_nactive * fs->lfs_ssize);
+	util = ((double)nb) / (fs->clfs_nactive * clfs_sb_getssize(fs));
 	cleaner_stats.util_tot += util;
 	cleaner_stats.util_sos += util * util;
 	cleaner_stats.bytes_written += nb;
@@ -1127,14 +1129,14 @@
 	 * XXX do something about this.
 	 */
 	if_extra = 0;
-	extra = fs->lfs_bsize * (off_t)check_hidden_cost(fs, bip, bic, &if_extra);
-	if_extra *= fs->lfs_bsize;
+	extra = clfs_sb_getbsize(fs) * (off_t)check_hidden_cost(fs, bip, bic, &if_extra);
+	if_extra *= clfs_sb_getbsize(fs);
 
 	/*
 	 * Use markv to move the blocks.
 	 */
 	if (do_small) 
-		inc = MAXPHYS / fs->lfs_bsize - 1;
+		inc = MAXPHYS / clfs_sb_getbsize(fs) - 1;
 	else
 		inc = LFS_MARKV_MAXBLKCNT / 2;
 	for (mc = 0, mbip = bip; mc < bic; mc += inc, mbip += inc) {
@@ -1176,9 +1178,9 @@
 	       fs->lfs_fsmnt, (int64_t)nb, (int64_t)(extra - if_extra),
 	       (int64_t)if_extra, (int64_t)(nb + extra), ngood,
 	       (ngood ? (int64_t)(100 - (100 * (nb + extra)) /
-					 (ngood * fs->lfs_ssize)) :
+					 (ngood * clfs_sb_getssize(fs))) :
 		(int64_t)0));
-	if (nb + extra >= ngood * fs->lfs_ssize)
+	if (nb + extra >= ngood * clfs_sb_getssize(fs))
 		syslog(LOG_WARNING, "%s: cleaner not making forward progress",
 		       fs->lfs_fsmnt);
 
@@ -1214,13 +1216,13 @@
 	 * the cached information, so invalidate the buffer before
 	 * handing it back.
 	 */
-	if (bread(fs->lfs_ivnode, 0, fs->lfs_bsize, 0, &bp)) {
+	if (bread(fs->lfs_ivnode, 0, clfs_sb_getbsize(fs), 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;
+	cleaner_stats.bytes_read += clfs_sb_getbsize(fs);
 
 	/*
 	 * If the number of segments changed under us, reinit.

@@ -1,4 +1,4 @@
-/*      $NetBSD: lfs_inode.c,v 1.19 2013/06/19 06:15:54 dholland Exp $ */
+/*      $NetBSD: lfs_inode.c,v 1.20 2015/07/24 06:56:41 dholland Exp $ */
 
 /*-
  * Copyright (c) 1980, 1991, 1993, 1994
@@ -39,7 +39,7 @@
 #if 0
 static char sccsid[] = "@(#)main.c      8.6 (Berkeley) 5/1/95";
 #else
-__RCSID("$NetBSD: lfs_inode.c,v 1.19 2013/06/19 06:15:54 dholland Exp $");
+__RCSID("$NetBSD: lfs_inode.c,v 1.20 2015/07/24 06:56:41 dholland Exp $");
 #endif
 #endif /* not lint */
 
@@ -116,12 +116,12 @@
 			LFS_FSBTODB(sblock, (off_t)sblock->lfs_sboffs[1]));
 	} else {
 		if (sblock->lfs_version > 1) {
-			if (u.lfss.lfs_serial < sblock->lfs_serial) {
+			if (lfs_sb_getserial(&u.lfss) < lfs_sb_getserial(sblock)) {
 				memcpy(sblock, u.tbuf, sizeof(u.tbuf));
 				sboff = lfs_fsbtob(sblock, (off_t)sblock->lfs_sboffs[1]);
 			}
 		} else {
-			if (u.lfss.lfs_otstamp < sblock->lfs_otstamp) {
+			if (lfs_sb_getotstamp(&u.lfss) < lfs_sb_getotstamp(sblock)) {
 				memcpy(sblock, u.tbuf, sizeof(u.tbuf));
 				sboff = lfs_fsbtob(sblock, (off_t)sblock->lfs_sboffs[1]);
 			}
@@ -146,13 +146,13 @@
 
 	spcl.c_flags = iswap32(iswap32(spcl.c_flags) | DR_NEWINODEFMT);
 
-	ufsi.ufs_dsize = LFS_FSBTODB(sblock,sblock->lfs_size);
+	ufsi.ufs_dsize = LFS_FSBTODB(sblock, lfs_sb_getsize(sblock));
 	if (sblock->lfs_version == 1) 
-		ufsi.ufs_dsize = sblock->lfs_size >> sblock->lfs_blktodb;
-	ufsi.ufs_bsize = sblock->lfs_bsize;
+		ufsi.ufs_dsize = lfs_sb_getsize(sblock) >> sblock->lfs_blktodb;
+	ufsi.ufs_bsize = lfs_sb_getbsize(sblock);
 	ufsi.ufs_bshift = sblock->lfs_bshift;
-	ufsi.ufs_fsize = sblock->lfs_fsize;
-	ufsi.ufs_frag = sblock->lfs_frag;
+	ufsi.ufs_fsize = lfs_sb_getfsize(sblock);
+	ufsi.ufs_frag = lfs_sb_getfrag(sblock);
 	ufsi.ufs_fsatoda = sblock->lfs_fsbtodb;
 	if (sblock->lfs_version == 1)
 		ufsi.ufs_fsatoda = 0;
@@ -164,7 +164,7 @@
 	ufsi.ufs_fmask = ~(sblock->lfs_ffmask);
 	ufsi.ufs_qfmask = sblock->lfs_ffmask;
 
-	dev_bsize = sblock->lfs_bsize >> sblock->lfs_blktodb;
+	dev_bsize = lfs_sb_getbsize(sblock) >> sblock->lfs_blktodb;
 
 	return &ufsi;
 }
@@ -172,10 +172,10 @@
 ino_t
 fs_maxino(void)
 {
-	return ((getino(sblock->lfs_ifile)->dp1.di_size
-		   - (sblock->lfs_cleansz + sblock->lfs_segtabsz)
-		   * sblock->lfs_bsize)
-		  / sblock->lfs_bsize) * sblock->lfs_ifpb - 1;
+	return ((getino(lfs_sb_getifile(sblock))->dp1.di_size
+		   - (lfs_sb_getcleansz(sblock) + lfs_sb_getsegtabsz(sblock))
+		   * lfs_sb_getbsize(sblock))
+		  / lfs_sb_getbsize(sblock)) * lfs_sb_getifpb(sblock) - 1;
 }
 
 void
@@ -240,7 +240,7 @@
 			if(up == UNASSIGNED || up == LFS_UNUSED_DADDR)
 				return UNASSIGNED;
 			/* printf("lbn %d: parent is the triple\n", -lbn); */
-			bread(LFS_FSBTODB(sblock, up), bp, sblock->lfs_bsize);
+			bread(LFS_FSBTODB(sblock, up), bp, lfs_sb_getbsize(sblock));
 			/* XXX ondisk32 */
 			return (daddr_t)((int32_t *)bp)[off];
 		} else /* residue == 0 */ {
@@ -273,7 +273,7 @@
 	up = lfs_bmap(fs,idinode,up);
 	if(up == UNASSIGNED || up == LFS_UNUSED_DADDR)
 		return UNASSIGNED;
-	bread(LFS_FSBTODB(sblock, up), bp, sblock->lfs_bsize);
+	bread(LFS_FSBTODB(sblock, up), bp, lfs_sb_getbsize(sblock));
 	/* XXX ondisk32 */
 	return (daddr_t)((int32_t *)bp)[off];
 }
@@ -288,15 +288,15 @@
 	union dinode *dp;
 	struct ulfs1_dinode *ldp;
     
-	lbn = ino/sblock->lfs_ifpb + sblock->lfs_cleansz + sblock->lfs_segtabsz;
-	dp = getino(sblock->lfs_ifile);
+	lbn = ino/lfs_sb_getifpb(sblock) + lfs_sb_getcleansz(sblock) + lfs_sb_getsegtabsz(sblock);
+	dp = getino(lfs_sb_getifile(sblock));
 	/* XXX XXX this is horribly unsafe */
 	ldp = (struct ulfs1_dinode *)dp;
 	blkno = lfs_bmap(sblock, ldp ,lbn);
 	if (blkno != ifblkno)
 		bread(LFS_FSBTODB(sblock, blkno), (char *)ifileblock,
-		    sblock->lfs_bsize);
-	return ifileblock + (ino % sblock->lfs_ifpb);
+		    lfs_sb_getbsize(sblock));
+	return ifileblock + (ino % lfs_sb_getifpb(sblock));
 }
 
 /* Search a block for a specific dinode. */
@@ -321,12 +321,12 @@
 	static union dinode empty_dinode; /* Always stays zeroed */
 	struct ulfs1_dinode *dp;
 
-	if(inum == sblock->lfs_ifile) {
+	if(inum == lfs_sb_getifile(sblock)) {
 		/* Load the ifile inode if not already */
 		if(ifile_dinode.dlp1.di_inumber == 0) {
-			blkno = sblock->lfs_idaddr;
+			blkno = lfs_sb_getidaddr(sblock);
 			bread(LFS_FSBTODB(sblock, blkno), (char *)inoblock, 
-				(int)sblock->lfs_bsize);
+				(int)lfs_sb_getbsize(sblock));
 			dp = lfs_ifind(sblock, inum, inoblock);
 			ifile_dinode.dlp1 = *dp; /* Structure copy */
 		}
@@ -340,7 +340,7 @@
 
 	if(blkno != inoblkno) {
 		bread(LFS_FSBTODB(sblock, blkno), (char *)inoblock, 
-			(int)sblock->lfs_bsize);
+			(int)lfs_sb_getbsize(sblock));
 #ifdef notyet
 		if (needswap)
 			for (i = 0; i < MAXINOPB; i++)

@@ -1,4 +1,4 @@
-/* $NetBSD: dir.c,v 1.33 2015/03/29 19:35:58 chopps Exp $	 */
+/* $NetBSD: dir.c,v 1.34 2015/07/24 06:56:41 dholland Exp $	 */
 
 /*
  * Copyright (c) 1980, 1986, 1993
@@ -141,7 +141,7 @@
 	if (idesc->id_entryno == 0 &&
 	    (idesc->id_filesize & (LFS_DIRBLKSIZ - 1)) != 0)
 		idesc->id_filesize = roundup(idesc->id_filesize, LFS_DIRBLKSIZ);
-	blksiz = idesc->id_numfrags * fs->lfs_fsize;
+	blksiz = idesc->id_numfrags * lfs_sb_getfsize(fs);
 	if (chkrange(idesc->id_blkno, idesc->id_numfrags)) {
 		idesc->id_filesize -= blksiz;
 		return (SKIP);
@@ -177,7 +177,7 @@
 	struct ubuf *bp;
 	long size, blksiz, fix, dploc;
 
-	blksiz = idesc->id_numfrags * fs->lfs_fsize;
+	blksiz = idesc->id_numfrags * lfs_sb_getfsize(fs);
 	bread(vp, idesc->id_lblkno, blksiz, 0, &bp);
 	if (idesc->id_loc % LFS_DIRBLKSIZ == 0 && idesc->id_filesize > 0 &&
 	    idesc->id_loc < blksiz) {
@@ -568,21 +568,21 @@
 		return (0);
 	dp->di_db[lastbn + 1] = dp->di_db[lastbn];
 	dp->di_db[lastbn] = 0;
-	bp = getblk(vp, lastbn, fs->lfs_bsize);
+	bp = getblk(vp, lastbn, lfs_sb_getbsize(fs));
 	VOP_BWRITE(bp);
-	dp->di_size += fs->lfs_bsize;
-	dp->di_blocks += lfs_btofsb(fs, fs->lfs_bsize);
+	dp->di_size += lfs_sb_getbsize(fs);
+	dp->di_blocks += lfs_btofsb(fs, lfs_sb_getbsize(fs));
 	bread(vp, dp->di_db[lastbn + 1],
 	    (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, 0, &bp);
+	bread(vp, lastbn, lfs_sb_getbsize(fs), 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 < &bp->b_data[lfs_sb_getbsize(fs)];
 	    cp += LFS_DIRBLKSIZ)
 		memcpy(cp, &emptydir, sizeof emptydir);
 	VOP_BWRITE(bp);
@@ -602,8 +602,8 @@
 bad:
 	dp->di_db[lastbn] = dp->di_db[lastbn + 1];
 	dp->di_db[lastbn + 1] = 0;
-	dp->di_size -= fs->lfs_bsize;
-	dp->di_blocks -= lfs_btofsb(fs, fs->lfs_bsize);
+	dp->di_size -= lfs_sb_getbsize(fs);
+	dp->di_blocks -= lfs_btofsb(fs, lfs_sb_getbsize(fs));
 	return (0);
 }
 
@@ -626,7 +626,7 @@
 	dirp->dotdot_ino = parent;
 	vp = vget(fs, ino);
 	dp = VTOD(vp);
-	bread(vp, dp->di_db[0], fs->lfs_fsize, 0, &bp);
+	bread(vp, dp->di_db[0], lfs_sb_getfsize(fs), 0, &bp);
 	if (bp->b_flags & B_ERROR) {
 		brelse(bp, 0);
 		freeino(ino);
@@ -634,7 +634,7 @@
 	}
 	memcpy(bp->b_data, dirp, sizeof(struct lfs_dirtemplate));
 	for (cp = &bp->b_data[LFS_DIRBLKSIZ];
-	    cp < &bp->b_data[fs->lfs_fsize];
+	    cp < &bp->b_data[lfs_sb_getfsize(fs)];
 	    cp += LFS_DIRBLKSIZ)
 		memcpy(cp, &emptydir, sizeof emptydir);
 	VOP_BWRITE(bp);

@@ -1,4 +1,4 @@
-/* $NetBSD: inode.c,v 1.54 2015/06/16 23:18:55 christos Exp $	 */
+/* $NetBSD: inode.c,v 1.55 2015/07/24 06:56:41 dholland Exp $	 */
 
 /*-
  * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
@@ -142,7 +142,7 @@
 			dp->di_blocks == 0))))
 		return (KEEPON);
 	dino = *dp;
-	ndb = howmany(dino.di_size, fs->lfs_bsize);
+	ndb = howmany(dino.di_size, lfs_sb_getbsize(fs));
 
 	thisvp = vget(fs, idesc->id_number);
 	for (lbn = 0; lbn < ULFS_NDADDR; lbn++) {
@@ -155,7 +155,7 @@
 				idesc->id_numfrags =
 			    	lfs_numfrags(fs, lfs_fragroundup(fs, offset));
 			} else
-				idesc->id_numfrags = fs->lfs_frag;
+				idesc->id_numfrags = lfs_sb_getfrag(fs);
 		}
 		if (*ap == 0) {
 			if (idesc->id_type == DATA && ndb >= 0) {
@@ -168,7 +168,7 @@
 					vp = vget(fs, idesc->id_number);
 					dp = VTOD(vp);
 					dp->di_size = (ap - &dino.di_db[0]) *
-					    fs->lfs_bsize;
+					    lfs_sb_getbsize(fs);
 					printf(
 					    "YOU MUST RERUN FSCK AFTERWARDS\n");
 					rerun = 1;
@@ -187,9 +187,9 @@
 		if (ret & STOP)
 			return (ret);
 	}
-	idesc->id_numfrags = fs->lfs_frag;
-	remsize = dino.di_size - fs->lfs_bsize * ULFS_NDADDR;
-	sizepb = fs->lfs_bsize;
+	idesc->id_numfrags = lfs_sb_getfrag(fs);
+	remsize = dino.di_size - lfs_sb_getbsize(fs) * ULFS_NDADDR;
+	sizepb = lfs_sb_getbsize(fs);
 	for (ap = &dino.di_ib[0], n = 1; n <= ULFS_NIADDR; ap++, n++) {
 		if (*ap) {
 			idesc->id_blkno = *ap;
@@ -245,10 +245,10 @@
 		return (SKIP);
 
 	devvp = fs->lfs_devvp;
-	bread(devvp, LFS_FSBTODB(fs, idesc->id_blkno), fs->lfs_bsize,
+	bread(devvp, LFS_FSBTODB(fs, idesc->id_blkno), lfs_sb_getbsize(fs),
 	    0, &bp);
 	ilevel--;
-	for (sizepb = fs->lfs_bsize, i = 0; i < ilevel; i++)
+	for (sizepb = lfs_sb_getbsize(fs), i = 0; i < ilevel; i++)
 		sizepb *= LFS_NINDIR(fs);
 	if (isize > sizepb * LFS_NINDIR(fs))
 		nif = LFS_NINDIR(fs);
@@ -356,7 +356,7 @@
 	struct inoinfo **inpp, **ninpsort;
 	unsigned int blks;
 
-	blks = howmany(dp->di_size, fs->lfs_bsize);
+	blks = howmany(dp->di_size, lfs_sb_getbsize(fs));
 	if (blks > ULFS_NDADDR)
 		blks = ULFS_NDADDR + ULFS_NIADDR;
 	inp = emalloc(sizeof(*inp) + (blks - 1) * sizeof(ulfs_daddr_t));
@@ -463,8 +463,8 @@
 		return;
 	}
 	ifp->if_daddr = LFS_UNUSED_DADDR;
-	ifp->if_nextfree = fs->lfs_freehd;
-	fs->lfs_freehd = inumber;
+	ifp->if_nextfree = lfs_sb_getfreehd(fs);
+	lfs_sb_setfreehd(fs, inumber);
 	sbdirty();
 	VOP_BWRITE(bp);
 
@@ -608,14 +608,14 @@
 	if (vp == NULL)
 		return (0);
 	dp = (VTOI(vp)->i_din.ffs1_din);
-	bp = getblk(vp, 0, fs->lfs_fsize);
+	bp = getblk(vp, 0, lfs_sb_getfsize(fs));
 	VOP_BWRITE(bp);
 	dp->di_mode = type;
 	(void) time(&t);
 	dp->di_atime = t;
 	dp->di_mtime = dp->di_ctime = dp->di_atime;
-	dp->di_size = fs->lfs_fsize;
-	dp->di_blocks = lfs_btofsb(fs, fs->lfs_fsize);
+	dp->di_size = lfs_sb_getfsize(fs);
+	dp->di_blocks = lfs_btofsb(fs, lfs_sb_getfsize(fs));
 	n_files++;
 	inodirty(VTOI(vp));
 	typemap[ino] = LFS_IFTODT(type);

@@ -1,4 +1,4 @@
-/* $NetBSD: lfs.c,v 1.45 2015/05/31 15:44:30 hannken Exp $ */
+/* $NetBSD: lfs.c,v 1.46 2015/07/24 06:56:41 dholland Exp $ */
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
  * All rights reserved.
@@ -143,7 +143,7 @@
 
 	fs = bp->b_vp->v_fs;
 	if (!(bp->b_flags & B_DELWRI)) {
-		fs->lfs_avail -= lfs_btofsb(fs, bp->b_bcount);
+		lfs_sb_subavail(fs, lfs_btofsb(fs, bp->b_bcount));
 	}
 	bp->b_flags |= B_DELWRI | B_LOCKED;
 	reassignbuf(bp, bp->b_vp);
@@ -204,7 +204,7 @@
 			brelse(bp, 0);
 
 		xap->in_exists = 1;
-		bp = getblk(vp, metalbn, fs->lfs_bsize);
+		bp = getblk(vp, metalbn, lfs_sb_getbsize(fs));
 
 		if (!(bp->b_flags & (B_DONE | B_DELWRI))) {
 			bp->b_blkno = LFS_FSBTODB(fs, daddr);
@@ -486,7 +486,7 @@
 		bp->b_flags |= B_INVAL;
 		brelse(bp, 0);
 
-		dev_bsize = fs->lfs_fsize >> fs->lfs_fsbtodb;
+		dev_bsize = lfs_sb_getfsize(fs) >> fs->lfs_fsbtodb;
 	
 		if (tryalt) {
 			(void)bread(devvp, LFS_FSBTODB(fs, fs->lfs_sboffs[1]),
@@ -497,7 +497,7 @@
 			bp->b_flags |= B_INVAL;
 			brelse(bp, 0);
 	
-			if (check_sb(fs) || fs->lfs_idaddr <= 0) {
+			if (check_sb(fs) || lfs_sb_getidaddr(fs) <= 0) {
 				if (debug)
 					printf("Primary superblock is no good, using first alternate\n");
 				free(fs);
@@ -527,9 +527,9 @@
 	/* Compatibility */
 	if (fs->lfs_version < 2) {
 		fs->lfs_sumsize = LFS_V1_SUMMARY_SIZE;
-		fs->lfs_ibsize = fs->lfs_bsize;
+		fs->lfs_ibsize = lfs_sb_getbsize(fs);
 		fs->lfs_s0addr = fs->lfs_sboffs[0];
-		fs->lfs_tstamp = fs->lfs_otstamp;
+		lfs_sb_settstamp(fs, lfs_sb_getotstamp(fs));
 		fs->lfs_fsbtodb = 0;
 	}
 
@@ -540,13 +540,13 @@
 	}
 
 	if (idaddr == 0)
-		idaddr = fs->lfs_idaddr;
+		idaddr = lfs_sb_getidaddr(fs);
 	else
-		fs->lfs_idaddr = idaddr;
+		lfs_sb_setidaddr(fs, idaddr);
 	/* NB: If dummy_read!=0, idaddr==0 here so we get a fake inode. */
 	fs->lfs_ivnode = lfs_raw_vget(fs,
-		(dummy_read ? LFS_IFILE_INUM : fs->lfs_ifile), devvp->v_fd,
-		idaddr);
+		(dummy_read ? LFS_IFILE_INUM : lfs_sb_getifile(fs)),
+		devvp->v_fd, idaddr);
 	if (fs->lfs_ivnode == NULL)
 		return NULL;
 
@@ -578,9 +578,9 @@
 	bc = 0;
 	hitclean = 0;
 	odaddr = -1;
-	daddr = osb->lfs_offset;
+	daddr = lfs_sb_getoffset(osb);
 	nodirop_daddr = daddr;
-	serial = osb->lfs_serial;
+	serial = lfs_sb_getserial(osb);
 	while (daddr != goal) {
 		/*
 		 * Don't mistakenly read a superblock, if there is one here.
@@ -649,7 +649,7 @@
 		daddr += lfs_btofsb(osb, osb->lfs_sumsize + bc);
 		if (lfs_dtosn(osb, odaddr) != lfs_dtosn(osb, daddr) ||
 		    lfs_dtosn(osb, daddr) != lfs_dtosn(osb, daddr +
-			lfs_btofsb(osb, osb->lfs_sumsize + osb->lfs_bsize) - 1)) {
+			lfs_btofsb(osb, osb->lfs_sumsize + lfs_sb_getbsize(osb)) - 1)) {
 			daddr = sp->ss_next;
 		}
 
@@ -689,16 +689,16 @@
 
 	osb = NULL;
 	if (debug)
-		pwarn("sb0 %lld, sb1 %lld",
-		      (long long) sb0->lfs_serial,
-		      (long long) sb1->lfs_serial);
+		pwarn("sb0 %ju, sb1 %ju",
+		      (uintmax_t) lfs_sb_getserial(sb0),
+		      (uintmax_t) lfs_sb_getserial(sb1));
 
 	if ((sb0->lfs_version == 1 &&
-		sb0->lfs_otstamp != sb1->lfs_otstamp) ||
+		lfs_sb_getotstamp(sb0) != lfs_sb_getotstamp(sb1)) ||
 	    (sb0->lfs_version > 1 &&
-		sb0->lfs_serial != sb1->lfs_serial)) {
+		lfs_sb_getserial(sb0) != lfs_sb_getserial(sb1))) {
 		if (sb0->lfs_version == 1) {
-			if (sb0->lfs_otstamp > sb1->lfs_otstamp) {
+			if (lfs_sb_getotstamp(sb0) > lfs_sb_getotstamp(sb1)) {
 				osb = sb1;
 				nsb = sb0;
 			} else {
@@ -706,7 +706,7 @@
 				nsb = sb1;
 			}
 		} else {
-			if (sb0->lfs_serial > sb1->lfs_serial) {
+			if (lfs_sb_getserial(sb0) > lfs_sb_getserial(sb1)) {
 				osb = sb1;
 				nsb = sb0;
 			} else {
@@ -718,18 +718,18 @@
 			printf("Attempting to verify newer checkpoint...");
 			fflush(stdout);
 		}
-		daddr = try_verify(osb, devvp, nsb->lfs_offset, debug);
+		daddr = try_verify(osb, devvp, lfs_sb_getoffset(nsb), debug);
 
 		if (debug)
 			printf("done.\n");
-		if (daddr == nsb->lfs_offset) {
-			pwarn("** Newer checkpoint verified, recovered %lld seconds of data\n",
-			    (long long) nsb->lfs_tstamp - (long long) osb->lfs_tstamp);
+		if (daddr == lfs_sb_getoffset(nsb)) {
+			pwarn("** Newer checkpoint verified; recovered %jd seconds of data\n",
+			    (intmax_t)(lfs_sb_gettstamp(nsb) - lfs_sb_gettstamp(osb)));
 			sbdirty();
 		} else {
-			pwarn("** Newer checkpoint invalid, lost %lld seconds of data\n", (long long) nsb->lfs_tstamp - (long long) osb->lfs_tstamp);
+			pwarn("** Newer checkpoint invalid; lost %jd seconds of data\n", (intmax_t)(lfs_sb_gettstamp(nsb) - lfs_sb_gettstamp(osb)));
 		}
-		return (daddr == nsb->lfs_offset ? nsb : osb);
+		return (daddr == lfs_sb_getoffset(nsb) ? nsb : osb);
 	}
 	/* Nothing to check */
 	return osb;
@@ -804,7 +804,7 @@
 			for (k = 0; k < fp->fi_nblocks; k++) {
 				len = (k == fp->fi_nblocks - 1 ?
 				       fp->fi_lastlength
-				       : fs->lfs_bsize);
+				       : lfs_sb_getbsize(fs));
 				bread(devvp, LFS_FSBTODB(fs, daddr), len,
 				    0, &bp);
 				datap[datac++] = ((u_int32_t *) (bp->b_data))[0];
@@ -876,7 +876,7 @@
 	brelse(bp, 0);
 
 	/* Extend IFILE so that the next lfs_valloc will succeed. */
-	if (fs->lfs_freehd == LFS_UNUSED_INUM) {
+	if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {
 		if ((error = extend_ifile(fs)) != 0) {
 			LFS_PUT_HEADFREE(fs, cip, cbp, new_ino);
 			return NULL;
@@ -885,7 +885,7 @@
 
 	/* Set superblock modified bit and increment file count. */
         sbdirty();
-	++fs->lfs_nfiles;
+	lfs_sb_addnfiles(fs, 1);
 
         return lfs_raw_vget(fs, ino, fs->lfs_devvp->v_fd, 0x0);
 }
@@ -913,16 +913,16 @@
 	ip = VTOI(vp);
 	blkno = lfs_lblkno(fs, ip->i_ffs1_size);
 
-	lfs_balloc(vp, ip->i_ffs1_size, fs->lfs_bsize, &bp);
-	ip->i_ffs1_size += fs->lfs_bsize;
+	lfs_balloc(vp, ip->i_ffs1_size, lfs_sb_getbsize(fs), &bp);
+	ip->i_ffs1_size += lfs_sb_getbsize(fs);
 	ip->i_flag |= IN_MODIFIED;
 	
-	i = (blkno - fs->lfs_segtabsz - fs->lfs_cleansz) *
-		fs->lfs_ifpb;
+	i = (blkno - lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs)) *
+		lfs_sb_getifpb(fs);
 	LFS_GET_HEADFREE(fs, cip, cbp, &oldlast);
 	LFS_PUT_HEADFREE(fs, cip, cbp, i);
-	max = i + fs->lfs_ifpb;
-	fs->lfs_bfree -= lfs_btofsb(fs, fs->lfs_bsize);
+	max = i + lfs_sb_getifpb(fs);
+	lfs_sb_subbfree(fs, lfs_btofsb(fs, lfs_sb_getbsize(fs)));
 
 	if (fs->lfs_version == 1) {
 		for (ifp_v1 = (IFILE_V1 *)bp->b_data; i < max; ++ifp_v1) {
@@ -946,8 +946,9 @@
 	LFS_BWRITE_LOG(bp);
 
 #ifdef IN_FSCK_LFS
-	reset_maxino(((ip->i_ffs1_size >> fs->lfs_bshift) - fs->lfs_segtabsz -
-		     fs->lfs_cleansz) * fs->lfs_ifpb);
+	reset_maxino(((ip->i_ffs1_size >> fs->lfs_bshift)
+		      - lfs_sb_getsegtabsz(fs)
+		      - lfs_sb_getcleansz(fs)) * lfs_sb_getifpb(fs));
 #endif
 	return 0;
 }
@@ -1006,12 +1007,12 @@
 	lastblock = lfs_lblkno(fs, ip->i_ffs1_size);
 	if (lastblock < ULFS_NDADDR && lastblock < lbn) {
 		osize = lfs_blksize(fs, ip, lastblock);
-		if (osize < fs->lfs_bsize && osize > 0) {
-			if ((error = lfs_fragextend(vp, osize, fs->lfs_bsize,
+		if (osize < lfs_sb_getbsize(fs) && osize > 0) {
+			if ((error = lfs_fragextend(vp, osize, lfs_sb_getbsize(fs),
 						    lastblock,
 						    (bpp ? &bp : NULL))))
 				return (error);
-			ip->i_ffs1_size = (lastblock + 1) * fs->lfs_bsize;
+			ip->i_ffs1_size = (lastblock + 1) * lfs_sb_getbsize(fs);
 			ip->i_flag |= IN_CHANGE | IN_UPDATE;
 			if (bpp)
 				(void) VOP_BWRITE(bp);
@@ -1037,7 +1038,7 @@
 				bp->b_blkno = UNWRITTEN;
 			}
 			ip->i_lfs_effnblks += frags;
-			fs->lfs_bfree -= frags;
+			lfs_sb_subbfree(fs, frags);
 			ip->i_ffs1_db[lbn] = UNWRITTEN;
 		} else {
 			if (nsize <= osize) {
@@ -1078,7 +1079,7 @@
 			bcount += frags;
 		}
 	}
-	fs->lfs_bfree -= bcount;
+	lfs_sb_subbfree(fs, bcount);
 	ip->i_lfs_effnblks += bcount;
 
 	if (daddr == UNASSIGNED) {
@@ -1093,7 +1094,7 @@
 			idaddr = ip->i_ffs1_ib[indirs[0].in_off];
 			for (i = 1; i < num; ++i) {
 				ibp = getblk(vp, indirs[i].in_lbn,
-				    fs->lfs_bsize);
+				    lfs_sb_getbsize(fs));
 				if (!indirs[i].in_exists) {
 					memset(ibp->b_data, 0, ibp->b_bufsize);
 					ibp->b_blkno = UNWRITTEN;
@@ -1149,7 +1150,7 @@
 			break;
 		    default:
 			idp = &indirs[num - 1];
-			if (bread(vp, idp->in_lbn, fs->lfs_bsize, 0, &ibp))
+			if (bread(vp, idp->in_lbn, lfs_sb_getbsize(fs), 0, &ibp))
 				panic("lfs_balloc: bread bno %lld",
 				    (long long)idp->in_lbn);
 			/* XXX ondisk32 */
@@ -1161,7 +1162,7 @@
 		 * Not a brand new block, also not in the cache;
 		 * read it in from disk.
 		 */
-		if (iosize == fs->lfs_bsize)
+		if (iosize == lfs_sb_getbsize(fs))
 			/* Optimization: I/O is unnecessary. */
 			bp->b_blkno = daddr;
 		else {
@@ -1204,7 +1205,7 @@
 		goto out;
 	}
 
-	fs->lfs_bfree -= frags;
+	lfs_sb_subbfree(fs, frags);
 	ip->i_lfs_effnblks += frags;
 	ip->i_flag |= IN_CHANGE | IN_UPDATE;
 

@@ -1,4 +1,4 @@
-/* $NetBSD: main.c,v 1.49 2015/06/16 23:18:55 christos Exp $	 */
+/* $NetBSD: main.c,v 1.50 2015/07/24 06:56:41 dholland Exp $	 */
 
 /*
  * Copyright (c) 1980, 1986, 1993
@@ -308,9 +308,9 @@
 	/*
 	 * print out summary statistics
 	 */
-	pwarn("%llu files, %lld used, %lld free\n",
-	    (unsigned long long)n_files, (long long) n_blks,
-	    (long long) fs->lfs_bfree);
+	pwarn("%ju files, %jd used, %jd free\n",
+	    (uintmax_t) n_files, (intmax_t) n_blks,
+	    (intmax_t) lfs_sb_getbfree(fs));
 
 	ckfini(1);
 

@@ -1,4 +1,4 @@
-/* $NetBSD: pass0.c,v 1.35 2013/06/08 02:16:03 dholland Exp $	 */
+/* $NetBSD: pass0.c,v 1.36 2015/07/24 06:56:41 dholland Exp $	 */
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@@ -198,11 +198,11 @@
 		cip->free_head = freehd;
 		writeit = 1;
 	}
-	if (freehd != fs->lfs_freehd) {
-		pwarn("FREE LIST HEAD IN SUPERBLOCK SHOULD BE %d (WAS %d)\n",
-			(int)fs->lfs_freehd, (int)freehd);
+	if (freehd != lfs_sb_getfreehd(fs)) {
+		pwarn("FREE LIST HEAD IN SUPERBLOCK SHOULD BE %u (WAS %ju)\n",
+			lfs_sb_getfreehd(fs), (uintmax_t)freehd);
 		if (preen || reply("FIX")) {
-			fs->lfs_freehd = freehd;
+			lfs_sb_setfreehd(fs, freehd);
 			sbdirty();
 		}
 	}
@@ -221,7 +221,7 @@
 	else
 		brelse(cbp, 0);
 
-	if (fs->lfs_freehd == 0) {
+	if (lfs_sb_getfreehd(fs) == 0) {
 		pwarn("%sree list head is 0x0\n", preen ? "f" : "F");
 		if (preen || reply("FIX"))
 			extend_ifile(fs);

@@ -1,4 +1,4 @@
-/* $NetBSD: pass1.c,v 1.37 2013/06/18 18:18:58 christos Exp $	 */
+/* $NetBSD: pass1.c,v 1.38 2015/07/24 06:56:41 dholland Exp $	 */
 
 /*
  * Copyright (c) 1980, 1986, 1993
@@ -111,8 +111,8 @@
 	for (i = 0; i < maxino; i++) {
 		dins[i] = emalloc(sizeof(**dins));
 		dins[i]->ino = i;
-		if (i == fs->lfs_ifile)
-			dins[i]->daddr = fs->lfs_idaddr;
+		if (i == lfs_sb_getifile(fs))
+			dins[i]->daddr = lfs_sb_getidaddr(fs);
 		else {
 			LFS_IENTRY(ifp, fs, i, bp);
 			dins[i]->daddr = ifp->if_daddr;
@@ -200,7 +200,7 @@
 	}
 	lastino = inumber;
 	if (/* dp->di_size < 0 || */
-	    dp->di_size + fs->lfs_bsize - 1 < dp->di_size) {
+	    dp->di_size + lfs_sb_getbsize(fs) - 1 < dp->di_size) {
 		if (debug)
 			printf("bad size %llu:",
 			    (unsigned long long) dp->di_size);
@@ -209,11 +209,11 @@
 	if (!preen && mode == LFS_IFMT && reply("HOLD BAD BLOCK") == 1) {
 		vp = vget(fs, inumber);
 		dp = VTOD(vp);
-		dp->di_size = fs->lfs_fsize;
+		dp->di_size = lfs_sb_getfsize(fs);
 		dp->di_mode = LFS_IFREG | 0600;
 		inodirty(VTOI(vp));
 	}
-	ndb = howmany(dp->di_size, fs->lfs_bsize);
+	ndb = howmany(dp->di_size, lfs_sb_getbsize(fs));
 	if (ndb < 0) {
 		if (debug)
 			printf("bad size %llu ndb %d:",
@@ -339,7 +339,7 @@
 			return (STOP);
 		}
 	} else if (!testbmap(blkno)) {
-		seg_table[lfs_dtosn(fs, blkno)].su_nbytes += idesc->id_numfrags * fs->lfs_fsize;
+		seg_table[lfs_dtosn(fs, blkno)].su_nbytes += idesc->id_numfrags * lfs_sb_getfsize(fs);
 	}
 	for (ndblks = idesc->id_numfrags; ndblks > 0; blkno++, ndblks--) {
 		if (anyout && chkrange(blkno, 1)) {

@@ -1,4 +1,4 @@
-/* $NetBSD: utilities.c,v 1.37 2015/06/16 23:58:30 christos Exp $	 */
+/* $NetBSD: utilities.c,v 1.38 2015/07/24 06:56:41 dholland Exp $	 */
 
 /*
  * Copyright (c) 1980, 1986, 1993
@@ -118,8 +118,8 @@
 write_superblocks(void)
 {
 	if (debug)
-		pwarn("writing superblocks with lfs_idaddr = 0x%x\n",
-			(int)fs->lfs_idaddr);
+		pwarn("writing superblocks with lfs_idaddr = 0x%jx\n",
+			(uintmax_t)lfs_sb_getidaddr(fs));
 	lfs_writesuper(fs, fs->lfs_sboffs[0]);
 	lfs_writesuper(fs, fs->lfs_sboffs[1]);
 	fsmodified = 1;

@@ -1,4 +1,4 @@
-/* $NetBSD: pass4.c,v 1.23 2015/06/16 23:18:55 christos Exp $	 */
+/* $NetBSD: pass4.c,v 1.24 2015/07/24 06:56:41 dholland Exp $	 */
 
 /*
  * Copyright (c) 1980, 1986, 1993
@@ -173,7 +173,7 @@
 				sup->su_nbytes -= lfs_fsbtob(fs, 1);
 				VOP_BWRITE(bp);
 				seg_table[sn].su_nbytes -= lfs_fsbtob(fs, 1);
-				++fs->lfs_bfree;
+				lfs_sb_addbfree(fs, 1);
 				n_blks--;
 			}
 		}

@@ -1,4 +1,4 @@
-/* $NetBSD: pass5.c,v 1.29 2015/05/31 15:44:30 hannken Exp $	 */
+/* $NetBSD: pass5.c,v 1.30 2015/07/24 06:56:41 dholland Exp $	 */
 
 /*-
  * Copyright (c) 2000, 2003 The NetBSD Foundation, Inc.
@@ -131,8 +131,8 @@
 	}
 
 	/* Also may be available bytes in current seg */
-	i = lfs_dtosn(fs, fs->lfs_offset);
-	avail += lfs_sntod(fs, i + 1) - fs->lfs_offset;
+	i = lfs_dtosn(fs, lfs_sb_getoffset(fs));
+	avail += lfs_sntod(fs, i + 1) - lfs_sb_getoffset(fs);
 	/* But do not count minfreesegs */
 	avail -= lfs_segtod(fs, (fs->lfs_minfreeseg -
 		(fs->lfs_minfreeseg / 2)));
@@ -150,11 +150,11 @@
 			sbdirty();
 		}
 	}
-	if (avail != fs->lfs_avail) {
-		pwarn("AVAIL GIVEN AS %d, SHOULD BE %ld\n", fs->lfs_avail,
-		    avail);
+	if (avail != lfs_sb_getavail(fs)) {
+		pwarn("AVAIL GIVEN AS %d, SHOULD BE %ld\n",
+		      lfs_sb_getavail(fs), avail);
 		if (preen || reply("FIX")) {
-			fs->lfs_avail = avail;
+			lfs_sb_setavail(fs, avail);
 			sbdirty();
 		}
 	}
@@ -171,15 +171,16 @@
 	if (fs->lfs_version > 1 &&
 	    fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD))
 		labelskew = lfs_btofsb(fs, LFS_LABELPAD);
-	if (fs->lfs_bfree > fs->lfs_dsize - bb - labelskew ||
-	    fs->lfs_bfree < fs->lfs_dsize - ubb - labelskew) {
-		pwarn("BFREE GIVEN AS %d, SHOULD BE BETWEEN %ld AND %ld\n",
-		    fs->lfs_bfree, (fs->lfs_dsize - ubb - labelskew),
-		    fs->lfs_dsize - bb - labelskew);
+	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",
+		    (intmax_t)lfs_sb_getbfree(fs),
+		    lfs_sb_getdsize(fs) - ubb - labelskew,
+		    lfs_sb_getdsize(fs) - bb - labelskew);
 		if (preen || reply("FIX")) {
-			fs->lfs_bfree =
-				((fs->lfs_dsize - labelskew - ubb) +
-				 fs->lfs_dsize - labelskew - bb) / 2;
+			lfs_sb_setbfree(fs,
+				((lfs_sb_getdsize(fs) - labelskew - ubb) +
+				 lfs_sb_getdsize(fs) - labelskew - bb) / 2);
 			sbdirty();
 		}
 	}

@@ -1,4 +1,4 @@
-/* $NetBSD: pass6.c,v 1.34 2015/05/31 15:44:30 hannken Exp $	 */
+/* $NetBSD: pass6.c,v 1.35 2015/07/24 06:56:41 dholland Exp $	 */
 
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
@@ -120,7 +120,7 @@
 		break;
 	default:
 		ap = &a[num - 1];
-		if (bread(vp, ap->in_lbn, fs->lfs_bsize, 0, &bp))
+		if (bread(vp, ap->in_lbn, lfs_sb_getbsize(fs), 0, &bp))
 			errx(1, "lfs_updatemeta: bread bno %" PRId64,
 			    ap->in_lbn);
 
@@ -140,7 +140,7 @@
 		if (lbn >= 0 && lbn < ULFS_NDADDR)
 			osize = ip->i_lfs_fragsize[lbn];
 		else
-			osize = fs->lfs_bsize;
+			osize = lfs_sb_getbsize(fs);
 		LFS_SEGENTRY(sup, fs, oldsn, bp);
 		seg_table[oldsn].su_nbytes -= osize;
 		sup->su_nbytes -= osize;
@@ -161,7 +161,7 @@
 		off_t minsize;
 
 		minsize = (lbn << fs->lfs_bshift);
-		minsize += (size - fs->lfs_fsize) + 1;
+		minsize += (size - lfs_sb_getfsize(fs)) + 1;
 		if (ip->i_ffs1_size < minsize)
 			ip->i_ffs1_size = minsize;
 	}
@@ -186,9 +186,9 @@
 
 	/* Check bfree accounting as well */
 	if (daddr <= 0) {
-		fs->lfs_bfree -= lfs_btofsb(fs, size);
+		lfs_sb_subbfree(fs, lfs_btofsb(fs, size));
 	} else if (size != osize) {
-		fs->lfs_bfree -= (frags - ofrags);
+		lfs_sb_subbfree(fs, frags - ofrags);
 	}
 
 	/*
@@ -264,7 +264,7 @@
 	    VTOI(vp)->i_ffs1_gen == fip->fi_version) {
 		for (i = 0; i < fip->fi_nblocks; i++) {
 			size = (i == fip->fi_nblocks - 1 ?
-				fip->fi_lastlength : fs->lfs_bsize);
+				fip->fi_lastlength : lfs_sb_getbsize(fs));
 			if (debug)
 				pwarn("ino %lld lbn %lld -> 0x%lx\n",
 					(long long)fip->fi_ino,
@@ -298,8 +298,8 @@
 			break;
 		}
 		if (seg_table[sn].su_flags & SEGUSE_ACTIVE) {
-			if (sn != lfs_dtosn(fs, fs->lfs_offset) ||
-			    idesc->id_blkno > fs->lfs_offset) {
+			if (sn != lfs_dtosn(fs, lfs_sb_getoffset(fs)) ||
+			    idesc->id_blkno > lfs_sb_getoffset(fs)) {
 				++anynew;
 			}
 		}
@@ -336,21 +336,21 @@
 		lbn = -ilbn;
 	else
 		lbn = ilbn + 1;
-	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);
+	bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getbsize(fs), 0, &bp);
+	buf = emalloc(lfs_sb_getbsize(fs));
+	memcpy(buf, bp->b_data, lfs_sb_getbsize(fs));
 	brelse(bp, 0);
 
-	obuf = emalloc(fs->lfs_bsize);
+	obuf = emalloc(lfs_sb_getbsize(fs));
 	if (vp) {
-		bread(vp, ilbn, fs->lfs_bsize, 0, &bp);
-		memcpy(obuf, bp->b_data, fs->lfs_bsize);
+		bread(vp, ilbn, lfs_sb_getbsize(fs), 0, &bp);
+		memcpy(obuf, bp->b_data, lfs_sb_getbsize(fs));
 		brelse(bp, 0);
 	} else
-		memset(obuf, 0, fs->lfs_bsize);
+		memset(obuf, 0, lfs_sb_getbsize(fs));
 
 	for (dap = buf, odap = obuf;
-	     dap < (int32_t *)((char *)buf + fs->lfs_bsize);
+	     dap < (int32_t *)((char *)buf + lfs_sb_getbsize(fs));
 	     ++dap, ++odap) {
 		if (*dap > 0 && *dap != *odap) {
 			rfw_update_single(vp, lbn, *dap, lfs_dblksize(fs, dp, lbn));
@@ -397,7 +397,7 @@
 		odaddr = (ip ? ip->i_ffs1_ib[i] : 0x0);
 		if (dp->di_ib[i] > 0 && dp->di_ib[i] != odaddr) {
 			lbn = -(ULFS_NDADDR + off + i);
-			rfw_update_single(vp, i, dp->di_ib[i], fs->lfs_bsize);
+			rfw_update_single(vp, i, dp->di_ib[i], lfs_sb_getbsize(fs));
 			account_indir(vp, dp, lbn, dp->di_ib[i], i);
 		}
 		if (off == 0)
@@ -566,15 +566,15 @@
 
 	/* Find last valid partial segment */
 	lastgood = try_verify(fs, devvp, 0, debug);
-	if (lastgood == fs->lfs_offset) {
+	if (lastgood == lfs_sb_getoffset(fs)) {
 		if (debug)
 			pwarn("not rolling forward, nothing to recover\n");
 		return;
 	}
 
 	if (debug)
-		pwarn("could roll forward from 0x%" PRIx32 " to 0x%" PRIx32 "\n",
-			fs->lfs_offset, lastgood);
+		pwarn("could roll forward from 0x%jx to 0x%jx\n",
+			(uintmax_t)lfs_sb_getoffset(fs), (uintmax_t)lastgood);
 
 	if (!preen && reply("ROLL FORWARD") == 0)
 		return;
@@ -585,7 +585,7 @@
 
 	ibbuf = emalloc(fs->lfs_ibsize);
 	nnewfiles = ndelfiles = nmvfiles = nnewblocks = 0;
-	daddr = fs->lfs_offset;
+	daddr = lfs_sb_getoffset(fs);
 	hassuper = 0;
 	lastserial = 0;
 	while (daddr != lastgood) {
@@ -622,12 +622,12 @@
 		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);
+		lfs_sb_subbfree(fs, lfs_btofsb(fs, fs->lfs_sumsize));
+		lfs_sb_adddmeta(fs, lfs_btofsb(fs, fs->lfs_sumsize));
 		sbdirty();
 		if (lfs_sntod(fs, lfs_dtosn(fs, daddr)) == daddr +
 		    hassuper * lfs_btofsb(fs, LFS_SBPAD) &&
-		    lfs_dtosn(fs, daddr) != lfs_dtosn(fs, fs->lfs_offset)) {
+		    lfs_dtosn(fs, daddr) != lfs_dtosn(fs, lfs_sb_getoffset(fs))) {
 			--fs->lfs_nclean;
 			sbdirty();
 		}
@@ -647,7 +647,7 @@
 			
 			inums = ecalloc(LFS_INOPB(fs) + 1, sizeof(*inums));
 			ibdaddr = *--idaddrp;
-			fs->lfs_bfree -= lfs_btofsb(fs, fs->lfs_ibsize);
+			lfs_sb_subbfree(fs, lfs_btofsb(fs, fs->lfs_ibsize));
 			sbdirty();
 			bread(devvp, LFS_FSBTODB(fs, ibdaddr), fs->lfs_ibsize,
 			      0, &ibp);
@@ -659,7 +659,7 @@
 			     dp < (struct ulfs1_dinode *)ibbuf + LFS_INOPB(fs);
 			     ++dp) {
 				if (dp->di_inumber == 0 ||
-				    dp->di_inumber == fs->lfs_ifile)
+				    dp->di_inumber == lfs_sb_getifile(fs))
 					continue;
 				/* Basic sanity checks */
 				if (dp->di_nlink < 0 
@@ -780,7 +780,7 @@
 		daddr += lfs_btofsb(fs, fs->lfs_sumsize + bc);
 		if (lfs_dtosn(fs, odaddr) != lfs_dtosn(fs, daddr) ||
 		    lfs_dtosn(fs, daddr) != lfs_dtosn(fs, daddr +
-			lfs_btofsb(fs, fs->lfs_sumsize + fs->lfs_bsize) - 1)) {
+			lfs_btofsb(fs, fs->lfs_sumsize + lfs_sb_getbsize(fs)) - 1)) {
 			daddr = ((SEGSUM *)bp->b_data)->ss_next;
 		}
 		brelse(bp, 0);
@@ -790,7 +790,7 @@
 	free(ibbuf);
 
 	/* Set serial here, just to be sure (XXX should be right already) */
-	fs->lfs_serial = lastserial + 1;
+	lfs_sb_setserial(fs, lastserial + 1);
 
 	/*
 	 * Check our new vnodes.  Any blocks must lie in segments that
@@ -814,7 +814,7 @@
 	 * do the pretend-write, though, if we've already seen them
 	 * (the accounting would have been done for us already).
 	 */
-	daddr = fs->lfs_offset;
+	daddr = lfs_sb_getoffset(fs);
 	while (daddr != lastgood) {
 		if (!(seg_table[lfs_dtosn(fs, daddr)].su_flags & SEGUSE_DIRTY)) {
 			seg_table[lfs_dtosn(fs, daddr)].su_flags |= SEGUSE_DIRTY;
@@ -848,11 +848,11 @@
 		}
 		odaddr = daddr;
 		daddr += lfs_btofsb(fs, fs->lfs_sumsize + bc);
-		fs->lfs_avail -= lfs_btofsb(fs, fs->lfs_sumsize + bc);
+		lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs) + bc));
 		if (lfs_dtosn(fs, odaddr) != lfs_dtosn(fs, daddr) ||
 		    lfs_dtosn(fs, daddr) != lfs_dtosn(fs, daddr +
-			lfs_btofsb(fs, fs->lfs_sumsize + fs->lfs_bsize) - 1)) {
-			fs->lfs_avail -= lfs_sntod(fs, lfs_dtosn(fs, daddr) + 1) - daddr;
+			lfs_btofsb(fs, lfs_sb_getsumsize(fs) + lfs_sb_getbsize(fs)) - 1)) {
+			lfs_sb_subavail(fs, lfs_sntod(fs, lfs_dtosn(fs, daddr) + 1) - daddr);
 			daddr = ((SEGSUM *)bp->b_data)->ss_next;
 		}
 		LFS_CLEANERINFO(cip, fs, cbp);
@@ -874,9 +874,9 @@
 	}
 		
 	/* Update offset to point at correct location */
-	fs->lfs_offset = lastgood;
-	fs->lfs_curseg = lfs_sntod(fs, lfs_dtosn(fs, lastgood));
-	for (sn = curseg = lfs_dtosn(fs, fs->lfs_curseg);;) {
+	lfs_sb_setoffset(fs, lastgood);
+	lfs_sb_setcurseg(fs, lfs_sntod(fs, lfs_dtosn(fs, lastgood)));
+	for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs));;) {
 		sn = (sn + 1) % fs->lfs_nseg;
 		if (sn == curseg)
 			errx(1, "no clean segments");
@@ -888,7 +888,7 @@
 		}
 		brelse(bp, 0);
 	}
-	fs->lfs_nextseg = lfs_sntod(fs, sn);
+	lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
 
 	if (preen) {
 		if (ndelfiles)

@@ -1,4 +1,4 @@
-/* $NetBSD: segwrite.c,v 1.31 2015/06/17 00:18:35 christos Exp $ */
+/* $NetBSD: segwrite.c,v 1.32 2015/07/24 06:56:41 dholland Exp $ */
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
  * All rights reserved.
@@ -164,7 +164,7 @@
 		vp = fs->lfs_ivnode;
 		fs->lfs_flags &= ~LFS_IFDIRTY;
 		ip = VTOI(vp);
-		if (LIST_FIRST(&vp->v_dirtyblkhd) != NULL || fs->lfs_idaddr <= 0)
+		if (LIST_FIRST(&vp->v_dirtyblkhd) != NULL || lfs_sb_getidaddr(fs) <= 0)
 			lfs_writefile(fs, sp, vp);
 
 		redo = lfs_writeinode(fs, sp, ip);
@@ -201,7 +201,7 @@
 
 	ip = VTOI(vp);
 
-	if (sp->seg_bytes_left < fs->lfs_bsize ||
+	if (sp->seg_bytes_left < lfs_sb_getbsize(fs) ||
 	    sp->sum_bytes_left < sizeof(struct finfo))
 		(void) lfs_writeseg(fs, sp);
 
@@ -257,8 +257,8 @@
 			(void) lfs_writeseg(fs, sp);
 
 		/* Get next inode block. */
-		daddr = fs->lfs_offset;
-		fs->lfs_offset += lfs_btofsb(fs, fs->lfs_ibsize);
+		daddr = lfs_sb_getoffset(fs);
+		lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
 		sp->ibp = *sp->cbpp++ =
 		    getblk(fs->lfs_devvp, LFS_FSBTODB(fs, daddr),
 		    fs->lfs_ibsize);
@@ -270,11 +270,11 @@
 			((struct ulfs1_dinode *) sp->ibp->b_data)[i].di_inumber = 0;
 
 		++sp->start_bpp;
-		fs->lfs_avail -= lfs_btofsb(fs, fs->lfs_ibsize);
+		lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
 		/* Set remaining space counters. */
-		sp->seg_bytes_left -= fs->lfs_ibsize;
+		sp->seg_bytes_left -= lfs_sb_getibsize(fs);
 		sp->sum_bytes_left -= sizeof(ulfs_daddr_t);
-		ndx = fs->lfs_sumsize / sizeof(ulfs_daddr_t) -
+		ndx = lfs_sb_getsumsize(fs) / sizeof(ulfs_daddr_t) -
 		    sp->ninodes / LFS_INOPB(fs) - 1;
 		((ulfs_daddr_t *) (sp->segsum))[ndx] = daddr;
 	}
@@ -326,8 +326,8 @@
 	 */
 	ino = ip->i_number;
 	if (ino == LFS_IFILE_INUM) {
-		daddr = fs->lfs_idaddr;
-		fs->lfs_idaddr = LFS_DBTOFSB(fs, bp->b_blkno);
+		daddr = lfs_sb_getidaddr(fs);
+		lfs_sb_setidaddr(fs, LFS_DBTOFSB(fs, bp->b_blkno));
 		sbdirty();
 	} else {
 		LFS_IENTRY(ifp, fs, ino, ibp);
@@ -366,7 +366,7 @@
 	 * release and reacquire the splbio().
 	 */
 	fs = sp->fs;
-	blksinblk = howmany(bp->b_bcount, fs->lfs_bsize);
+	blksinblk = howmany(bp->b_bcount, lfs_sb_getbsize(fs));
 	if (sp->sum_bytes_left < sizeof(ulfs_daddr_t) * blksinblk ||
 	    sp->seg_bytes_left < bp->b_bcount) {
 		lfs_updatemeta(sp);
@@ -473,7 +473,7 @@
 		break;
 	default:
 		ap = &a[num - 1];
-		if (bread(vp, ap->in_lbn, fs->lfs_bsize, 0, &bp))
+		if (bread(vp, ap->in_lbn, lfs_sb_getbsize(fs), 0, &bp))
 			errx(EXIT_FAILURE, "%s: bread bno %" PRId64, __func__,
 			    ap->in_lbn);
 
@@ -493,7 +493,7 @@
 		if (lbn >= 0 && lbn < ULFS_NDADDR)
 			osize = ip->i_lfs_fragsize[lbn];
 		else
-			osize = fs->lfs_bsize;
+			osize = lfs_sb_getbsize(fs);
 		LFS_SEGENTRY(sup, fs, oldsn, bp);
 		sup->su_nbytes -= osize;
 		if (!(bp->b_flags & B_GATHERED))
@@ -541,14 +541,14 @@
 			nblocks = i;
 			break;
 		}
-		num = howmany(sp->start_bpp[i]->b_bcount, fs->lfs_bsize);
+		num = howmany(sp->start_bpp[i]->b_bcount, lfs_sb_getbsize(fs));
 		nblocks -= num - 1;
 	}
 
 	/*
 	 * Sort the blocks.
 	 */
-	lfs_shellsort(sp->start_bpp, sp->start_lbp, nblocks, fs->lfs_bsize);
+	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.
@@ -567,7 +567,7 @@
 		sbp = *sp->start_bpp;
 		lbn = *sp->start_lbp;
 
-		sbp->b_blkno = LFS_FSBTODB(fs, fs->lfs_offset);
+		sbp->b_blkno = LFS_FSBTODB(fs, lfs_sb_getoffset(fs));
 
 		/*
 		 * If we write a frag in the wrong place, the cleaner won't
@@ -584,12 +584,12 @@
 		 * update its address on disk.
 		 */
 		for (bytesleft = sbp->b_bcount; bytesleft > 0;
-		    bytesleft -= fs->lfs_bsize) {
-			size = MIN(bytesleft, fs->lfs_bsize);
+		    bytesleft -= lfs_sb_getbsize(fs)) {
+			size = MIN(bytesleft, lfs_sb_getbsize(fs));
 			frags = lfs_numfrags(fs, size);
 			lbn = *sp->start_lbp++;
-			lfs_update_single(fs, sp, lbn, fs->lfs_offset, size);
-			fs->lfs_offset += frags;
+			lfs_update_single(fs, sp, lbn, lfs_sb_getoffset(fs), size);
+			lfs_sb_addoffset(fs, frags);
 		}
 
 	}
@@ -614,14 +614,14 @@
 	/* Advance to the next segment. */
 	if (!LFS_PARTIAL_FITS(fs)) {
 		/* lfs_avail eats the remaining space */
-		fs->lfs_avail -= fs->lfs_fsbpseg - (fs->lfs_offset -
-		    fs->lfs_curseg);
+		lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) -
+		    lfs_sb_getcurseg(fs)));
 		lfs_newseg(fs);
 		repeat = 1;
-		fs->lfs_offset = fs->lfs_curseg;
+		lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
 
-		sp->seg_number = lfs_dtosn(fs, fs->lfs_curseg);
-		sp->seg_bytes_left = lfs_fsbtob(fs, fs->lfs_fsbpseg);
+		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
@@ -629,22 +629,22 @@
 		 */
 		LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
 		if (sup->su_flags & SEGUSE_SUPERBLOCK) {
-			fs->lfs_offset += lfs_btofsb(fs, LFS_SBPAD);
+			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 &&
 		    fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD)) {
-			fs->lfs_offset += lfs_btofsb(fs, LFS_LABELPAD) - fs->lfs_s0addr;
+			lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_LABELPAD) - fs->lfs_s0addr);
 			sp->seg_bytes_left -= LFS_LABELPAD - lfs_fsbtob(fs, fs->lfs_s0addr);
 		}
 	} else {
-		sp->seg_number = lfs_dtosn(fs, fs->lfs_curseg);
-		sp->seg_bytes_left = lfs_fsbtob(fs, fs->lfs_fsbpseg -
-		    (fs->lfs_offset - fs->lfs_curseg));
+		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)));
 	}
-	fs->lfs_lastpseg = fs->lfs_offset;
+	lfs_sb_setlastpseg(fs, lfs_sb_getoffset(fs));
 
 	sp->fs = fs;
 	sp->ibp = NULL;
@@ -655,15 +655,15 @@
 	/* Get a new buffer for SEGSUM and enter it into the buffer list. */
 	sp->cbpp = sp->bpp;
 	sbp = *sp->cbpp = getblk(fs->lfs_devvp,
-	    LFS_FSBTODB(fs, fs->lfs_offset), fs->lfs_sumsize);
+	    LFS_FSBTODB(fs, lfs_sb_getoffset(fs)), lfs_sb_getsumsize(fs));
 	sp->segsum = sbp->b_data;
-	memset(sp->segsum, 0, fs->lfs_sumsize);
+	memset(sp->segsum, 0, lfs_sb_getsumsize(fs));
 	sp->start_bpp = ++sp->cbpp;
-	fs->lfs_offset += lfs_btofsb(fs, fs->lfs_sumsize);
+	lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
 
 	/* Set point to SEGSUM, initialize it. */
 	ssp = sp->segsum;
-	ssp->ss_next = fs->lfs_nextseg;
+	ssp->ss_next = lfs_sb_getnextseg(fs);
 	ssp->ss_nfinfo = ssp->ss_ninos = 0;
 	ssp->ss_magic = SS_MAGIC;
 
@@ -673,8 +673,8 @@
 	sp->start_lbp = &sp->fip->fi_blocks[0];
 	sp->fip->fi_lastlength = 0;
 
-	sp->seg_bytes_left -= fs->lfs_sumsize;
-	sp->sum_bytes_left = fs->lfs_sumsize - SEGSUM_SIZE(fs);
+	sp->seg_bytes_left -= lfs_sb_getsumsize(fs);
+	sp->sum_bytes_left = lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs);
 
 	LFS_LOCK_BUF(sbp);
 	brelse(sbp, 0);
@@ -692,12 +692,12 @@
 	struct ubuf *bp;
 	int curseg, isdirty, sn;
 
-	LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, fs->lfs_nextseg), bp);
+	LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
 	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, fs->lfs_nextseg), bp);
+	LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
 
 	LFS_CLEANERINFO(cip, fs, bp);
 	--cip->clean;
@@ -705,9 +705,9 @@
 	fs->lfs_nclean = cip->clean;
 	LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
 
-	fs->lfs_lastseg = fs->lfs_curseg;
-	fs->lfs_curseg = fs->lfs_nextseg;
-	for (sn = curseg = lfs_dtosn(fs, fs->lfs_curseg) + fs->lfs_interleave;;) {
+	lfs_sb_setlastseg(fs, lfs_sb_getcurseg(fs));
+	lfs_sb_setcurseg(fs, lfs_sb_getnextseg(fs));
+	for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + lfs_sb_getinterleave(fs);;) {
 		sn = (sn + 1) % fs->lfs_nseg;
 		if (sn == curseg)
 			errx(EXIT_FAILURE, "%s: no clean segments", __func__);
@@ -720,7 +720,7 @@
 	}
 
 	++fs->lfs_nactive;
-	fs->lfs_nextseg = lfs_sntod(fs, sn);
+	lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
 }
 
 
@@ -776,9 +776,9 @@
 		sup->su_lastmod = write_time;
 	sup->su_ninos += ninos;
 	++sup->su_nsums;
-	fs->lfs_dmeta += (lfs_btofsb(fs, fs->lfs_sumsize) + lfs_btofsb(fs, ninos *
+	fs->lfs_dmeta += (lfs_btofsb(fs, lfs_sb_getsumsize(fs)) + lfs_btofsb(fs, ninos *
 		fs->lfs_ibsize));
-	fs->lfs_avail -= lfs_btofsb(fs, fs->lfs_sumsize);
+	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 */
@@ -797,7 +797,7 @@
 		++bpp;
 		/* Loop through gop_write cluster blocks */
 		for (byteoffset = 0; byteoffset < (*bpp)->b_bcount;
-		    byteoffset += fs->lfs_bsize) {
+		    byteoffset += lfs_sb_getbsize(fs)) {
 			memcpy(dp, (*bpp)->b_data + byteoffset, el_size);
 			dp += el_size;
 		}
@@ -808,7 +808,8 @@
 		ssp->ss_ocreate = write_time;
 	else {
 		ssp->ss_create = write_time;
-		ssp->ss_serial = ++fs->lfs_serial;
+		lfs_sb_addserial(fs, 1);
+		ssp->ss_serial = lfs_sb_getserial(fs);
 		ssp->ss_ident = fs->lfs_ident;
 	}
 	/* Set the summary block busy too */
@@ -817,11 +818,11 @@
 
 	ssp->ss_datasum = cksum(datap, (nblocks - 1) * el_size);
 	ssp->ss_sumsum =
-	    cksum(&ssp->ss_datasum, fs->lfs_sumsize - sizeof(ssp->ss_sumsum));
+	    cksum(&ssp->ss_datasum, lfs_sb_getsumsize(fs) - sizeof(ssp->ss_sumsum));
 	free(datap);
 	datap = dp = NULL;
-	fs->lfs_bfree -= (lfs_btofsb(fs, ninos * fs->lfs_ibsize) +
-	    lfs_btofsb(fs, fs->lfs_sumsize));
+	lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
+	    lfs_btofsb(fs, lfs_sb_getsumsize(fs))));
 
 	if (devvp == NULL)
 		errx(EXIT_FAILURE, "devvp is NULL");
@@ -893,6 +894,7 @@
 lfs_seglock(struct lfs * fs, unsigned long flags)
 {
 	struct segment *sp;
+	size_t allocsize;
 
 	if (fs->lfs_seglock) {
 		++fs->lfs_seglock;
@@ -902,10 +904,10 @@
 	fs->lfs_seglock = 1;
 
 	sp = fs->lfs_sp = emalloc(sizeof(*sp));
-	sp->bpp = emalloc(fs->lfs_ssize * sizeof(struct ubuf *));
+	allocsize = lfs_sb_getssize(fs) * sizeof(struct ubuf *);
+	sp->bpp = emalloc(allocsize);
 	if (!sp->bpp)
-		err(!preen, "Could not allocate %zu bytes",
-		    (size_t)(fs->lfs_ssize * sizeof(struct ubuf *)));
+		err(!preen, "Could not allocate %zu bytes", allocsize);
 	sp->seg_flags = flags;
 	sp->vp = NULL;
 	sp->seg_iocount = 0;
@@ -929,7 +931,7 @@
 	if (fs->lfs_seglock == 1) {
 		if (sp->bpp != sp->cbpp) {
 			/* Free allocated segment summary */
-			fs->lfs_offset -= lfs_btofsb(fs, fs->lfs_sumsize);
+			lfs_sb_suboffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
 			bp = *sp->bpp;
 			bremfree(bp);
 			bp->b_flags |= B_DONE | B_INVAL;
@@ -997,8 +999,8 @@
 
 	/* Set timestamp of this version of the superblock */
 	if (fs->lfs_version == 1)
-		fs->lfs_otstamp = write_time;
-	fs->lfs_tstamp = write_time;
+		lfs_sb_setotstamp(fs, write_time);
+	lfs_sb_settstamp(fs, write_time);
 
 	/* Checksum the superblock and copy it into a buffer. */
 	fs->lfs_cksum = lfs_sb_cksum(&(fs->lfs_dlfs));

@@ -1,4 +1,4 @@
-/* $NetBSD: segwrite.h,v 1.4 2013/06/06 00:52:50 dholland Exp $ */
+/* $NetBSD: segwrite.h,v 1.5 2015/07/24 06:56:41 dholland Exp $ */
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
  * All rights reserved.
@@ -32,8 +32,8 @@
  * to go on to a new segment.
  */
 #define	LFS_PARTIAL_FITS(fs) \
-	((fs)->lfs_fsbpseg - ((fs)->lfs_offset - (fs)->lfs_curseg) > \
-	(fs)->lfs_frag)
+	(lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)) > \
+	lfs_sb_getfrag(fs))
 
 /* op values to lfs_writevnodes */
 #define	VN_REG		0

@@ -1,4 +1,4 @@
-/* $NetBSD: setup.c,v 1.46 2015/05/31 15:44:30 hannken Exp $ */
+/* $NetBSD: setup.c,v 1.47 2015/07/24 06:56:41 dholland Exp $ */
 
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
@@ -216,7 +216,7 @@
 	}
 
         /* Resize buffer cache now that we have a superblock to guess from. */ 
-        bufrehash((fs->lfs_segtabsz + maxino / fs->lfs_ifpb) << 4);
+        bufrehash((lfs_sb_getsegtabsz(fs) + maxino / lfs_sb_getifpb(fs)) << 4);
 
 	if (fs->lfs_pflags & LFS_PF_CLEAN) {
 		if (doskipclean) {
@@ -249,10 +249,11 @@
 					break;
 			}
 		}
-		fs->lfs_offset = tdaddr;
+		lfs_sb_setoffset(fs, tdaddr);
 		if (debug)
-			pwarn("begin with offset/serial 0x%x/%d\n",
-				(int)fs->lfs_offset, (int)fs->lfs_serial);
+			pwarn("begin with offset/serial 0x%jx/%jd\n",
+				(uintmax_t)lfs_sb_getoffset(fs),
+				(intmax_t)lfs_sb_getserial(fs));
 		while (tdaddr < idaddr) {
 			bread(fs->lfs_devvp, LFS_FSBTODB(fs, tdaddr),
 			      fs->lfs_sumsize,
@@ -278,8 +279,8 @@
 			}
 
 			tdaddr += lfs_btofsb(fs, bc) + 1;
-			fs->lfs_offset = tdaddr;
-			fs->lfs_serial = sp->ss_serial + 1;
+			lfs_sb_setoffset(fs, tdaddr);
+			lfs_sb_setserial(fs, sp->ss_serial + 1);
 			brelse(bp, 0);
 		}
 
@@ -287,8 +288,8 @@
 		 * Set curseg, nextseg appropriately -- inlined from
 		 * lfs_newseg()
 		 */
-		curseg = lfs_dtosn(fs, fs->lfs_offset);
-		fs->lfs_curseg = lfs_sntod(fs, curseg);
+		curseg = lfs_dtosn(fs, lfs_sb_getoffset(fs));
+		lfs_sb_setcurseg(fs, lfs_sntod(fs, curseg));
 		for (sn = curseg + fs->lfs_interleave;;) {  
 			sn = (sn + 1) % fs->lfs_nseg;
 			if (sn == curseg)
@@ -303,62 +304,62 @@
 
 		/* Skip superblock if necessary */
 		for (i = 0; i < LFS_MAXNUMSB; i++)
-			if (fs->lfs_offset == fs->lfs_sboffs[i])
-				fs->lfs_offset += lfs_btofsb(fs, LFS_SBPAD);
+			if (lfs_sb_getoffset(fs) == fs->lfs_sboffs[i])
+				lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_SBPAD));
 
 		++fs->lfs_nactive;
-		fs->lfs_nextseg = lfs_sntod(fs, sn);
+		lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
 		if (debug) {
-			pwarn("offset = 0x%" PRIx32 ", serial = %" PRId64 "\n",
-				fs->lfs_offset, fs->lfs_serial);
+			pwarn("offset = 0x%" PRIx32 ", serial = %" PRIu64 "\n",
+				lfs_sb_getoffset(fs), lfs_sb_getserial(fs));
 			pwarn("curseg = %" PRIx32 ", nextseg = %" PRIx32 "\n",
-				fs->lfs_curseg, fs->lfs_nextseg);
+				lfs_sb_getcurseg(fs), lfs_sb_getnextseg(fs));
 		}
 
 		if (!nflag && !skipclean) {
-			fs->lfs_idaddr = idaddr;
+			lfs_sb_setidaddr(fs, idaddr);
 			fsmodified = 1;
 			sbdirty();
 		}
 	}
 
 	if (debug) {
-		pwarn("idaddr    = 0x%lx\n", idaddr ? (unsigned long)idaddr :
-			(unsigned long)fs->lfs_idaddr);
+		pwarn("idaddr    = 0x%jx\n", idaddr ? (uintmax_t)idaddr :
+			(uintmax_t)lfs_sb_getidaddr(fs));
 		pwarn("dev_bsize = %lu\n", dev_bsize);
-		pwarn("lfs_bsize = %lu\n", (unsigned long) fs->lfs_bsize);
-		pwarn("lfs_fsize = %lu\n", (unsigned long) fs->lfs_fsize);
-		pwarn("lfs_frag  = %lu\n", (unsigned long) fs->lfs_frag);
+		pwarn("lfs_bsize = %lu\n", (unsigned long) lfs_sb_getbsize(fs));
+		pwarn("lfs_fsize = %lu\n", (unsigned long) lfs_sb_getfsize(fs));
+		pwarn("lfs_frag  = %lu\n", (unsigned long) lfs_sb_getfrag(fs));
 		pwarn("lfs_inopb = %lu\n", (unsigned long) fs->lfs_inopb);
 	}
 	if (fs->lfs_version == 1)
-		maxfsblock = fs->lfs_size * (fs->lfs_bsize / dev_bsize);
+		maxfsblock = lfs_sb_getsize(fs) * (lfs_sb_getbsize(fs) / dev_bsize);
 	else
-		maxfsblock = fs->lfs_size;
+		maxfsblock = lfs_sb_getsize(fs);
 	maxfilesize = calcmaxfilesize(fs->lfs_bshift);
-	if (/* fs->lfs_minfree < 0 || */ fs->lfs_minfree > 99) {
-		pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
-		    fs->lfs_minfree);
+	if (/* lfs_sb_getminfree(fs) < 0 || */ lfs_sb_getminfree(fs) > 99) {
+		pfatal("IMPOSSIBLE MINFREE=%u IN SUPERBLOCK",
+		    lfs_sb_getminfree(fs));
 		if (reply("SET TO DEFAULT") == 1) {
-			fs->lfs_minfree = 10;
+			lfs_sb_setminfree(fs, 10);
 			sbdirty();
 		}
 	}
-	if (fs->lfs_bmask != fs->lfs_bsize - 1) {
+	if (fs->lfs_bmask != lfs_sb_getbsize(fs) - 1) {
 		pwarn("INCORRECT BMASK=0x%x IN SUPERBLOCK (SHOULD BE 0x%x)",
 		    (unsigned int) fs->lfs_bmask,
-		    (unsigned int) fs->lfs_bsize - 1);
-		fs->lfs_bmask = fs->lfs_bsize - 1;
+		    (unsigned int) lfs_sb_getbsize(fs) - 1);
+		fs->lfs_bmask = lfs_sb_getbsize(fs) - 1;
 		if (preen)
 			printf(" (FIXED)\n");
 		if (preen || reply("FIX") == 1) {
 			sbdirty();
 		}
 	}
-	if (fs->lfs_ffmask != fs->lfs_fsize - 1) {
+	if (fs->lfs_ffmask != lfs_sb_getfsize(fs) - 1) {
 		pwarn("INCORRECT FFMASK=%" PRId64 " IN SUPERBLOCK",
 		    fs->lfs_ffmask);
-		fs->lfs_ffmask = fs->lfs_fsize - 1;
+		fs->lfs_ffmask = lfs_sb_getfsize(fs) - 1;
 		if (preen)
 			printf(" (FIXED)\n");
 		if (preen || reply("FIX") == 1) {
@@ -406,12 +407,12 @@
 	 * 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;
+	maxino = ((VTOI(ivp)->i_ffs1_size - (lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs))
+		* lfs_sb_getbsize(fs)) / lfs_sb_getbsize(fs)) * lfs_sb_getifpb(fs);
 	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, 0, &bp);
+	for (i = 0; i < VTOI(ivp)->i_ffs1_size; i += lfs_sb_getbsize(fs)) {
+		bread(ivp, i >> fs->lfs_bshift, lfs_sb_getbsize(fs), 0, &bp);
 		/* XXX check B_ERROR */
 		brelse(bp, 0);
 	}
@@ -431,8 +432,8 @@
 	}
 
 	/* Initialize Ifile entry */
-	din_table[fs->lfs_ifile] = fs->lfs_idaddr;
-	seg_table[lfs_dtosn(fs, fs->lfs_idaddr)].su_nbytes += LFS_DINODE1_SIZE;
+	din_table[lfs_sb_getifile(fs)] = lfs_sb_getidaddr(fs);
+	seg_table[lfs_dtosn(fs, lfs_sb_getidaddr(fs))].su_nbytes += LFS_DINODE1_SIZE;
 
 #ifndef VERBOSE_BLOCKMAP
 	bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));
@@ -446,8 +447,8 @@
 	lncntp = ecalloc(maxino, sizeof(int16_t));
 
 	if (preen) {
-		n_files = fs->lfs_nfiles;
-		n_blks  = fs->lfs_dsize - fs->lfs_bfree;
+		n_files = lfs_sb_getnfiles(fs);
+		n_blks  = lfs_sb_getdsize(fs) - lfs_sb_getbfree(fs);
 		numdirs = maxino;
 		inplast = 0; 
 		listmax = numdirs + 10;

@@ -1,4 +1,4 @@
-/*	$NetBSD: make_lfs.c,v 1.31 2015/05/31 15:44:31 hannken Exp $	*/
+/*	$NetBSD: make_lfs.c,v 1.32 2015/07/24 06:56:41 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.31 2015/05/31 15:44:31 hannken Exp $");
+__RCSID("$NetBSD: make_lfs.c,v 1.32 2015/07/24 06:56:41 dholland Exp $");
 #endif
 #endif /* not lint */
 
@@ -224,15 +224,15 @@
 	int i;
 	int nblocks, bb, base, factor, lvl;
 
-	nblocks = howmany(nfrags, fs->lfs_frag);
+	nblocks = howmany(nfrags, lfs_sb_getfrag(fs));
 	if (nblocks >= ULFS_NDADDR)
-		nfrags = roundup(nfrags, fs->lfs_frag);
+		nfrags = roundup(nfrags, lfs_sb_getfrag(fs));
 
 	dip->di_nlink = 1;
 	dip->di_blocks = nfrags;
 
 	dip->di_size = (nfrags << fs->lfs_ffshift);
-	dip->di_atime = dip->di_mtime = dip->di_ctime = fs->lfs_tstamp;
+	dip->di_atime = dip->di_mtime = dip->di_ctime = lfs_sb_gettstamp(fs);
 	dip->di_atimensec = dip->di_mtimensec = dip->di_ctimensec = 0;
 	dip->di_inumber = ino;
 	dip->di_gen = 1;
@@ -321,6 +321,7 @@
 	struct uvnode *vp, *save_devvp;
 	int bb, ubb, dmeta, labelskew;
 	u_int64_t tsepb, tnseg;
+	time_t stamp;
 
 	/*
 	 * Initialize buffer cache.  Use a ballpark guess of the length of
@@ -402,17 +403,17 @@
 		fs->lfs_bshift = lfs_log2(bsize);
 		if (1 << fs->lfs_bshift != bsize)
 			fatal("%d: block size not a power of 2", bsize);
-		fs->lfs_bsize = bsize;
-		fs->lfs_fsize = fsize;
+		lfs_sb_setbsize(fs, bsize);
+		lfs_sb_setfsize(fs, fsize);
 		fs->lfs_bmask = bsize - 1;
 		fs->lfs_ffmask = fsize - 1;
 		fs->lfs_ffshift = lfs_log2(fsize);
 		if (1 << fs->lfs_ffshift != fsize)
 			fatal("%d: frag size not a power of 2", fsize);
-		fs->lfs_frag = lfs_numfrags(fs, bsize);
-		fs->lfs_fbmask = fs->lfs_frag - 1;
-		fs->lfs_fbshift = lfs_log2(fs->lfs_frag);
-		fs->lfs_ifpb = bsize / sizeof(IFILE);
+		lfs_sb_setfrag(fs, lfs_numfrags(fs, bsize));
+		fs->lfs_fbmask = lfs_sb_getfrag(fs) - 1;
+		fs->lfs_fbshift = lfs_log2(lfs_sb_getfrag(fs));
+		lfs_sb_setifpb(fs, bsize / sizeof(IFILE));
 		/* XXX ondisk32 */
 		fs->lfs_nindir = bsize / sizeof(int32_t);
 	}
@@ -423,10 +424,10 @@
 		if (1 << fs->lfs_segshift != ssize)
 			fatal("%d: segment size not power of 2", ssize);
 		fs->lfs_segmask = ssize - 1;
-		fs->lfs_ifpb = fs->lfs_bsize / sizeof(IFILE_V1);
-		fs->lfs_ibsize = fs->lfs_bsize;
-		fs->lfs_sepb = bsize / sizeof(SEGUSE_V1);
-		fs->lfs_ssize = ssize >> fs->lfs_bshift;
+		lfs_sb_setifpb(fs, lfs_sb_getbsize(fs) / sizeof(IFILE_V1));
+		lfs_sb_setibsize(fs, lfs_sb_getbsize(fs));
+		lfs_sb_setsepb(fs, bsize / sizeof(SEGUSE_V1));
+		lfs_sb_setssize(fs, ssize >> fs->lfs_bshift);
 	} else {
 		if (ssize % fsize) {
 			fprintf(stderr, 
@@ -439,15 +440,15 @@
 		fs->lfs_sumsize = fsize;
 		fs->lfs_segshift = 0;
 		fs->lfs_segmask = 0;
-		fs->lfs_sepb = bsize / sizeof(SEGUSE);
-		fs->lfs_ssize = ssize;
-		fs->lfs_ibsize = ibsize;
+		lfs_sb_setsepb(fs, bsize / sizeof(SEGUSE));
+		lfs_sb_setssize(fs, ssize);
+		lfs_sb_setibsize(fs, ibsize);
 	}
 	fs->lfs_inopb = fs->lfs_ibsize / sizeof(struct ulfs1_dinode);
-	fs->lfs_minfree = minfree;
+	lfs_sb_setminfree(fs, minfree);
 
 	if (version > 1) {
-		fs->lfs_inopf = secsize/LFS_DINODE1_SIZE;
+		lfs_sb_setinopf(fs, secsize/LFS_DINODE1_SIZE);
 		fs->lfs_interleave = interleave;
 		if (roll_id == 0)
 			roll_id = arc4random();
@@ -457,22 +458,25 @@
 	/*
 	 * Fill in parts of superblock that can be computed from file system
 	 * size, disk geometry and current time.
+	 *
+	 * XXX: this seems to set dlfs_size wrong for version 1... as in,
+	 * sets it and then overwrites it.
 	 */
 	db_per_blk = bsize/secsize;
 	fs->lfs_blktodb = lfs_log2(db_per_blk);
 	fs->lfs_fsbtodb = lfs_log2(fsize / secsize);
 	if (version == 1) {
-		fs->lfs_sushift = lfs_log2(fs->lfs_sepb);
+		fs->lfs_sushift = lfs_log2(lfs_sb_getsepb(fs));
 		fs->lfs_fsbtodb = 0;
-		fs->lfs_size = dkw->dkw_size >> fs->lfs_blktodb;
+		lfs_sb_setsize(fs, dkw->dkw_size >> fs->lfs_blktodb);
 	}
 	label_fsb = lfs_btofsb(fs, roundup(LFS_LABELPAD, fsize));
 	sb_fsb = lfs_btofsb(fs, roundup(LFS_SBPAD, fsize));
 	fs->lfs_fsbpseg = LFS_DBTOFSB(fs, ssize / secsize);
-	fs->lfs_size = dkw->dkw_size >> fs->lfs_fsbtodb;
-	fs->lfs_dsize = LFS_DBTOFSB(fs, dkw->dkw_size) -
-		MAX(label_fsb, LFS_DBTOFSB(fs, start));
-	fs->lfs_nseg = fs->lfs_dsize / lfs_segtod(fs, 1);
+	lfs_sb_setsize(fs, dkw->dkw_size >> fs->lfs_fsbtodb);
+	lfs_sb_setdsize(fs, LFS_DBTOFSB(fs, dkw->dkw_size) -
+		MAX(label_fsb, LFS_DBTOFSB(fs, start)));
+	fs->lfs_nseg = lfs_sb_getdsize(fs) / lfs_segtod(fs, 1);
 
 	fs->lfs_nclean = fs->lfs_nseg - 1;
 	fs->lfs_maxfilesize = maxfilesize(fs->lfs_bshift);
@@ -511,7 +515,7 @@
 		}
 		fatal("Could not allocate enough segments with segment "
 			"size %d and block size %d;\nplease decrease the "
-			"segment size.\n", ssize, fs->lfs_bsize);
+			"segment size.\n", ssize, lfs_sb_getbsize(fs));
 	}
 	if(warned_segtoobig)
 		fprintf(stderr,"Using segment size %d, block size %d, frag size %d.\n", ssize, bsize, fsize);
@@ -538,18 +542,19 @@
 	 * and segment usage table, and half a block per segment that can't
 	 * be written due to fragmentation.
 	 */
-	fs->lfs_dsize = (fs->lfs_nseg - fs->lfs_minfreeseg) *
-		lfs_segtod(fs, 1);
-	fs->lfs_bfree = fs->lfs_dsize;
-	fs->lfs_bfree -= LFS_DBTOFSB(fs, ((fs->lfs_nseg / 2) << 
-		fs->lfs_blktodb));
+	lfs_sb_setdsize(fs, (fs->lfs_nseg - fs->lfs_minfreeseg) *
+		lfs_segtod(fs, 1));
+	lfs_sb_setbfree(fs, lfs_sb_getdsize(fs));
+	lfs_sb_subbfree(fs, LFS_DBTOFSB(fs, ((lfs_sb_getnseg(fs) / 2) << 
+		lfs_sb_getblktodb(fs))));
 
-	fs->lfs_segtabsz = SEGTABSIZE_SU(fs);
-	fs->lfs_cleansz = CLEANSIZE_SU(fs);
-	if ((fs->lfs_tstamp = time(NULL)) == -1)
+	lfs_sb_setsegtabsz(fs, SEGTABSIZE_SU(fs));
+	lfs_sb_setcleansz(fs, CLEANSIZE_SU(fs));
+	if (time(&stamp) == -1)
 		fatal("time: %s", strerror(errno));
+	lfs_sb_settstamp(fs, stamp);
 	if (version == 1)
-		fs->lfs_otstamp = fs->lfs_tstamp;
+		lfs_sb_setotstamp(fs, stamp);
 
 	if ((sb_interval = fs->lfs_nseg / LFS_MAXNUMSB) < LFS_MIN_SBINTERVAL)
 		sb_interval = LFS_MIN_SBINTERVAL;
@@ -576,7 +581,7 @@
 		fs->lfs_s0addr = fs->lfs_sboffs[0];
 	else
 		fs->lfs_s0addr = LFS_DBTOFSB(fs, start);
-        fs->lfs_dsize -= sb_fsb;
+        lfs_sb_setdsize(fs, lfs_sb_getdsize(fs) - sb_fsb);
 	for (i = 1; i < LFS_MAXNUMSB; i++) {
 		sb_addr = ((i * sb_interval) * lfs_segtod(fs, 1))
 		    + fs->lfs_sboffs[0];
@@ -587,7 +592,7 @@
 		    >= LFS_DBTOFSB(fs, dkw->dkw_size))
 			break;
 		fs->lfs_sboffs[i] = sb_addr;
-		fs->lfs_dsize -= sb_fsb;
+		lfs_sb_setdsize(fs, lfs_sb_getdsize(fs) - sb_fsb);
 	}
 
 	/* We need >= 2 superblocks */
@@ -596,10 +601,10 @@
 		      "superblock.\nPlease decrease the segment size.\n");
 	}
 
-	fs->lfs_lastseg = lfs_sntod(fs, fs->lfs_nseg - 2);
-	fs->lfs_curseg = lfs_sntod(fs, fs->lfs_nseg - 1);
-	fs->lfs_offset = lfs_sntod(fs, fs->lfs_nseg);
-	fs->lfs_nextseg = lfs_sntod(fs, 0);
+	lfs_sb_setlastseg(fs, lfs_sntod(fs, lfs_sb_getnseg(fs) - 2));
+	lfs_sb_setcurseg(fs, lfs_sntod(fs, lfs_sb_getnseg(fs) - 1));
+	lfs_sb_setoffset(fs, lfs_sntod(fs, lfs_sb_getnseg(fs)));
+	lfs_sb_setnextseg(fs, lfs_sntod(fs, 0));
 
 	/*
 	 * Initialize the Ifile inode.  Do this before we do anything
@@ -613,10 +618,10 @@
 	dip->di_mode  = LFS_IFREG | 0600;
 	dip->di_flags = SF_IMMUTABLE;
 	make_dinode(LFS_IFILE_INUM, dip,
-		lfs_blkstofrags(fs, fs->lfs_cleansz + fs->lfs_segtabsz + 1), fs);
-	dip->di_size = (fs->lfs_cleansz + fs->lfs_segtabsz + 1) << fs->lfs_bshift;
+		lfs_blkstofrags(fs, lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs) + 1), fs);
+	dip->di_size = (lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs) + 1) << fs->lfs_bshift;
 	for (i = 0; i < ULFS_NDADDR && i < (dip->di_size >> fs->lfs_bshift); i++)
-		VTOI(fs->lfs_ivnode)->i_lfs_fragsize[i] = fs->lfs_bsize;
+		VTOI(fs->lfs_ivnode)->i_lfs_fragsize[i] = lfs_sb_getbsize(fs);
 
 	/*
 	 * Set up in-superblock segment usage cache
@@ -639,7 +644,7 @@
 	cip->dirty = 0;
 	if (version > 1) {
 		cip->free_head = HIGHEST_USED_INO + 1;
-		cip->free_tail = fs->lfs_ifpb - 1;
+		cip->free_tail = lfs_sb_getifpb(fs) - 1;
 	}
 	LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
 
@@ -652,13 +657,13 @@
 		if (i == 0 &&
 		    fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD + LFS_SBPAD)) {
 			segp->su_flags = SEGUSE_SUPERBLOCK;
-			fs->lfs_bfree -= sb_fsb;
+			lfs_sb_subbfree(fs, sb_fsb);
 			++j;
 		}
 		if (i > 0) { 
 			if ((i % sb_interval) == 0 && j < LFS_MAXNUMSB) {
 				segp->su_flags = SEGUSE_SUPERBLOCK;
-				fs->lfs_bfree -= sb_fsb;
+				lfs_sb_subbfree(fs, sb_fsb);
 				++j;
 			} else
 				segp->su_flags = 0;
@@ -674,7 +679,7 @@
 	/* Initialize root directory */
 	vp = lfs_raw_vget(fs, ULFS_ROOTINO, devfd, 0x0);
 	dip = VTOI(vp)->i_din.ffs1_din;
-	make_dinode(ULFS_ROOTINO, dip, howmany(LFS_DIRBLKSIZ,fs->lfs_fsize), fs);
+	make_dinode(ULFS_ROOTINO, dip, howmany(LFS_DIRBLKSIZ, lfs_sb_getfsize(fs)), fs);
 	dip->di_mode = LFS_IFDIR | UMASK;
 	VTOI(vp)->i_lfs_osize = dip->di_size = LFS_DIRBLKSIZ;
 #ifdef MAKE_LF_DIR
@@ -683,13 +688,13 @@
 	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)
+		lfs_btofsb(fs, roundup(LFS_DIRBLKSIZ, lfs_sb_getfsize(fs)));
+	for (i = 0; i < ULFS_NDADDR && i < howmany(LFS_DIRBLKSIZ, lfs_sb_getbsize(fs)); i++)
+		VTOI(vp)->i_lfs_fragsize[i] = lfs_sb_getbsize(fs);
+	if (LFS_DIRBLKSIZ < lfs_sb_getbsize(fs))
 		VTOI(vp)->i_lfs_fragsize[i - 1] =
-			roundup(LFS_DIRBLKSIZ,fs->lfs_fsize);
-	bread(vp, 0, fs->lfs_fsize, 0, &bp);
+			roundup(LFS_DIRBLKSIZ, lfs_sb_getfsize(fs));
+	bread(vp, 0, lfs_sb_getfsize(fs), 0, &bp);
 	make_dir(bp->b_data, lfs_root_dir, 
 		 sizeof(lfs_root_dir) / sizeof(struct lfs_direct));
 	VOP_BWRITE(bp);
@@ -704,9 +709,9 @@
         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)
+	for (i = 0; i < ULFS_NDADDR && i < howmany(DIRBLKSIZ, lfs_sb_getbsize(fs)); i++)
+		VTOI(vp)->i_lfs_fragsize[i] = lfs_sb_getbsize(fs);
+	if (DIRBLKSIZ < lfs_sb_getbsize(fs))
 		VTOI(vp)->i_lfs_fragsize[i - 1] =
 			roundup(DIRBLKSIZ,fs->lfs_fsize);
 	bread(vp, 0, fs->lfs_fsize, 0, &bp);
@@ -736,7 +741,7 @@
 	/* Link remaining IFILE entries in free list */
 	if (version == 1) {
 		for (;
-		     i < fs->lfs_ifpb; ++ip_v1) {
+		     i < lfs_sb_getifpb(fs); ++ip_v1) {
 			ip_v1->if_version = 1;
 			ip_v1->if_daddr = LFS_UNUSED_DADDR;
 			ip_v1->if_nextfree = ++i;
@@ -745,7 +750,7 @@
 		ip_v1->if_nextfree = LFS_UNUSED_INUM;
 	} else {
 		for (;
-		     i < fs->lfs_ifpb; ++ip) {
+		     i < lfs_sb_getifpb(fs); ++ip) {
 			ip->if_version = 1;
 			ip->if_daddr = LFS_UNUSED_DADDR;
 			ip->if_nextfree = ++i;
@@ -763,7 +768,7 @@
 	 * Now that we've written everything, look to see what's available
 	 * for writing.
 	 */
-	fs->lfs_avail = 0;
+	lfs_sb_setavail(fs, 0);
 	bb = ubb = dmeta = 0;
 	for (i = 0; i < fs->lfs_nseg; i++) {
 		LFS_SEGENTRY(segp, fs, i, bp);
@@ -778,31 +783,31 @@
                         dmeta += lfs_btofsb(fs,
                             fs->lfs_ibsize * segp->su_ninos);
 		} else {
-                        fs->lfs_avail += lfs_segtod(fs, 1);
+                        lfs_sb_addavail(fs, lfs_segtod(fs, 1));
                         if (segp->su_flags & SEGUSE_SUPERBLOCK)
-                                fs->lfs_avail -= lfs_btofsb(fs, LFS_SBPAD);
+                                lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_SBPAD));
                         if (i == 0 && fs->lfs_version > 1 &&
                             fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD))
-                                fs->lfs_avail -= lfs_btofsb(fs, LFS_LABELPAD) -
-                                    fs->lfs_s0addr;
+                                lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_LABELPAD) -
+                                    fs->lfs_s0addr);
                 }
 		brelse(bp, 0);
         }
         /* Also may be available bytes in current seg */
-        i = lfs_dtosn(fs, fs->lfs_offset);
-        fs->lfs_avail += lfs_sntod(fs, i + 1) - fs->lfs_offset;
+        i = lfs_dtosn(fs, lfs_sb_getoffset(fs));
+        lfs_sb_addavail(fs, lfs_sntod(fs, i + 1) - lfs_sb_getoffset(fs));
         /* But do not count minfreesegs */
-        fs->lfs_avail -= lfs_segtod(fs, (fs->lfs_minfreeseg - (fs->lfs_minfreeseg / 2)));
+        lfs_sb_subavail(fs, lfs_segtod(fs, (fs->lfs_minfreeseg - (fs->lfs_minfreeseg / 2))));
 
         labelskew = 0;
         if (fs->lfs_version > 1 && fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD))
                 labelskew = lfs_btofsb(fs, LFS_LABELPAD);
-        fs->lfs_bfree = fs->lfs_dsize - labelskew - (ubb + bb) / 2;
+        lfs_sb_setbfree(fs, lfs_sb_getdsize(fs) - labelskew - (ubb + bb) / 2);
 
 	/* Put that in the Ifile version too, and write it */
 	LFS_CLEANERINFO(cip, fs, bp);
-	cip->bfree = fs->lfs_bfree;
-	cip->avail = fs->lfs_avail;
+	cip->bfree = lfs_sb_getbfree(fs);
+	cip->avail = lfs_sb_getavail(fs);
 	LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
 	if (!Nflag)
 		lfs_segwrite(fs, SEGM_CKP);
@@ -831,7 +836,7 @@
 
 		/* Leave the time stamp on the alt sb, zero the rest */
 		if (i == 2) {
-			fs->lfs_tstamp = 0;
+			lfs_sb_settstamp(fs, 0);
 			fs->lfs_cksum = lfs_sb_cksum(&(fs->lfs_dlfs));
 		}
 		if (!Nflag)

@@ -1,4 +1,4 @@
-/*	$NetBSD: resize_lfs.c,v 1.9 2014/03/23 05:38:14 dholland Exp $	*/
+/*	$NetBSD: resize_lfs.c,v 1.10 2015/07/24 06:56:41 dholland Exp $	*/
 /*-
  * Copyright (c) 2005 The NetBSD Foundation, Inc.
  * All rights reserved.
@@ -134,7 +134,7 @@
 	close(devfd);
 
 	/* Calculate new number of segments. */
-	newnsegs = (newsize * secsize) / fs->lfs_ssize;
+	newnsegs = (newsize * secsize) / lfs_sb_getssize(fs);
 	if (newnsegs == fs->lfs_nseg) {
 		errx(0, "the filesystem is unchanged.");
 	}

@@ -1,4 +1,4 @@
-/* $NetBSD: scan_ffs.c,v 1.25 2013/06/23 22:03:34 dholland Exp $ */
+/* $NetBSD: scan_ffs.c,v 1.26 2015/07/24 06:56:42 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.25 2013/06/23 22:03:34 dholland Exp $");
+__RCSID("$NetBSD: scan_ffs.c,v 1.26 2015/07/24 06:56:42 dholland Exp $");
 #endif /* not lint */
 
 #include <sys/types.h>
@@ -249,17 +249,18 @@
 {
 	if (flags & VERBOSE)
                	(void)printf("offset: %" PRIu64 " size %" PRIu32
-			" fsid %" PRIx32 "\n", sbi->lfs_off, sbi->lfs->lfs_size,
+			" fsid %" PRIx32 "\n", sbi->lfs_off,
+			lfs_sb_getsize(sbi->lfs),
 			sbi->lfs->lfs_ident);
 	switch (flag) {
 	case LABELS:
 		(void)printf("X:  %9" PRIu64,
-               		(uint64_t)(sbi->lfs->lfs_size *
-               		sbi->lfs->lfs_fsize / 512));
+               		(uint64_t)(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",
-			sbi->lfs->lfs_fsize, sbi->lfs->lfs_bsize,
-			sbi->lfs->lfs_nseg, sbi->lfs_path, 
+			lfs_sb_getfsize(sbi->lfs), lfs_sb_getbsize(sbi->lfs),
+			lfs_sb_getnseg(sbi->lfs), sbi->lfs_path, 
 			sbi->lfs->lfs_version);
 		break;
 	case BLOCKS:
@@ -267,15 +268,15 @@
 		(void)printf(" sb at %" PRIu64, sbi->lfs_off + btodb(LFS_LABELPAD));
 		(void)printf(" fsid %" PRIx32, sbi->lfs->lfs_ident);
 		(void)printf(" size %" PRIu64 ", last mounted on %s\n",
-			(uint64_t)(sbi->lfs->lfs_size *
-			sbi->lfs->lfs_fsize / 512), sbi->lfs_path);
+			(uint64_t)(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)(sbi->lfs->lfs_size *
-			sbi->lfs->lfs_fsize / 512), sbi->lfs_path);
+			(uint64_t)(lfs_sb_getsize(sbi->lfs) *
+			lfs_sb_getfsize(sbi->lfs) / 512), sbi->lfs_path);
 		break;
 	}
 }

@@ -1,4 +1,4 @@
-/* $NetBSD: lfsv1.c,v 1.10 2015/07/24 06:53:24 dholland Exp $ */
+/* $NetBSD: lfsv1.c,v 1.11 2015/07/24 06:56:42 dholland Exp $ */
 
 #define	LIBSA_LFS
 #define	REQUIRED_LFS_VERSION	1
@@ -15,12 +15,12 @@
 
 #define ufs_dinode		ulfs1_dinode
 
-#define	fs_bsize		dlfs_ibsize
+#define	fs_bsize		lfs_dlfs.dlfs_ibsize
 #define	IFILE_Vx		IFILE_V1
 
 #define	INOPBx(fs) LFS_INOPB(fs)
 
-#define UFS_NINDIR(fs)		((fs)->dlfs_nindir)
+#define UFS_NINDIR		LFS_NINDIR
 #define ufs_blkoff(a, b)	lfs_blkoff((a), (b))
 #define ufs_lblkno(a, b)	lfs_lblkno((a), (b))
 #define dblksize(a, b, c)	lfs_dblksize((a), (b), (c))

@@ -1,4 +1,4 @@
-/* $NetBSD: lfsv2.c,v 1.10 2015/07/24 06:53:24 dholland Exp $ */
+/* $NetBSD: lfsv2.c,v 1.11 2015/07/24 06:56:42 dholland Exp $ */
 
 #define	LIBSA_LFS
 #define	REQUIRED_LFS_VERSION	2
@@ -16,7 +16,7 @@
 /* XXX wrong! but for now it won't build with ulfs2_dinode */
 #define ufs_dinode		ulfs1_dinode
 
-#define	fs_bsize		dlfs_bsize
+#define	fs_bsize		lfs_dlfs.dlfs_bsize
 #define	IFILE_Vx		IFILE
 
 #ifdef LFS_IFILE_FRAG_ADDRESSING	/* XXX see sys/ufs/lfs/ -- not tested */
@@ -25,7 +25,7 @@
 #define	INOPBx(fs) LFS_INOPB(fs)
 #endif
 
-#define UFS_NINDIR(fs)		((fs)->dlfs_nindir)
+#define UFS_NINDIR		LFS_NINDIR
 #define ufs_blkoff(a, b)	lfs_blkoff((a), (b))
 #define ufs_lblkno(a, b)	lfs_lblkno((a), (b))
 #define dblksize(a, b, c)	lfs_dblksize((a), (b), (c))

@@ -1,4 +1,4 @@
-/*	$NetBSD: ufs.c,v 1.66 2015/07/24 06:53:24 dholland Exp $	*/
+/*	$NetBSD: ufs.c,v 1.67 2015/07/24 06:56:42 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1993
@@ -70,6 +70,7 @@
 #include <sys/queue.h>
 #include <sys/condvar.h>
 #include <sys/mount.h>			/* XXX for MNAMELEN */
+#define STRUCT_LFS struct salfs
 #include <ufs/lfs/lfs.h>
 #else
 #include <ufs/ffs/fs.h>
@@ -102,35 +103,12 @@
 #ifdef LIBSA_LFS
 /*
  * In-core LFS superblock - just the on-disk one.
+ * XXX: struct salfs is currently in lfs.h
  */
-typedef struct dlfs FS;
-#define fs_magic	dlfs_magic
-#define fs_maxsymlinklen dlfs_maxsymlinklen
+typedef struct salfs FS;
+#define fs_magic	lfs_dlfs.dlfs_magic
+#define fs_maxsymlinklen lfs_dlfs.dlfs_maxsymlinklen
 
-/* XXX these will go away in the near future */
-#undef lfs_bmask
-#define lfs_bmask dlfs_bmask
-#undef lfs_ifile
-#define lfs_ifile dlfs_ifile
-#undef lfs_ifpb
-#define lfs_ifpb dlfs_ifpb
-#undef lfs_cleansz
-#define lfs_cleansz dlfs_cleansz
-#undef lfs_segtabsz
-#define lfs_segtabsz dlfs_segtabsz
-#undef lfs_idaddr
-#define lfs_idaddr dlfs_idaddr
-#undef lfs_inopb
-#define lfs_inopb dlfs_inopb
-#undef lfs_bshift
-#define lfs_bshift dlfs_bshift
-#undef lfs_bsize
-#define lfs_bsize dlfs_bsize
-#undef lfs_ffmask
-#define lfs_ffmask dlfs_ffmask
-#undef lfs_fsbtodb
-#define lfs_fsbtodb dlfs_fsbtodb
-
 #define FS_MAGIC	LFS_MAGIC
 #define SBLOCKSIZE	LFS_SBPAD
 #define SBLOCKOFFSET	LFS_LABELPAD
@@ -227,14 +205,14 @@
 	size_t buf_after_ent;
 	int rc;
 
-	rc = read_inode(fs->lfs_ifile, f);
+	rc = read_inode(lfs_sb_getifile(fs), f);
 	if (rc)
 		return rc;
 
 	ifileent_blkno =
-	    (inumber / fs->lfs_ifpb) + fs->lfs_cleansz + fs->lfs_segtabsz;
-	fp->f_seekp = (off_t)ifileent_blkno * fs->fs_bsize +
-	    (inumber % fs->lfs_ifpb) * sizeof (IFILE_Vx);
+	    (inumber / lfs_sb_getifpb(fs)) + lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs);
+	fp->f_seekp = (off_t)ifileent_blkno * lfs_sb_getbsize(fs) +
+	    (inumber % lfs_sb_getifpb(fs)) * sizeof (IFILE_Vx);
 	rc = buf_read_file(f, &ent_in_buf, &buf_after_ent);
 	if (rc)
 		return rc;
@@ -267,8 +245,8 @@
 #endif
 
 #ifdef LIBSA_LFS
-	if (inumber == fs->lfs_ifile)
-		inode_sector = FSBTODB(fs, fs->lfs_idaddr);
+	if (inumber == lfs_sb_getifile(fs))
+		inode_sector = FSBTODB(fs, lfs_sb_getidaddr(fs));
 	else if ((rc = find_inode_sector(inumber, f, &inode_sector)) != 0)
 		return rc;
 #else

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs.h,v 1.163 2015/07/24 06:51:46 dholland Exp $	*/
+/*	$NetBSD: lfs.h,v 1.164 2015/07/24 06:56:42 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  */
@@ -477,23 +477,23 @@
 
 #define LFS_SET_UINO(ip, flags) do {					\
 	if (((flags) & IN_ACCESSED) && !((ip)->i_flag & IN_ACCESSED))	\
-		++(ip)->i_lfs->lfs_uinodes;				\
+		lfs_sb_adduinodes((ip)->i_lfs, 1);			\
 	if (((flags) & IN_CLEANING) && !((ip)->i_flag & IN_CLEANING))	\
-		++(ip)->i_lfs->lfs_uinodes;				\
+		lfs_sb_adduinodes((ip)->i_lfs, 1);			\
 	if (((flags) & IN_MODIFIED) && !((ip)->i_flag & IN_MODIFIED))	\
-		++(ip)->i_lfs->lfs_uinodes;				\
+		lfs_sb_adduinodes((ip)->i_lfs, 1);			\
 	(ip)->i_flag |= (flags);					\
 } while (0)
 
 #define LFS_CLR_UINO(ip, flags) do {					\
 	if (((flags) & IN_ACCESSED) && ((ip)->i_flag & IN_ACCESSED))	\
-		--(ip)->i_lfs->lfs_uinodes;				\
+		lfs_sb_subuinodes((ip)->i_lfs, 1);			\
 	if (((flags) & IN_CLEANING) && ((ip)->i_flag & IN_CLEANING))	\
-		--(ip)->i_lfs->lfs_uinodes;				\
+		lfs_sb_subuinodes((ip)->i_lfs, 1);			\
 	if (((flags) & IN_MODIFIED) && ((ip)->i_flag & IN_MODIFIED))	\
-		--(ip)->i_lfs->lfs_uinodes;				\
+		lfs_sb_subuinodes((ip)->i_lfs, 1);			\
 	(ip)->i_flag &= ~(flags);					\
-	if ((ip)->i_lfs->lfs_uinodes < 0) {				\
+	if (lfs_sb_getuinodes((ip)->i_lfs) < 0) {			\
 		panic("lfs_uinodes < 0");				\
 	}								\
 } while (0)
@@ -531,9 +531,9 @@
 	u_int32_t su_flags;		/* 12: segment flags  */
 };
 
-#define	SEGUPB(fs)	(fs->lfs_sepb)
+#define	SEGUPB(fs)	(lfs_sb_getsepb(fs))
 #define	SEGTABSIZE_SU(fs)						\
-	(((fs)->lfs_nseg + SEGUPB(fs) - 1) / (fs)->lfs_sepb)
+	((lfs_sb_getnseg(fs) + SEGUPB(fs) - 1) / lfs_sb_getsepb(fs))
 
 #ifdef _KERNEL
 # define SHARE_IFLOCK(F) 						\
@@ -555,14 +555,14 @@
 	SHARE_IFLOCK(F);						\
 	VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS;			\
 	if ((_e = bread((F)->lfs_ivnode,				\
-	    ((IN) / (F)->lfs_sepb) + (F)->lfs_cleansz,			\
-	    (F)->lfs_bsize, 0, &(BP))) != 0)			\
+	    ((IN) / lfs_sb_getsepb(F)) + lfs_sb_getcleansz(F),		\
+	    lfs_sb_getbsize(F), 0, &(BP))) != 0)			\
 		panic("lfs: ifile read: %d", _e);			\
 	if ((F)->lfs_version == 1)					\
 		(SP) = (SEGUSE *)((SEGUSE_V1 *)(BP)->b_data +		\
-			((IN) & ((F)->lfs_sepb - 1)));			\
+			((IN) & (lfs_sb_getsepb(F) - 1)));		\
 	else								\
-		(SP) = (SEGUSE *)(BP)->b_data + ((IN) % (F)->lfs_sepb);	\
+		(SP) = (SEGUSE *)(BP)->b_data + ((IN) % lfs_sb_getsepb(F)); \
 	UNSHARE_IFLOCK(F);						\
 } while (0)
 
@@ -623,14 +623,14 @@
 	SHARE_IFLOCK(F);						\
 	VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS;			\
 	if ((_e = bread((F)->lfs_ivnode,				\
-	(IN) / (F)->lfs_ifpb + (F)->lfs_cleansz + (F)->lfs_segtabsz,	\
-	(F)->lfs_bsize, 0, &(BP))) != 0)			\
+	(IN) / lfs_sb_getifpb(F) + lfs_sb_getcleansz(F) + lfs_sb_getsegtabsz(F), \
+	lfs_sb_getbsize(F), 0, &(BP))) != 0)				\
 		panic("lfs: ifile ino %d read %d", (int)(IN), _e);	\
 	if ((F)->lfs_version == 1)					\
 		(IP) = (IFILE *)((IFILE_V1 *)(BP)->b_data +		\
-				 (IN) % (F)->lfs_ifpb);			\
+				 (IN) % lfs_sb_getifpb(F));		\
 	else								\
-		(IP) = (IFILE *)(BP)->b_data + (IN) % (F)->lfs_ifpb;	\
+		(IP) = (IFILE *)(BP)->b_data + (IN) % lfs_sb_getifpb(F); \
 	UNSHARE_IFLOCK(F);						\
 } while (0)
 
@@ -650,14 +650,14 @@
 } CLEANERINFO;
 
 #define	CLEANSIZE_SU(fs)						\
-	((sizeof(CLEANERINFO) + (fs)->lfs_bsize - 1) >> (fs)->lfs_bshift)
+	((sizeof(CLEANERINFO) + lfs_sb_getbsize(fs) - 1) >> (fs)->lfs_bshift)
 
 /* Read in the block with the cleaner info from the ifile. */
 #define LFS_CLEANERINFO(CP, F, BP) do {					\
 	SHARE_IFLOCK(F);						\
 	VTOI((F)->lfs_ivnode)->i_flag |= IN_ACCESS;			\
 	if (bread((F)->lfs_ivnode,					\
-	    (daddr_t)0, (F)->lfs_bsize, 0, &(BP)))		\
+	    (daddr_t)0, lfs_sb_getbsize(F), 0, &(BP)))			\
 		panic("lfs: ifile read");				\
 	(CP) = (CLEANERINFO *)(BP)->b_data;				\
 	UNSHARE_IFLOCK(F);						\
@@ -668,14 +668,14 @@
  */
 #define LFS_SYNC_CLEANERINFO(cip, fs, bp, w) do {		 	\
     mutex_enter(&lfs_lock);						\
-    if ((w) || (cip)->bfree != (fs)->lfs_bfree ||		 	\
-	(cip)->avail != (fs)->lfs_avail - (fs)->lfs_ravail - 		\
-	(fs)->lfs_favail) {	 					\
-	(cip)->bfree = (fs)->lfs_bfree;				 	\
-	(cip)->avail = (fs)->lfs_avail - (fs)->lfs_ravail -		\
-		(fs)->lfs_favail;				 	\
+    if ((w) || (cip)->bfree != lfs_sb_getbfree(fs) ||		 	\
+	(cip)->avail != lfs_sb_getavail(fs) - fs->lfs_ravail -	 	\
+	fs->lfs_favail) {	 					\
+	(cip)->bfree = lfs_sb_getbfree(fs);			 	\
+	(cip)->avail = lfs_sb_getavail(fs) - fs->lfs_ravail -		\
+		fs->lfs_favail;					 	\
 	if (((bp)->b_flags & B_GATHERED) == 0) {		 	\
-		(fs)->lfs_flags |= LFS_IFDIRTY;			 	\
+		fs->lfs_flags |= LFS_IFDIRTY;				\
 	}								\
 	mutex_exit(&lfs_lock);						\
 	(void) LFS_BWRITE_LOG(bp); /* Ifile */			 	\
@@ -692,14 +692,14 @@
 #define LFS_GET_HEADFREE(FS, CIP, BP, FREEP) do {			\
 	if ((FS)->lfs_version > 1) {					\
 		LFS_CLEANERINFO((CIP), (FS), (BP));			\
-		(FS)->lfs_freehd = (CIP)->free_head;			\
+		lfs_sb_setfreehd(FS, (CIP)->free_head);			\
 		brelse(BP, 0);						\
 	}								\
-	*(FREEP) = (FS)->lfs_freehd;					\
+	*(FREEP) = lfs_sb_getfreehd(FS);				\
 } while (0)
 
 #define LFS_PUT_HEADFREE(FS, CIP, BP, VAL) do {				\
-	(FS)->lfs_freehd = (VAL);					\
+	lfs_sb_setfreehd(FS, VAL);					\
 	if ((FS)->lfs_version > 1) {					\
 		LFS_CLEANERINFO((CIP), (FS), (BP));			\
 		(CIP)->free_head = (VAL);				\
@@ -802,7 +802,6 @@
 	int32_t	  dlfs_offset;	  /* 72: offset in curseg for next partial */
 	int32_t	  dlfs_lastpseg;  /* 76: address of last partial written */
 	u_int32_t dlfs_inopf;	  /* 80: v1: time stamp; v2: inodes per frag */
-#define dlfs_otstamp dlfs_inopf
 
 /* These are configuration parameters. */
 	u_int32_t dlfs_minfree;	  /* 84: minimum percentage of free blocks */
@@ -875,67 +874,6 @@
  */
 struct lfs {
 	struct dlfs lfs_dlfs;		/* on-disk parameters */
-#define lfs_magic lfs_dlfs.dlfs_magic
-#define lfs_version lfs_dlfs.dlfs_version
-#define lfs_size lfs_dlfs.dlfs_size
-#define lfs_ssize lfs_dlfs.dlfs_ssize
-#define lfs_dsize lfs_dlfs.dlfs_dsize
-#define lfs_bsize lfs_dlfs.dlfs_bsize
-#define lfs_fsize lfs_dlfs.dlfs_fsize
-#define lfs_frag lfs_dlfs.dlfs_frag
-#define lfs_freehd lfs_dlfs.dlfs_freehd
-#define lfs_bfree lfs_dlfs.dlfs_bfree
-#define lfs_nfiles lfs_dlfs.dlfs_nfiles
-#define lfs_avail lfs_dlfs.dlfs_avail
-#define lfs_uinodes lfs_dlfs.dlfs_uinodes
-#define lfs_idaddr lfs_dlfs.dlfs_idaddr
-#define lfs_ifile lfs_dlfs.dlfs_ifile
-#define lfs_lastseg lfs_dlfs.dlfs_lastseg
-#define lfs_nextseg lfs_dlfs.dlfs_nextseg
-#define lfs_curseg lfs_dlfs.dlfs_curseg
-#define lfs_offset lfs_dlfs.dlfs_offset
-#define lfs_lastpseg lfs_dlfs.dlfs_lastpseg
-#define lfs_otstamp lfs_dlfs.dlfs_inopf
-#define lfs_inopf lfs_dlfs.dlfs_inopf
-#define lfs_minfree lfs_dlfs.dlfs_minfree
-#define lfs_maxfilesize lfs_dlfs.dlfs_maxfilesize
-#define lfs_fsbpseg lfs_dlfs.dlfs_fsbpseg
-#define lfs_inopb lfs_dlfs.dlfs_inopb
-#define lfs_ifpb lfs_dlfs.dlfs_ifpb
-#define lfs_sepb lfs_dlfs.dlfs_sepb
-#define lfs_nindir lfs_dlfs.dlfs_nindir
-#define lfs_nseg lfs_dlfs.dlfs_nseg
-#define lfs_nspf lfs_dlfs.dlfs_nspf
-#define lfs_cleansz lfs_dlfs.dlfs_cleansz
-#define lfs_segtabsz lfs_dlfs.dlfs_segtabsz
-#define lfs_segmask lfs_dlfs.dlfs_segmask
-#define lfs_segshift lfs_dlfs.dlfs_segshift
-#define lfs_bmask lfs_dlfs.dlfs_bmask
-#define lfs_bshift lfs_dlfs.dlfs_bshift
-#define lfs_ffmask lfs_dlfs.dlfs_ffmask
-#define lfs_ffshift lfs_dlfs.dlfs_ffshift
-#define lfs_fbmask lfs_dlfs.dlfs_fbmask
-#define lfs_fbshift lfs_dlfs.dlfs_fbshift
-#define lfs_blktodb lfs_dlfs.dlfs_blktodb
-#define lfs_fsbtodb lfs_dlfs.dlfs_fsbtodb
-#define lfs_sushift lfs_dlfs.dlfs_sushift
-#define lfs_maxsymlinklen lfs_dlfs.dlfs_maxsymlinklen
-#define lfs_sboffs lfs_dlfs.dlfs_sboffs
-#define lfs_cksum lfs_dlfs.dlfs_cksum
-#define lfs_pflags lfs_dlfs.dlfs_pflags
-#define lfs_fsmnt lfs_dlfs.dlfs_fsmnt
-#define lfs_nclean lfs_dlfs.dlfs_nclean
-#define lfs_dmeta lfs_dlfs.dlfs_dmeta
-#define lfs_minfreeseg lfs_dlfs.dlfs_minfreeseg
-#define lfs_sumsize lfs_dlfs.dlfs_sumsize
-#define lfs_serial lfs_dlfs.dlfs_serial
-#define lfs_ibsize lfs_dlfs.dlfs_ibsize
-#define lfs_s0addr lfs_dlfs.dlfs_start
-#define lfs_tstamp lfs_dlfs.dlfs_tstamp
-#define lfs_inodefmt lfs_dlfs.dlfs_inodefmt
-#define lfs_interleave lfs_dlfs.dlfs_interleave
-#define lfs_ident lfs_dlfs.dlfs_ident
-#define lfs_resvseg lfs_dlfs.dlfs_resvseg
 
 /* These fields are set at mount time and are meaningless on disk. */
 	struct segment *lfs_sp;		/* current segment being written */
@@ -1013,9 +951,159 @@
 	uint32_t lfs_quota_magic;
 	uint8_t lfs_quota_flags;
 	uint64_t lfs_quotaino[2];
+
+	/* Sleep address replacing &lfs_avail inside the on-disk superblock */
+	/* XXX: should be replaced with a condvar */
+	int lfs_availsleep;
+	/* This one replaces &lfs_nextseg... all ditto */
+	int lfs_nextsegsleep;
 #endif
 };
 
+/*
+ * Smaller "struct lfs" used by libsa. XXX: this should not need to be
+ * exposed here, but currently it must be in order for the superblock
+ * accessors to work. Blah.
+ */
+struct salfs {
+	struct dlfs lfs_dlfs;
+};
+
+/*
+ * Generate accessors for the on-disk superblock fields with cpp.
+ *
+ * STRUCT_LFS is used by the libsa code to get accessors that work
+ * with struct salfs instead of struct lfs.
+ */
+
+#ifndef STRUCT_LFS
+#define STRUCT_LFS struct lfs
+#endif
+
+#define LFS_DEF_SB_ACCESSOR(type, field) \
+	static __unused inline type				\
+	lfs_sb_get##field(STRUCT_LFS *fs)			\
+	{							\
+		return fs->lfs_dlfs.dlfs_##field;		\
+	}							\
+	static __unused inline void				\
+	lfs_sb_set##field(STRUCT_LFS *fs, type val)		\
+	{							\
+		fs->lfs_dlfs.dlfs_##field = val;		\
+	}							\
+	static __unused inline void				\
+	lfs_sb_add##field(STRUCT_LFS *fs, type val)		\
+	{							\
+		type *p = &fs->lfs_dlfs.dlfs_##field;		\
+		*p += val;					\
+	}							\
+	static __unused inline void				\
+	lfs_sb_sub##field(STRUCT_LFS *fs, type val)		\
+	{							\
+		type *p = &fs->lfs_dlfs.dlfs_##field;		\
+		*p -= val;					\
+	}
+
+#define lfs_magic lfs_dlfs.dlfs_magic
+#define lfs_version lfs_dlfs.dlfs_version
+LFS_DEF_SB_ACCESSOR(u_int32_t, size);
+LFS_DEF_SB_ACCESSOR(u_int32_t, ssize);
+LFS_DEF_SB_ACCESSOR(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(u_int32_t, nfiles);
+LFS_DEF_SB_ACCESSOR(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);
+LFS_DEF_SB_ACCESSOR(int32_t, lastseg);
+LFS_DEF_SB_ACCESSOR(int32_t, nextseg);
+LFS_DEF_SB_ACCESSOR(int32_t, curseg);
+LFS_DEF_SB_ACCESSOR(int32_t, offset);
+LFS_DEF_SB_ACCESSOR(int32_t, lastpseg);
+LFS_DEF_SB_ACCESSOR(u_int32_t, inopf);
+LFS_DEF_SB_ACCESSOR(u_int32_t, minfree);
+#define lfs_maxfilesize lfs_dlfs.dlfs_maxfilesize
+LFS_DEF_SB_ACCESSOR(uint64_t, maxfilesize);
+#define lfs_fsbpseg lfs_dlfs.dlfs_fsbpseg
+LFS_DEF_SB_ACCESSOR(u_int32_t, fsbpseg);
+#define lfs_inopb lfs_dlfs.dlfs_inopb
+LFS_DEF_SB_ACCESSOR(u_int32_t, inopb);
+LFS_DEF_SB_ACCESSOR(u_int32_t, ifpb);
+LFS_DEF_SB_ACCESSOR(u_int32_t, sepb);
+#define lfs_nindir lfs_dlfs.dlfs_nindir
+LFS_DEF_SB_ACCESSOR(u_int32_t, nindir);
+#define lfs_nseg lfs_dlfs.dlfs_nseg
+LFS_DEF_SB_ACCESSOR(u_int32_t, nseg);
+#define lfs_nspf lfs_dlfs.dlfs_nspf
+LFS_DEF_SB_ACCESSOR(u_int32_t, nspf);
+LFS_DEF_SB_ACCESSOR(u_int32_t, cleansz);
+LFS_DEF_SB_ACCESSOR(u_int32_t, segtabsz);
+#define lfs_segmask lfs_dlfs.dlfs_segmask
+LFS_DEF_SB_ACCESSOR(u_int32_t, segmask);
+#define lfs_segshift lfs_dlfs.dlfs_segshift
+LFS_DEF_SB_ACCESSOR(u_int32_t, segshift);
+#define lfs_bmask lfs_dlfs.dlfs_bmask
+LFS_DEF_SB_ACCESSOR(u_int64_t, bmask);
+#define lfs_bshift lfs_dlfs.dlfs_bshift
+LFS_DEF_SB_ACCESSOR(u_int32_t, bshift);
+#define lfs_ffmask lfs_dlfs.dlfs_ffmask
+LFS_DEF_SB_ACCESSOR(u_int64_t, ffmask);
+#define lfs_ffshift lfs_dlfs.dlfs_ffshift
+LFS_DEF_SB_ACCESSOR(u_int32_t, ffshift);
+#define lfs_fbmask lfs_dlfs.dlfs_fbmask
+LFS_DEF_SB_ACCESSOR(u_int64_t, fbmask);
+#define lfs_fbshift lfs_dlfs.dlfs_fbshift
+LFS_DEF_SB_ACCESSOR(u_int32_t, fbshift);
+#define lfs_blktodb lfs_dlfs.dlfs_blktodb
+LFS_DEF_SB_ACCESSOR(u_int32_t, blktodb);
+#define lfs_fsbtodb lfs_dlfs.dlfs_fsbtodb
+LFS_DEF_SB_ACCESSOR(u_int32_t, fsbtodb);
+#define lfs_sushift lfs_dlfs.dlfs_sushift
+LFS_DEF_SB_ACCESSOR(u_int32_t, sushift);
+#define lfs_maxsymlinklen lfs_dlfs.dlfs_maxsymlinklen
+LFS_DEF_SB_ACCESSOR(int32_t, maxsymlinklen);
+#define lfs_sboffs lfs_dlfs.dlfs_sboffs
+#define lfs_cksum lfs_dlfs.dlfs_cksum
+LFS_DEF_SB_ACCESSOR(u_int32_t, cksum);
+#define lfs_pflags lfs_dlfs.dlfs_pflags
+LFS_DEF_SB_ACCESSOR(u_int16_t, pflags);
+#define lfs_fsmnt lfs_dlfs.dlfs_fsmnt
+#define lfs_nclean lfs_dlfs.dlfs_nclean
+LFS_DEF_SB_ACCESSOR(u_int32_t, nclean);
+#define lfs_dmeta lfs_dlfs.dlfs_dmeta
+LFS_DEF_SB_ACCESSOR(int32_t, dmeta);
+#define lfs_minfreeseg lfs_dlfs.dlfs_minfreeseg
+LFS_DEF_SB_ACCESSOR(u_int32_t, minfreeseg);
+#define lfs_sumsize lfs_dlfs.dlfs_sumsize
+LFS_DEF_SB_ACCESSOR(u_int32_t, sumsize);
+LFS_DEF_SB_ACCESSOR(u_int64_t, serial);
+#define lfs_ibsize lfs_dlfs.dlfs_ibsize
+LFS_DEF_SB_ACCESSOR(u_int32_t, ibsize);
+#define lfs_s0addr lfs_dlfs.dlfs_start
+LFS_DEF_SB_ACCESSOR(int32_t, start);
+LFS_DEF_SB_ACCESSOR(u_int64_t, tstamp);
+#define lfs_inodefmt lfs_dlfs.dlfs_inodefmt
+LFS_DEF_SB_ACCESSOR(u_int32_t, inodefmt);
+#define lfs_interleave lfs_dlfs.dlfs_interleave
+LFS_DEF_SB_ACCESSOR(u_int32_t, interleave);
+#define lfs_ident lfs_dlfs.dlfs_ident
+LFS_DEF_SB_ACCESSOR(u_int32_t, ident);
+#define lfs_resvseg lfs_dlfs.dlfs_resvseg
+LFS_DEF_SB_ACCESSOR(u_int32_t, resvseg);
+
+/* special-case accessors */
+
+/*
+ * the v1 otstamp field lives in what's now dlfs_inopf
+ */
+#define lfs_sb_getotstamp(fs) lfs_sb_getinopf(fs)
+#define lfs_sb_setotstamp(fs, val) lfs_sb_setinopf(fs, val)
+
+
 /* LFS_NINDIR is the number of indirects in a file system block. */
 #define	LFS_NINDIR(fs)	((fs)->lfs_nindir)
 
@@ -1026,7 +1114,7 @@
 
 #define	lfs_blksize(fs, ip, lbn) \
 	(((lbn) >= ULFS_NDADDR || (ip)->i_ffs1_size >= ((lbn) + 1) << (fs)->lfs_bshift) \
-	    ? (fs)->lfs_bsize \
+	    ? lfs_sb_getbsize(fs) \
 	    : (lfs_fragroundup(fs, lfs_blkoff(fs, (ip)->i_ffs1_size))))
 #define	lfs_blkoff(fs, loc)	((int)((loc) & (fs)->lfs_bmask))
 #define lfs_fragoff(fs, loc)    /* calculates (loc % fs->lfs_fsize) */ \
@@ -1048,7 +1136,7 @@
 
 #define lfs_numfrags(fs, loc)	/* calculates (loc / fs->lfs_fsize) */	\
 	((loc) >> (fs)->lfs_ffshift)
-#define lfs_blkroundup(fs, size)/* calculates roundup(size, fs->lfs_bsize) */ \
+#define lfs_blkroundup(fs, size)/* calculates roundup(size, lfs_sb_getbsize(fs)) */ \
 	((off_t)(((size) + (fs)->lfs_bmask) & (~(fs)->lfs_bmask)))
 #define lfs_fragroundup(fs, size)/* calculates roundup(size, fs->lfs_fsize) */ \
 	((off_t)(((size) + (fs)->lfs_ffmask) & (~(fs)->lfs_ffmask)))
@@ -1062,15 +1150,15 @@
 	((fsb) &~ ((fs)->lfs_frag - 1))
 #define lfs_dblksize(fs, dp, lbn) \
 	(((lbn) >= ULFS_NDADDR || (dp)->di_size >= ((lbn) + 1) << (fs)->lfs_bshift)\
-	    ? (fs)->lfs_bsize \
+	    ? lfs_sb_getbsize(fs) \
 	    : (lfs_fragroundup(fs, lfs_blkoff(fs, (dp)->di_size))))
 
 #define	lfs_segsize(fs)	((fs)->lfs_version == 1 ?	     		\
-			   lfs_lblktosize((fs), (fs)->lfs_ssize) :	\
-			   (fs)->lfs_ssize)
+			   lfs_lblktosize((fs), lfs_sb_getssize(fs)) :	\
+			   lfs_sb_getssize(fs))
 #define lfs_segtod(fs, seg) (((fs)->lfs_version == 1     ?	    	\
-			   (fs)->lfs_ssize << (fs)->lfs_blktodb :	\
-			   lfs_btofsb((fs), (fs)->lfs_ssize)) * (seg))
+			   lfs_sb_getssize(fs) << (fs)->lfs_blktodb :	\
+			   lfs_btofsb((fs), lfs_sb_getssize(fs))) * (seg))
 #define	lfs_dtosn(fs, daddr)	/* block address to segment number */	\
 	((uint32_t)(((daddr) - (fs)->lfs_s0addr) / lfs_segtod((fs), 1)))
 #define lfs_sntod(fs, sn)	/* segment number to disk address */	\
@@ -1154,19 +1242,19 @@
  * but avoids falsely reporting "disk full" when the sample size (D) is small.
  */
 #define LFS_EST_CMETA(F) (int32_t)((					\
-	((F)->lfs_dmeta * (int64_t)(F)->lfs_nclean) / 			\
-	((F)->lfs_nseg)))
+	(lfs_sb_getdmeta(F) * (int64_t)lfs_sb_getnclean(F)) / 		\
+	(lfs_sb_getnseg(F))))
 
 /* Estimate total size of the disk not including metadata */
-#define LFS_EST_NONMETA(F) ((F)->lfs_dsize - (F)->lfs_dmeta - LFS_EST_CMETA(F))
+#define LFS_EST_NONMETA(F) (lfs_sb_getdsize(F) - lfs_sb_getdmeta(F) - LFS_EST_CMETA(F))
 
 /* Estimate number of blocks actually available for writing */
-#define LFS_EST_BFREE(F) ((F)->lfs_bfree > LFS_EST_CMETA(F) ?		     \
-			  (F)->lfs_bfree - LFS_EST_CMETA(F) : 0)
+#define LFS_EST_BFREE(F) (lfs_sb_getbfree(F) > LFS_EST_CMETA(F) ?	     \
+			  lfs_sb_getbfree(F) - LFS_EST_CMETA(F) : 0)
 
 /* Amount of non-meta space not available to mortal man */
 #define LFS_EST_RSVD(F) (int32_t)((LFS_EST_NONMETA(F) *			     \
-				   (u_int64_t)(F)->lfs_minfree) /	     \
+				   (u_int64_t)lfs_sb_getminfree(F)) /	     \
 				  100)
 
 /* Can credential C write BB blocks */
@@ -1184,7 +1272,7 @@
  * directory direct block (1) + ULFS_NIADDR indirect blocks + inode block (1) +
  * ifile direct block (1) + ULFS_NIADDR indirect blocks = 3 + 2 * ULFS_NIADDR blocks.
  */
-#define LFS_NRESERVE(F) (lfs_btofsb((F), (2 * ULFS_NIADDR + 3) << (F)->lfs_bshift))
+#define LFS_NRESERVE(F) (lfs_btofsb((F), (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(F)))
 
 /* Statistics Counters */
 struct lfs_stats {	/* Must match sysctl list in lfs_vfsops.h ! */

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_alloc.c,v 1.121 2015/07/16 08:31:45 dholland Exp $	*/
+/*	$NetBSD: lfs_alloc.c,v 1.122 2015/07/24 06:56:42 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003, 2007 The NetBSD Foundation, Inc.
@@ -60,7 +60,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_alloc.c,v 1.121 2015/07/16 08:31:45 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_alloc.c,v 1.122 2015/07/24 06:56:42 dholland Exp $");
 
 #if defined(_KERNEL_OPT)
 #include "opt_quota.h"
@@ -128,23 +128,23 @@
 	vp = fs->lfs_ivnode;
 	ip = VTOI(vp);
 	blkno = lfs_lblkno(fs, ip->i_size);
-	if ((error = lfs_balloc(vp, ip->i_size, fs->lfs_bsize, cred, 0,
+	if ((error = lfs_balloc(vp, ip->i_size, lfs_sb_getbsize(fs), cred, 0,
 				&bp)) != 0) {
 		return (error);
 	}
-	ip->i_size += fs->lfs_bsize;
+	ip->i_size += lfs_sb_getbsize(fs);
 	ip->i_ffs1_size = ip->i_size;
 	uvm_vnp_setsize(vp, ip->i_size);
 
-	maxino = ((ip->i_size >> fs->lfs_bshift) - fs->lfs_cleansz -
-		  fs->lfs_segtabsz) * fs->lfs_ifpb;
+	maxino = ((ip->i_size >> fs->lfs_bshift) - lfs_sb_getcleansz(fs) -
+		  lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);
 	fs->lfs_ino_bitmap = (lfs_bm_t *)
 		realloc(fs->lfs_ino_bitmap, ((maxino + BMMASK) >> BMSHIFT) *
 			sizeof(lfs_bm_t), M_SEGMENT, M_WAITOK);
 	KASSERT(fs->lfs_ino_bitmap != NULL);
 
-	i = (blkno - fs->lfs_segtabsz - fs->lfs_cleansz) *
-		fs->lfs_ifpb;
+	i = (blkno - lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs)) *
+		lfs_sb_getifpb(fs);
 
 	/*
 	 * We insert the new inodes at the head of the free list.
@@ -155,10 +155,10 @@
 	LFS_GET_HEADFREE(fs, cip, cbp, &oldlast);
 	LFS_PUT_HEADFREE(fs, cip, cbp, i);
 #ifdef DIAGNOSTIC
-	if (fs->lfs_freehd == LFS_UNUSED_INUM)
+	if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM)
 		panic("inode 0 allocated [2]");
 #endif /* DIAGNOSTIC */
-	xmax = i + fs->lfs_ifpb;
+	xmax = i + lfs_sb_getifpb(fs);
 
 	if (fs->lfs_version == 1) {
 		for (ifp_v1 = (IFILE_V1 *)bp->b_data; i < xmax; ++ifp_v1) {
@@ -231,7 +231,7 @@
 	brelse(bp, 0);
 
 	/* Extend IFILE so that the next lfs_valloc will succeed. */
-	if (fs->lfs_freehd == LFS_UNUSED_INUM) {
+	if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM) {
 		if ((error = lfs_extend_ifile(fs, cred)) != 0) {
 			LFS_PUT_HEADFREE(fs, cip, cbp, *ino);
 			lfs_segunlock(fs);
@@ -239,7 +239,7 @@
 		}
 	}
 #ifdef DIAGNOSTIC
-	if (fs->lfs_freehd == LFS_UNUSED_INUM)
+	if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM)
 		panic("inode 0 allocated [3]");
 #endif /* DIAGNOSTIC */
 
@@ -247,7 +247,7 @@
 	mutex_enter(&lfs_lock);
 	fs->lfs_fmod = 1;
 	mutex_exit(&lfs_lock);
-	++fs->lfs_nfiles;
+	lfs_sb_addnfiles(fs, 1);
 
 	lfs_segunlock(fs);
 
@@ -267,7 +267,7 @@
 
 	/* If the Ifile is too short to contain this inum, extend it */
 	while (VTOI(fs->lfs_ivnode)->i_size <= (ino /
-		fs->lfs_ifpb + fs->lfs_cleansz + fs->lfs_segtabsz)
+		lfs_sb_getifpb(fs) + lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs))
 		<< fs->lfs_bshift) {
 		lfs_extend_ifile(fs, NOCRED);
 	}
@@ -312,7 +312,7 @@
 	ino_t ino, maxino;
 
 	maxino = ((fs->lfs_ivnode->v_size >> fs->lfs_bshift) -
-		  fs->lfs_cleansz - fs->lfs_segtabsz) * fs->lfs_ifpb;
+		  lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) * fs->lfs_ifpb;
 	for (ino = maxino - 1; ino > LFS_UNUSED_INUM; --ino) {
 		if (ISSET_BITMAP_FREE(fs, ino) == 0)
 			break;
@@ -330,7 +330,7 @@
 {
 	ino_t tino, bound, bb, freehdbb;
 
-	if (fs->lfs_freehd == LFS_UNUSED_INUM)	 /* No free inodes at all */
+	if (lfs_sb_getfreehd(fs) == LFS_UNUSED_INUM)	 /* No free inodes at all */
 		return LFS_UNUSED_INUM;
 
 	/* Search our own word first */
@@ -346,7 +346,7 @@
 	 * Find a word with a free inode in it.  We have to be a bit
 	 * careful here since ino_t is unsigned.
 	 */
-	freehdbb = (fs->lfs_freehd >> BMSHIFT);
+	freehdbb = (lfs_sb_getfreehd(fs) >> BMSHIFT);
 	for (bb = (ino >> BMSHIFT) - 1; bb >= freehdbb && bb > 0; --bb)
 		if (fs->lfs_ino_bitmap[bb])
 			break;
@@ -528,7 +528,7 @@
 	mutex_enter(&lfs_lock);
 	fs->lfs_fmod = 1;
 	mutex_exit(&lfs_lock);
-	--fs->lfs_nfiles;
+	lfs_sb_subnfiles(fs, 1);
 
 	lfs_segunlock(fs);
 
@@ -554,7 +554,7 @@
 	lfs_seglock(fs, SEGM_PROT);
 
 	maxino = ((fs->lfs_ivnode->v_size >> fs->lfs_bshift) -
-		  fs->lfs_cleansz - fs->lfs_segtabsz) * fs->lfs_ifpb;
+		  lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);
 	fs->lfs_ino_bitmap =
 		malloc(((maxino + BMMASK) >> BMSHIFT) * sizeof(lfs_bm_t),
 		       M_SEGMENT, M_WAITOK | M_ZERO);
@@ -562,7 +562,7 @@
 
 	firstino = lastino = LFS_UNUSED_INUM;
 	for (ino = 0; ino < maxino; ino++) {
-		if (ino % fs->lfs_ifpb == 0)
+		if (ino % lfs_sb_getifpb(fs) == 0)
 			LFS_IENTRY(ifp, fs, ino, bp);
 		else
 			++ifp;
@@ -606,7 +606,7 @@
 			SET_BITMAP_FREE(fs, ino);
 		}
 
-		if ((ino + 1) % fs->lfs_ifpb == 0)
+		if ((ino + 1) % lfs_sb_getifpb(fs) == 0)
 			brelse(bp, 0);
 	}
 

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_balloc.c,v 1.81 2015/03/28 19:24:05 maxv Exp $	*/
+/*	$NetBSD: lfs_balloc.c,v 1.82 2015/07/24 06:56:42 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.81 2015/03/28 19:24:05 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_balloc.c,v 1.82 2015/07/24 06:56:42 dholland Exp $");
 
 #if defined(_KERNEL_OPT)
 #include "opt_quota.h"
@@ -125,7 +125,7 @@
 	ip = VTOI(vp);
 	fs = ip->i_lfs;
 	offset = lfs_blkoff(fs, startoffset);
-	KASSERT(iosize <= fs->lfs_bsize);
+	KASSERT(iosize <= lfs_sb_getbsize(fs));
 	lbn = lfs_lblkno(fs, startoffset);
 	/* (void)lfs_check(vp, lbn, 0); */
 
@@ -154,13 +154,13 @@
 	lastblock = lfs_lblkno(fs, ip->i_size);
 	if (lastblock < ULFS_NDADDR && lastblock < lbn) {
 		osize = lfs_blksize(fs, ip, lastblock);
-		if (osize < fs->lfs_bsize && osize > 0) {
-			if ((error = lfs_fragextend(vp, osize, fs->lfs_bsize,
+		if (osize < lfs_sb_getbsize(fs) && osize > 0) {
+			if ((error = lfs_fragextend(vp, osize, lfs_sb_getbsize(fs),
 						    lastblock,
 						    (bpp ? &bp : NULL), cred)))
 				return (error);
 			ip->i_ffs1_size = ip->i_size =
-			    (lastblock + 1) * fs->lfs_bsize;
+			    (lastblock + 1) * lfs_sb_getbsize(fs);
 			uvm_vnp_setsize(vp, ip->i_size);
 			ip->i_flag |= IN_CHANGE | IN_UPDATE;
 			if (bpp)
@@ -192,7 +192,7 @@
 			}
 			ip->i_lfs_effnblks += frags;
 			mutex_enter(&lfs_lock);
-			fs->lfs_bfree -= frags;
+			lfs_sb_setbfree(fs, lfs_sb_getbfree(fs) - frags);
 			mutex_exit(&lfs_lock);
 			ip->i_ffs1_db[lbn] = UNWRITTEN;
 		} else {
@@ -237,7 +237,7 @@
 	}
 	if (ISSPACE(fs, bcount, cred)) {
 		mutex_enter(&lfs_lock);
-		fs->lfs_bfree -= bcount;
+		lfs_sb_setbfree(fs, lfs_sb_getbfree(fs) - bcount);
 		mutex_exit(&lfs_lock);
 		ip->i_lfs_effnblks += bcount;
 	} else {
@@ -256,7 +256,7 @@
 			idaddr = ip->i_ffs1_ib[indirs[0].in_off];
 			for (i = 1; i < num; ++i) {
 				ibp = getblk(vp, indirs[i].in_lbn,
-				    fs->lfs_bsize, 0,0);
+				    lfs_sb_getbsize(fs), 0,0);
 				if (!indirs[i].in_exists) {
 					clrbuf(ibp);
 					ibp->b_blkno = UNWRITTEN;
@@ -329,7 +329,7 @@
 			break;
 		    default:
 			idp = &indirs[num - 1];
-			if (bread(vp, idp->in_lbn, fs->lfs_bsize,
+			if (bread(vp, idp->in_lbn, lfs_sb_getbsize(fs),
 				  B_MODIFY, &ibp))
 				panic("lfs_balloc: bread bno %lld",
 				    (long long)idp->in_lbn);
@@ -349,7 +349,7 @@
 		 * Not a brand new block, also not in the cache;
 		 * read it in from disk.
 		 */
-		if (iosize == fs->lfs_bsize)
+		if (iosize == lfs_sb_getbsize(fs))
 			/* Optimization: I/O is unnecessary. */
 			bp->b_blkno = daddr;
 		else {
@@ -437,11 +437,11 @@
 			lfs_availwait(fs, frags);
 			goto top;
 		}
-		fs->lfs_avail -= frags;
+		lfs_sb_subavail(fs, frags);
 	}
 
 	mutex_enter(&lfs_lock);
-	fs->lfs_bfree -= frags;
+	lfs_sb_setbfree(fs, lfs_sb_getbfree(fs) - frags);
 	mutex_exit(&lfs_lock);
 	ip->i_lfs_effnblks += frags;
 	ip->i_flag |= IN_CHANGE | IN_UPDATE;
@@ -515,9 +515,9 @@
 
 	++ip->i_lfs_nbtree;
 	fs->lfs_favail += lfs_btofsb(fs, (1 << fs->lfs_bshift));
-	fs->lfs_pages += fs->lfs_bsize >> PAGE_SHIFT;
+	fs->lfs_pages += lfs_sb_getbsize(fs) >> PAGE_SHIFT;
 	++locked_fakequeue_count;
-	lfs_subsys_pages += fs->lfs_bsize >> PAGE_SHIFT;
+	lfs_subsys_pages += lfs_sb_getbsize(fs) >> PAGE_SHIFT;
 	mutex_exit(&lfs_lock);
 }
 
@@ -531,10 +531,10 @@
 	SPLAY_REMOVE(lfs_splay, &ip->i_lfs_lbtree, lbp);
 	if (fs->lfs_favail > lfs_btofsb(fs, (1 << fs->lfs_bshift)))
 		fs->lfs_favail -= lfs_btofsb(fs, (1 << fs->lfs_bshift));
-	fs->lfs_pages -= fs->lfs_bsize >> PAGE_SHIFT;
+	fs->lfs_pages -= lfs_sb_getbsize(fs) >> PAGE_SHIFT;
 	if (locked_fakequeue_count > 0)
 		--locked_fakequeue_count;
-	lfs_subsys_pages -= fs->lfs_bsize >> PAGE_SHIFT;
+	lfs_subsys_pages -= lfs_sb_getbsize(fs) >> PAGE_SHIFT;
 	mutex_exit(&lfs_lock);
 
 	pool_put(&lfs_lbnentry_pool, lbp);

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_subr.c,v 1.81 2015/07/16 08:31:45 dholland Exp $	*/
+/*	$NetBSD: lfs_subr.c,v 1.82 2015/07/24 06:56:42 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_subr.c,v 1.81 2015/07/16 08:31:45 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_subr.c,v 1.82 2015/07/24 06:56:42 dholland Exp $");
 
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -124,7 +124,7 @@
 	for (j = 0; j < LFS_N_SBLOCKS; j++, i++)
 		fs->lfs_resblk[i].size = LFS_SBPAD;
 	for (j = 0; j < LFS_N_IBLOCKS; j++, i++)
-		fs->lfs_resblk[i].size = fs->lfs_bsize;
+		fs->lfs_resblk[i].size = lfs_sb_getbsize(fs);
 	for (j = 0; j < LFS_N_CLUSTERS; j++, i++)
 		fs->lfs_resblk[i].size = MAXPHYS;
 	for (j = 0; j < LFS_N_CLEAN; j++, i++)
@@ -145,7 +145,7 @@
 	pool_init(&fs->lfs_segpool, sizeof(struct segment), 0, 0, 0,
 		"lfssegpool", &pool_allocator_nointr, IPL_NONE);
 	maxbpp = ((fs->lfs_sumsize - SEGSUM_SIZE(fs)) / sizeof(int32_t) + 2);
-	maxbpp = MIN(maxbpp, lfs_segsize(fs) / fs->lfs_fsize + 2);
+	maxbpp = MIN(maxbpp, lfs_segsize(fs) / lfs_sb_getfsize(fs) + 2);
 	pool_init(&fs->lfs_bpppool, maxbpp * sizeof(struct buf *), 0, 0, 0,
 		"lfsbpppl", &pool_allocator_nointr, IPL_NONE);
 }
@@ -336,7 +336,7 @@
 	 */
 	mutex_enter(&lfs_lock);
 	++fs->lfs_iocount;
-	fs->lfs_startseg = fs->lfs_curseg;
+	fs->lfs_startseg = lfs_sb_getcurseg(fs);
 	mutex_exit(&lfs_lock);
 	return 0;
 }
@@ -450,7 +450,7 @@
 		KASSERT(sp->cbpp == sp->bpp + 1);
 
 		/* Free allocated segment summary */
-		fs->lfs_offset -= lfs_btofsb(fs, fs->lfs_sumsize);
+		lfs_sb_suboffset(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
 		bp = *sp->bpp;
 		lfs_freebuf(fs, bp);
 
@@ -633,7 +633,7 @@
 	lfs_wakeup_cleaner(fs);
 	mutex_enter(&lfs_lock);
 	while (LFS_STARVED_FOR_SEGS(fs))
-		mtsleep(&fs->lfs_avail, PRIBIO, "relock", 0,
+		mtsleep(&fs->lfs_availsleep, PRIBIO, "relock", 0,
 			&lfs_lock);
 	mutex_exit(&lfs_lock);
 
@@ -658,6 +658,6 @@
 	if (fs->lfs_nowrap > 0)
 		return;
 
-	wakeup(&fs->lfs_nextseg);
+	wakeup(&fs->lfs_nextsegsleep);
 	wakeup(&lfs_allclean_wakeup);
 }

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_bio.c,v 1.128 2013/11/27 17:24:44 christos Exp $	*/
+/*	$NetBSD: lfs_bio.c,v 1.129 2015/07/24 06:56:42 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.128 2013/11/27 17:24:44 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.129 2015/07/24 06:56:42 dholland Exp $");
 
 #include <sys/param.h>
 #include <sys/systm.h>
@@ -245,8 +245,8 @@
 		if (lfs_fits(fs, fsb + fs->lfs_ravail + fs->lfs_favail))
 			break;
 
-		error = mtsleep(&fs->lfs_avail, PCATCH | PUSER, "lfs_reserve",
-				0, &lfs_lock);
+		error = mtsleep(&fs->lfs_availsleep, PCATCH | PUSER,
+				"lfs_reserve", 0, &lfs_lock);
 		if (error) {
 			mutex_exit(&lfs_lock);
 			return error;
@@ -355,19 +355,20 @@
 int
 lfs_fits(struct lfs *fs, int fsb)
 {
-	int needed;
+	int64_t needed;
 
 	ASSERT_NO_SEGLOCK(fs);
-	needed = fsb + lfs_btofsb(fs, fs->lfs_sumsize) +
-		 ((howmany(fs->lfs_uinodes + 1, LFS_INOPB(fs)) + fs->lfs_segtabsz +
+	needed = fsb + lfs_btofsb(fs, lfs_sb_getsumsize(fs)) +
+		 ((howmany(lfs_sb_getuinodes(fs) + 1, LFS_INOPB(fs)) +
+		   lfs_sb_getsegtabsz(fs) +
 		   1) << (fs->lfs_bshift - fs->lfs_ffshift));
 
-	if (needed >= fs->lfs_avail) {
+	if (needed >= lfs_sb_getavail(fs)) {
 #ifdef DEBUG
 		DLOG((DLOG_AVAIL, "lfs_fits: no fit: fsb = %ld, uinodes = %ld, "
-		      "needed = %ld, avail = %ld\n",
-		      (long)fsb, (long)fs->lfs_uinodes, (long)needed,
-		      (long)fs->lfs_avail));
+		      "needed = %jd, avail = %jd\n",
+		      (long)fsb, (long)fs->lfs_uinodes, (intmax_t)needed,
+		      (intmax_t)lfs_sb_getavail(fs)));
 #endif
 		return 0;
 	}
@@ -411,7 +412,8 @@
 		if (LFS_SEGLOCK_HELD(fs))
 			panic("lfs_availwait: deadlock");
 #endif
-		error = tsleep(&fs->lfs_avail, PCATCH | PUSER, "cleaner", 0);
+		error = tsleep(&fs->lfs_availsleep, PCATCH | PUSER,
+			       "cleaner", 0);
 		if (error)
 			return (error);
 	}
@@ -480,7 +482,7 @@
 			LFS_SET_UINO(ip, IN_MODIFIED);
 		}
 		mutex_exit(&lfs_lock);
-		fs->lfs_avail -= fsb;
+		lfs_sb_subavail(fs, fsb);
 
 		mutex_enter(&bufcache_lock);
 		mutex_enter(vp->v_interlock);
@@ -596,8 +598,8 @@
 	wakeup(&lfs_writing);
 }
 
-#define INOCOUNT(fs) howmany((fs)->lfs_uinodes, LFS_INOPB(fs))
-#define INOBYTES(fs) ((fs)->lfs_uinodes * sizeof (struct ulfs1_dinode))
+#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.

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_inode.c,v 1.137 2015/07/16 08:31:45 dholland Exp $	*/
+/*	$NetBSD: lfs_inode.c,v 1.138 2015/07/24 06:56:42 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.137 2015/07/16 08:31:45 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_inode.c,v 1.138 2015/07/24 06:56:42 dholland Exp $");
 
 #if defined(_KERNEL_OPT)
 #include "opt_quota.h"
@@ -113,11 +113,11 @@
 			return (ldip);
 
 	printf("searched %d entries\n", (int)(fin - dip));
-	printf("offset is 0x%x (seg %d)\n", fs->lfs_offset,
-	       lfs_dtosn(fs, fs->lfs_offset));
-	printf("block is 0x%llx (seg %lld)\n",
-	       (unsigned long long)LFS_DBTOFSB(fs, bp->b_blkno),
-	       (long long)lfs_dtosn(fs, LFS_DBTOFSB(fs, bp->b_blkno)));
+	printf("offset is 0x%jx (seg %d)\n", (uintmax_t)lfs_sb_getoffset(fs),
+	       lfs_dtosn(fs, lfs_sb_getoffset(fs)));
+	printf("block is 0x%jx (seg %d)\n",
+	       (uintmax_t)LFS_DBTOFSB(fs, bp->b_blkno),
+	       lfs_dtosn(fs, LFS_DBTOFSB(fs, bp->b_blkno)));
 
 	return NULL;
 }
@@ -301,7 +301,7 @@
 			uvm_vnp_setsize(ovp, length);
 			oip->i_flag |= IN_CHANGE | IN_UPDATE;
 			KASSERT(ovp->v_size == oip->i_size);
-			oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + fs->lfs_bsize - 1) - 1;
+			oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + lfs_sb_getbsize(fs) - 1) - 1;
 			return (lfs_update(ovp, NULL, NULL, 0));
 		} else {
 			error = lfs_reserve(fs, ovp, NULL,
@@ -318,7 +318,7 @@
 			uvm_vnp_setsize(ovp, length);
 			(void) VOP_BWRITE(bp->b_vp, bp);
 			oip->i_flag |= IN_CHANGE | IN_UPDATE;
-			oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + fs->lfs_bsize - 1) - 1;
+			oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + lfs_sb_getbsize(fs) - 1) - 1;
 			return (lfs_update(ovp, NULL, NULL, 0));
 		}
 	}
@@ -367,8 +367,10 @@
 			locked_queue_bytes -= obufsize - bp->b_bufsize;
 			mutex_exit(&lfs_lock);
 		}
-		if (bp->b_oflags & BO_DELWRI)
-			fs->lfs_avail += odb - lfs_btofsb(fs, size);
+		if (bp->b_oflags & BO_DELWRI) {
+			lfs_sb_addavail(fs, odb - lfs_btofsb(fs, size));
+			/* XXX shouldn't this wake up on lfs_availsleep? */
+		}
 		(void) VOP_BWRITE(bp->b_vp, bp);
 	} else { /* vp->v_type == VREG && length < osize && offset != 0 */
 		/*
@@ -423,14 +425,14 @@
 	 * the file is truncated to 0.
 	 */
 	/* Avoid sign overflow - XXX assumes that off_t is a quad_t. */
-	if (length > QUAD_MAX - fs->lfs_bsize)
-		lastblock = lfs_lblkno(fs, QUAD_MAX - fs->lfs_bsize);
+	if (length > QUAD_MAX - lfs_sb_getbsize(fs))
+		lastblock = lfs_lblkno(fs, QUAD_MAX - lfs_sb_getbsize(fs));
 	else
-		lastblock = lfs_lblkno(fs, length + fs->lfs_bsize - 1) - 1;
+		lastblock = lfs_lblkno(fs, length + lfs_sb_getbsize(fs) - 1) - 1;
 	lastiblock[SINGLE] = lastblock - ULFS_NDADDR;
 	lastiblock[DOUBLE] = lastiblock[SINGLE] - LFS_NINDIR(fs);
 	lastiblock[TRIPLE] = lastiblock[DOUBLE] - LFS_NINDIR(fs) * LFS_NINDIR(fs);
-	nblocks = lfs_btofsb(fs, fs->lfs_bsize);
+	nblocks = lfs_btofsb(fs, lfs_sb_getbsize(fs));
 	/*
 	 * Record changed file and block pointers before we start
 	 * freeing blocks.  lastiblock values are also normalized to -1
@@ -472,7 +474,7 @@
 					real_released += nblocks;
 				blocksreleased += nblocks;
 				oip->i_ffs1_ib[level] = 0;
-				lfs_blkfree(fs, oip, bn, fs->lfs_bsize,
+				lfs_blkfree(fs, oip, bn, lfs_sb_getbsize(fs),
 					    &lastseg, &bc);
         			lfs_deregister_block(ovp, bn);
 			}
@@ -565,7 +567,7 @@
 	oip->i_lfs_effnblks -= blocksreleased;
 	oip->i_ffs1_blocks -= real_released;
 	mutex_enter(&lfs_lock);
-	fs->lfs_bfree += blocksreleased;
+	lfs_sb_addbfree(fs, blocksreleased);
 	mutex_exit(&lfs_lock);
 #ifdef DIAGNOSTIC
 	if (oip->i_size == 0 &&
@@ -594,7 +596,7 @@
 	    -lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << fs->lfs_bshift));
 	genfs_node_unlock(ovp);
   errout:
-	oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + fs->lfs_bsize - 1) - 1;
+	oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + lfs_sb_getbsize(fs) - 1) - 1;
 	if (ovp != fs->lfs_ivnode)
 		lfs_segunlock(fs);
 	return (allerror ? allerror : error);
@@ -723,7 +725,7 @@
 	last = lastbn;
 	if (lastbn > 0)
 		last /= factor;
-	nblocks = lfs_btofsb(fs, fs->lfs_bsize);
+	nblocks = lfs_btofsb(fs, lfs_sb_getbsize(fs));
 	/*
 	 * Get buffer of block pointers, zero those entries corresponding
 	 * to blocks to be free'd, and update on disk copy first.  Since
@@ -733,12 +735,12 @@
 	 * explicitly instead of letting bread do everything for us.
 	 */
 	vp = ITOV(ip);
-	bp = getblk(vp, lbn, (int)fs->lfs_bsize, 0, 0);
+	bp = getblk(vp, lbn, lfs_sb_getbsize(fs), 0, 0);
 	if (bp->b_oflags & (BO_DONE | BO_DELWRI)) {
 		/* Braces must be here in case trace evaluates to nothing. */
-		trace(TR_BREADHIT, pack(vp, fs->lfs_bsize), lbn);
+		trace(TR_BREADHIT, pack(vp, lfs_sb_getbsize(fs)), lbn);
 	} else {
-		trace(TR_BREADMISS, pack(vp, fs->lfs_bsize), lbn);
+		trace(TR_BREADMISS, pack(vp, lfs_sb_getbsize(fs)), lbn);
 		curlwp->l_ru.ru_inblock++; /* pay for read */
 		bp->b_flags |= B_READ;
 		if (bp->b_bcount > bp->b_bufsize)
@@ -755,8 +757,8 @@
 
 	bap = (int32_t *)bp->b_data;	/* XXX ondisk32 */
 	if (lastbn >= 0) {
-		copy = lfs_malloc(fs, fs->lfs_bsize, LFS_NB_IBLOCK);
-		memcpy((void *)copy, (void *)bap, (u_int)fs->lfs_bsize);
+		copy = lfs_malloc(fs, lfs_sb_getbsize(fs), LFS_NB_IBLOCK);
+		memcpy((void *)copy, (void *)bap, lfs_sb_getbsize(fs));
 		memset((void *)&bap[last + 1], 0,
 		/* XXX ondisk32 */
 		  (u_int)(LFS_NINDIR(fs) - (last + 1)) * sizeof (int32_t));
@@ -784,7 +786,7 @@
 			blocksreleased += blkcount;
 			real_released += rblkcount;
 		}
-		lfs_blkfree(fs, ip, nb, fs->lfs_bsize, lastsegp, bcp);
+		lfs_blkfree(fs, ip, nb, lfs_sb_getbsize(fs), lastsegp, bcp);
 		if (bap[i] > 0)
 			real_released += nblocks;
 		blocksreleased += nblocks;
@@ -813,8 +815,8 @@
 		mutex_enter(&bufcache_lock);
 		if (bp->b_oflags & BO_DELWRI) {
 			LFS_UNLOCK_BUF(bp);
-			fs->lfs_avail += lfs_btofsb(fs, bp->b_bcount);
-			wakeup(&fs->lfs_avail);
+			lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));
+			wakeup(&fs->lfs_availsleep);
 		}
 		brelsel(bp, BC_INVAL);
 		mutex_exit(&bufcache_lock);
@@ -865,8 +867,8 @@
 		mutex_enter(bp->b_objlock);
 		if (bp->b_oflags & BO_DELWRI) {
 			bp->b_oflags &= ~BO_DELWRI;
-			fs->lfs_avail += lfs_btofsb(fs, bp->b_bcount);
-			wakeup(&fs->lfs_avail);
+			lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));
+			wakeup(&fs->lfs_availsleep);
 		}
 		mutex_exit(bp->b_objlock);
 		LFS_UNLOCK_BUF(bp);
@@ -887,8 +889,8 @@
 		mutex_enter(bp->b_objlock);
 		if (bp->b_oflags & BO_DELWRI) {
 			bp->b_oflags &= ~BO_DELWRI;
-			fs->lfs_avail += lfs_btofsb(fs, bp->b_bcount);
-			wakeup(&fs->lfs_avail);
+			lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));
+			wakeup(&fs->lfs_availsleep);
 		}
 		mutex_exit(bp->b_objlock);
 		LFS_UNLOCK_BUF(bp);

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_pages.c,v 1.1 2014/05/16 09:34:03 dholland Exp $	*/
+/*	$NetBSD: lfs_pages.c,v 1.2 2015/07/24 06:56:42 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_pages.c,v 1.1 2014/05/16 09:34:03 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_pages.c,v 1.2 2015/07/24 06:56:42 dholland Exp $");
 
 #ifdef _KERNEL_OPT
 #include "opt_compat_netbsd.h"
@@ -251,7 +251,7 @@
 	int any_dirty;	/* number of dirty pages */
 	int dirty;	/* number of dirty pages in a block */
 	int tdirty;
-	int pages_per_block = fs->lfs_bsize >> PAGE_SHIFT;
+	int pages_per_block = lfs_sb_getbsize(fs) >> PAGE_SHIFT;
 	int pagedaemon = (curlwp == uvm.pagedaemon_lwp);
 
 	KASSERT(mutex_owned(vp->v_interlock));
@@ -347,7 +347,7 @@
 			if (by_list) {
 				curpg = TAILQ_NEXT(curpg, listq.queue);
 			} else {
-				soff += fs->lfs_bsize;
+				soff += lfs_sb_getbsize(fs);
 			}
 			continue;
 		}
@@ -394,7 +394,7 @@
 		if (by_list) {
 			curpg = TAILQ_NEXT(curpg, listq.queue);
 		} else {
-			soff += MAX(PAGE_SIZE, fs->lfs_bsize);
+			soff += MAX(PAGE_SIZE, lfs_sb_getbsize(fs));
 		}
 	}
 
@@ -524,7 +524,7 @@
 	if (!sync && !reclaim &&
 	    ap->a_offlo >= ip->i_size && ap->a_offlo < blkeof) {
 		origoffset = ap->a_offlo;
-		for (off = origoffset; off < blkeof; off += fs->lfs_bsize) {
+		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) {
@@ -793,7 +793,7 @@
 				mutex_exit(vp->v_interlock);
 			} else {
 				if ((sp->seg_flags & SEGM_SINGLE) &&
-				    fs->lfs_curseg != fs->lfs_startseg)
+				    lfs_sb_getcurseg(fs) != fs->lfs_startseg)
 					donewriting = 1;
 			}
 		} else if (error) {

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_rfw.c,v 1.21 2015/07/16 08:31:45 dholland Exp $	*/
+/*	$NetBSD: lfs_rfw.c,v 1.22 2015/07/24 06:56:42 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@@ -30,7 +30,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_rfw.c,v 1.21 2015/07/16 08:31:45 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_rfw.c,v 1.22 2015/07/24 06:56:42 dholland Exp $");
 
 #if defined(_KERNEL_OPT)
 #include "opt_quota.h"
@@ -192,7 +192,8 @@
 	/* No need to write, the block is already on disk */
 	if (bp->b_oflags & BO_DELWRI) {
 		LFS_UNLOCK_BUF(bp);
-		fs->lfs_avail += lfs_btofsb(fs, bp->b_bcount);
+		lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));
+		/* XXX should this wake up fs->lfs_availsleep? */
 	}
 	brelse(bp, BC_INVAL);
 
@@ -208,7 +209,7 @@
 
 		if (lbn < ULFS_NDADDR)
 			newsize = ip->i_ffs1_size = (lbn << fs->lfs_bshift) +
-				(size - fs->lfs_fsize) + 1;
+				(size - lfs_sb_getfsize(fs)) + 1;
 		else
 			newsize = ip->i_ffs1_size = (lbn << fs->lfs_bshift) + 1;
 
@@ -387,7 +388,7 @@
 			offset = -1;
 			goto err1;
 		}
-		if (ssp->ss_create < fs->lfs_tstamp) {
+		if (ssp->ss_create < lfs_sb_gettstamp(fs)) {
 			DLOG((DLOG_RF, "Old data at 0x%" PRIx64 "\n", offset));
 			offset = -1;
 			goto err1;
@@ -440,7 +441,7 @@
 		if (ninos && *iaddr == offset) {
 			if (flags & CHECK_CKSUM) {
 				/* Read in the head and add to the buffer */
-				error = bread(devvp, LFS_FSBTODB(fs, offset), fs->lfs_bsize,
+				error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getbsize(fs),
 					      0, &dbp);
 				if (error) {
 					offset = -1;
@@ -462,7 +463,7 @@
 			--i; /* compensate */
 			continue;
 		}
-		size = fs->lfs_bsize;
+		size = lfs_sb_getbsize(fs);
 		for (j = 0; j < fip->fi_nblocks; ++j) {
 			if (j == fip->fi_nblocks - 1)
 				size = fip->fi_lastlength;
@@ -502,7 +503,7 @@
 	}
 
 	/* If we're at the end of the segment, move to the next */
-	if (lfs_dtosn(fs, offset + lfs_btofsb(fs, fs->lfs_sumsize + fs->lfs_bsize)) !=
+	if (lfs_dtosn(fs, offset + lfs_btofsb(fs, fs->lfs_sumsize + lfs_sb_getbsize(fs))) !=
 	   lfs_dtosn(fs, offset)) {
 		if (lfs_dtosn(fs, offset) == lfs_dtosn(fs, ssp->ss_next)) {
 			offset = -1;
@@ -514,7 +515,7 @@
 	}
 
 	if (flags & CHECK_UPDATE) {
-		fs->lfs_avail -= (offset - oldoffset);
+		lfs_sb_subavail(fs, offset - oldoffset);
 		/* Don't clog the buffer queue */
 		mutex_enter(&lfs_lock);
 		if (locked_queue_count > LFS_MAX_BUFS ||
@@ -532,7 +533,7 @@
 
 	/* XXX should we update the serial number even for bad psegs? */
 	if ((flags & CHECK_UPDATE) && offset > 0 && fs->lfs_version > 1)
-		fs->lfs_serial = nextserial;
+		lfs_sb_setserial(fs, nextserial);
 	return offset;
 }
 
@@ -570,7 +571,7 @@
 		 * the segments in question dirty, so they won't be
 		 * reallocated.
 		 */
-		lastgoodpseg = oldoffset = offset = fs->lfs_offset;
+		lastgoodpseg = oldoffset = offset = lfs_sb_getoffset(fs);
 		flags = 0x0;
 		DLOG((DLOG_RF, "LFS roll forward phase 1: start at offset 0x%"
 		      PRIx64 "\n", offset));
@@ -579,7 +580,7 @@
 			--fs->lfs_nclean;
 		sup->su_flags |= SEGUSE_DIRTY;
 		LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, offset), bp);
-		nextserial = fs->lfs_serial + 1;
+		nextserial = lfs_sb_getserial(fs) + 1;
 		while ((offset = check_segsum(fs, offset, nextserial,
 		    cred, CHECK_CKSUM, &flags, l)) > 0) {
 			nextserial++;
@@ -613,13 +614,13 @@
 		}
 		DLOG((DLOG_RF, "LFS roll forward phase 1: completed: "
 		      "lastgoodpseg=0x%" PRIx64 "\n", lastgoodpseg));
-		oldoffset = fs->lfs_offset;
-		if (fs->lfs_offset != lastgoodpseg) {
+		oldoffset = lfs_sb_getoffset(fs);
+		if (lfs_sb_getoffset(fs) != lastgoodpseg) {
 			/* Don't overwrite what we're trying to preserve */
-			offset = fs->lfs_offset;
-			fs->lfs_offset = lastgoodpseg;
-			fs->lfs_curseg = lfs_sntod(fs, lfs_dtosn(fs, fs->lfs_offset));
-			for (sn = curseg = lfs_dtosn(fs, fs->lfs_curseg);;) {
+			offset = lfs_sb_getoffset(fs);
+			lfs_sb_setoffset(fs, lastgoodpseg);
+			lfs_sb_setcurseg(fs, lfs_sntod(fs, lfs_dtosn(fs, lfs_sb_getoffset(fs))));
+			for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs));;) {
 				sn = (sn + 1) % fs->lfs_nseg;
 				if (sn == curseg)
 					panic("lfs_mountfs: no clean segments");
@@ -629,7 +630,7 @@
 				if (!dirty)
 					break;
 			}
-			fs->lfs_nextseg = lfs_sntod(fs, sn);
+			lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
 
 			/*
 			 * Phase II: Roll forward from the first superblock.
@@ -638,7 +639,7 @@
 				DLOG((DLOG_RF, "LFS roll forward phase 2: 0x%"
 				      PRIx64 "\n", offset));
 				offset = check_segsum(fs, offset,
-				    fs->lfs_serial + 1, cred, CHECK_UPDATE,
+				    lfs_sb_getserial(fs) + 1, cred, CHECK_UPDATE,
 				    NULL, l);
 			}
 
@@ -647,8 +648,8 @@
 			 */
 			lfs_segwrite(mp, SEGM_CKP | SEGM_SYNC);
 			DLOG((DLOG_RF, "lfs_mountfs: roll forward ",
-			      "recovered %lld blocks\n",
-			      (long long)(lastgoodpseg - oldoffset)));
+			      "recovered %jd blocks\n",
+			      (intmax_t)(lastgoodpseg - oldoffset)));
 		}
 		DLOG((DLOG_RF, "LFS roll forward complete\n"));
 	}

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_segment.c,v 1.241 2015/06/07 13:39:48 hannken Exp $	*/
+/*	$NetBSD: lfs_segment.c,v 1.242 2015/07/24 06:56:42 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_segment.c,v 1.241 2015/06/07 13:39:48 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_segment.c,v 1.242 2015/07/24 06:56:42 dholland Exp $");
 
 #define _VFS_VNODE_PRIVATE	/* XXX: check for VI_MARKER, this has to go */
 
@@ -121,8 +121,9 @@
  * to go on to a new segment.
  */
 #define	LFS_PARTIAL_FITS(fs) \
-	((fs)->lfs_fsbpseg - ((fs)->lfs_offset - (fs)->lfs_curseg) > \
-	(fs)->lfs_frag)
+	(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
@@ -242,9 +243,10 @@
 						continue;
 					if ((pg->flags & PG_CLEAN) == 0 ||
 					    pmap_is_modified(pg)) {
-						fs->lfs_avail += lfs_btofsb(fs,
-							bp->b_bcount);
-						wakeup(&fs->lfs_avail);
+						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);
@@ -261,9 +263,9 @@
 				   && tbp->b_lblkno == bp->b_lblkno
 				   && tbp != bp)
 				{
-					fs->lfs_avail += lfs_btofsb(fs,
-						bp->b_bcount);
-					wakeup(&fs->lfs_avail);
+					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);
@@ -308,8 +310,8 @@
 
 			KASSERT((bp->b_flags & B_GATHERED) == 0);
 			if (bp->b_oflags & BO_DELWRI) { /* XXX always true? */
-				fs->lfs_avail += lfs_btofsb(fs, bp->b_bcount);
-				wakeup(&fs->lfs_avail);
+				lfs_sb_addavail(fs, lfs_btofsb(fs, bp->b_bcount));
+				wakeup(&fs->lfs_availsleep);
 			}
 			/* Copied from lfs_writeseg */
 			if (bp->b_iodone != NULL) {
@@ -503,8 +505,8 @@
 			mutex_exit(&mntvnode_lock);
 			if (lfs_writeseg(fs, sp) &&
 			    (sp->seg_flags & SEGM_SINGLE) &&
-			    fs->lfs_curseg != fs->lfs_startseg) {
-				DLOG((DLOG_VNODE, "lfs_writevnodes: breaking out of segment write at daddr 0x%x\n", fs->lfs_offset));
+			    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;
@@ -660,8 +662,8 @@
 		do {
 			um_error = lfs_writevnodes(fs, mp, sp, VN_REG);
 			if ((sp->seg_flags & SEGM_SINGLE) &&
-			    fs->lfs_curseg != fs->lfs_startseg) {
-				DLOG((DLOG_SEG, "lfs_segwrite: breaking out of segment write at daddr 0x%x\n", fs->lfs_offset));
+			    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;
 			}
 
@@ -692,16 +694,16 @@
 	if (do_ckp || fs->lfs_doifile) {
 		segleft = fs->lfs_nseg;
 		curseg = 0;
-		for (n = 0; n < fs->lfs_segtabsz; n++) {
+		for (n = 0; n < lfs_sb_getsegtabsz(fs); n++) {
 			dirty = 0;
-			if (bread(fs->lfs_ivnode, fs->lfs_cleansz + n,
-			    fs->lfs_bsize, B_MODIFY, &bp))
+			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, fs->lfs_sepb);
+			maxseg = min(segleft, lfs_sb_getsepb(fs));
 			for (i = 0; i < maxseg; i++) {
 				sn = curseg + i;
-				if (sn != lfs_dtosn(fs, fs->lfs_curseg) &&
+				if (sn != lfs_dtosn(fs, lfs_sb_getcurseg(fs)) &&
 				    segusep->su_flags & SEGUSE_ACTIVE) {
 					segusep->su_flags &= ~SEGUSE_ACTIVE;
 					--fs->lfs_nactive;
@@ -720,8 +722,8 @@
 				error = LFS_BWRITE_LOG(bp); /* Ifile */
 			else
 				brelse(bp, 0);
-			segleft -= fs->lfs_sepb;
-			curseg += fs->lfs_sepb;
+			segleft -= lfs_sb_getsepb(fs);
+			curseg += lfs_sb_getsepb(fs);
 		}
 	}
 
@@ -790,8 +792,8 @@
 		else if (do_ckp) {
 			int do_panic = 0;
 			LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) {
-				if (bp->b_lblkno < fs->lfs_cleansz +
-				    fs->lfs_segtabsz &&
+				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,
@@ -906,7 +908,7 @@
 	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] < fs->lfs_bsize)
+			    ip->i_lfs_fragsize[i] < lfs_sb_getbsize(fs))
 				++frag;
 	}
 #ifdef DIAGNOSTIC
@@ -946,8 +948,8 @@
 	 */
 	ino = ip->i_number;
 	if (ino == LFS_IFILE_INUM) {
-		daddr = fs->lfs_idaddr;
-		fs->lfs_idaddr = LFS_DBTOFSB(fs, ndaddr);
+		daddr = lfs_sb_getidaddr(fs);
+		lfs_sb_setidaddr(fs, LFS_DBTOFSB(fs, ndaddr));
 	} else {
 		LFS_IENTRY(ifp, fs, ino, bp);
 		daddr = ifp->if_daddr;
@@ -961,9 +963,9 @@
 	 * (XXX should already be dirty?) and tell the caller to do it again.
 	 */
 	if (ip->i_number == LFS_IFILE_INUM) {
-		sn = lfs_dtosn(fs, fs->lfs_offset);
+		sn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
 		if (lfs_sntod(fs, sn) + lfs_btofsb(fs, fs->lfs_sumsize) ==
-		    fs->lfs_offset) {
+		    lfs_sb_getoffset(fs)) {
 			LFS_SEGENTRY(sup, fs, sn, bp);
 			KASSERT(bp->b_oflags & BO_DELWRI);
 			LFS_WRITESEGENTRY(sup, fs, sn, bp);
@@ -982,7 +984,7 @@
 	 * zero here; keep track of how many duplicates we have in
 	 * "dupino" so we don't panic below.
 	 */
-	if (daddr >= fs->lfs_lastpseg && daddr <= fs->lfs_offset) {
+	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,
@@ -1028,7 +1030,7 @@
 			fs->lfs_flags |= LFS_IFDIRTY;
 			mutex_exit(&lfs_lock);
 			/* Don't double-account */
-			fs->lfs_idaddr = 0x0;
+			lfs_sb_setidaddr(fs, 0x0);
 		}
 		LFS_WRITESEGENTRY(sup, fs, oldsn, bp); /* Ifile */
 	}
@@ -1106,8 +1108,8 @@
 			(void) lfs_writeseg(fs, sp);
 
 		/* Get next inode block. */
-		daddr = fs->lfs_offset;
-		fs->lfs_offset += lfs_btofsb(fs, fs->lfs_ibsize);
+		daddr = lfs_sb_getoffset(fs);
+		lfs_sb_addoffset(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
 		sp->ibp = *sp->cbpp++ =
 			getblk(VTOI(fs->lfs_ivnode)->i_devvp,
 			    LFS_FSBTODB(fs, daddr), fs->lfs_ibsize, 0, 0);
@@ -1119,7 +1121,7 @@
 			    0;
 
 		++sp->start_bpp;
-		fs->lfs_avail -= lfs_btofsb(fs, fs->lfs_ibsize);
+		lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
 		/* Set remaining space counters. */
 		sp->seg_bytes_left -= fs->lfs_ibsize;
 		sp->sum_bytes_left -= sizeof(int32_t);
@@ -1212,8 +1214,8 @@
 	}
 	if (ip->i_lfs_effnblks != ip->i_ffs1_blocks) {
 		DLOG((DLOG_SEG, "lfs_writeinode: cleansing ino %d eff %d != nblk %d)"
-		      " at %x\n", ip->i_number, ip->i_lfs_effnblks,
-		      ip->i_ffs1_blocks, fs->lfs_offset));
+		      " at %jx\n", ip->i_number, ip->i_lfs_effnblks,
+		      ip->i_ffs1_blocks, (uintmax_t)lfs_sb_getoffset(fs)));
 		for (daddrp = cdp->di_db; daddrp < cdp->di_ib + ULFS_NIADDR;
 		     daddrp++) {
 			if (*daddrp == UNWRITTEN) {
@@ -1228,7 +1230,7 @@
 	 * Check dinode held blocks against dinode size.
 	 * This should be identical to the check in lfs_vget().
 	 */
-	for (i = (cdp->di_size + fs->lfs_bsize - 1) >> fs->lfs_bshift;
+	for (i = (cdp->di_size + lfs_sb_getbsize(fs) - 1) >> fs->lfs_bshift;
 	     i < ULFS_NDADDR; i++) {
 		KASSERT(i >= 0);
 		if ((cdp->di_mode & LFS_IFMT) == LFS_IFLNK)
@@ -1308,7 +1310,7 @@
 		panic ("lfs_gatherblock: Null vp in segment");
 #endif
 	fs = sp->fs;
-	blksinblk = howmany(bp->b_bcount, fs->lfs_bsize);
+	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)
@@ -1391,9 +1393,9 @@
 			    (bp->b_cflags & BC_BUSY) != 0 &&
 			    (bp->b_flags & B_GATHERED) == 0)
 				log(LOG_NOTICE, "lfs_gather: ifile lbn %"
-				      PRId64 " busy (%x) at 0x%x",
+				      PRId64 " busy (%x) at 0x%jx",
 				      bp->b_lblkno, bp->b_flags,
-				      (unsigned)fs->lfs_offset);
+				      (uintmax_t)lfs_sb_getoffset(fs));
 #endif
 			continue;
 		}
@@ -1497,7 +1499,7 @@
 		    break;
 	    default:
 		    ap = &a[num - 1];
-		    if (bread(vp, ap->in_lbn, fs->lfs_bsize,
+		    if (bread(vp, ap->in_lbn, lfs_sb_getbsize(fs),
 			B_MODIFY, &bp))
 			    panic("lfs_updatemeta: bread bno %" PRId64,
 				  ap->in_lbn);
@@ -1543,7 +1545,7 @@
 		if (lbn >= 0 && lbn < ULFS_NDADDR)
 			osize = ip->i_lfs_fragsize[lbn];
 		else
-			osize = fs->lfs_bsize;
+			osize = lfs_sb_getbsize(fs);
 		LFS_SEGENTRY(sup, fs, oldsn, bp);
 #ifdef DIAGNOSTIC
 		if (sup->su_nbytes + sizeof (struct ulfs1_dinode) * ndupino
@@ -1618,7 +1620,7 @@
 			nblocks = i;
 			break;
 		}
-		num = howmany(sp->start_bpp[i]->b_bcount, fs->lfs_bsize);
+		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;
 	}
@@ -1635,7 +1637,7 @@
 	 * 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, fs->lfs_bsize);
+	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.
@@ -1660,7 +1662,7 @@
 		lbn = *sp->start_lbp;
 		KASSERT(sbp->b_lblkno == lbn);
 
-		sbp->b_blkno = LFS_FSBTODB(fs, fs->lfs_offset);
+		sbp->b_blkno = LFS_FSBTODB(fs, lfs_sb_getoffset(fs));
 
 		/*
 		 * If we write a frag in the wrong place, the cleaner won't
@@ -1676,16 +1678,16 @@
 		 * For each subblock in this possibly oversized block,
 		 * update its address on disk.
 		 */
-		KASSERT(lbn >= 0 || sbp->b_bcount == fs->lfs_bsize);
+		KASSERT(lbn >= 0 || sbp->b_bcount == lfs_sb_getbsize(fs));
 		KASSERT(vp == sbp->b_vp);
 		for (bytesleft = sbp->b_bcount; bytesleft > 0;
-		     bytesleft -= fs->lfs_bsize) {
-			size = MIN(bytesleft, fs->lfs_bsize);
+		     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, fs->lfs_offset,
+			lfs_update_single(fs, sp, sp->vp, lbn, lfs_sb_getoffset(fs),
 			    size);
-			fs->lfs_offset += bb;
+			lfs_sb_addoffset(fs, bb);
 		}
 
 	}
@@ -1706,12 +1708,12 @@
 
 	ASSERT_SEGLOCK(fs);
 
-	osn = lfs_dtosn(fs, fs->lfs_offset);
+	osn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
 	if (osn < newsn)
 		return 0;
 
 	/* lfs_avail eats the remaining space in this segment */
-	fs->lfs_avail -= fs->lfs_fsbpseg - (fs->lfs_offset - fs->lfs_curseg);
+	lfs_sb_subavail(fs, fs->lfs_fsbpseg - (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
 
 	/* Find a low-numbered segment */
 	for (sn = 0; sn < fs->lfs_nseg; ++sn) {
@@ -1726,9 +1728,9 @@
 		panic("lfs_rewind: no clean segments");
 	if (newsn >= 0 && sn >= newsn)
 		return ENOENT;
-	fs->lfs_nextseg = sn;
+	lfs_sb_setnextseg(fs, sn);
 	lfs_newseg(fs);
-	fs->lfs_offset = fs->lfs_curseg;
+	lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
 
 	return 0;
 }
@@ -1754,15 +1756,15 @@
 		struct buf *bp;
 
 		/* lfs_avail eats the remaining space */
-		fs->lfs_avail -= fs->lfs_fsbpseg - (fs->lfs_offset -
-						   fs->lfs_curseg);
+		lfs_sb_subavail(fs, fs->lfs_fsbpseg - (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;
-		fs->lfs_offset = fs->lfs_curseg;
+		lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
 
-		sp->seg_number = lfs_dtosn(fs, fs->lfs_curseg);
+		sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
 		sp->seg_bytes_left = lfs_fsbtob(fs, fs->lfs_fsbpseg);
 
 		/*
@@ -1771,28 +1773,28 @@
 		 */
 		LFS_SEGENTRY(sup, fs, sp->seg_number, bp);
 		if (sup->su_flags & SEGUSE_SUPERBLOCK) {
-			fs->lfs_offset += lfs_btofsb(fs, LFS_SBPAD);
+			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 &&
 		    fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD)) {
-			fs->lfs_offset +=
-			    lfs_btofsb(fs, LFS_LABELPAD) - fs->lfs_s0addr;
+			lfs_sb_addoffset(fs,
+			    lfs_btofsb(fs, LFS_LABELPAD) - fs->lfs_s0addr);
 			sp->seg_bytes_left -=
 			    LFS_LABELPAD - lfs_fsbtob(fs, fs->lfs_s0addr);
 		}
 	} else {
-		sp->seg_number = lfs_dtosn(fs, fs->lfs_curseg);
+		sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
 		sp->seg_bytes_left = lfs_fsbtob(fs, fs->lfs_fsbpseg -
-				      (fs->lfs_offset - fs->lfs_curseg));
+				      (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
 	}
-	fs->lfs_lastpseg = fs->lfs_offset;
+	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] = fs->lfs_offset;
+		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);
@@ -1815,19 +1817,19 @@
 
 	/* Get a new buffer for SEGSUM */
 	sbp = lfs_newbuf(fs, VTOI(fs->lfs_ivnode)->i_devvp,
-	    LFS_FSBTODB(fs, fs->lfs_offset), fs->lfs_sumsize, LFS_NB_SUMMARY);
+	    LFS_FSBTODB(fs, lfs_sb_getoffset(fs)), fs->lfs_sumsize, LFS_NB_SUMMARY);
 
 	/* ... and enter it into the buffer list. */
 	*sp->cbpp = sbp;
 	sp->cbpp++;
-	fs->lfs_offset += lfs_btofsb(fs, fs->lfs_sumsize);
+	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, fs->lfs_sumsize);
-	ssp->ss_next = fs->lfs_nextseg;
+	ssp->ss_next = lfs_sb_getnextseg(fs);
 	ssp->ss_nfinfo = ssp->ss_ninos = 0;
 	ssp->ss_magic = SS_MAGIC;
 
@@ -1878,7 +1880,7 @@
 
 	/* Honor LFCNWRAPSTOP */
 	mutex_enter(&lfs_lock);
-	while (fs->lfs_nextseg < fs->lfs_curseg && fs->lfs_nowrap) {
+	while (lfs_sb_getnextseg(fs) < lfs_sb_getcurseg(fs) && fs->lfs_nowrap) {
 		if (fs->lfs_wrappass) {
 			log(LOG_NOTICE, "%s: wrappass=%d\n",
 				fs->lfs_fsmnt, fs->lfs_wrappass);
@@ -1894,14 +1896,14 @@
 	fs->lfs_wrapstatus = LFS_WRAP_GOING;
 	mutex_exit(&lfs_lock);
 
-	LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, fs->lfs_nextseg), bp);
+	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, fs->lfs_nextseg)));
+	      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, fs->lfs_nextseg), bp);
+	LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getnextseg(fs)), bp);
 
 	LFS_CLEANERINFO(cip, fs, bp);
 	--cip->clean;
@@ -1909,10 +1911,10 @@
 	fs->lfs_nclean = cip->clean;
 	LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
 
-	fs->lfs_lastseg = fs->lfs_curseg;
-	fs->lfs_curseg = fs->lfs_nextseg;
+	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, fs->lfs_curseg) + fs->lfs_interleave;;) {
+	for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + fs->lfs_interleave;;) {
 		sn = (sn + 1) % fs->lfs_nseg;
 
 		if (sn == curseg) {
@@ -1937,7 +1939,7 @@
 		lfs_unset_inval_all(fs);
 
 	++fs->lfs_nactive;
-	fs->lfs_nextseg = lfs_sntod(fs, sn);
+	lfs_sb_setnextseg(fs, lfs_sntod(fs, sn));
 	if (lfs_dostats) {
 		++lfs_stats.segsused;
 	}
@@ -2063,7 +2065,7 @@
 		sup->su_lastmod = time_second;
 	sup->su_ninos += ninos;
 	++sup->su_nsums;
-	fs->lfs_avail -= lfs_btofsb(fs, fs->lfs_sumsize);
+	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 */
@@ -2150,8 +2152,8 @@
 					 * back around to us in the next
 					 * segment.
 					 */
-					fs->lfs_avail -=
-					    lfs_btofsb(fs, bp->b_bcount);
+					lfs_sb_subavail(fs,
+					    lfs_btofsb(fs, bp->b_bcount));
 				}
 			} else {
 				lfs_freebuf(fs, newbp);
@@ -2180,7 +2182,7 @@
 		++bpp;
 		/* Loop through gop_write cluster blocks */
 		for (byteoffset = 0; byteoffset < (*bpp)->b_bcount;
-		     byteoffset += fs->lfs_bsize) {
+		     byteoffset += lfs_sb_getbsize(fs)) {
 #ifdef LFS_USE_B_INVAL
 			if (((*bpp)->b_cflags & BC_INVAL) != 0 &&
 			    (*bpp)->b_iodone != NULL) {
@@ -2203,7 +2205,8 @@
 		ssp->ss_ocreate = time_second;
 	else {
 		ssp->ss_create = time_second;
-		ssp->ss_serial = ++fs->lfs_serial;
+		lfs_sb_addserial(fs, 1);
+		ssp->ss_serial = lfs_sb_getserial(fs);
 		ssp->ss_ident  = fs->lfs_ident;
 	}
 	ssp->ss_datasum = lfs_cksum_fold(sum);
@@ -2211,10 +2214,10 @@
 	    fs->lfs_sumsize - sizeof(ssp->ss_sumsum));
 
 	mutex_enter(&lfs_lock);
-	fs->lfs_bfree -= (lfs_btofsb(fs, ninos * fs->lfs_ibsize) +
-			  lfs_btofsb(fs, fs->lfs_sumsize));
-	fs->lfs_dmeta += (lfs_btofsb(fs, ninos * fs->lfs_ibsize) +
-			  lfs_btofsb(fs, fs->lfs_sumsize));
+	lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * fs->lfs_ibsize) +
+			  lfs_btofsb(fs, fs->lfs_sumsize)));
+	lfs_sb_adddmeta(fs, (lfs_btofsb(fs, ninos * fs->lfs_ibsize) +
+			  lfs_btofsb(fs, fs->lfs_sumsize)));
 	mutex_exit(&lfs_lock);
 
 	/*
@@ -2264,7 +2267,7 @@
 				break;
 
 			/* Clusters from GOP_WRITE are expedited */
-			if (bp->b_bcount > fs->lfs_bsize) {
+			if (bp->b_bcount > lfs_sb_getbsize(fs)) {
 				if (cbp->b_bcount > 0)
 					/* Put in its own buffer */
 					break;
@@ -2380,8 +2383,8 @@
 
 	/* Set timestamp of this version of the superblock */
 	if (fs->lfs_version == 1)
-		fs->lfs_otstamp = time_second;
-	fs->lfs_tstamp = time_second;
+		lfs_sb_setotstamp(fs, time_second);
+	lfs_sb_settstamp(fs, time_second);
 
 	/* Checksum the superblock and copy it into a buffer. */
 	fs->lfs_cksum = lfs_sb_cksum(&(fs->lfs_dlfs));
@@ -2759,7 +2762,7 @@
 
 	KASSERT(vers > 0);
 
-	if (sp->seg_bytes_left < fs->lfs_bsize ||
+	if (sp->seg_bytes_left < lfs_sb_getbsize(fs) ||
 	    sp->sum_bytes_left < sizeof(struct finfo))
 		(void) lfs_writeseg(fs, fs->lfs_sp);
 	

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_syscalls.c,v 1.160 2015/05/31 15:48:03 hannken Exp $	*/
+/*	$NetBSD: lfs_syscalls.c,v 1.161 2015/07/24 06:56:42 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003, 2007, 2007, 2008
@@ -61,7 +61,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_syscalls.c,v 1.160 2015/05/31 15:48:03 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_syscalls.c,v 1.161 2015/07/24 06:56:42 dholland Exp $");
 
 #ifndef LFS
 # define LFS		/* for prototypes in syscallargs.h */
@@ -252,7 +252,7 @@
 		return EROFS;
 
 	maxino = (lfs_fragstoblks(fs, VTOI(fs->lfs_ivnode)->i_ffs1_blocks) -
-		      fs->lfs_cleansz - fs->lfs_segtabsz) * fs->lfs_ifpb;
+		      lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);
 
 	cnt = blkcnt;
 
@@ -390,7 +390,7 @@
 		if (blkp->bi_lbn >= 0)
 			obsize = lfs_blksize(fs, ip, blkp->bi_lbn);
 		else
-			obsize = fs->lfs_bsize;
+			obsize = lfs_sb_getbsize(fs);
 		/* Check for fragment size change */
 		if (blkp->bi_lbn >= 0 && blkp->bi_lbn < ULFS_NDADDR) {
 			obsize = ip->i_lfs_fragsize[blkp->bi_lbn];
@@ -420,7 +420,7 @@
 			bp->b_blkno = LFS_FSBTODB(fs, blkp->bi_daddr);
 		} else {
 			/* Indirect block or ifile */
-			if (blkp->bi_size != fs->lfs_bsize &&
+			if (blkp->bi_size != lfs_sb_getbsize(fs) &&
 			    ip->i_number != LFS_IFILE_INUM)
 				panic("lfs_markv: partial indirect block?"
 				    " size=%d\n", blkp->bi_size);
@@ -702,7 +702,7 @@
 			 */
 			lastino = blkp->bi_inode;
 			if (blkp->bi_inode == LFS_IFILE_INUM)
-				v_daddr = fs->lfs_idaddr;
+				v_daddr = lfs_sb_getidaddr(fs);
 			else {
 				LFS_IENTRY(ifp, fs, blkp->bi_inode, bp);
 				v_daddr = ifp->if_daddr;
@@ -763,7 +763,7 @@
 			if (blkp->bi_lbn >= 0)
 				blkp->bi_size = lfs_blksize(fs, ip, blkp->bi_lbn);
 			else
-				blkp->bi_size = fs->lfs_bsize;
+				blkp->bi_size = lfs_sb_getbsize(fs);
 		}
 	}
 
@@ -844,7 +844,7 @@
 	CLEANERINFO *cip;
 	SEGUSE *sup;
 
-	if (lfs_dtosn(fs, fs->lfs_curseg) == segnum) {
+	if (lfs_dtosn(fs, lfs_sb_getcurseg(fs)) == segnum) {
 		return (EBUSY);
 	}
 
@@ -868,19 +868,19 @@
 		return (EALREADY);
 	}
 
-	fs->lfs_avail += lfs_segtod(fs, 1);
+	lfs_sb_addavail(fs, lfs_segtod(fs, 1));
 	if (sup->su_flags & SEGUSE_SUPERBLOCK)
-		fs->lfs_avail -= lfs_btofsb(fs, LFS_SBPAD);
+		lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_SBPAD));
 	if (fs->lfs_version > 1 && segnum == 0 &&
 	    fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD))
-		fs->lfs_avail -= lfs_btofsb(fs, LFS_LABELPAD) - fs->lfs_s0addr;
+		lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_LABELPAD) - fs->lfs_s0addr);
 	mutex_enter(&lfs_lock);
-	fs->lfs_bfree += sup->su_nsums * lfs_btofsb(fs, fs->lfs_sumsize) +
-		lfs_btofsb(fs, sup->su_ninos * fs->lfs_ibsize);
-	fs->lfs_dmeta -= sup->su_nsums * lfs_btofsb(fs, fs->lfs_sumsize) +
-		lfs_btofsb(fs, sup->su_ninos * fs->lfs_ibsize);
-	if (fs->lfs_dmeta < 0)
-		fs->lfs_dmeta = 0;
+	lfs_sb_addbfree(fs, sup->su_nsums * lfs_btofsb(fs, fs->lfs_sumsize) +
+		lfs_btofsb(fs, sup->su_ninos * lfs_sb_getibsize(fs)));
+	lfs_sb_subdmeta(fs, sup->su_nsums * lfs_btofsb(fs, fs->lfs_sumsize) +
+		lfs_btofsb(fs, sup->su_ninos * lfs_sb_getibsize(fs)));
+	if (lfs_sb_getdmeta(fs) < 0)
+		lfs_sb_setdmeta(fs, 0);
 	mutex_exit(&lfs_lock);
 	sup->su_flags &= ~SEGUSE_DIRTY;
 	LFS_WRITESEGENTRY(sup, fs, segnum, bp);
@@ -889,10 +889,10 @@
 	++cip->clean;
 	--cip->dirty;
 	fs->lfs_nclean = cip->clean;
-	cip->bfree = fs->lfs_bfree;
 	mutex_enter(&lfs_lock);
-	cip->avail = fs->lfs_avail - fs->lfs_ravail - fs->lfs_favail;
-	wakeup(&fs->lfs_avail);
+	cip->bfree = lfs_sb_getbfree(fs);
+	cip->avail = lfs_sb_getavail(fs) - fs->lfs_ravail - fs->lfs_favail;
+	wakeup(&fs->lfs_availsleep);
 	mutex_exit(&lfs_lock);
 	(void) LFS_BWRITE_LOG(bp);
 
@@ -919,7 +919,7 @@
 	if (fsidp == NULL || (mntp = vfs_getvfs(fsidp)) == NULL)
 		addr = &lfs_allclean_wakeup;
 	else
-		addr = &VFSTOULFS(mntp)->um_lfs->lfs_nextseg;
+		addr = &VFSTOULFS(mntp)->um_lfs->lfs_nextsegsleep;
 	/*
 	 * XXX THIS COULD SLEEP FOREVER IF TIMEOUT IS {0,0}!
 	 * XXX IS THAT WHAT IS INTENDED?

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_vfsops.c,v 1.326 2015/07/16 08:31:45 dholland Exp $	*/
+/*	$NetBSD: lfs_vfsops.c,v 1.327 2015/07/24 06:56:42 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.326 2015/07/16 08:31:45 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_vfsops.c,v 1.327 2015/07/24 06:56:42 dholland Exp $");
 
 #if defined(_KERNEL_OPT)
 #include "opt_lfs.h"
@@ -462,9 +462,9 @@
 				fsflags = SEGM_SINGLE;
 
  				mutex_enter(&lfs_lock);
-				ooffset = fs->lfs_offset;
+				ooffset = lfs_sb_getoffset(fs);
 
-				if (fs->lfs_nextseg < fs->lfs_curseg && fs->lfs_nowrap) {
+				if (lfs_sb_getnextseg(fs) < lfs_sb_getcurseg(fs) && fs->lfs_nowrap) {
 					/* Don't try to write if we're suspended */
 					mutex_exit(&lfs_lock);
 					vfs_unbusy(mp, false, &nmp);
@@ -497,7 +497,7 @@
  					lfs_writer_leave(fs);
 					mutex_enter(&lfs_lock);
 				}
-				if (fs->lfs_offset != ooffset)
+				if (lfs_sb_getoffset(fs) != ooffset)
 					++wrote_something;
 				mutex_exit(&lfs_lock);
  			}
@@ -609,7 +609,7 @@
 	(void)copystr(mp->mnt_stat.f_mntonname, fs->lfs_fsmnt, MNAMELEN - 1, 0);
 	(void)lfs_statvfs(mp, &mp->mnt_stat);
 	vfs_unbusy(mp, false, NULL);
-	setrootfstime((time_t)(VFSTOULFS(mp)->um_lfs->lfs_tstamp));
+	setrootfstime((time_t)lfs_sb_gettstamp(VFSTOULFS(mp)->um_lfs));
 	return (0);
 }
 
@@ -953,10 +953,10 @@
 	/* Compatibility */
 	if (fs->lfs_version < 2) {
 		fs->lfs_sumsize = LFS_V1_SUMMARY_SIZE;
-		fs->lfs_ibsize = fs->lfs_bsize;
+		lfs_sb_setibsize(fs, lfs_sb_getbsize(fs));
 		fs->lfs_s0addr = fs->lfs_sboffs[0];
-		fs->lfs_tstamp = fs->lfs_otstamp;
-		fs->lfs_fsbtodb = 0;
+		lfs_sb_settstamp(fs, lfs_sb_getotstamp(fs));
+		lfs_sb_setfsbtodb(fs, 0);
 	}
 	if (fs->lfs_resvseg == 0)
 		fs->lfs_resvseg = MIN(fs->lfs_minfreeseg - 1, \
@@ -1003,7 +1003,7 @@
 	fs->lfs_iocount = 0;
 	fs->lfs_diropwait = 0;
 	fs->lfs_activesb = 0;
-	fs->lfs_uinodes = 0;
+	lfs_sb_setuinodes(fs, 0);
 	fs->lfs_ravail = 0;
 	fs->lfs_favail = 0;
 	fs->lfs_sbactive = 0;
@@ -1029,7 +1029,7 @@
 	/* ulfs-level information */
 	fs->um_flags = 0;
 	fs->um_bptrtodb = fs->lfs_ffshift - DEV_BSHIFT;
-	fs->um_seqinc = fs->lfs_frag;
+	fs->um_seqinc = lfs_sb_getfrag(fs);
 	fs->um_nindir = fs->lfs_nindir;
 	fs->um_lognindir = ffs(fs->lfs_nindir) - 1;
 	fs->um_maxsymlinklen = fs->lfs_maxsymlinklen;
@@ -1051,7 +1051,7 @@
 	mp->mnt_stat.f_fsidx.__fsid_val[1] = makefstype(MOUNT_LFS);
 	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
 	mp->mnt_stat.f_namemax = LFS_MAXNAMLEN;
-	mp->mnt_stat.f_iosize = fs->lfs_bsize;
+	mp->mnt_stat.f_iosize = lfs_sb_getbsize(fs);
 	mp->mnt_flag |= MNT_LOCAL;
 	mp->mnt_fs_bshift = fs->lfs_bshift;
 	if (fs->um_maxsymlinklen > 0)
@@ -1197,20 +1197,20 @@
 	 * the superblock.
 	 */
 	LFS_CLEANERINFO(cip, fs, bp);
-	cip->clean = fs->lfs_nclean;
-	cip->dirty = fs->lfs_nseg - fs->lfs_nclean;
-	cip->avail = fs->lfs_avail;
-	cip->bfree = fs->lfs_bfree;
+	cip->clean = lfs_sb_getnclean(fs);
+	cip->dirty = lfs_sb_getnseg(fs) - lfs_sb_getnclean(fs);
+	cip->avail = lfs_sb_getavail(fs);
+	cip->bfree = lfs_sb_getbfree(fs);
 	(void) LFS_BWRITE_LOG(bp); /* Ifile */
 
 	/*
 	 * Mark the current segment as ACTIVE, since we're going to
 	 * be writing to it.
 	 */
-	LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, fs->lfs_offset), bp);
+	LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getoffset(fs)), bp);
 	sup->su_flags |= SEGUSE_DIRTY | SEGUSE_ACTIVE;
 	fs->lfs_nactive++;
-	LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, fs->lfs_offset), bp);  /* Ifile */
+	LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, lfs_sb_getoffset(fs)), bp);  /* Ifile */
 
 	/* Now that roll-forward is done, unlock the Ifile */
 	vput(vp);
@@ -1363,13 +1363,13 @@
 	if (fs->lfs_magic != LFS_MAGIC)
 		panic("lfs_statvfs: magic");
 
-	sbp->f_bsize = fs->lfs_bsize;
-	sbp->f_frsize = fs->lfs_fsize;
-	sbp->f_iosize = fs->lfs_bsize;
+	sbp->f_bsize = lfs_sb_getbsize(fs);
+	sbp->f_frsize = lfs_sb_getfsize(fs);
+	sbp->f_iosize = lfs_sb_getbsize(fs);
 	sbp->f_blocks = LFS_EST_NONMETA(fs) - VTOI(fs->lfs_ivnode)->i_lfs_effnblks;
 
 	sbp->f_bfree = LFS_EST_BFREE(fs);
-	KASSERT(sbp->f_bfree <= fs->lfs_dsize);
+	KASSERT(sbp->f_bfree <= lfs_sb_getdsize(fs));
 #if 0
 	if (sbp->f_bfree < 0)
 		sbp->f_bfree = 0;
@@ -1381,9 +1381,9 @@
 	else
 		sbp->f_bavail = 0;
 
-	sbp->f_files = fs->lfs_bfree / lfs_btofsb(fs, fs->lfs_ibsize)
+	sbp->f_files = lfs_sb_getbfree(fs) / lfs_btofsb(fs, lfs_sb_getibsize(fs))
 	    * LFS_INOPB(fs);
-	sbp->f_ffree = sbp->f_files - fs->lfs_nfiles;
+	sbp->f_ffree = sbp->f_files - lfs_sb_getnfiles(fs);
 	sbp->f_favail = sbp->f_ffree;
 	sbp->f_fresvd = 0;
 	copy_statvfs_info(sbp, mp);
@@ -1415,7 +1415,7 @@
 	 * XXX the log, we'll likely block.
 	 */
 	mutex_enter(&lfs_lock);
-	if (fs->lfs_nowrap && fs->lfs_nextseg < fs->lfs_curseg) {
+	if (fs->lfs_nowrap && lfs_sb_getnextseg(fs) < lfs_sb_getcurseg(fs)) {
 		mutex_exit(&lfs_lock);
 		return 0;
 	}
@@ -1424,7 +1424,8 @@
 	lfs_writer_enter(fs, "lfs_dirops");
 
 	/* All syncs must be checkpoints until roll-forward is implemented. */
-	DLOG((DLOG_FLUSH, "lfs_sync at 0x%x\n", fs->lfs_offset));
+	DLOG((DLOG_FLUSH, "lfs_sync at 0x%jx\n",
+	      (uintmax_t)lfs_sb_getoffset(fs)));
 	error = lfs_segwrite(mp, SEGM_CKP | (waitfor ? SEGM_SYNC : 0));
 	lfs_writer_leave(fs);
 #ifdef LFS_QUOTA
@@ -1543,7 +1544,7 @@
 
 	/* Translate the inode number to a disk address. */
 	if (ino == LFS_IFILE_INUM)
-		daddr = fs->lfs_idaddr;
+		daddr = lfs_sb_getidaddr(fs);
 	else {
 		/* XXX bounds-check this too */
 		LFS_IENTRY(ifp, fs, ino, bp);
@@ -1580,7 +1581,7 @@
 	retries = 0;
 again:
 	error = bread(ump->um_devvp, LFS_FSBTODB(fs, daddr),
-		(fs->lfs_version == 1 ? fs->lfs_bsize : fs->lfs_ibsize),
+		(fs->lfs_version == 1 ? lfs_sb_getbsize(fs) : fs->lfs_ibsize),
 		0, &bp);
 	if (error) {
 		lfs_deinit_vnode(ump, vp);
@@ -1771,7 +1772,7 @@
 
 	if (lfh.lfid_ino >
 	    ((VTOI(fs->lfs_ivnode)->i_ffs1_size >> fs->lfs_bshift) -
-	     fs->lfs_cleansz - fs->lfs_segtabsz) * fs->lfs_ifpb)
+	     lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs))
 		return ESTALE;
 
 	return (ulfs_fhtovp(mp, &lfh.lfid_ufid, vpp));
@@ -1987,9 +1988,9 @@
 				       UVMPAGER_MAPIN_WAITOK : 0))) == 0x0) {
 		DLOG((DLOG_PAGE, "lfs_gop_write: forcing write\n"));
 #if 0
-		      " with nfinfo=%d at offset 0x%x\n",
+		      " with nfinfo=%d at offset 0x%jx\n",
 		      (int)((SEGSUM *)(sp->segsum))->ss_nfinfo,
-		      (unsigned)fs->lfs_offset));
+		      (uintmax_t)lfs_sb_getoffset(fs)));
 #endif
 		lfs_updatemeta(sp);
 		lfs_release_finfo(fs);
@@ -2116,7 +2117,7 @@
 		mutex_exit(&lfs_lock);
 	}
 
-	if ((sp->seg_flags & SEGM_SINGLE) && fs->lfs_curseg != fs->lfs_startseg)
+	if ((sp->seg_flags & SEGM_SINGLE) && lfs_sb_getcurseg(fs) != fs->lfs_startseg)
 		return EAGAIN;
 
 	return (0);
@@ -2201,7 +2202,7 @@
 	memset(ip->i_lfs_fragsize, 0, ULFS_NDADDR * sizeof(*ip->i_lfs_fragsize));
 	if (vp->v_type != VLNK || ip->i_size >= ip->i_lfs->um_maxsymlinklen) {
 #ifdef DEBUG
-		for (i = (ip->i_size + fs->lfs_bsize - 1) >> fs->lfs_bshift;
+		for (i = (ip->i_size + lfs_sb_getbsize(fs) - 1) >> fs->lfs_bshift;
 		    i < ULFS_NDADDR; i++) {
 			if ((vp->v_type == VBLK || vp->v_type == VCHR) &&
 			    i == 0)
@@ -2247,7 +2248,7 @@
 	uvm_vnp_setsize(vp, ip->i_size);
 
 	/* Initialize hiblk from file size */
-	ip->i_lfs_hiblk = lfs_lblkno(ip->i_lfs, ip->i_size + ip->i_lfs->lfs_bsize - 1) - 1;
+	ip->i_lfs_hiblk = lfs_lblkno(ip->i_lfs, ip->i_size + lfs_sb_getbsize(ip->i_lfs) - 1) - 1;
 
 	*vpp = vp;
 }
@@ -2313,8 +2314,8 @@
 	}
 
 	/* Note old and new segment table endpoints, and old ifile size */
-	olast = fs->lfs_cleansz + fs->lfs_segtabsz;
-	nlast = howmany(newnsegs, fs->lfs_sepb) + fs->lfs_cleansz;
+	olast = lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs);
+	nlast = howmany(newnsegs, lfs_sb_getsepb(fs)) + lfs_sb_getcleansz(fs);
 	ilast = ivp->v_size >> fs->lfs_bshift;
 	noff = nlast - olast;
 
@@ -2327,21 +2328,21 @@
 	rw_enter(&fs->lfs_iflock, RW_WRITER);
 	for (i = 0; i < ilast; i++) {
 		/* XXX what to do if bread fails? */
-		bread(ivp, i, fs->lfs_bsize, 0, &bp);
+		bread(ivp, i, lfs_sb_getbsize(fs), 0, &bp);
 		brelse(bp, 0);
 	}
 
 	/* Allocate new Ifile blocks */
 	for (i = ilast; i < ilast + noff; i++) {
-		if (lfs_balloc(ivp, i * fs->lfs_bsize, fs->lfs_bsize, NOCRED, 0,
+		if (lfs_balloc(ivp, i * lfs_sb_getbsize(fs), lfs_sb_getbsize(fs), NOCRED, 0,
 			       &bp) != 0)
 			panic("balloc extending ifile");
-		memset(bp->b_data, 0, fs->lfs_bsize);
+		memset(bp->b_data, 0, lfs_sb_getbsize(fs));
 		VOP_BWRITE(bp->b_vp, bp);
 	}
 
 	/* Register new ifile size */
-	ip->i_size += noff * fs->lfs_bsize; 
+	ip->i_size += noff * lfs_sb_getbsize(fs); 
 	ip->i_ffs1_size = ip->i_size;
 	uvm_vnp_setsize(ivp, ip->i_size);
 
@@ -2357,13 +2358,13 @@
 			inc = -1;
 		}
 		for (i = start; i != end; i += inc) {
-			if (bread(ivp, i, fs->lfs_bsize,
+			if (bread(ivp, i, lfs_sb_getbsize(fs),
 			    B_MODIFY, &bp) != 0)
 				panic("resize: bread dst blk failed");
-			if (bread(ivp, i - noff, fs->lfs_bsize,
+			if (bread(ivp, i - noff, lfs_sb_getbsize(fs),
 			    0, &obp))
 				panic("resize: bread src blk failed");
-			memcpy(bp->b_data, obp->b_data, fs->lfs_bsize);
+			memcpy(bp->b_data, obp->b_data, lfs_sb_getbsize(fs));
 			VOP_BWRITE(bp->b_vp, bp);
 			brelse(obp, 0);
 		}
@@ -2372,12 +2373,12 @@
 	/* If we are expanding, write the new empty SEGUSE entries */
 	if (newnsegs > oldnsegs) {
 		for (i = oldnsegs; i < newnsegs; i++) {
-			if ((error = bread(ivp, i / fs->lfs_sepb +
-					   fs->lfs_cleansz, fs->lfs_bsize,
+			if ((error = bread(ivp, i / lfs_sb_getsepb(fs) +
+					   lfs_sb_getcleansz(fs), lfs_sb_getbsize(fs),
 					   B_MODIFY, &bp)) != 0)
 				panic("lfs: ifile read: %d", error);
-			while ((i + 1) % fs->lfs_sepb && i < newnsegs) {
-				sup = &((SEGUSE *)bp->b_data)[i % fs->lfs_sepb];
+			while ((i + 1) % lfs_sb_getsepb(fs) && i < newnsegs) {
+				sup = &((SEGUSE *)bp->b_data)[i % lfs_sb_getsepb(fs)];
 				memset(sup, 0, sizeof(*sup));
 				i++;
 			}
@@ -2405,18 +2406,18 @@
 	 */
 	gain = (newnsegs - oldnsegs);
 	fs->lfs_nseg = newnsegs;
-	fs->lfs_segtabsz = nlast - fs->lfs_cleansz;
-	fs->lfs_size += gain * lfs_btofsb(fs, fs->lfs_ssize);
-	fs->lfs_dsize += gain * lfs_btofsb(fs, fs->lfs_ssize) - lfs_btofsb(fs, sbbytes);
-	fs->lfs_bfree += gain * lfs_btofsb(fs, fs->lfs_ssize) - lfs_btofsb(fs, sbbytes)
-		       - gain * lfs_btofsb(fs, fs->lfs_bsize / 2);
+	lfs_sb_setsegtabsz(fs, nlast - lfs_sb_getcleansz(fs));
+	lfs_sb_addsize(fs, gain * lfs_btofsb(fs, lfs_sb_getssize(fs)));
+	lfs_sb_adddsize(fs, gain * lfs_btofsb(fs, lfs_sb_getssize(fs)) - lfs_btofsb(fs, sbbytes));
+	lfs_sb_addbfree(fs, gain * lfs_btofsb(fs, lfs_sb_getssize(fs)) - lfs_btofsb(fs, sbbytes)
+		       - gain * lfs_btofsb(fs, lfs_sb_getbsize(fs) / 2));
 	if (gain > 0) {
 		fs->lfs_nclean += gain;
-		fs->lfs_avail += gain * lfs_btofsb(fs, fs->lfs_ssize);
+		lfs_sb_addavail(fs, gain * lfs_btofsb(fs, lfs_sb_getssize(fs)));
 	} else {
 		fs->lfs_nclean -= cgain;
-		fs->lfs_avail -= cgain * lfs_btofsb(fs, fs->lfs_ssize) -
-				 lfs_btofsb(fs, csbbytes);
+		lfs_sb_subavail(fs, cgain * lfs_btofsb(fs, lfs_sb_getssize(fs)) -
+				 lfs_btofsb(fs, csbbytes));
 	}
 
 	/* Resize segment flag cache */
@@ -2434,7 +2435,7 @@
 
 	/* Update cleaner info so the cleaner can die */
 	/* XXX what to do if bread fails? */
-	bread(ivp, 0, fs->lfs_bsize, B_MODIFY, &bp);
+	bread(ivp, 0, lfs_sb_getbsize(fs), B_MODIFY, &bp);
 	((CLEANERINFO *)bp->b_data)->clean = fs->lfs_nclean;
 	((CLEANERINFO *)bp->b_data)->dirty = fs->lfs_nseg - fs->lfs_nclean;
 	VOP_BWRITE(bp->b_vp, bp);

@@ -1,4 +1,4 @@
-/*	$NetBSD: lfs_vnops.c,v 1.273 2015/06/07 13:39:48 hannken Exp $	*/
+/*	$NetBSD: lfs_vnops.c,v 1.274 2015/07/24 06:56:42 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@@ -125,7 +125,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.273 2015/06/07 13:39:48 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.274 2015/07/24 06:56:42 dholland Exp $");
 
 #ifdef _KERNEL_OPT
 #include "opt_compat_netbsd.h"
@@ -420,8 +420,8 @@
 				     PGO_CLEANIT | (wait ? PGO_SYNCIO : 0));
 		if (error == EAGAIN) {
 			mutex_enter(&lfs_lock);
-			mtsleep(&fs->lfs_avail, PCATCH | PUSER, "lfs_fsync",
-				hz / 100 + 1, &lfs_lock);
+			mtsleep(&fs->lfs_availsleep, PCATCH | PUSER,
+				"lfs_fsync", hz / 100 + 1, &lfs_lock);
 			mutex_exit(&lfs_lock);
 		}
 	} while (error == EAGAIN);
@@ -1234,7 +1234,7 @@
 		lfs_wakeup_cleaner(fs);
 	}
 	if (waitfor) {
-		mtsleep(&fs->lfs_nextseg, PCATCH | PUSER, "segment",
+		mtsleep(&fs->lfs_nextsegsleep, PCATCH | PUSER, "segment",
 		    0, &lfs_lock);
 	}
 
@@ -1854,7 +1854,7 @@
 		 * to be immediately reclaimed.
 		 */
 		lfs_writer_enter(fs, "pndirop");
-		off = fs->lfs_offset;
+		off = lfs_sb_getoffset(fs);
 		lfs_seglock(fs, SEGM_FORCE_CKP | SEGM_CKP);
 		lfs_flush_dirops(fs);
 		LFS_CLEANERINFO(cip, fs, bp);

@@ -1,4 +1,4 @@
-/*	$NetBSD: ulfs_inode.h,v 1.12 2014/05/17 07:08:35 dholland Exp $	*/
+/*	$NetBSD: ulfs_inode.h,v 1.13 2015/07/24 06:56:42 dholland Exp $	*/
 /*  from NetBSD: inode.h,v 1.64 2012/11/19 00:36:21 jakllsch Exp  */
 
 /*
@@ -76,10 +76,10 @@
 #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 * ((fs)->lfs_bsize + LFS_DINODE1_SIZE))
+#define SIZEOF_DIROP(fs)	(2 * (lfs_sb_getbsize(fs) + LFS_DINODE1_SIZE))
 #define LFS_MAX_FSDIROP(fs)						\
 	((fs)->lfs_nclean <= (fs)->lfs_resvseg ? 0 :			\
-	 (((fs)->lfs_nclean - (fs)->lfs_resvseg) * (fs)->lfs_ssize) /	\
+	 (((fs)->lfs_nclean - (fs)->lfs_resvseg) * lfs_sb_getssize(fs)) / \
           (2 * SIZEOF_DIROP(fs)))
 #define LFS_MAX_PAGES	lfs_max_pages()
 #define LFS_WAIT_PAGES	lfs_wait_pages()

@@ -1,4 +1,4 @@
-/*	$NetBSD: ulfs_quota2.c,v 1.18 2015/03/28 19:24:05 maxv Exp $	*/
+/*	$NetBSD: ulfs_quota2.c,v 1.19 2015/07/24 06:56:42 dholland Exp $	*/
 /*  from NetBSD: ufs_quota2.c,v 1.35 2012/09/27 07:47:56 bouyer Exp  */
 /*  from NetBSD: ffs_quota2.c,v 1.4 2011/06/12 03:36:00 rmind Exp  */
 
@@ -29,7 +29,7 @@
   */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ulfs_quota2.c,v 1.18 2015/03/28 19:24:05 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ulfs_quota2.c,v 1.19 2015/07/24 06:56:42 dholland Exp $");
 
 #include <sys/buf.h>
 #include <sys/param.h>
@@ -1562,7 +1562,7 @@
 		return 0;
 
 	fs->um_flags |= ULFS_QUOTA2;
-	ump->umq2_bsize = fs->lfs_bsize;
+	ump->umq2_bsize = lfs_sb_getbsize(fs);
 	ump->umq2_bmask = fs->lfs_bmask;
 	if (fs->lfs_quota_magic != Q2_HEAD_MAGIC) {
 		printf("%s: Invalid quota magic number\n",

@@ -1,4 +1,4 @@
-/*	$NetBSD: ulfs_readwrite.c,v 1.17 2015/04/12 22:51:23 riastradh Exp $	*/
+/*	$NetBSD: ulfs_readwrite.c,v 1.18 2015/07/24 06:56:42 dholland Exp $	*/
 /*  from NetBSD: ufs_readwrite.c,v 1.105 2013/01/22 09:39:18 dholland Exp  */
 
 /*-
@@ -33,7 +33,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(1, "$NetBSD: ulfs_readwrite.c,v 1.17 2015/04/12 22:51:23 riastradh Exp $");
+__KERNEL_RCSID(1, "$NetBSD: ulfs_readwrite.c,v 1.18 2015/07/24 06:56:42 dholland Exp $");
 
 #ifdef LFS_READWRITE
 #define	FS			struct lfs
@@ -44,7 +44,7 @@
 #define	WRITE_S			"lfs_write"
 #define	BUFRD			lfs_bufrd
 #define	BUFWR			lfs_bufwr
-#define	fs_bsize		lfs_bsize
+#define	fs_sb_getbsize(fs)	lfs_sb_getbsize(fs)
 #define	fs_bmask		lfs_bmask
 #else
 #define	FS			struct fs
@@ -55,6 +55,7 @@
 #define	WRITE_S			"ffs_write"
 #define	BUFRD			ffs_bufrd
 #define	BUFWR			ffs_bufwr
+#define fs_sb_getbsize(fs)	(fs)->fs_bsize
 #endif
 
 static int	ulfs_post_read_update(struct vnode *, int, int);
@@ -186,7 +187,7 @@
 		nextlbn = lbn + 1;
 		size = lfs_blksize(fs, ip, lbn);
 		blkoffset = lfs_blkoff(fs, uio->uio_offset);
-		xfersize = MIN(MIN(fs->fs_bsize - blkoffset, uio->uio_resid),
+		xfersize = MIN(MIN(fs_sb_getbsize(fs) - blkoffset, uio->uio_resid),
 		    bytesinfile);
 
 		if (lfs_lblktosize(fs, nextlbn) >= ip->i_size)
@@ -353,7 +354,7 @@
 
 		oldoff = uio->uio_offset;
 		blkoffset = lfs_blkoff(fs, uio->uio_offset);
-		bytelen = MIN(fs->fs_bsize - blkoffset, uio->uio_resid);
+		bytelen = MIN(fs_sb_getbsize(fs) - blkoffset, uio->uio_resid);
 		if (bytelen == 0) {
 			break;
 		}
@@ -514,8 +515,8 @@
 	while (uio->uio_resid > 0) {
 		lbn = lfs_lblkno(fs, uio->uio_offset);
 		blkoffset = lfs_blkoff(fs, uio->uio_offset);
-		xfersize = MIN(fs->fs_bsize - blkoffset, uio->uio_resid);
-		if (fs->fs_bsize > xfersize)
+		xfersize = MIN(fs_sb_getbsize(fs) - blkoffset, uio->uio_resid);
+		if (fs_sb_getbsize(fs) > xfersize)
 			flags |= B_CLRBUF;
 		else
 			flags &= ~B_CLRBUF;

@@ -1,4 +1,4 @@
-/*	$NetBSD: dumplfs.c,v 1.42 2015/05/31 15:44:31 hannken Exp $	*/
+/*	$NetBSD: dumplfs.c,v 1.43 2015/07/24 06:56:42 dholland Exp $	*/
 
 /*-
  * Copyright (c) 1991, 1993
@@ -40,7 +40,7 @@
 #if 0
 static char sccsid[] = "@(#)dumplfs.c	8.5 (Berkeley) 5/24/95";
 #else
-__RCSID("$NetBSD: dumplfs.c,v 1.42 2015/05/31 15:44:31 hannken Exp $");
+__RCSID("$NetBSD: dumplfs.c,v 1.43 2015/07/24 06:56:42 dholland Exp $");
 #endif
 #endif /* not lint */
 
@@ -204,13 +204,13 @@
 	
 		lfs_master = &lfs_sb1;
 		if (lfs_sb1.lfs_version > 1) {
-			if (lfs_sb1.lfs_serial > lfs_sb2.lfs_serial) {
+			if (lfs_sb_getserial(&lfs_sb1) > lfs_sb_getserial(&lfs_sb2)) {
 				lfs_master = &lfs_sb2;
 				sbdaddr = lfs_sb1.lfs_sboffs[1];
 			} else
 				sbdaddr = lfs_sb1.lfs_sboffs[0];
 		} else {
-			if (lfs_sb1.lfs_otstamp > lfs_sb2.lfs_otstamp) {
+			if (lfs_sb_getotstamp(&lfs_sb1) > lfs_sb_getotstamp(&lfs_sb2)) {
 				lfs_master = &lfs_sb2;
 				sbdaddr = lfs_sb1.lfs_sboffs[1];
 			} else
@@ -228,9 +228,9 @@
 	/* Compatibility */
 	if (lfs_master->lfs_version == 1) {
 		lfs_master->lfs_sumsize = LFS_V1_SUMMARY_SIZE;
-		lfs_master->lfs_ibsize = lfs_master->lfs_bsize;
+		lfs_master->lfs_ibsize = lfs_sb_getbsize(lfs_master);
 		lfs_master->lfs_s0addr = lfs_master->lfs_sboffs[0];
-		lfs_master->lfs_tstamp = lfs_master->lfs_otstamp;
+		lfs_sb_settstamp(lfs_master, lfs_sb_getotstamp(lfs_master));
 		lfs_master->lfs_fsbtodb = 0;
 	}
 
@@ -270,9 +270,9 @@
 	int32_t *addrp, *dindir, *iaddrp, *indir;
 	int block_limit, i, inum, j, nblocks, psize;
 
-	psize = lfsp->lfs_bsize;
+	psize = lfs_sb_getbsize(lfsp);
 	if (!addr)
-		addr = lfsp->lfs_idaddr;
+		addr = lfs_sb_getidaddr(lfsp);
 
 	if (!(dpage = malloc(psize)))
 		err(1, "malloc");
@@ -292,7 +292,7 @@
 	dump_dinode(dip);
 
 	(void)printf("\nIFILE contents\n");
-	nblocks = dip->di_size >> lfsp->lfs_bshift;
+	nblocks = dip->di_size >> lfs_sb_getbshift(lfsp);
 	block_limit = MIN(nblocks, ULFS_NDADDR);
 
 	/* Get the direct block */
@@ -301,19 +301,19 @@
 	for (inum = 0, addrp = dip->di_db, i = 0; i < block_limit;
 	    i++, addrp++) {
 		get(fd, fsbtobyte(lfsp, *addrp), ipage, psize);
-		if (i < lfsp->lfs_cleansz) {
+		if (i < lfs_sb_getcleansz(lfsp)) {
 			dump_cleaner_info(lfsp, ipage);
 			if (do_segentries)
 				print_suheader;
 			continue;
 		} 
 
-		if (i < (lfsp->lfs_segtabsz + lfsp->lfs_cleansz)) {
+		if (i < (lfs_sb_getsegtabsz(lfsp) + lfs_sb_getcleansz(lfsp))) {
 			if (do_segentries)
 				inum = dump_ipage_segusage(lfsp, inum, ipage, 
-							   lfsp->lfs_sepb);
+							   lfs_sb_getsepb(lfsp));
 			else
-				inum = (i < lfsp->lfs_segtabsz + lfsp->lfs_cleansz - 1);
+				inum = (i < lfs_sb_getsegtabsz(lfsp) + lfs_sb_getcleansz(lfsp) - 1);
 			if (!inum) {
 				if(!do_ientries)
 					goto e0;
@@ -321,7 +321,7 @@
 					print_iheader;
 			}
 		} else
-			inum = dump_ipage_ifile(lfsp, inum, ipage, lfsp->lfs_ifpb);
+			inum = dump_ipage_ifile(lfsp, inum, ipage, lfs_sb_getifpb(lfsp));
 	}
 
 	if (nblocks <= ULFS_NDADDR)
@@ -331,22 +331,22 @@
 	if (!(indir = malloc(psize)))
 		err(1, "malloc");
 	get(fd, fsbtobyte(lfsp, dip->di_ib[0]), indir, psize);
-	block_limit = MIN(i + lfsp->lfs_nindir, nblocks);
+	block_limit = MIN(i + lfs_sb_getnindir(lfsp), nblocks);
 	for (addrp = indir; i < block_limit; i++, addrp++) {
 		if (*addrp == LFS_UNUSED_DADDR)
 			break;
 		get(fd, fsbtobyte(lfsp, *addrp), ipage, psize);
-		if (i < lfsp->lfs_cleansz) {
+		if (i < lfs_sb_getcleansz(lfsp)) {
 			dump_cleaner_info(lfsp, ipage);
 			continue;
 		}
 
-		if (i < lfsp->lfs_segtabsz + lfsp->lfs_cleansz) {
+		if (i < lfs_sb_getsegtabsz(lfsp) + lfs_sb_getcleansz(lfsp)) {
 			if (do_segentries)
 				inum = dump_ipage_segusage(lfsp, inum, ipage, 
-							   lfsp->lfs_sepb);
+							   lfs_sb_getsepb(lfsp));
 			else
-				inum = (i < lfsp->lfs_segtabsz + lfsp->lfs_cleansz - 1);
+				inum = (i < lfs_sb_getsegtabsz(lfsp) + lfs_sb_getcleansz(lfsp) - 1);
 			if (!inum) {
 				if(!do_ientries)
 					goto e1;
@@ -354,37 +354,37 @@
 					print_iheader;
 			}
 		} else
-			inum = dump_ipage_ifile(lfsp, inum, ipage, lfsp->lfs_ifpb);
+			inum = dump_ipage_ifile(lfsp, inum, ipage, lfs_sb_getifpb(lfsp));
 	}
 
-	if (nblocks <= lfsp->lfs_nindir * lfsp->lfs_ifpb)
+	if (nblocks <= lfs_sb_getnindir(lfsp) * lfs_sb_getifpb(lfsp))
 		goto e1;
 
 	/* Get the double indirect block */
 	if (!(dindir = malloc(psize)))
 		err(1, "malloc");
 	get(fd, fsbtobyte(lfsp, dip->di_ib[1]), dindir, psize);
-	for (iaddrp = dindir, j = 0; j < lfsp->lfs_nindir; j++, iaddrp++) {
+	for (iaddrp = dindir, j = 0; j < lfs_sb_getnindir(lfsp); j++, iaddrp++) {
 		if (*iaddrp == LFS_UNUSED_DADDR)
 			break;
 		get(fd, fsbtobyte(lfsp, *iaddrp), indir, psize);
-		block_limit = MIN(i + lfsp->lfs_nindir, nblocks);
+		block_limit = MIN(i + lfs_sb_getnindir(lfsp), nblocks);
 		for (addrp = indir; i < block_limit; i++, addrp++) {
 			if (*addrp == LFS_UNUSED_DADDR)
 				break;
 			get(fd, fsbtobyte(lfsp, *addrp), ipage, psize);
-			if (i < lfsp->lfs_cleansz) {
+			if (i < lfs_sb_getcleansz(lfsp)) {
 				dump_cleaner_info(lfsp, ipage);
 				continue;
 			}
 
-			if (i < lfsp->lfs_segtabsz + lfsp->lfs_cleansz) {
+			if (i < lfs_sb_getsegtabsz(lfsp) + lfs_sb_getcleansz(lfsp)) {
 				if (do_segentries)
 					inum = dump_ipage_segusage(lfsp,
-						 inum, ipage, lfsp->lfs_sepb);
+						 inum, ipage, lfs_sb_getsepb(lfsp));
 				else
-					inum = (i < lfsp->lfs_segtabsz +
-						lfsp->lfs_cleansz - 1);
+					inum = (i < lfs_sb_getsegtabsz(lfsp) +
+						lfs_sb_getcleansz(lfsp) - 1);
 				if (!inum) {
 					if(!do_ientries)
 						goto e2;
@@ -393,7 +393,7 @@
 				}
 			} else
 				inum = dump_ipage_ifile(lfsp, inum,
-				    ipage, lfsp->lfs_ifpb);
+				    ipage, lfs_sb_getifpb(lfsp));
 		}
 	}
 e2:	free(dindir);
@@ -428,7 +428,7 @@
 
 	max = i + tot;
 	for (sp = (SEGUSE *)pp, cnt = i;
-	     cnt < lfsp->lfs_nseg && cnt < max; cnt++) {
+	     cnt < lfs_sb_getnseg(lfsp) && cnt < max; cnt++) {
 		if (seglist == NULL)
 			print_suentry(cnt, sp, lfsp);
 		else {
@@ -443,7 +443,7 @@
 		else
 			sp = (SEGUSE *)((SEGUSE_V1 *)sp + 1);
 	}
-	if (max >= lfsp->lfs_nseg)
+	if (max >= lfs_sb_getnseg(lfsp))
 		return (0);
 	else
 		return (max);
@@ -498,7 +498,7 @@
 
 	if (sp->ss_magic != SS_MAGIC || 
 	    sp->ss_sumsum != (ck = cksum(&sp->ss_datasum, 
-	    lfsp->lfs_sumsize - sizeof(sp->ss_sumsum)))) {
+	    lfs_sb_getsumsize(lfsp) - sizeof(sp->ss_sumsum)))) {
 		/* Don't print "corrupt" if we're just too close to the edge */
 		if (lfs_dtosn(lfsp, addr + LFS_FSBTODB(lfsp, 1)) ==
 		    lfs_dtosn(lfsp, addr))
@@ -537,16 +537,16 @@
 
 	/* Dump out inode disk addresses */
 	dp = (int32_t *)sp;
-	dp += lfsp->lfs_sumsize / sizeof(int32_t);
-	inop = malloc(lfsp->lfs_bsize);
+	dp += lfs_sb_getsumsize(lfsp) / sizeof(int32_t);
+	inop = malloc(lfs_sb_getbsize(lfsp));
 	printf("    Inode addresses:");
 	numbytes = 0;
 	numblocks = 0;
 	for (dp--, i = 0; i < sp->ss_ninos; dp--) {
 		++numblocks;
-		numbytes += lfsp->lfs_ibsize;	/* add bytes for inode block */
+		numbytes += lfs_sb_getibsize(lfsp);	/* add bytes for inode block */
 		printf("\t0x%x {", *dp);
-		get(fd, fsbtobyte(lfsp, *dp), inop, lfsp->lfs_ibsize);
+		get(fd, fsbtobyte(lfsp, *dp), inop, lfs_sb_getibsize(lfsp));
 		for (j = 0; i < sp->ss_ninos && j < LFS_INOPB(lfsp); j++, i++) {
 			if (j > 0) 
 				(void)printf(", ");
@@ -577,7 +577,7 @@
 			if (j == fp->fi_nblocks - 1)
 				numbytes += fp->fi_lastlength;
 			else
-				numbytes += lfsp->lfs_bsize;
+				numbytes += lfs_sb_getbsize(lfsp);
 		}
 		if ((j % 8) != 0)
 			(void)printf("\n");
@@ -593,7 +593,7 @@
 	 * to prevent us from continuing, but it odes merit a warning.)
 	 */
 	idp = (int32_t *)sp;
-	idp += lfsp->lfs_sumsize / sizeof(int32_t);
+	idp += lfs_sb_getsumsize(lfsp) / sizeof(int32_t);
 	--idp;
 	if (lfsp->lfs_version == 1) {
 		fp = (FINFO *)((SEGSUM_V1 *)sp + 1);
@@ -605,31 +605,31 @@
 	datap = (char *)malloc(el_size * numblocks);
 	memset(datap, 0, el_size * numblocks);
 	acc = 0;
-	addr += lfs_btofsb(lfsp, lfsp->lfs_sumsize);
-	buf = malloc(lfsp->lfs_bsize);
+	addr += lfs_btofsb(lfsp, lfs_sb_getsumsize(lfsp));
+	buf = malloc(lfs_sb_getbsize(lfsp));
 	for (i = 0; i < sp->ss_nfinfo; i++) {
 		while (addr == *idp) {
-			get(fd, fsbtobyte(lfsp, addr), buf, lfsp->lfs_ibsize);
+			get(fd, fsbtobyte(lfsp, addr), buf, lfs_sb_getibsize(lfsp));
 			memcpy(datap + acc * el_size, buf, el_size);
-			addr += lfs_btofsb(lfsp, lfsp->lfs_ibsize);
+			addr += lfs_btofsb(lfsp, lfs_sb_getibsize(lfsp));
 			--idp;
 			++acc;
 		}
 		for (j = 0; j < fp->fi_nblocks; j++) {
-			get(fd, fsbtobyte(lfsp, addr), buf, lfsp->lfs_fsize);
+			get(fd, fsbtobyte(lfsp, addr), buf, lfs_sb_getfsize(lfsp));
 			memcpy(datap + acc * el_size, buf, el_size);
 			if (j == fp->fi_nblocks - 1)
 				addr += lfs_btofsb(lfsp, fp->fi_lastlength);
 			else
-				addr += lfs_btofsb(lfsp, lfsp->lfs_bsize);
+				addr += lfs_btofsb(lfsp, lfs_sb_getbsize(lfsp));
 			++acc;
 		}
 		fp = (FINFO *)&(fp->fi_blocks[fp->fi_nblocks]);
 	}
 	while (addr == *idp) {
-		get(fd, fsbtobyte(lfsp, addr), buf, lfsp->lfs_ibsize);
+		get(fd, fsbtobyte(lfsp, addr), buf, lfs_sb_getibsize(lfsp));
 		memcpy(datap + acc * el_size, buf, el_size);
-		addr += lfs_btofsb(lfsp, lfsp->lfs_ibsize);
+		addr += lfs_btofsb(lfsp, lfs_sb_getibsize(lfsp));
 		--idp;
 		++acc;
 	}
@@ -658,7 +658,7 @@
 	(void)printf("\nSEGMENT %lld (Disk Address 0x%llx)\n",
 		     (long long)lfs_dtosn(lfsp, addr), (long long)addr);
 	sum_offset = fsbtobyte(lfsp, addr);
-	sumblock = malloc(lfsp->lfs_sumsize);
+	sumblock = malloc(lfs_sb_getsumsize(lfsp));
 
 	if (lfsp->lfs_version > 1 && segnum == 0) {
 		if (lfs_fsbtob(lfsp, lfsp->lfs_s0addr) < LFS_LABELPAD) {
@@ -674,12 +674,12 @@
 	sb = 0;
 	did_one = 0;
 	do {
-		get(fd, sum_offset, sumblock, lfsp->lfs_sumsize);
+		get(fd, sum_offset, sumblock, lfs_sb_getsumsize(lfsp));
 		sump = (SEGSUM *)sumblock;
 		if ((lfsp->lfs_version > 1 &&
-		     sump->ss_ident != lfsp->lfs_ident) ||
+		     sump->ss_ident != lfs_sb_getident(lfsp)) ||
 		    sump->ss_sumsum != cksum (&sump->ss_datasum, 
-			      lfsp->lfs_sumsize - sizeof(sump->ss_sumsum))) {
+			      lfs_sb_getsumsize(lfsp) - sizeof(sump->ss_sumsum))) {
 			sbp = (struct lfs *)sump;
 			if ((sb = (sbp->lfs_magic == LFS_MAGIC))) {
 				printf("Superblock at 0x%x\n",
@@ -704,7 +704,7 @@
 			nbytes = dump_sum(fd, lfsp, sump, segnum, 
 				lfs_btofsb(lfsp, sum_offset));
 			if (nbytes >= 0)
-				sum_offset += lfsp->lfs_sumsize + nbytes;
+				sum_offset += lfs_sb_getsumsize(lfsp) + nbytes;
 			else
 				sum_offset = 0;
 			did_one = 1;
@@ -722,56 +722,57 @@
 static void
 dump_super(struct lfs *lfsp)
 {
+	time_t stamp;
 	int i;
 
  	(void)printf("    %s0x%-8x  %s0x%-8x  %s%-10d\n",
  		     "magic    ", lfsp->lfs_magic,
  		     "version  ", lfsp->lfs_version,
- 		     "size     ", lfsp->lfs_size);
+ 		     "size     ", lfs_sb_getsize(lfsp));
  	(void)printf("    %s%-10d  %s%-10d  %s%-10d\n",
- 		     "ssize    ", lfsp->lfs_ssize,
- 		     "dsize    ", lfsp->lfs_dsize,
- 		     "bsize    ", lfsp->lfs_bsize);
+ 		     "ssize    ", lfs_sb_getssize(lfsp),
+ 		     "dsize    ", lfs_sb_getdsize(lfsp),
+ 		     "bsize    ", lfs_sb_getbsize(lfsp));
  	(void)printf("    %s%-10d  %s%-10d  %s%-10d\n",
- 		     "fsize    ", lfsp->lfs_fsize,
- 		     "frag     ", lfsp->lfs_frag,
- 		     "minfree  ", lfsp->lfs_minfree);
+ 		     "fsize    ", lfs_sb_getfsize(lfsp),
+ 		     "frag     ", lfs_sb_getfrag(lfsp),
+ 		     "minfree  ", lfs_sb_getminfree(lfsp));
  	(void)printf("    %s%-10d  %s%-10d  %s%-10d\n",
- 		     "inopb    ", lfsp->lfs_inopb,
- 		     "ifpb     ", lfsp->lfs_ifpb,
- 		     "nindir   ", lfsp->lfs_nindir);
+ 		     "inopb    ", lfs_sb_getinopb(lfsp),
+ 		     "ifpb     ", lfs_sb_getifpb(lfsp),
+ 		     "nindir   ", lfs_sb_getnindir(lfsp));
  	(void)printf("    %s%-10d  %s%-10d  %s%-10d\n",
- 		     "nseg     ", lfsp->lfs_nseg,
- 		     "sepb     ", lfsp->lfs_sepb,
- 		     "cleansz  ", lfsp->lfs_cleansz);
+ 		     "nseg     ", lfs_sb_getnseg(lfsp),
+ 		     "sepb     ", lfs_sb_getsepb(lfsp),
+ 		     "cleansz  ", lfs_sb_getcleansz(lfsp));
  	(void)printf("    %s%-10d  %s0x%-8x  %s%-10d\n",
- 		     "segtabsz ", lfsp->lfs_segtabsz,
- 		     "segmask  ", lfsp->lfs_segmask,
- 		     "segshift ", lfsp->lfs_segshift);
- 	(void)printf("    %s0x%-8qx  %s%-10d  %s0x%-8qX\n",
- 		     "bmask    ", (long long)lfsp->lfs_bmask,
- 		     "bshift   ", lfsp->lfs_bshift,
- 		     "ffmask   ", (long long)lfsp->lfs_ffmask);
- 	(void)printf("    %s%-10d  %s0x%-8qx  %s%u\n",
- 		     "ffshift  ", lfsp->lfs_ffshift,
- 		     "fbmask   ", (long long)lfsp->lfs_fbmask,
- 		     "fbshift  ", lfsp->lfs_fbshift);
+ 		     "segtabsz ", lfs_sb_getsegtabsz(lfsp),
+ 		     "segmask  ", lfs_sb_getsegmask(lfsp),
+ 		     "segshift ", lfs_sb_getsegshift(lfsp));
+ 	(void)printf("    %s0x%-8jx  %s%-10d  %s0x%-8jX\n",
+ 		     "bmask    ", (uintmax_t)lfs_sb_getbmask(lfsp),
+ 		     "bshift   ", lfs_sb_getbshift(lfsp),
+ 		     "ffmask   ", (uintmax_t)lfs_sb_getffmask(lfsp));
+ 	(void)printf("    %s%-10d  %s0x%-8jx  %s%u\n",
+ 		     "ffshift  ", lfs_sb_getffshift(lfsp),
+ 		     "fbmask   ", (uintmax_t)lfs_sb_getfbmask(lfsp),
+ 		     "fbshift  ", lfs_sb_getfbshift(lfsp));
  	
  	(void)printf("    %s%-10d  %s%-10d  %s0x%-8x\n",
- 		     "sushift  ", lfsp->lfs_sushift,
- 		     "fsbtodb  ", lfsp->lfs_fsbtodb,
- 		     "cksum    ", lfsp->lfs_cksum);
+ 		     "sushift  ", lfs_sb_getsushift(lfsp),
+ 		     "fsbtodb  ", lfs_sb_getfsbtodb(lfsp),
+ 		     "cksum    ", lfs_sb_getcksum(lfsp));
  	(void)printf("    %s%-10d  %s%-10d  %s%-10d\n",
- 		     "nclean   ", lfsp->lfs_nclean,
- 		     "dmeta    ", lfsp->lfs_dmeta,
- 		     "minfreeseg ", lfsp->lfs_minfreeseg);
+ 		     "nclean   ", lfs_sb_getnclean(lfsp),
+ 		     "dmeta    ", lfs_sb_getdmeta(lfsp),
+ 		     "minfreeseg ", lfs_sb_getminfreeseg(lfsp));
  	(void)printf("    %s0x%-8x  %s%-9d %s%-10d\n",
- 		     "roll_id  ", lfsp->lfs_ident,
- 		     "interleave ", lfsp->lfs_interleave,
- 		     "sumsize  ", lfsp->lfs_sumsize);
- 	(void)printf("    %s%-10d  %s0x%-8qx\n",
+ 		     "roll_id  ", lfs_sb_getident(lfsp),
+ 		     "interleave ", lfs_sb_getinterleave(lfsp),
+ 		     "sumsize  ", lfs_sb_getsumsize(lfsp));
+ 	(void)printf("    %s%-10d  %s0x%-8jx\n",
 		     "seg0addr ", lfsp->lfs_s0addr,
- 		     "maxfilesize  ", (long long)lfsp->lfs_maxfilesize);
+ 		     "maxfilesize  ", (uintmax_t)lfs_sb_getmaxfilesize(lfsp));
  	
  	
  	(void)printf("  Superblock disk addresses:\n    ");
@@ -784,22 +785,23 @@
  	
  	(void)printf("  Checkpoint Info\n");
  	(void)printf("    %s%-10d  %s0x%-8x  %s%-10d\n",
- 		     "freehd   ", lfsp->lfs_freehd,
- 		     "idaddr   ", lfsp->lfs_idaddr,
- 		     "ifile    ", lfsp->lfs_ifile);
+ 		     "freehd   ", lfs_sb_getfreehd(lfsp),
+ 		     "idaddr   ", lfs_sb_getidaddr(lfsp),
+ 		     "ifile    ", lfs_sb_getifile(lfsp));
  	(void)printf("    %s%-10d  %s%-10d  %s%-10d\n",
- 		     "uinodes  ", lfsp->lfs_uinodes,
- 		     "bfree    ", lfsp->lfs_bfree,
- 		     "avail    ", lfsp->lfs_avail);
+ 		     "uinodes  ", lfs_sb_getuinodes(lfsp),
+ 		     "bfree    ", lfs_sb_getbfree(lfsp),
+ 		     "avail    ", lfs_sb_getavail(lfsp));
  	(void)printf("    %s%-10d  %s0x%-8x  %s0x%-8x\n",
- 		     "nfiles   ", lfsp->lfs_nfiles,
- 		     "lastseg  ", lfsp->lfs_lastseg,
- 		     "nextseg  ", lfsp->lfs_nextseg);
- 	(void)printf("    %s0x%-8x  %s0x%-8x  %s%-10lld\n",
- 		     "curseg   ", lfsp->lfs_curseg,
- 		     "offset   ", lfsp->lfs_offset,
-		     "serial   ", (long long)lfsp->lfs_serial);
- 	(void)printf("    tstamp   %s", ctime((time_t *)&lfsp->lfs_tstamp));
+ 		     "nfiles   ", lfs_sb_getnfiles(lfsp),
+ 		     "lastseg  ", lfs_sb_getlastseg(lfsp),
+ 		     "nextseg  ", lfs_sb_getnextseg(lfsp));
+ 	(void)printf("    %s0x%-8x  %s0x%-8x  %s%-10ju\n",
+ 		     "curseg   ", lfs_sb_getcurseg(lfsp),
+ 		     "offset   ", lfs_sb_getoffset(lfsp),
+		     "serial   ", (uintmax_t)lfs_sb_getserial(lfsp));
+	stamp = lfs_sb_gettstamp(lfsp);
+ 	(void)printf("    tstamp   %s", ctime(&stamp));
 }
 
 static void