Module Name: src
Committed By: dholland
Date: Fri Jul 24 06:59:32 UTC 2015
Modified Files:
src/libexec/lfs_cleanerd: cleaner.h coalesce.c lfs_cleanerd.c
src/sbin/dump_lfs: lfs_inode.c
src/sbin/fsck_lfs: inode.c lfs.c main.c pass1.c pass5.c pass6.c
segwrite.c setup.c utilities.c
src/sbin/newfs_lfs: make_lfs.c
src/sbin/resize_lfs: resize_lfs.c
src/sbin/scan_ffs: scan_ffs.c
src/sys/ufs/lfs: lfs.h lfs_alloc.c lfs_balloc.c lfs_bio.c lfs_inode.c
lfs_pages.c lfs_rfw.c lfs_segment.c lfs_subr.c lfs_syscalls.c
lfs_vfsops.c lfs_vnops.c ulfs_inode.h ulfs_quota2.c
ulfs_readwrite.c
src/usr.sbin/dumplfs: dumplfs.c
Log Message:
More lfs superblock accessors.
(This changes the rest of the code over; all the accessors were
already added.)
The difference between this commit and the previous one is arbitrary,
but the previous one passed the regression tests on its own so I'm
keeping it separate to help with any bisections that might be needed
in the future.
To generate a diff of this commit:
cvs rdiff -u -r1.6 -r1.7 src/libexec/lfs_cleanerd/cleaner.h
cvs rdiff -u -r1.25 -r1.26 src/libexec/lfs_cleanerd/coalesce.c
cvs rdiff -u -r1.39 -r1.40 src/libexec/lfs_cleanerd/lfs_cleanerd.c
cvs rdiff -u -r1.20 -r1.21 src/sbin/dump_lfs/lfs_inode.c
cvs rdiff -u -r1.55 -r1.56 src/sbin/fsck_lfs/inode.c
cvs rdiff -u -r1.46 -r1.47 src/sbin/fsck_lfs/lfs.c
cvs rdiff -u -r1.50 -r1.51 src/sbin/fsck_lfs/main.c
cvs rdiff -u -r1.38 -r1.39 src/sbin/fsck_lfs/pass1.c \
src/sbin/fsck_lfs/utilities.c
cvs rdiff -u -r1.30 -r1.31 src/sbin/fsck_lfs/pass5.c
cvs rdiff -u -r1.35 -r1.36 src/sbin/fsck_lfs/pass6.c
cvs rdiff -u -r1.32 -r1.33 src/sbin/fsck_lfs/segwrite.c
cvs rdiff -u -r1.47 -r1.48 src/sbin/fsck_lfs/setup.c
cvs rdiff -u -r1.32 -r1.33 src/sbin/newfs_lfs/make_lfs.c
cvs rdiff -u -r1.10 -r1.11 src/sbin/resize_lfs/resize_lfs.c
cvs rdiff -u -r1.26 -r1.27 src/sbin/scan_ffs/scan_ffs.c
cvs rdiff -u -r1.164 -r1.165 src/sys/ufs/lfs/lfs.h
cvs rdiff -u -r1.122 -r1.123 src/sys/ufs/lfs/lfs_alloc.c
cvs rdiff -u -r1.82 -r1.83 src/sys/ufs/lfs/lfs_balloc.c \
src/sys/ufs/lfs/lfs_subr.c
cvs rdiff -u -r1.129 -r1.130 src/sys/ufs/lfs/lfs_bio.c
cvs rdiff -u -r1.138 -r1.139 src/sys/ufs/lfs/lfs_inode.c
cvs rdiff -u -r1.2 -r1.3 src/sys/ufs/lfs/lfs_pages.c
cvs rdiff -u -r1.22 -r1.23 src/sys/ufs/lfs/lfs_rfw.c
cvs rdiff -u -r1.242 -r1.243 src/sys/ufs/lfs/lfs_segment.c
cvs rdiff -u -r1.161 -r1.162 src/sys/ufs/lfs/lfs_syscalls.c
cvs rdiff -u -r1.327 -r1.328 src/sys/ufs/lfs/lfs_vfsops.c
cvs rdiff -u -r1.274 -r1.275 src/sys/ufs/lfs/lfs_vnops.c
cvs rdiff -u -r1.13 -r1.14 src/sys/ufs/lfs/ulfs_inode.h
cvs rdiff -u -r1.19 -r1.20 src/sys/ufs/lfs/ulfs_quota2.c
cvs rdiff -u -r1.18 -r1.19 src/sys/ufs/lfs/ulfs_readwrite.c
cvs rdiff -u -r1.43 -r1.44 src/usr.sbin/dumplfs/dumplfs.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/libexec/lfs_cleanerd/cleaner.h
diff -u src/libexec/lfs_cleanerd/cleaner.h:1.6 src/libexec/lfs_cleanerd/cleaner.h:1.7
--- src/libexec/lfs_cleanerd/cleaner.h:1.6 Fri Jul 24 06:56:41 2015
+++ src/libexec/lfs_cleanerd/cleaner.h Fri Jul 24 06:59:31 2015
@@ -52,7 +52,8 @@ struct clfs {
static __unused inline void \
clfs_sb_add##field(struct clfs *fs, type val) \
{ \
- fs->lfs_dlfs.dlfs_##field += val; \
+ type *p = &fs->lfs_dlfs.dlfs_##field; \
+ *p += val; \
}
/* more ugh... */
@@ -61,22 +62,57 @@ 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, inopb);
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);
+CLFS_DEF_SB_ACCESSOR(u_int64_t, bmask);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, bshift);
+CLFS_DEF_SB_ACCESSOR(u_int64_t, ffmask);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, ffshift);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, fbshift);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, blktodb);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, minfreeseg);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, sumsize);
+CLFS_DEF_SB_ACCESSOR(u_int32_t, ibsize);
+CLFS_DEF_SB_ACCESSOR(int32_t, s0addr);
+static __unused inline int32_t
+clfs_sb_getsboff(struct clfs *fs, unsigned n)
+{
+ assert(n < LFS_MAXNUMSB);
+ return fs->lfs_dlfs.dlfs_sboffs[n];
+}
+static __unused inline const char *
+clfs_sb_getfsmnt(struct clfs *fs)
+{
+ return (const char *)fs->lfs_dlfs.dlfs_fsmnt;
+}
/* 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_getinopb(fs) clfs_sb_getinopb(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)
+#define lfs_sb_getbmask(fs) clfs_sb_getbmask(fs)
+#define lfs_sb_getbshift(fs) clfs_sb_getbshift(fs)
+#define lfs_sb_getffmask(fs) clfs_sb_getffmask(fs)
+#define lfs_sb_getffshift(fs) clfs_sb_getffshift(fs)
+#define lfs_sb_getfbshift(fs) clfs_sb_getfbshift(fs)
+#define lfs_sb_getblktodb(fs) clfs_sb_getblktodb(fs)
+#define lfs_sb_getminfreeseg(fs) clfs_sb_getminfreeseg(fs)
+#define lfs_sb_getsumsize(fs) clfs_sb_getsumsize(fs)
+#define lfs_sb_getibsize(fs) clfs_sb_getibsize(fs)
+#define lfs_sb_gets0addr(fs) clfs_sb_gets0addr(fs)
+#define lfs_sb_getsboff(fs, n) clfs_sb_getsboff(fs, n)
+#define lfs_sb_getfsmnt(fs) clfs_sb_getfsmnt(fs)
/*
* Fraction of the could-be-clean segments required to be clean.
Index: src/libexec/lfs_cleanerd/coalesce.c
diff -u src/libexec/lfs_cleanerd/coalesce.c:1.25 src/libexec/lfs_cleanerd/coalesce.c:1.26
--- src/libexec/lfs_cleanerd/coalesce.c:1.25 Fri Jul 24 06:56:41 2015
+++ src/libexec/lfs_cleanerd/coalesce.c Fri Jul 24 06:59:31 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: coalesce.c,v 1.25 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: coalesce.c,v 1.26 2015/07/24 06:59:31 dholland Exp $ */
/*-
* Copyright (c) 2002, 2005 The NetBSD Foundation, Inc.
@@ -49,6 +49,7 @@
#include <util.h>
#include <errno.h>
#include <err.h>
+#include <assert.h>
#include <syslog.h>
@@ -118,9 +119,9 @@ get_dinode(struct clfs *fs, ino_t ino)
if (daddr == 0x0)
return NULL;
- bread(fs->clfs_devvp, daddr, fs->lfs_ibsize, 0, &bp);
+ bread(fs->clfs_devvp, daddr, lfs_sb_getibsize(fs), 0, &bp);
for (dip = (struct ulfs1_dinode *)bp->b_data;
- dip < (struct ulfs1_dinode *)(bp->b_data + fs->lfs_ibsize); dip++)
+ dip < (struct ulfs1_dinode *)(bp->b_data + lfs_sb_getibsize(fs)); dip++)
if (dip->di_inumber == ino) {
r = (struct ulfs1_dinode *)malloc(sizeof(*r));
if (r == NULL)
@@ -201,7 +202,7 @@ clean_inode(struct clfs *fs, ino_t ino)
lim.blkcnt = nb;
if (kops.ko_fcntl(fs->clfs_ifilefd, LFCNBMAPV, &lim) < 0) {
syslog(LOG_WARNING, "%s: coalesce: LFCNBMAPV: %m",
- fs->lfs_fsmnt);
+ lfs_sb_getfsmnt(fs));
retval = COALESCE_BADBMAPV;
goto out;
}
@@ -218,7 +219,7 @@ clean_inode(struct clfs *fs, ino_t ino)
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
- - clfs_sb_getfrag(fs)) >> fs->lfs_fbshift;
+ - clfs_sb_getfrag(fs)) >> lfs_sb_getfbshift(fs);
}
/*
@@ -339,7 +340,7 @@ int clean_all_inodes(struct clfs *fs)
memset(totals, 0, sizeof(totals));
fstat(fs->clfs_ifilefd, &st);
- maxino = lfs_sb_getifpb(fs) * (st.st_size >> fs->lfs_bshift) -
+ maxino = lfs_sb_getifpb(fs) * (st.st_size >> lfs_sb_getbshift(fs)) -
lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs);
for (i = 0; i < maxino; i++) {
@@ -383,14 +384,14 @@ fork_coalesce(struct clfs *fs)
*/
childpid = fork();
if (childpid < 0) {
- syslog(LOG_ERR, "%s: fork to coaleasce: %m", fs->lfs_fsmnt);
+ syslog(LOG_ERR, "%s: fork to coaleasce: %m", lfs_sb_getfsmnt(fs));
return 0;
} else if (childpid == 0) {
syslog(LOG_NOTICE, "%s: new coalescing process, pid %d",
- fs->lfs_fsmnt, getpid());
+ lfs_sb_getfsmnt(fs), getpid());
num = clean_all_inodes(fs);
syslog(LOG_NOTICE, "%s: coalesced %d discontiguous inodes",
- fs->lfs_fsmnt, num);
+ lfs_sb_getfsmnt(fs), num);
exit(0);
}
Index: src/libexec/lfs_cleanerd/lfs_cleanerd.c
diff -u src/libexec/lfs_cleanerd/lfs_cleanerd.c:1.39 src/libexec/lfs_cleanerd/lfs_cleanerd.c:1.40
--- src/libexec/lfs_cleanerd/lfs_cleanerd.c:1.39 Fri Jul 24 06:56:41 2015
+++ src/libexec/lfs_cleanerd/lfs_cleanerd.c Fri Jul 24 06:59:31 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_cleanerd.c,v 1.39 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: lfs_cleanerd.c,v 1.40 2015/07/24 06:59:31 dholland Exp $ */
/*-
* Copyright (c) 2005 The NetBSD Foundation, Inc.
@@ -120,7 +120,7 @@ dlog(const char *fmt, ...)
void
handle_error(struct clfs **cfsp, int n)
{
- syslog(LOG_NOTICE, "%s: detaching cleaner", cfsp[n]->lfs_fsmnt);
+ syslog(LOG_NOTICE, "%s: detaching cleaner", lfs_sb_getfsmnt(cfsp[n]));
free(cfsp[n]);
if (n != nfss - 1)
cfsp[n] = cfsp[nfss - 1];
@@ -133,9 +133,11 @@ handle_error(struct clfs **cfsp, int n)
int
reinit_fs(struct clfs *fs)
{
- char fsname[MNAMELEN];
+ char fsname[sizeof(fs->lfs_dlfs.dlfs_fsmnt)];
+
+ memcpy(fsname, fs->lfs_dlfs.dlfs_fsmnt, sizeof(fsname));
+ fsname[sizeof(fsname) - 1] = '\0';
- strncpy(fsname, (char *)fs->lfs_fsmnt, MNAMELEN);
kops.ko_close(fs->clfs_ifilefd);
kops.ko_close(fs->clfs_devfd);
fd_reclaim(fs->clfs_devvp);
@@ -174,11 +176,11 @@ init_unmounted_fs(struct clfs *fs, char
atatime);
/* Allocate and clear segtab */
- fs->clfs_segtab = (struct clfs_seguse *)malloc(fs->lfs_nseg *
+ fs->clfs_segtab = (struct clfs_seguse *)malloc(lfs_sb_getnseg(fs) *
sizeof(*fs->clfs_segtab));
- fs->clfs_segtabp = (struct clfs_seguse **)malloc(fs->lfs_nseg *
+ fs->clfs_segtabp = (struct clfs_seguse **)malloc(lfs_sb_getnseg(fs) *
sizeof(*fs->clfs_segtabp));
- for (i = 0; i < fs->lfs_nseg; i++) {
+ for (i = 0; i < lfs_sb_getnseg(fs); i++) {
fs->clfs_segtabp[i] = &(fs->clfs_segtab[i]);
fs->clfs_segtab[i].flags = 0x0;
}
@@ -200,6 +202,7 @@ init_unmounted_fs(struct clfs *fs, char
int
init_fs(struct clfs *fs, char *fsname)
{
+ char mnttmp[sizeof(fs->lfs_dlfs.dlfs_fsmnt)];
struct statvfs sf;
int rootfd;
int i;
@@ -261,7 +264,9 @@ init_fs(struct clfs *fs, char *fsname)
}
/* Assume fsname is the mounted name */
- strncpy((char *)fs->lfs_fsmnt, fsname, MNAMELEN);
+ strncpy(mnttmp, fsname, sizeof(mnttmp));
+ mnttmp[sizeof(mnttmp) - 1] = '\0';
+ memcpy(fs->lfs_dlfs.dlfs_fsmnt, mnttmp, sizeof(mnttmp));
/* Set up vnodes for Ifile and raw device */
fs->lfs_ivnode = fd_vget(fs->clfs_ifilefd, clfs_sb_getbsize(fs), 0, 0);
@@ -269,9 +274,9 @@ init_fs(struct clfs *fs, char *fsname)
atatime);
/* Allocate and clear segtab */
- fs->clfs_segtab = (struct clfs_seguse *)malloc(fs->lfs_nseg *
+ fs->clfs_segtab = (struct clfs_seguse *)malloc(lfs_sb_getnseg(fs) *
sizeof(*fs->clfs_segtab));
- fs->clfs_segtabp = (struct clfs_seguse **)malloc(fs->lfs_nseg *
+ fs->clfs_segtabp = (struct clfs_seguse **)malloc(lfs_sb_getnseg(fs) *
sizeof(*fs->clfs_segtabp));
if (fs->clfs_segtab == NULL || fs->clfs_segtabp == NULL) {
syslog(LOG_ERR, "%s: couldn't malloc segment table: %m",
@@ -279,7 +284,7 @@ init_fs(struct clfs *fs, char *fsname)
return -1;
}
- for (i = 0; i < fs->lfs_nseg; i++) {
+ for (i = 0; i < lfs_sb_getnseg(fs); i++) {
fs->clfs_segtabp[i] = &(fs->clfs_segtab[i]);
fs->clfs_segtab[i].flags = 0x0;
}
@@ -316,7 +321,7 @@ reload_ifile(struct clfs *fs)
ohashmax = hashmax;
bufrehash(st.st_size / clfs_sb_getbsize(fs));
dlog("%s: resized buffer hash from %d to %d",
- fs->lfs_fsmnt, ohashmax, hashmax);
+ lfs_sb_getfsmnt(fs), ohashmax, hashmax);
}
}
@@ -335,7 +340,7 @@ lfs_ientry(IFILE **ifpp, struct clfs *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);
+ lfs_sb_getfsmnt(fs), (int)ino);
*ifpp = (IFILE *)(*bpp)->b_data + ino % lfs_sb_getifpb(fs);
return;
}
@@ -400,7 +405,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
*/
cp = fd_ptrget(fs->clfs_devvp, daddr);
ssp = (SEGSUM *)cp;
- iaddrp = ((int32_t *)(cp + fs->lfs_ibsize)) - 1;
+ iaddrp = ((int32_t *)(cp + lfs_sb_getibsize(fs))) - 1;
fip = (FINFO *)(cp + sizeof(SEGSUM));
/*
@@ -408,14 +413,14 @@ parse_pseg(struct clfs *fs, daddr_t dadd
*/
if (ssp->ss_magic != SS_MAGIC) {
syslog(LOG_WARNING, "%s: sumsum magic number bad at 0x%x:"
- " read 0x%x, expected 0x%x", fs->lfs_fsmnt,
+ " read 0x%x, expected 0x%x", lfs_sb_getfsmnt(fs),
(int32_t)daddr, ssp->ss_magic, SS_MAGIC);
return 0x0;
}
- ck = cksum(&ssp->ss_datasum, fs->lfs_sumsize - sizeof(ssp->ss_sumsum));
+ ck = cksum(&ssp->ss_datasum, lfs_sb_getsumsize(fs) - sizeof(ssp->ss_sumsum));
if (ck != ssp->ss_sumsum) {
syslog(LOG_WARNING, "%s: sumsum checksum mismatch at 0x%x:"
- " read 0x%x, computed 0x%x", fs->lfs_fsmnt,
+ " read 0x%x, computed 0x%x", lfs_sb_getfsmnt(fs),
(int32_t)daddr, ssp->ss_sumsum, ck);
return 0x0;
}
@@ -439,7 +444,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
*/
if (fic >= ssp->ss_nfinfo && *iaddrp != daddr) {
syslog(LOG_WARNING, "%s: bad pseg at %x (seg %d)",
- fs->lfs_fsmnt, odaddr, lfs_dtosn(fs, odaddr));
+ lfs_sb_getfsmnt(fs), odaddr, lfs_dtosn(fs, odaddr));
*bipp = bip;
return 0x0;
}
@@ -451,7 +456,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
cp = fd_ptrget(fs->clfs_devvp, daddr);
ck = lfs_cksum_part(cp, sizeof(u_int32_t), ck);
dip = (struct ulfs1_dinode *)cp;
- for (i = 0; i < fs->lfs_inopb; i++) {
+ for (i = 0; i < lfs_sb_getinopb(fs); i++) {
if (dip[i].di_inumber == 0)
break;
@@ -488,7 +493,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
bip[*bic - 1].bi_size = LFS_DINODE1_SIZE;
}
inoc += i;
- daddr += lfs_btofsb(fs, fs->lfs_ibsize);
+ daddr += lfs_btofsb(fs, lfs_sb_getibsize(fs));
--iaddrp;
continue;
}
@@ -519,7 +524,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
nssp = (SEGSUM *)nbp->b_data;
--nssp->ss_nfinfo;
nssp->ss_sumsum = cksum(&nssp->ss_datasum,
- fs->lfs_sumsize - sizeof(nssp->ss_sumsum));
+ lfs_sb_getsumsize(fs) - sizeof(nssp->ss_sumsum));
bwrite(nbp);
#endif
syslog(LOG_WARNING, "zero-length FINFO at %x (seg %d)",
@@ -586,7 +591,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
#ifndef REPAIR_ZERO_FINFO
if (ssp->ss_datasum != ck) {
syslog(LOG_WARNING, "%s: data checksum bad at 0x%x:"
- " read 0x%x, computed 0x%x", fs->lfs_fsmnt, odaddr,
+ " read 0x%x, computed 0x%x", lfs_sb_getfsmnt(fs), odaddr,
ssp->ss_datasum, ck);
*bic = obic;
return 0x0;
@@ -639,7 +644,7 @@ load_segment(struct clfs *fs, int sn, BL
if (daddr < lfs_btofsb(fs, LFS_LABELPAD))
daddr = lfs_btofsb(fs, LFS_LABELPAD);
for (i = 0; i < LFS_MAXNUMSB; i++) {
- if (fs->lfs_sboffs[i] == daddr) {
+ if (lfs_sb_getsboff(fs, i) == daddr) {
daddr += lfs_btofsb(fs, LFS_SBPAD);
break;
}
@@ -819,7 +824,7 @@ toss_old_blocks(struct clfs *fs, BLOCK_I
lim.blkcnt = *bic;
if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNBMAPV, &lim)) < 0) {
syslog(LOG_WARNING, "%s: bmapv returned %d (%m)",
- fs->lfs_fsmnt, r);
+ lfs_sb_getfsmnt(fs), r);
return;
}
@@ -856,7 +861,7 @@ invalidate_segment(struct clfs *fs, int
int blkcnt;
} */ lim;
- dlog("%s: inval seg %d", fs->lfs_fsmnt, sn);
+ dlog("%s: inval seg %d", lfs_sb_getfsmnt(fs), sn);
bip = NULL;
bic = 0;
@@ -880,7 +885,7 @@ invalidate_segment(struct clfs *fs, int
lim.blkcnt = bic;
if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNMARKV, &lim)) < 0) {
syslog(LOG_WARNING, "%s: markv returned %d (%m) "
- "for seg %d", fs->lfs_fsmnt, r, sn);
+ "for seg %d", lfs_sb_getfsmnt(fs), r, sn);
return r;
}
@@ -889,7 +894,7 @@ invalidate_segment(struct clfs *fs, int
*/
if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNINVAL, &sn)) < 0) {
syslog(LOG_WARNING, "%s: inval returned %d (%m) "
- "for seg %d", fs->lfs_fsmnt, r, sn);
+ "for seg %d", lfs_sb_getfsmnt(fs), r, sn);
return r;
}
@@ -1035,12 +1040,12 @@ clean_fs(struct clfs *fs, CLEANERINFO *c
}
/* Sort segments based on cleanliness, fulness, and condition */
- heapsort(fs->clfs_segtabp, fs->lfs_nseg, sizeof(struct clfs_seguse *),
+ heapsort(fs->clfs_segtabp, lfs_sb_getnseg(fs), sizeof(struct clfs_seguse *),
cb_comparator);
/* If no segment is cleanable, just return */
if (fs->clfs_segtabp[0]->priority == 0) {
- dlog("%s: no segment cleanable", fs->lfs_fsmnt);
+ dlog("%s: no segment cleanable", lfs_sb_getfsmnt(fs));
return 0;
}
@@ -1057,12 +1062,12 @@ clean_fs(struct clfs *fs, CLEANERINFO *c
dlog("%s: cleaning with goal %" PRId64
" bytes (%d segs clean, %d cleanable)",
- fs->lfs_fsmnt, goal, cip->clean, npos);
+ lfs_sb_getfsmnt(fs), goal, cip->clean, npos);
syslog(LOG_INFO, "%s: cleaning with goal %" PRId64
" bytes (%d segs clean, %d cleanable)",
- fs->lfs_fsmnt, goal, cip->clean, npos);
+ lfs_sb_getfsmnt(fs), goal, cip->clean, npos);
totbytes = 0;
- for (i = 0; i < fs->lfs_nseg && totbytes < goal; i++) {
+ for (i = 0; i < lfs_sb_getnseg(fs) && totbytes < goal; i++) {
if (fs->clfs_segtabp[i]->priority == 0)
break;
/* Upper bound on number of segments at once */
@@ -1071,7 +1076,7 @@ clean_fs(struct clfs *fs, CLEANERINFO *c
sn = (fs->clfs_segtabp[i] - fs->clfs_segtab);
dlog("%s: add seg %d prio %" PRIu64
" containing %ld bytes",
- fs->lfs_fsmnt, sn, fs->clfs_segtabp[i]->priority,
+ lfs_sb_getfsmnt(fs), sn, fs->clfs_segtabp[i]->priority,
fs->clfs_segtabp[i]->nbytes);
if ((r = load_segment(fs, sn, &bip, &bic)) > 0) {
++ngood;
@@ -1089,13 +1094,13 @@ clean_fs(struct clfs *fs, CLEANERINFO *c
goal = MAX(cip->clean - 1, 1);
dlog("%s: cleaning with goal %d segments (%d clean, %d cleanable)",
- fs->lfs_fsmnt, (int)goal, cip->clean, npos);
- for (i = 0; i < fs->lfs_nseg && ngood < goal; i++) {
+ lfs_sb_getfsmnt(fs), (int)goal, cip->clean, npos);
+ for (i = 0; i < lfs_sb_getnseg(fs) && ngood < goal; i++) {
if (fs->clfs_segtabp[i]->priority == 0)
break;
sn = (fs->clfs_segtabp[i] - fs->clfs_segtab);
dlog("%s: add seg %d prio %" PRIu64,
- fs->lfs_fsmnt, sn, fs->clfs_segtabp[i]->priority);
+ lfs_sb_getfsmnt(fs), sn, fs->clfs_segtabp[i]->priority);
if ((r = load_segment(fs, sn, &bip, &bic)) > 0)
++ngood;
else if (r == 0)
@@ -1109,7 +1114,7 @@ clean_fs(struct clfs *fs, CLEANERINFO *c
/* If there is nothing to do, try again later. */
if (bic == 0) {
dlog("%s: no blocks to clean in %d cleanable segments",
- fs->lfs_fsmnt, (int)ngood);
+ lfs_sb_getfsmnt(fs), (int)ngood);
fd_release_all(fs->clfs_devvp);
return 0;
}
@@ -1152,16 +1157,16 @@ clean_fs(struct clfs *fs, CLEANERINFO *c
if ((r = kops.ko_fcntl(fs->clfs_ifilefd, LFCNMARKV, &lim))<0) {
int oerrno = errno;
syslog(LOG_WARNING, "%s: markv returned %d (errno %d, %m)",
- fs->lfs_fsmnt, r, errno);
+ lfs_sb_getfsmnt(fs), r, errno);
if (oerrno != EAGAIN && oerrno != ESHUTDOWN) {
syslog(LOG_DEBUG, "%s: errno %d, returning",
- fs->lfs_fsmnt, oerrno);
+ lfs_sb_getfsmnt(fs), oerrno);
fd_release_all(fs->clfs_devvp);
return r;
}
if (oerrno == ESHUTDOWN) {
syslog(LOG_NOTICE, "%s: filesystem unmounted",
- fs->lfs_fsmnt);
+ lfs_sb_getfsmnt(fs));
fd_release_all(fs->clfs_devvp);
return r;
}
@@ -1175,14 +1180,14 @@ clean_fs(struct clfs *fs, CLEANERINFO *c
PRId64 " supporting indirect + %"
PRId64 " supporting Ifile = %"
PRId64 " bytes to clean %d segs (%" PRId64 "%% recovery)",
- fs->lfs_fsmnt, (int64_t)nb, (int64_t)(extra - if_extra),
+ lfs_sb_getfsmnt(fs), (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 * clfs_sb_getssize(fs))) :
(int64_t)0));
if (nb + extra >= ngood * clfs_sb_getssize(fs))
syslog(LOG_WARNING, "%s: cleaner not making forward progress",
- fs->lfs_fsmnt);
+ lfs_sb_getfsmnt(fs));
/*
* Finally call reclaim to prompt cleaning of the segments.
@@ -1217,7 +1222,7 @@ needs_cleaning(struct clfs *fs, CLEANERI
* handing it back.
*/
if (bread(fs->lfs_ivnode, 0, clfs_sb_getbsize(fs), 0, &bp)) {
- syslog(LOG_ERR, "%s: can't read inode", fs->lfs_fsmnt);
+ syslog(LOG_ERR, "%s: can't read inode", lfs_sb_getfsmnt(fs));
return -1;
}
*cip = *(CLEANERINFO *)bp->b_data; /* Structure copy */
@@ -1229,24 +1234,25 @@ needs_cleaning(struct clfs *fs, CLEANERI
* We don't have to start over from scratch, however,
* since we don't hold any buffers.
*/
- if (fs->lfs_nseg != cip->clean + cip->dirty) {
+ if (lfs_sb_getnseg(fs) != cip->clean + cip->dirty) {
if (reinit_fs(fs) < 0) {
/* The normal case for unmount */
- syslog(LOG_NOTICE, "%s: filesystem unmounted", fs->lfs_fsmnt);
+ syslog(LOG_NOTICE, "%s: filesystem unmounted", lfs_sb_getfsmnt(fs));
return -1;
}
- syslog(LOG_NOTICE, "%s: nsegs changed", fs->lfs_fsmnt);
+ syslog(LOG_NOTICE, "%s: nsegs changed", lfs_sb_getfsmnt(fs));
}
/* Compute theoretical "free segments" maximum based on usage */
fsb_per_seg = lfs_segtod(fs, 1);
- max_free_segs = MAX(cip->bfree, 0) / fsb_per_seg + fs->lfs_minfreeseg;
+ max_free_segs = MAX(cip->bfree, 0) / fsb_per_seg + lfs_sb_getminfreeseg(fs);
dlog("%s: bfree = %d, avail = %d, clean = %d/%d",
- fs->lfs_fsmnt, cip->bfree, cip->avail, cip->clean, fs->lfs_nseg);
+ lfs_sb_getfsmnt(fs), cip->bfree, cip->avail, cip->clean,
+ lfs_sb_getnseg(fs));
/* If the writer is waiting on us, clean it */
- if (cip->clean <= fs->lfs_minfreeseg ||
+ if (cip->clean <= lfs_sb_getminfreeseg(fs) ||
(cip->flags & LFS_CLEANER_MUST_CLEAN))
return 1;
@@ -1270,7 +1276,7 @@ needs_cleaning(struct clfs *fs, CLEANERI
time(&now);
if (fstat(fs->clfs_ifilefd, &st) < 0) {
syslog(LOG_ERR, "%s: failed to stat ifile",
- fs->lfs_fsmnt);
+ lfs_sb_getfsmnt(fs));
return -1;
}
if (now - st.st_mtime > segwait_timeout &&
@@ -1280,7 +1286,7 @@ needs_cleaning(struct clfs *fs, CLEANERI
/* CPU idle - use one-minute load avg */
if (getloadavg(&loadavg, 1) == -1) {
syslog(LOG_ERR, "%s: failed to get load avg",
- fs->lfs_fsmnt);
+ lfs_sb_getfsmnt(fs));
return -1;
}
if (loadavg < load_threshold &&
Index: src/sbin/dump_lfs/lfs_inode.c
diff -u src/sbin/dump_lfs/lfs_inode.c:1.20 src/sbin/dump_lfs/lfs_inode.c:1.21
--- src/sbin/dump_lfs/lfs_inode.c:1.20 Fri Jul 24 06:56:41 2015
+++ src/sbin/dump_lfs/lfs_inode.c Fri Jul 24 06:59:31 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_inode.c,v 1.20 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: lfs_inode.c,v 1.21 2015/07/24 06:59:31 dholland Exp $ */
/*-
* Copyright (c) 1980, 1991, 1993, 1994
@@ -39,7 +39,7 @@ __COPYRIGHT("@(#) Copyright (c) 1980, 19
#if 0
static char sccsid[] = "@(#)main.c 8.6 (Berkeley) 5/1/95";
#else
-__RCSID("$NetBSD: lfs_inode.c,v 1.20 2015/07/24 06:56:41 dholland Exp $");
+__RCSID("$NetBSD: lfs_inode.c,v 1.21 2015/07/24 06:59:31 dholland Exp $");
#endif
#endif /* not lint */
@@ -95,8 +95,8 @@ fs_read_sblock(char *superblock)
#endif
quit("bad sblock magic number\n");
}
- if (lfs_fsbtob(sblock, (off_t)sblock->lfs_sboffs[0]) != sboff) {
- sboff = lfs_fsbtob(sblock, (off_t)sblock->lfs_sboffs[0]);
+ if (lfs_fsbtob(sblock, (off_t)lfs_sb_getsboff(sblock, 0)) != sboff) {
+ sboff = lfs_fsbtob(sblock, (off_t)lfs_sb_getsboff(sblock, 0));
continue;
}
break;
@@ -105,7 +105,7 @@ fs_read_sblock(char *superblock)
/*
* Read the secondary and take the older of the two
*/
- rawread(lfs_fsbtob(sblock, (off_t)sblock->lfs_sboffs[1]), u.tbuf,
+ rawread(lfs_fsbtob(sblock, (off_t)lfs_sb_getsboff(sblock, 1)), u.tbuf,
sizeof(u.tbuf));
#ifdef notyet
if (ns)
@@ -113,17 +113,17 @@ fs_read_sblock(char *superblock)
#endif
if (u.lfss.lfs_magic != LFS_MAGIC) {
msg("Warning: secondary superblock at 0x%" PRIx64 " bad magic\n",
- LFS_FSBTODB(sblock, (off_t)sblock->lfs_sboffs[1]));
+ LFS_FSBTODB(sblock, (off_t)lfs_sb_getsboff(sblock, 1)));
} else {
if (sblock->lfs_version > 1) {
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]);
+ sboff = lfs_fsbtob(sblock, (off_t)lfs_sb_getsboff(sblock, 1));
}
} else {
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]);
+ sboff = lfs_fsbtob(sblock, (off_t)lfs_sb_getsboff(sblock, 1));
}
}
}
@@ -148,23 +148,23 @@ fs_parametrize(void)
ufsi.ufs_dsize = LFS_FSBTODB(sblock, lfs_sb_getsize(sblock));
if (sblock->lfs_version == 1)
- ufsi.ufs_dsize = lfs_sb_getsize(sblock) >> sblock->lfs_blktodb;
+ ufsi.ufs_dsize = lfs_sb_getsize(sblock) >> lfs_sb_getblktodb(sblock);
ufsi.ufs_bsize = lfs_sb_getbsize(sblock);
- ufsi.ufs_bshift = sblock->lfs_bshift;
+ ufsi.ufs_bshift = lfs_sb_getbshift(sblock);
ufsi.ufs_fsize = lfs_sb_getfsize(sblock);
ufsi.ufs_frag = lfs_sb_getfrag(sblock);
- ufsi.ufs_fsatoda = sblock->lfs_fsbtodb;
+ ufsi.ufs_fsatoda = lfs_sb_getfsbtodb(sblock);
if (sblock->lfs_version == 1)
ufsi.ufs_fsatoda = 0;
- ufsi.ufs_nindir = sblock->lfs_nindir;
- ufsi.ufs_inopb = sblock->lfs_inopb;
- ufsi.ufs_maxsymlinklen = sblock->lfs_maxsymlinklen;
- ufsi.ufs_bmask = ~(sblock->lfs_bmask);
- ufsi.ufs_qbmask = sblock->lfs_bmask;
- ufsi.ufs_fmask = ~(sblock->lfs_ffmask);
- ufsi.ufs_qfmask = sblock->lfs_ffmask;
+ ufsi.ufs_nindir = lfs_sb_getnindir(sblock);
+ ufsi.ufs_inopb = lfs_sb_getinopb(sblock);
+ ufsi.ufs_maxsymlinklen = lfs_sb_getmaxsymlinklen(sblock);
+ ufsi.ufs_bmask = ~(lfs_sb_getbmask(sblock));
+ ufsi.ufs_qbmask = lfs_sb_getbmask(sblock);
+ ufsi.ufs_fmask = ~(lfs_sb_getffmask(sblock));
+ ufsi.ufs_qfmask = lfs_sb_getffmask(sblock);
- dev_bsize = lfs_sb_getbsize(sblock) >> sblock->lfs_blktodb;
+ dev_bsize = lfs_sb_getbsize(sblock) >> lfs_sb_getblktodb(sblock);
return &ufsi;
}
Index: src/sbin/fsck_lfs/inode.c
diff -u src/sbin/fsck_lfs/inode.c:1.55 src/sbin/fsck_lfs/inode.c:1.56
--- src/sbin/fsck_lfs/inode.c:1.55 Fri Jul 24 06:56:41 2015
+++ src/sbin/fsck_lfs/inode.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: inode.c,v 1.55 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: inode.c,v 1.56 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
@@ -137,8 +137,8 @@ ckinode(struct ulfs1_dinode *dp, struct
idesc->id_filesize = dp->di_size;
mode = dp->di_mode & LFS_IFMT;
if (mode == LFS_IFBLK || mode == LFS_IFCHR ||
- (mode == LFS_IFLNK && (dp->di_size < fs->lfs_maxsymlinklen ||
- (fs->lfs_maxsymlinklen == 0 &&
+ (mode == LFS_IFLNK && (dp->di_size < lfs_sb_getmaxsymlinklen(fs) ||
+ (lfs_sb_getmaxsymlinklen(fs) == 0 &&
dp->di_blocks == 0))))
return (KEEPON);
dino = *dp;
Index: src/sbin/fsck_lfs/lfs.c
diff -u src/sbin/fsck_lfs/lfs.c:1.46 src/sbin/fsck_lfs/lfs.c:1.47
--- src/sbin/fsck_lfs/lfs.c:1.46 Fri Jul 24 06:56:41 2015
+++ src/sbin/fsck_lfs/lfs.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs.c,v 1.46 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: lfs.c,v 1.47 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
* All rights reserved.
@@ -249,7 +249,7 @@ ulfs_getlbns(struct lfs * fs, struct uvn
bn = -bn;
lognindir = -1;
- for (indir = fs->lfs_nindir; indir; indir >>= 1)
+ for (indir = lfs_sb_getnindir(fs); indir; indir >>= 1)
++lognindir;
/* Determine the number of levels of indirection. After this loop is
@@ -287,7 +287,7 @@ ulfs_getlbns(struct lfs * fs, struct uvn
lbc -= lognindir;
blockcnt = (int64_t) 1 << lbc;
- off = (bn >> lbc) & (fs->lfs_nindir - 1);
+ off = (bn >> lbc) & (lfs_sb_getnindir(fs) - 1);
++numlevels;
ap->in_lbn = metalbn;
@@ -366,7 +366,7 @@ lfs_raw_vget(struct lfs * fs, ino_t ino,
/* Load inode block and find inode */
if (daddr > 0) {
- bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), fs->lfs_ibsize,
+ bread(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs),
0, &bp);
bp->b_flags |= B_AGE;
dip = lfs_ifind(fs, ino, bp);
@@ -416,7 +416,7 @@ lfs_vget(void *vfs, ino_t ino)
LFS_IENTRY(ifp, fs, ino, bp);
daddr = ifp->if_daddr;
brelse(bp, 0);
- if (daddr <= 0 || lfs_dtosn(fs, daddr) >= fs->lfs_nseg)
+ if (daddr <= 0 || lfs_dtosn(fs, daddr) >= lfs_sb_getnseg(fs))
return NULL;
return lfs_raw_vget(fs, ino, fs->lfs_ivnode->v_fd, daddr);
}
@@ -435,9 +435,9 @@ check_sb(struct lfs *fs)
}
/* checksum */
checksum = lfs_sb_cksum(&(fs->lfs_dlfs));
- if (fs->lfs_cksum != checksum) {
+ if (lfs_sb_getcksum(fs) != checksum) {
printf("Superblock checksum (%lx) does not match computed checksum (%lx)\n",
- (unsigned long) fs->lfs_cksum, (unsigned long) checksum);
+ (unsigned long) lfs_sb_getcksum(fs), (unsigned long) checksum);
return 1;
}
return 0;
@@ -486,10 +486,10 @@ lfs_init(int devfd, daddr_t sblkno, dadd
bp->b_flags |= B_INVAL;
brelse(bp, 0);
- dev_bsize = lfs_sb_getfsize(fs) >> fs->lfs_fsbtodb;
+ dev_bsize = lfs_sb_getfsize(fs) >> lfs_sb_getfsbtodb(fs);
if (tryalt) {
- (void)bread(devvp, LFS_FSBTODB(fs, fs->lfs_sboffs[1]),
+ (void)bread(devvp, LFS_FSBTODB(fs, lfs_sb_getsboff(fs, 1)),
LFS_SBPAD, 0, &bp);
altfs = ecalloc(1, sizeof(*altfs));
altfs->lfs_dlfs = *((struct dlfs *) bp->b_data);
@@ -526,17 +526,17 @@ lfs_init(int devfd, daddr_t sblkno, dadd
/* Compatibility */
if (fs->lfs_version < 2) {
- fs->lfs_sumsize = LFS_V1_SUMMARY_SIZE;
- fs->lfs_ibsize = lfs_sb_getbsize(fs);
- fs->lfs_s0addr = fs->lfs_sboffs[0];
+ lfs_sb_setsumsize(fs, LFS_V1_SUMMARY_SIZE);
+ lfs_sb_setibsize(fs, lfs_sb_getbsize(fs));
+ lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 0));
lfs_sb_settstamp(fs, lfs_sb_getotstamp(fs));
- fs->lfs_fsbtodb = 0;
+ lfs_sb_setfsbtodb(fs, 0);
}
if (!dummy_read) {
fs->lfs_suflags = emalloc(2 * sizeof(u_int32_t *));
- fs->lfs_suflags[0] = emalloc(fs->lfs_nseg * sizeof(u_int32_t));
- fs->lfs_suflags[1] = emalloc(fs->lfs_nseg * sizeof(u_int32_t));
+ fs->lfs_suflags[0] = emalloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t));
+ fs->lfs_suflags[1] = emalloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t));
}
if (idaddr == 0)
@@ -586,18 +586,18 @@ try_verify(struct lfs *osb, struct uvnod
* Don't mistakenly read a superblock, if there is one here.
*/
if (lfs_sntod(osb, lfs_dtosn(osb, daddr)) == daddr) {
- if (daddr == osb->lfs_s0addr)
+ if (daddr == lfs_sb_gets0addr(osb))
daddr += lfs_btofsb(osb, LFS_LABELPAD);
for (i = 0; i < LFS_MAXNUMSB; i++) {
- if (osb->lfs_sboffs[i] < daddr)
+ if (lfs_sb_getsboff(osb, i) < daddr)
break;
- if (osb->lfs_sboffs[i] == daddr)
+ if (lfs_sb_getsboff(osb, i) == daddr)
daddr += lfs_btofsb(osb, LFS_SBPAD);
}
}
/* Read in summary block */
- bread(devvp, LFS_FSBTODB(osb, daddr), osb->lfs_sumsize,
+ bread(devvp, LFS_FSBTODB(osb, daddr), lfs_sb_getsumsize(osb),
0, &bp);
sp = (SEGSUM *)bp->b_data;
@@ -605,30 +605,31 @@ try_verify(struct lfs *osb, struct uvnod
* Check for a valid segment summary belonging to our fs.
*/
if (sp->ss_magic != SS_MAGIC ||
- sp->ss_ident != osb->lfs_ident ||
+ sp->ss_ident != lfs_sb_getident(osb) ||
sp->ss_serial < serial || /* XXX strengthen this */
- sp->ss_sumsum != cksum(&sp->ss_datasum, osb->lfs_sumsize -
+ sp->ss_sumsum != cksum(&sp->ss_datasum, lfs_sb_getsumsize(osb) -
sizeof(sp->ss_sumsum))) {
brelse(bp, 0);
if (debug) {
if (sp->ss_magic != SS_MAGIC)
- pwarn("pseg at 0x%x: "
+ pwarn("pseg at 0x%jx: "
"wrong magic number\n",
- (int)daddr);
- else if (sp->ss_ident != osb->lfs_ident)
- pwarn("pseg at 0x%x: "
- "expected ident %llx, got %llx\n",
- (int)daddr,
- (long long)sp->ss_ident,
- (long long)osb->lfs_ident);
+ (uintmax_t)daddr);
+ else if (sp->ss_ident != lfs_sb_getident(osb))
+ pwarn("pseg at 0x%jx: "
+ "expected ident %jx, got %jx\n",
+ (uintmax_t)daddr,
+ (uintmax_t)sp->ss_ident,
+ (uintmax_t)lfs_sb_getident(osb));
else if (sp->ss_serial >= serial)
- pwarn("pseg at 0x%x: "
- "serial %d < %d\n", (int)daddr,
+ pwarn("pseg at 0x%jx: "
+ "serial %d < %d\n",
+ (uintmax_t)daddr,
(int)sp->ss_serial, (int)serial);
else
- pwarn("pseg at 0x%x: "
+ pwarn("pseg at 0x%jx: "
"summary checksum wrong\n",
- (int)daddr);
+ (uintmax_t)daddr);
}
break;
}
@@ -646,10 +647,10 @@ try_verify(struct lfs *osb, struct uvnod
(int)sp->ss_serial);
assert (bc > 0);
odaddr = daddr;
- daddr += lfs_btofsb(osb, osb->lfs_sumsize + bc);
+ daddr += lfs_btofsb(osb, lfs_sb_getsumsize(osb) + bc);
if (lfs_dtosn(osb, odaddr) != lfs_dtosn(osb, daddr) ||
lfs_dtosn(osb, daddr) != lfs_dtosn(osb, daddr +
- lfs_btofsb(osb, osb->lfs_sumsize + lfs_sb_getbsize(osb)) - 1)) {
+ lfs_btofsb(osb, lfs_sb_getsumsize(osb) + lfs_sb_getbsize(osb)) - 1)) {
daddr = sp->ss_next;
}
@@ -754,28 +755,28 @@ check_summary(struct lfs *fs, SEGSUM *sp
/* Count the blocks. */
nblocks = howmany(sp->ss_ninos, LFS_INOPB(fs));
- bc = nblocks << (fs->lfs_version > 1 ? fs->lfs_ffshift : fs->lfs_bshift);
+ bc = nblocks << (fs->lfs_version > 1 ? lfs_sb_getffshift(fs) : lfs_sb_getbshift(fs));
assert(bc >= 0);
fp = (FINFO *) (sp + 1);
for (i = 0; i < sp->ss_nfinfo; i++) {
nblocks += fp->fi_nblocks;
bc += fp->fi_lastlength + ((fp->fi_nblocks - 1)
- << fs->lfs_bshift);
+ << lfs_sb_getbshift(fs));
assert(bc >= 0);
fp = (FINFO *) (fp->fi_blocks + fp->fi_nblocks);
- if (((char *)fp) - (char *)sp > fs->lfs_sumsize)
+ if (((char *)fp) - (char *)sp > lfs_sb_getsumsize(fs))
return 0;
}
datap = emalloc(nblocks * sizeof(*datap));
datac = 0;
dp = (ulfs_daddr_t *) sp;
- dp += fs->lfs_sumsize / sizeof(ulfs_daddr_t);
+ dp += lfs_sb_getsumsize(fs) / sizeof(ulfs_daddr_t);
dp--;
idp = dp;
- daddr = pseg_addr + lfs_btofsb(fs, fs->lfs_sumsize);
+ daddr = pseg_addr + lfs_btofsb(fs, lfs_sb_getsumsize(fs));
fp = (FINFO *) (sp + 1);
for (i = 0, j = 0;
i < sp->ss_nfinfo || j < howmany(sp->ss_ninos, LFS_INOPB(fs)); i++) {
@@ -789,13 +790,13 @@ check_summary(struct lfs *fs, SEGSUM *sp
break;
}
while (j < howmany(sp->ss_ninos, LFS_INOPB(fs)) && *idp == daddr) {
- bread(devvp, LFS_FSBTODB(fs, daddr), fs->lfs_ibsize,
+ bread(devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs),
0, &bp);
datap[datac++] = ((u_int32_t *) (bp->b_data))[0];
brelse(bp, 0);
++j;
- daddr += lfs_btofsb(fs, fs->lfs_ibsize);
+ daddr += lfs_btofsb(fs, lfs_sb_getibsize(fs));
--idp;
}
if (i < sp->ss_nfinfo) {
@@ -946,7 +947,7 @@ extend_ifile(struct lfs *fs)
LFS_BWRITE_LOG(bp);
#ifdef IN_FSCK_LFS
- reset_maxino(((ip->i_ffs1_size >> fs->lfs_bshift)
+ reset_maxino(((ip->i_ffs1_size >> lfs_sb_getbshift(fs))
- lfs_sb_getsegtabsz(fs)
- lfs_sb_getcleansz(fs)) * lfs_sb_getifpb(fs));
#endif
Index: src/sbin/fsck_lfs/main.c
diff -u src/sbin/fsck_lfs/main.c:1.50 src/sbin/fsck_lfs/main.c:1.51
--- src/sbin/fsck_lfs/main.c:1.50 Fri Jul 24 06:56:41 2015
+++ src/sbin/fsck_lfs/main.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: main.c,v 1.50 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: main.c,v 1.51 2015/07/24 06:59:32 dholland Exp $ */
/*
* Copyright (c) 1980, 1986, 1993
@@ -224,7 +224,7 @@ checkfilesys(const char *filesys, char *
* else.
*/
if (preen == 0) {
- printf("** Last Mounted on %s\n", fs->lfs_fsmnt);
+ printf("** Last Mounted on %s\n", lfs_sb_getfsmnt(fs));
if (hotroot())
printf("** Root file system\n");
/*
Index: src/sbin/fsck_lfs/pass1.c
diff -u src/sbin/fsck_lfs/pass1.c:1.38 src/sbin/fsck_lfs/pass1.c:1.39
--- src/sbin/fsck_lfs/pass1.c:1.38 Fri Jul 24 06:56:41 2015
+++ src/sbin/fsck_lfs/pass1.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: pass1.c,v 1.38 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: pass1.c,v 1.39 2015/07/24 06:59:32 dholland Exp $ */
/*
* Copyright (c) 1980, 1986, 1993
@@ -227,8 +227,8 @@ checkinode(ino_t inumber, struct inodesc
* Fake ndb value so direct/indirect block checks below
* will detect any garbage after symlink string.
*/
- if (dp->di_size < fs->lfs_maxsymlinklen ||
- (fs->lfs_maxsymlinklen == 0 && dp->di_blocks == 0)) {
+ if (dp->di_size < lfs_sb_getmaxsymlinklen(fs) ||
+ (lfs_sb_getmaxsymlinklen(fs) == 0 && dp->di_blocks == 0)) {
ndb = howmany(dp->di_size, sizeof(ulfs_daddr_t));
if (ndb > ULFS_NDADDR) {
j = ndb - ULFS_NDADDR;
Index: src/sbin/fsck_lfs/utilities.c
diff -u src/sbin/fsck_lfs/utilities.c:1.38 src/sbin/fsck_lfs/utilities.c:1.39
--- src/sbin/fsck_lfs/utilities.c:1.38 Fri Jul 24 06:56:41 2015
+++ src/sbin/fsck_lfs/utilities.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: utilities.c,v 1.38 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: utilities.c,v 1.39 2015/07/24 06:59:32 dholland Exp $ */
/*
* Copyright (c) 1980, 1986, 1993
@@ -120,8 +120,8 @@ write_superblocks(void)
if (debug)
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]);
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));
fsmodified = 1;
}
@@ -138,8 +138,8 @@ ckfini(int markclean)
}
}
- if (!nflag && (fs->lfs_pflags & LFS_PF_CLEAN) == 0) {
- fs->lfs_pflags |= LFS_PF_CLEAN;
+ if (!nflag && (lfs_sb_getpflags(fs) & LFS_PF_CLEAN) == 0) {
+ lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) | LFS_PF_CLEAN);
fsmodified = 1;
}
@@ -156,7 +156,7 @@ ckfini(int markclean)
else if (!reply("MARK FILE SYSTEM CLEAN"))
markclean = 0;
if (markclean) {
- fs->lfs_pflags |= LFS_PF_CLEAN;
+ lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) | LFS_PF_CLEAN);
sbdirty();
write_superblocks();
if (!preen)
Index: src/sbin/fsck_lfs/pass5.c
diff -u src/sbin/fsck_lfs/pass5.c:1.30 src/sbin/fsck_lfs/pass5.c:1.31
--- src/sbin/fsck_lfs/pass5.c:1.30 Fri Jul 24 06:56:41 2015
+++ src/sbin/fsck_lfs/pass5.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: pass5.c,v 1.30 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: pass5.c,v 1.31 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 2000, 2003 The NetBSD Foundation, Inc.
@@ -77,7 +77,7 @@ pass5(void)
avail = 0;
bb = ubb = 0;
dmeta = 0;
- for (i = 0; i < fs->lfs_nseg; i++) {
+ for (i = 0; i < lfs_sb_getnseg(fs); i++) {
diddirty = 0;
LFS_SEGENTRY(su, fs, i, bp);
if (!preen && !(su->su_flags & SEGUSE_DIRTY) &&
@@ -106,23 +106,23 @@ pass5(void)
}
if (su->su_flags & SEGUSE_DIRTY) {
bb += lfs_btofsb(fs, su->su_nbytes +
- su->su_nsums * fs->lfs_sumsize);
+ su->su_nsums * lfs_sb_getsumsize(fs));
ubb += lfs_btofsb(fs, su->su_nbytes +
- su->su_nsums * fs->lfs_sumsize +
- su->su_ninos * fs->lfs_ibsize);
+ su->su_nsums * lfs_sb_getsumsize(fs) +
+ su->su_ninos * lfs_sb_getibsize(fs));
dmeta += lfs_btofsb(fs,
- fs->lfs_sumsize * su->su_nsums);
+ lfs_sb_getsumsize(fs) * su->su_nsums);
dmeta += lfs_btofsb(fs,
- fs->lfs_ibsize * su->su_ninos);
+ lfs_sb_getibsize(fs) * su->su_ninos);
} else {
nclean++;
avail += lfs_segtod(fs, 1);
if (su->su_flags & SEGUSE_SUPERBLOCK)
avail -= lfs_btofsb(fs, LFS_SBPAD);
if (i == 0 && fs->lfs_version > 1 &&
- fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD))
+ lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))
avail -= lfs_btofsb(fs, LFS_LABELPAD) -
- fs->lfs_s0addr;
+ lfs_sb_gets0addr(fs);
}
if (diddirty)
VOP_BWRITE(bp);
@@ -134,19 +134,19 @@ pass5(void)
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)));
+ avail -= lfs_segtod(fs, (lfs_sb_getminfreeseg(fs) -
+ (lfs_sb_getminfreeseg(fs) / 2)));
/* Note we may have bytes to write yet */
avail -= lfs_btofsb(fs, locked_queue_bytes);
if (idaddr)
pwarn("NOTE: when using -i, expect discrepancies in dmeta,"
" avail, nclean, bfree\n");
- if (dmeta != fs->lfs_dmeta) {
- pwarn("DMETA GIVEN AS %d, SHOULD BE %ld\n", fs->lfs_dmeta,
- dmeta);
+ if (dmeta != lfs_sb_getdmeta(fs)) {
+ pwarn("DMETA GIVEN AS %d, SHOULD BE %ld\n",
+ lfs_sb_getdmeta(fs), dmeta);
if (preen || reply("FIX")) {
- fs->lfs_dmeta = dmeta;
+ lfs_sb_setdmeta(fs, dmeta);
sbdirty();
}
}
@@ -158,18 +158,18 @@ pass5(void)
sbdirty();
}
}
- if (nclean != fs->lfs_nclean) {
- pwarn("NCLEAN GIVEN AS %d, SHOULD BE %d\n", fs->lfs_nclean,
+ if (nclean != lfs_sb_getnclean(fs)) {
+ pwarn("NCLEAN GIVEN AS %d, SHOULD BE %d\n", lfs_sb_getnclean(fs),
nclean);
if (preen || reply("FIX")) {
- fs->lfs_nclean = nclean;
+ lfs_sb_setnclean(fs, nclean);
sbdirty();
}
}
labelskew = 0;
if (fs->lfs_version > 1 &&
- fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD))
+ lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))
labelskew = lfs_btofsb(fs, LFS_LABELPAD);
if (lfs_sb_getbfree(fs) > lfs_sb_getdsize(fs) - bb - labelskew ||
lfs_sb_getbfree(fs) < lfs_sb_getdsize(fs) - ubb - labelskew) {
Index: src/sbin/fsck_lfs/pass6.c
diff -u src/sbin/fsck_lfs/pass6.c:1.35 src/sbin/fsck_lfs/pass6.c:1.36
--- src/sbin/fsck_lfs/pass6.c:1.35 Fri Jul 24 06:56:41 2015
+++ src/sbin/fsck_lfs/pass6.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: pass6.c,v 1.35 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: pass6.c,v 1.36 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
@@ -152,15 +152,15 @@ rfw_update_single(struct uvnode *vp, dad
}
/* If block is beyond EOF, update size */
- if (lbn >= 0 && ip->i_ffs1_size <= (lbn << fs->lfs_bshift)) {
- ip->i_ffs1_size = (lbn << fs->lfs_bshift) + 1;
+ if (lbn >= 0 && ip->i_ffs1_size <= (lbn << lfs_sb_getbshift(fs))) {
+ ip->i_ffs1_size = (lbn << lfs_sb_getbshift(fs)) + 1;
}
/* If block frag size is too large for old EOF, update size */
if (lbn < ULFS_NDADDR) {
off_t minsize;
- minsize = (lbn << fs->lfs_bshift);
+ minsize = (lbn << lfs_sb_getbshift(fs));
minsize += (size - lfs_sb_getfsize(fs)) + 1;
if (ip->i_ffs1_size < minsize)
ip->i_ffs1_size = minsize;
@@ -292,7 +292,7 @@ pass6check(struct inodesc * idesc)
anyout = anynew = 0;
for (i = 0; i < idesc->id_numfrags; i++) {
sn = lfs_dtosn(fs, idesc->id_blkno + i);
- if (sn < 0 || sn >= fs->lfs_nseg ||
+ if (sn < 0 || sn >= lfs_sb_getnseg(fs) ||
(seg_table[sn].su_flags & SEGUSE_DIRTY) == 0) {
anyout = 1;
break;
@@ -583,7 +583,7 @@ pass6(void)
* changes to any other inode.
*/
- ibbuf = emalloc(fs->lfs_ibsize);
+ ibbuf = emalloc(lfs_sb_getibsize(fs));
nnewfiles = ndelfiles = nmvfiles = nnewblocks = 0;
daddr = lfs_sb_getoffset(fs);
hassuper = 0;
@@ -596,22 +596,22 @@ pass6(void)
/* Could be a superblock */
if (lfs_sntod(fs, lfs_dtosn(fs, daddr)) == daddr) {
- if (daddr == fs->lfs_s0addr) {
+ if (daddr == lfs_sb_gets0addr(fs)) {
++hassuper;
daddr += lfs_btofsb(fs, LFS_LABELPAD);
}
for (i = 0; i < LFS_MAXNUMSB; i++) {
- if (daddr == fs->lfs_sboffs[i]) {
+ if (daddr == lfs_sb_getsboff(fs, i)) {
++hassuper;
daddr += lfs_btofsb(fs, LFS_SBPAD);
}
- if (daddr < fs->lfs_sboffs[i])
+ if (daddr < lfs_sb_getsboff(fs, i))
break;
}
}
/* Read in summary block */
- bread(devvp, LFS_FSBTODB(fs, daddr), fs->lfs_sumsize, 0, &bp);
+ bread(devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getsumsize(fs), 0, &bp);
sp = (SEGSUM *)bp->b_data;
if (debug)
pwarn("sum at 0x%x: ninos=%d nfinfo=%d\n",
@@ -622,13 +622,13 @@ pass6(void)
LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), sbp);
++sup->su_nsums;
VOP_BWRITE(sbp);
- lfs_sb_subbfree(fs, lfs_btofsb(fs, fs->lfs_sumsize));
- lfs_sb_adddmeta(fs, lfs_btofsb(fs, fs->lfs_sumsize));
+ lfs_sb_subbfree(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
+ lfs_sb_adddmeta(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
sbdirty();
if (lfs_sntod(fs, lfs_dtosn(fs, daddr)) == daddr +
hassuper * lfs_btofsb(fs, LFS_SBPAD) &&
lfs_dtosn(fs, daddr) != lfs_dtosn(fs, lfs_sb_getoffset(fs))) {
- --fs->lfs_nclean;
+ lfs_sb_subnclean(fs, 1);
sbdirty();
}
@@ -637,21 +637,21 @@ pass6(void)
LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), sbp);
sup->su_ninos += howmany(sp->ss_ninos, LFS_INOPB(fs));
VOP_BWRITE(sbp);
- fs->lfs_dmeta += lfs_btofsb(fs, howmany(sp->ss_ninos,
+ lfs_sb_adddmeta(fs, lfs_btofsb(fs, howmany(sp->ss_ninos,
LFS_INOPB(fs)) *
- fs->lfs_ibsize);
+ lfs_sb_getibsize(fs)));
}
- idaddrp = ((ulfs_daddr_t *)((char *)bp->b_data + fs->lfs_sumsize));
+ idaddrp = ((ulfs_daddr_t *)((char *)bp->b_data + lfs_sb_getsumsize(fs)));
for (i = 0; i < howmany(sp->ss_ninos, LFS_INOPB(fs)); i++) {
ino_t *inums;
inums = ecalloc(LFS_INOPB(fs) + 1, sizeof(*inums));
ibdaddr = *--idaddrp;
- lfs_sb_subbfree(fs, lfs_btofsb(fs, fs->lfs_ibsize));
+ lfs_sb_subbfree(fs, lfs_btofsb(fs, lfs_sb_getibsize(fs)));
sbdirty();
- bread(devvp, LFS_FSBTODB(fs, ibdaddr), fs->lfs_ibsize,
- 0, &ibp);
- memcpy(ibbuf, ibp->b_data, fs->lfs_ibsize);
+ bread(devvp, LFS_FSBTODB(fs, ibdaddr),
+ lfs_sb_getibsize(fs), 0, &ibp);
+ memcpy(ibbuf, ibp->b_data, lfs_sb_getibsize(fs));
brelse(ibp, 0);
j = 0;
@@ -777,10 +777,10 @@ pass6(void)
lastserial = sp->ss_serial;
}
odaddr = daddr;
- daddr += lfs_btofsb(fs, fs->lfs_sumsize + bc);
+ daddr += 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 + lfs_sb_getbsize(fs)) - 1)) {
+ lfs_btofsb(fs, lfs_sb_getsumsize(fs) + lfs_sb_getbsize(fs)) - 1)) {
daddr = ((SEGSUM *)bp->b_data)->ss_next;
}
brelse(bp, 0);
@@ -825,19 +825,19 @@ pass6(void)
/* Could be a superblock */
if (lfs_sntod(fs, lfs_dtosn(fs, daddr)) == daddr) {
- if (daddr == fs->lfs_s0addr)
+ if (daddr == lfs_sb_gets0addr(fs))
daddr += lfs_btofsb(fs, LFS_LABELPAD);
for (i = 0; i < LFS_MAXNUMSB; i++) {
- if (daddr == fs->lfs_sboffs[i]) {
+ if (daddr == lfs_sb_getsboff(fs, i)) {
daddr += lfs_btofsb(fs, LFS_SBPAD);
}
- if (daddr < fs->lfs_sboffs[i])
+ if (daddr < lfs_sb_getsboff(fs, i))
break;
}
}
/* Read in summary block */
- bread(devvp, LFS_FSBTODB(fs, daddr), fs->lfs_sumsize, 0, &bp);
+ bread(devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getsumsize(fs), 0, &bp);
sp = (SEGSUM *)bp->b_data;
bc = check_summary(fs, sp, daddr, debug, devvp, pass6harvest);
if (bc == 0) {
@@ -847,7 +847,7 @@ pass6(void)
break;
}
odaddr = daddr;
- daddr += lfs_btofsb(fs, fs->lfs_sumsize + bc);
+ daddr += lfs_btofsb(fs, lfs_sb_getsumsize(fs) + 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 +
@@ -863,12 +863,12 @@ pass6(void)
/* Final address could also be a superblock */
if (lfs_sntod(fs, lfs_dtosn(fs, lastgood)) == lastgood) {
- if (lastgood == fs->lfs_s0addr)
+ if (lastgood == lfs_sb_gets0addr(fs))
lastgood += lfs_btofsb(fs, LFS_LABELPAD);
for (i = 0; i < LFS_MAXNUMSB; i++) {
- if (lastgood == fs->lfs_sboffs[i])
+ if (lastgood == lfs_sb_getsboff(fs, i))
lastgood += lfs_btofsb(fs, LFS_SBPAD);
- if (lastgood < fs->lfs_sboffs[i])
+ if (lastgood < lfs_sb_getsboff(fs, i))
break;
}
}
@@ -877,7 +877,7 @@ pass6(void)
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;
+ sn = (sn + 1) % lfs_sb_getnseg(fs);
if (sn == curseg)
errx(1, "no clean segments");
LFS_SEGENTRY(sup, fs, sn, bp);
Index: src/sbin/fsck_lfs/segwrite.c
diff -u src/sbin/fsck_lfs/segwrite.c:1.32 src/sbin/fsck_lfs/segwrite.c:1.33
--- src/sbin/fsck_lfs/segwrite.c:1.32 Fri Jul 24 06:56:41 2015
+++ src/sbin/fsck_lfs/segwrite.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: segwrite.c,v 1.32 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: segwrite.c,v 1.33 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
* All rights reserved.
@@ -252,7 +252,7 @@ lfs_writeinode(struct lfs * fs, struct s
if ((ip->i_number != LFS_IFILE_INUM || sp->idp == NULL) &&
sp->ibp == NULL) {
/* Allocate a new segment if necessary. */
- if (sp->seg_bytes_left < fs->lfs_ibsize ||
+ if (sp->seg_bytes_left < lfs_sb_getibsize(fs) ||
sp->sum_bytes_left < sizeof(ulfs_daddr_t))
(void) lfs_writeseg(fs, sp);
@@ -261,7 +261,7 @@ lfs_writeinode(struct lfs * fs, struct s
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);
+ lfs_sb_getibsize(fs));
sp->ibp->b_flags |= B_GATHERED;
gotblk++;
@@ -557,7 +557,7 @@ lfs_updatemeta(struct segment * sp)
* that you cannot have fragments.
*/
sp->fip->fi_lastlength = ((sp->start_bpp[nblocks - 1]->b_bcount - 1) &
- fs->lfs_bmask) + 1;
+ lfs_sb_getbmask(fs)) + 1;
/*
* Assign disk addresses, and update references to the logical
@@ -576,7 +576,7 @@ lfs_updatemeta(struct segment * sp)
* that the indirect block that actually ends the list
* is of a smaller size!)
*/
- if ((sbp->b_bcount & fs->lfs_bmask) && i != 0)
+ if ((sbp->b_bcount & lfs_sb_getbmask(fs)) && i != 0)
errx(EXIT_FAILURE, "%s: fragment is not last block", __func__);
/*
@@ -635,9 +635,9 @@ lfs_initseg(struct lfs * fs)
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)) {
- lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_LABELPAD) - fs->lfs_s0addr);
- sp->seg_bytes_left -= LFS_LABELPAD - lfs_fsbtob(fs, fs->lfs_s0addr);
+ lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD)) {
+ lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_LABELPAD) - lfs_sb_gets0addr(fs));
+ sp->seg_bytes_left -= LFS_LABELPAD - lfs_fsbtob(fs, lfs_sb_gets0addr(fs));
}
} else {
sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
@@ -702,13 +702,13 @@ lfs_newseg(struct lfs * fs)
LFS_CLEANERINFO(cip, fs, bp);
--cip->clean;
++cip->dirty;
- fs->lfs_nclean = cip->clean;
+ lfs_sb_setnclean(fs, cip->clean);
LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
lfs_sb_setlastseg(fs, lfs_sb_getcurseg(fs));
lfs_sb_setcurseg(fs, lfs_sb_getnextseg(fs));
for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + lfs_sb_getinterleave(fs);;) {
- sn = (sn + 1) % fs->lfs_nseg;
+ sn = (sn + 1) % lfs_sb_getnseg(fs);
if (sn == curseg)
errx(EXIT_FAILURE, "%s: no clean segments", __func__);
LFS_SEGENTRY(sup, fs, sn, bp);
@@ -776,8 +776,8 @@ lfs_writeseg(struct lfs * fs, struct seg
sup->su_lastmod = write_time;
sup->su_ninos += ninos;
++sup->su_nsums;
- fs->lfs_dmeta += (lfs_btofsb(fs, lfs_sb_getsumsize(fs)) + lfs_btofsb(fs, ninos *
- fs->lfs_ibsize));
+ lfs_sb_adddmeta(fs, (lfs_btofsb(fs, lfs_sb_getsumsize(fs)) + lfs_btofsb(fs, ninos *
+ lfs_sb_getibsize(fs))));
lfs_sb_subavail(fs, lfs_btofsb(fs, lfs_sb_getsumsize(fs)));
do_again = !(bp->b_flags & B_GATHERED);
@@ -810,7 +810,7 @@ lfs_writeseg(struct lfs * fs, struct seg
ssp->ss_create = write_time;
lfs_sb_addserial(fs, 1);
ssp->ss_serial = lfs_sb_getserial(fs);
- ssp->ss_ident = fs->lfs_ident;
+ ssp->ss_ident = lfs_sb_getident(fs);
}
/* Set the summary block busy too */
bremfree(*(sp->bpp));
@@ -950,8 +950,8 @@ lfs_segunlock(struct lfs * fs)
fs->lfs_nactive = 0;
/* Since we *know* everything's on disk, write both sbs */
- lfs_writesuper(fs, fs->lfs_sboffs[0]);
- lfs_writesuper(fs, fs->lfs_sboffs[1]);
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));
--fs->lfs_seglock;
fs->lfs_lockpid = 0;
@@ -1003,7 +1003,7 @@ lfs_writesuper(struct lfs *fs, ulfs_dadd
lfs_sb_settstamp(fs, write_time);
/* Checksum the superblock and copy it into a buffer. */
- fs->lfs_cksum = lfs_sb_cksum(&(fs->lfs_dlfs));
+ lfs_sb_setcksum(fs, lfs_sb_cksum(&(fs->lfs_dlfs)));
assert(daddr > 0);
bp = getblk(fs->lfs_devvp, LFS_FSBTODB(fs, daddr), LFS_SBPAD);
memset(bp->b_data + sizeof(struct dlfs), 0,
Index: src/sbin/fsck_lfs/setup.c
diff -u src/sbin/fsck_lfs/setup.c:1.47 src/sbin/fsck_lfs/setup.c:1.48
--- src/sbin/fsck_lfs/setup.c:1.47 Fri Jul 24 06:56:41 2015
+++ src/sbin/fsck_lfs/setup.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: setup.c,v 1.47 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: setup.c,v 1.48 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
@@ -218,7 +218,7 @@ setup(const char *dev)
/* Resize buffer cache now that we have a superblock to guess from. */
bufrehash((lfs_sb_getsegtabsz(fs) + maxino / lfs_sb_getifpb(fs)) << 4);
- if (fs->lfs_pflags & LFS_PF_CLEAN) {
+ if (lfs_sb_getpflags(fs) & LFS_PF_CLEAN) {
if (doskipclean) {
if (!quiet)
pwarn("%sile system is clean; not checking\n",
@@ -240,12 +240,12 @@ setup(const char *dev)
(unsigned long)idaddr);
tdaddr = lfs_sntod(fs, lfs_dtosn(fs, idaddr));
if (lfs_sntod(fs, lfs_dtosn(fs, tdaddr)) == tdaddr) {
- if (tdaddr == fs->lfs_s0addr)
+ if (tdaddr == lfs_sb_gets0addr(fs))
tdaddr += lfs_btofsb(fs, LFS_LABELPAD);
for (i = 0; i < LFS_MAXNUMSB; i++) {
- if (fs->lfs_sboffs[i] == tdaddr)
+ if (lfs_sb_getsboff(fs, i) == tdaddr)
tdaddr += lfs_btofsb(fs, LFS_SBPAD);
- if (fs->lfs_sboffs[i] > tdaddr)
+ if (lfs_sb_getsboff(fs, i) > tdaddr)
break;
}
}
@@ -256,11 +256,11 @@ setup(const char *dev)
(intmax_t)lfs_sb_getserial(fs));
while (tdaddr < idaddr) {
bread(fs->lfs_devvp, LFS_FSBTODB(fs, tdaddr),
- fs->lfs_sumsize,
+ lfs_sb_getsumsize(fs),
0, &bp);
sp = (SEGSUM *)bp->b_data;
if (sp->ss_sumsum != cksum(&sp->ss_datasum,
- fs->lfs_sumsize -
+ lfs_sb_getsumsize(fs) -
sizeof(sp->ss_sumsum))) {
brelse(bp, 0);
if (debug)
@@ -270,11 +270,11 @@ setup(const char *dev)
}
fp = (FINFO *)(sp + 1);
bc = howmany(sp->ss_ninos, LFS_INOPB(fs)) <<
- (fs->lfs_version > 1 ? fs->lfs_ffshift :
- fs->lfs_bshift);
+ (fs->lfs_version > 1 ? lfs_sb_getffshift(fs) :
+ lfs_sb_getbshift(fs));
for (i = 0; i < sp->ss_nfinfo; i++) {
bc += fp->fi_lastlength + ((fp->fi_nblocks - 1)
- << fs->lfs_bshift);
+ << lfs_sb_getbshift(fs));
fp = (FINFO *)(fp->fi_blocks + fp->fi_nblocks);
}
@@ -290,8 +290,8 @@ setup(const char *dev)
*/
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;
+ for (sn = curseg + lfs_sb_getinterleave(fs);;) {
+ sn = (sn + 1) % lfs_sb_getnseg(fs);
if (sn == curseg)
errx(1, "init: no clean segments");
LFS_SEGENTRY(sup, fs, sn, bp);
@@ -304,7 +304,7 @@ setup(const char *dev)
/* Skip superblock if necessary */
for (i = 0; i < LFS_MAXNUMSB; i++)
- if (lfs_sb_getoffset(fs) == fs->lfs_sboffs[i])
+ if (lfs_sb_getoffset(fs) == lfs_sb_getsboff(fs, i))
lfs_sb_addoffset(fs, lfs_btofsb(fs, LFS_SBPAD));
++fs->lfs_nactive;
@@ -330,13 +330,13 @@ setup(const char *dev)
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);
+ pwarn("lfs_inopb = %lu\n", (unsigned long) lfs_sb_getinopb(fs));
}
if (fs->lfs_version == 1)
maxfsblock = lfs_sb_getsize(fs) * (lfs_sb_getbsize(fs) / dev_bsize);
else
maxfsblock = lfs_sb_getsize(fs);
- maxfilesize = calcmaxfilesize(fs->lfs_bshift);
+ maxfilesize = calcmaxfilesize(lfs_sb_getbshift(fs));
if (/* lfs_sb_getminfree(fs) < 0 || */ lfs_sb_getminfree(fs) > 99) {
pfatal("IMPOSSIBLE MINFREE=%u IN SUPERBLOCK",
lfs_sb_getminfree(fs));
@@ -345,53 +345,55 @@ setup(const char *dev)
sbdirty();
}
}
- 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) lfs_sb_getbsize(fs) - 1);
- fs->lfs_bmask = lfs_sb_getbsize(fs) - 1;
+ if (lfs_sb_getbmask(fs) != lfs_sb_getbsize(fs) - 1) {
+ pwarn("INCORRECT BMASK=0x%jx IN SUPERBLOCK (SHOULD BE 0x%x)",
+ (uintmax_t)lfs_sb_getbmask(fs),
+ lfs_sb_getbsize(fs) - 1);
+ lfs_sb_setbmask(fs, lfs_sb_getbsize(fs) - 1);
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
}
}
- if (fs->lfs_ffmask != lfs_sb_getfsize(fs) - 1) {
- pwarn("INCORRECT FFMASK=%" PRId64 " IN SUPERBLOCK",
- fs->lfs_ffmask);
- fs->lfs_ffmask = lfs_sb_getfsize(fs) - 1;
+ if (lfs_sb_getffmask(fs) != lfs_sb_getfsize(fs) - 1) {
+ pwarn("INCORRECT FFMASK=0x%jx IN SUPERBLOCK (SHOULD BE 0x%x)",
+ (uintmax_t)lfs_sb_getffmask(fs),
+ lfs_sb_getfsize(fs) - 1);
+ lfs_sb_setffmask(fs, lfs_sb_getfsize(fs) - 1);
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
}
}
- if (fs->lfs_fbmask != (1 << fs->lfs_fbshift) - 1) {
- pwarn("INCORRECT FBMASK=%" PRId64 " IN SUPERBLOCK",
- fs->lfs_fbmask);
- fs->lfs_fbmask = (1 << fs->lfs_fbshift) - 1;
+ if (lfs_sb_getfbmask(fs) != (1U << lfs_sb_getfbshift(fs)) - 1) {
+ pwarn("INCORRECT FBMASK=0x%jx IN SUPERBLOCK (SHOULD BE 0x%x)",
+ (uintmax_t)lfs_sb_getfbmask(fs),
+ (1U << lfs_sb_getfbshift(fs)) - 1);
+ lfs_sb_setfbmask(fs, (1U << lfs_sb_getfbshift(fs)) - 1);
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
sbdirty();
}
}
- if (fs->lfs_maxfilesize != maxfilesize) {
+ if (lfs_sb_getmaxfilesize(fs) != maxfilesize) {
pwarn(
- "INCORRECT MAXFILESIZE=%llu IN SUPERBLOCK (SHOULD BE %llu WITH BSHIFT %d)",
- (unsigned long long) fs->lfs_maxfilesize,
- (unsigned long long) maxfilesize, (int)fs->lfs_bshift);
+ "INCORRECT MAXFILESIZE=%llu IN SUPERBLOCK (SHOULD BE %llu WITH BSHIFT %u)",
+ (unsigned long long) lfs_sb_getmaxfilesize(fs),
+ (unsigned long long) maxfilesize, lfs_sb_getbshift(fs));
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
- fs->lfs_maxfilesize = maxfilesize;
+ lfs_sb_setmaxfilesize(fs, maxfilesize);
sbdirty();
}
}
- if (fs->lfs_maxsymlinklen != ULFS1_MAXSYMLINKLEN) {
- pwarn("INCORRECT MAXSYMLINKLEN=%d IN SUPERBLOCK",
- fs->lfs_maxsymlinklen);
- fs->lfs_maxsymlinklen = ULFS1_MAXSYMLINKLEN;
+ if (lfs_sb_getmaxsymlinklen(fs) != ULFS1_MAXSYMLINKLEN) {
+ pwarn("INCORRECT MAXSYMLINKLEN=%d IN SUPERBLOCK (SHOULD BE %zu)",
+ lfs_sb_getmaxsymlinklen(fs), ULFS1_MAXSYMLINKLEN);
+ lfs_sb_setmaxsymlinklen(fs, ULFS1_MAXSYMLINKLEN);
if (preen)
printf(" (FIXED)\n");
if (preen || reply("FIX") == 1) {
@@ -412,7 +414,7 @@ setup(const char *dev)
if (debug)
pwarn("maxino = %llu\n", (unsigned long long)maxino);
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);
+ bread(ivp, i >> lfs_sb_getbshift(fs), lfs_sb_getbsize(fs), 0, &bp);
/* XXX check B_ERROR */
brelse(bp, 0);
}
@@ -421,9 +423,9 @@ setup(const char *dev)
* allocate and initialize the necessary maps
*/
din_table = ecalloc(maxino, sizeof(*din_table));
- seg_table = ecalloc(fs->lfs_nseg, sizeof(SEGUSE));
+ seg_table = ecalloc(lfs_sb_getnseg(fs), sizeof(SEGUSE));
/* Get segment flags */
- for (i = 0; i < fs->lfs_nseg; i++) {
+ for (i = 0; i < lfs_sb_getnseg(fs); i++) {
LFS_SEGENTRY(sup, fs, i, bp);
seg_table[i].su_flags = sup->su_flags & ~SEGUSE_ACTIVE;
if (preen)
Index: src/sbin/newfs_lfs/make_lfs.c
diff -u src/sbin/newfs_lfs/make_lfs.c:1.32 src/sbin/newfs_lfs/make_lfs.c:1.33
--- src/sbin/newfs_lfs/make_lfs.c:1.32 Fri Jul 24 06:56:41 2015
+++ src/sbin/newfs_lfs/make_lfs.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: make_lfs.c,v 1.32 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: make_lfs.c,v 1.33 2015/07/24 06:59:32 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.32 2015/07/24 06:56:41 dholland Exp $");
+__RCSID("$NetBSD: make_lfs.c,v 1.33 2015/07/24 06:59:32 dholland Exp $");
#endif
#endif /* not lint */
@@ -231,7 +231,7 @@ make_dinode(ino_t ino, struct ulfs1_dino
dip->di_nlink = 1;
dip->di_blocks = nfrags;
- dip->di_size = (nfrags << fs->lfs_ffshift);
+ dip->di_size = (nfrags << lfs_sb_getffshift(fs));
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;
@@ -400,34 +400,34 @@ make_lfs(int devfd, uint secsize, struct
tryagain:
/* Modify parts of superblock overridden by command line arguments */
if (bsize != DFL_LFSBLOCK || fsize != DFL_LFSFRAG) {
- fs->lfs_bshift = lfs_log2(bsize);
- if (1 << fs->lfs_bshift != bsize)
+ lfs_sb_setbshift(fs, lfs_log2(bsize));
+ if (1 << lfs_sb_getbshift(fs) != bsize)
fatal("%d: block size not a power of 2", bsize);
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)
+ lfs_sb_setbmask(fs, bsize - 1);
+ lfs_sb_setffmask(fs, fsize - 1);
+ lfs_sb_setffshift(fs, lfs_log2(fsize));
+ if (1 << lfs_sb_getffshift(fs) != fsize)
fatal("%d: frag size not a power of 2", fsize);
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_setfbmask(fs, lfs_sb_getfrag(fs) - 1);
+ lfs_sb_setfbshift(fs, lfs_log2(lfs_sb_getfrag(fs)));
lfs_sb_setifpb(fs, bsize / sizeof(IFILE));
/* XXX ondisk32 */
- fs->lfs_nindir = bsize / sizeof(int32_t);
+ lfs_sb_setnindir(fs, bsize / sizeof(int32_t));
}
if (fs->lfs_version == 1) {
- fs->lfs_sumsize = LFS_V1_SUMMARY_SIZE;
- fs->lfs_segshift = lfs_log2(ssize);
- if (1 << fs->lfs_segshift != ssize)
+ lfs_sb_setsumsize(fs, LFS_V1_SUMMARY_SIZE);
+ lfs_sb_setsegshift(fs, lfs_log2(ssize));
+ if (1 << lfs_sb_getsegshift(fs) != ssize)
fatal("%d: segment size not power of 2", ssize);
- fs->lfs_segmask = ssize - 1;
+ lfs_sb_setsegmask(fs, ssize - 1);
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);
+ lfs_sb_setssize(fs, ssize >> lfs_sb_getbshift(fs));
} else {
if (ssize % fsize) {
fprintf(stderr,
@@ -437,22 +437,22 @@ make_lfs(int devfd, uint secsize, struct
fprintf(stderr, "trying size %d.\n", ssize);
goto tryagain;
}
- fs->lfs_sumsize = fsize;
- fs->lfs_segshift = 0;
- fs->lfs_segmask = 0;
+ lfs_sb_setsumsize(fs, fsize);
+ lfs_sb_setsegshift(fs, 0);
+ lfs_sb_setsegmask(fs, 0);
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);
+ lfs_sb_setinopb(fs, lfs_sb_getibsize(fs) / sizeof(struct ulfs1_dinode));
lfs_sb_setminfree(fs, minfree);
if (version > 1) {
lfs_sb_setinopf(fs, secsize/LFS_DINODE1_SIZE);
- fs->lfs_interleave = interleave;
+ lfs_sb_setinterleave(fs, interleave);
if (roll_id == 0)
roll_id = arc4random();
- fs->lfs_ident = roll_id;
+ lfs_sb_setident(fs, roll_id);
}
/*
@@ -460,43 +460,43 @@ make_lfs(int devfd, uint secsize, struct
* 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.
+ * sets it and then overwrites it a few lines later.
*/
db_per_blk = bsize/secsize;
- fs->lfs_blktodb = lfs_log2(db_per_blk);
- fs->lfs_fsbtodb = lfs_log2(fsize / secsize);
+ lfs_sb_setblktodb(fs, lfs_log2(db_per_blk));
+ lfs_sb_setfsbtodb(fs, lfs_log2(fsize / secsize));
if (version == 1) {
- fs->lfs_sushift = lfs_log2(lfs_sb_getsepb(fs));
- fs->lfs_fsbtodb = 0;
- lfs_sb_setsize(fs, dkw->dkw_size >> fs->lfs_blktodb);
+ lfs_sb_setsushift(fs, lfs_log2(lfs_sb_getsepb(fs)));
+ lfs_sb_setfsbtodb(fs, 0);
+ lfs_sb_setsize(fs, dkw->dkw_size >> lfs_sb_getblktodb(fs));
}
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);
- lfs_sb_setsize(fs, dkw->dkw_size >> fs->lfs_fsbtodb);
+ lfs_sb_setfsbpseg(fs, LFS_DBTOFSB(fs, ssize / secsize));
+ lfs_sb_setsize(fs, dkw->dkw_size >> lfs_sb_getfsbtodb(fs));
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);
+ lfs_sb_setnseg(fs, lfs_sb_getdsize(fs) / lfs_segtod(fs, 1));
- fs->lfs_nclean = fs->lfs_nseg - 1;
- fs->lfs_maxfilesize = maxfilesize(fs->lfs_bshift);
+ lfs_sb_setnclean(fs, lfs_sb_getnseg(fs) - 1);
+ lfs_sb_setmaxfilesize(fs, maxfilesize(lfs_sb_getbshift(fs)));
if (minfreeseg == 0)
- fs->lfs_minfreeseg = fs->lfs_nseg / DFL_MIN_FREE_SEGS;
+ lfs_sb_setminfreeseg(fs, lfs_sb_getnseg(fs) / DFL_MIN_FREE_SEGS);
else
- fs->lfs_minfreeseg = minfreeseg;
- if (fs->lfs_minfreeseg < MIN_FREE_SEGS)
- fs->lfs_minfreeseg = MIN_FREE_SEGS;
+ lfs_sb_setminfreeseg(fs, minfreeseg);
+ if (lfs_sb_getminfreeseg(fs) < MIN_FREE_SEGS)
+ lfs_sb_setminfreeseg(fs, MIN_FREE_SEGS);
if (resvseg == 0)
- fs->lfs_resvseg = fs->lfs_minfreeseg / 2 + 1;
+ lfs_sb_setresvseg(fs, lfs_sb_getminfreeseg(fs) / 2 + 1);
else
- fs->lfs_resvseg = resvseg;
- if (fs->lfs_resvseg < MIN_RESV_SEGS)
- fs->lfs_resvseg = MIN_RESV_SEGS;
+ lfs_sb_setresvseg(fs, resvseg);
+ if (lfs_sb_getresvseg(fs) < MIN_RESV_SEGS)
+ lfs_sb_setresvseg(fs, MIN_RESV_SEGS);
- if(fs->lfs_nseg < (4 * fs->lfs_minfreeseg)
- || fs->lfs_nseg < LFS_MIN_SBINTERVAL + 1)
+ if(lfs_sb_getnseg(fs) < (4 * lfs_sb_getminfreeseg(fs))
+ || lfs_sb_getnseg(fs) < LFS_MIN_SBINTERVAL + 1)
{
if(seg_size == 0 && ssize > (bsize<<1)) {
if(!warned_segtoobig) {
@@ -526,13 +526,13 @@ make_lfs(int devfd, uint secsize, struct
*/
printf("Creating a version %d LFS", fs->lfs_version);
if (fs->lfs_version > 1)
- printf(" with roll-forward ident 0x%x", fs->lfs_ident);
+ printf(" with roll-forward ident 0x%x", lfs_sb_getident(fs));
printf("\n");
- fssize = (double)fs->lfs_nseg;
+ fssize = (double)lfs_sb_getnseg(fs);
fssize *= (double)ssize;
fssize /= 1048576.0;
printf("%.1fMB in %d segments of size %d\n", fssize,
- fs->lfs_nseg, ssize);
+ lfs_sb_getnseg(fs), ssize);
/*
* The number of free blocks is set from the number of segments
@@ -542,7 +542,7 @@ make_lfs(int devfd, uint secsize, struct
* and segment usage table, and half a block per segment that can't
* be written due to fragmentation.
*/
- lfs_sb_setdsize(fs, (fs->lfs_nseg - fs->lfs_minfreeseg) *
+ lfs_sb_setdsize(fs, (lfs_sb_getnseg(fs) - lfs_sb_getminfreeseg(fs)) *
lfs_segtod(fs, 1));
lfs_sb_setbfree(fs, lfs_sb_getdsize(fs));
lfs_sb_subbfree(fs, LFS_DBTOFSB(fs, ((lfs_sb_getnseg(fs) / 2) <<
@@ -556,7 +556,7 @@ make_lfs(int devfd, uint secsize, struct
if (version == 1)
lfs_sb_setotstamp(fs, stamp);
- if ((sb_interval = fs->lfs_nseg / LFS_MAXNUMSB) < LFS_MIN_SBINTERVAL)
+ if ((sb_interval = lfs_sb_getnseg(fs) / LFS_MAXNUMSB) < LFS_MIN_SBINTERVAL)
sb_interval = LFS_MIN_SBINTERVAL;
/*
@@ -576,27 +576,27 @@ make_lfs(int devfd, uint secsize, struct
start, btodb(LFS_LABELPAD),
btodb(LFS_LABELPAD + LFS_SBPAD));
}
- fs->lfs_sboffs[0] = label_fsb;
+ lfs_sb_setsboff(fs, 0, label_fsb);
if (version == 1)
- fs->lfs_s0addr = fs->lfs_sboffs[0];
+ lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 0));
else
- fs->lfs_s0addr = LFS_DBTOFSB(fs, start);
+ lfs_sb_sets0addr(fs, LFS_DBTOFSB(fs, start));
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];
+ + lfs_sb_getsboff(fs, 0);
/* Segment 0 eats the label, except for version 1 */
- if (fs->lfs_version > 1 && fs->lfs_s0addr < label_fsb)
+ if (fs->lfs_version > 1 && lfs_sb_gets0addr(fs) < label_fsb)
sb_addr -= label_fsb - start;
if (sb_addr + sizeof(struct dlfs)
>= LFS_DBTOFSB(fs, dkw->dkw_size))
break;
- fs->lfs_sboffs[i] = sb_addr;
+ lfs_sb_setsboff(fs, i, sb_addr);
lfs_sb_setdsize(fs, lfs_sb_getdsize(fs) - sb_fsb);
}
/* We need >= 2 superblocks */
- if(fs->lfs_sboffs[1] == 0x0) {
+ if (lfs_sb_getsboff(fs, 1) == 0x0) {
fatal("Could not assign a disk address for the second "
"superblock.\nPlease decrease the segment size.\n");
}
@@ -619,8 +619,8 @@ make_lfs(int devfd, uint secsize, struct
dip->di_flags = SF_IMMUTABLE;
make_dinode(LFS_IFILE_INUM, dip,
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++)
+ dip->di_size = (lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs) + 1) << lfs_sb_getbshift(fs);
+ for (i = 0; i < ULFS_NDADDR && i < (dip->di_size >> lfs_sb_getbshift(fs)); i++)
VTOI(fs->lfs_ivnode)->i_lfs_fragsize[i] = lfs_sb_getbsize(fs);
/*
@@ -629,10 +629,10 @@ make_lfs(int devfd, uint secsize, struct
fs->lfs_suflags = (u_int32_t **) malloc(2 * sizeof(u_int32_t *));
if (fs->lfs_suflags == NULL)
err(1, NULL);
- fs->lfs_suflags[0] = (u_int32_t *) malloc(fs->lfs_nseg * sizeof(u_int32_t));
+ fs->lfs_suflags[0] = (u_int32_t *) malloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t));
if (fs->lfs_suflags[0] == NULL)
err(1, NULL);
- fs->lfs_suflags[1] = (u_int32_t *) malloc(fs->lfs_nseg * sizeof(u_int32_t));
+ fs->lfs_suflags[1] = (u_int32_t *) malloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t));
if (fs->lfs_suflags[1] == NULL)
err(1, NULL);
@@ -640,7 +640,7 @@ make_lfs(int devfd, uint secsize, struct
* Initialize the cleanerinfo block
*/
LFS_CLEANERINFO(cip, fs, bp);
- cip->clean = fs->lfs_nseg;
+ cip->clean = lfs_sb_getnseg(fs);
cip->dirty = 0;
if (version > 1) {
cip->free_head = HIGHEST_USED_INO + 1;
@@ -651,11 +651,11 @@ make_lfs(int devfd, uint secsize, struct
/*
* Run through segment table and initialize that
*/
- for (i = j = 0; i < fs->lfs_nseg; i++) {
+ for (i = j = 0; i < lfs_sb_getnseg(fs); i++) {
LFS_SEGENTRY(segp, fs, i, bp);
if (i == 0 &&
- fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD + LFS_SBPAD)) {
+ lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD + LFS_SBPAD)) {
segp->su_flags = SEGUSE_SUPERBLOCK;
lfs_sb_subbfree(fs, sb_fsb);
++j;
@@ -770,26 +770,26 @@ make_lfs(int devfd, uint secsize, struct
*/
lfs_sb_setavail(fs, 0);
bb = ubb = dmeta = 0;
- for (i = 0; i < fs->lfs_nseg; i++) {
+ for (i = 0; i < lfs_sb_getnseg(fs); i++) {
LFS_SEGENTRY(segp, fs, i, bp);
if (segp->su_flags & SEGUSE_DIRTY) {
bb += lfs_btofsb(fs, segp->su_nbytes +
- segp->su_nsums * fs->lfs_sumsize);
+ segp->su_nsums * lfs_sb_getsumsize(fs));
ubb += lfs_btofsb(fs, segp->su_nbytes +
- segp->su_nsums * fs->lfs_sumsize +
- segp->su_ninos * fs->lfs_ibsize);
+ segp->su_nsums * lfs_sb_getsumsize(fs) +
+ segp->su_ninos * lfs_sb_getibsize(fs));
dmeta += lfs_btofsb(fs,
- fs->lfs_sumsize * segp->su_nsums);
+ lfs_sb_getsumsize(fs) * segp->su_nsums);
dmeta += lfs_btofsb(fs,
- fs->lfs_ibsize * segp->su_ninos);
+ lfs_sb_getibsize(fs) * segp->su_ninos);
} else {
lfs_sb_addavail(fs, lfs_segtod(fs, 1));
if (segp->su_flags & SEGUSE_SUPERBLOCK)
lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_SBPAD));
if (i == 0 && fs->lfs_version > 1 &&
- fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD))
+ lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))
lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_LABELPAD) -
- fs->lfs_s0addr);
+ lfs_sb_gets0addr(fs));
}
brelse(bp, 0);
}
@@ -797,10 +797,10 @@ make_lfs(int devfd, uint secsize, struct
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 */
- lfs_sb_subavail(fs, lfs_segtod(fs, (fs->lfs_minfreeseg - (fs->lfs_minfreeseg / 2))));
+ lfs_sb_subavail(fs, lfs_segtod(fs, (lfs_sb_getminfreeseg(fs) - (lfs_sb_getminfreeseg(fs) / 2))));
labelskew = 0;
- if (fs->lfs_version > 1 && fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD))
+ if (fs->lfs_version > 1 && lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))
labelskew = lfs_btofsb(fs, LFS_LABELPAD);
lfs_sb_setbfree(fs, lfs_sb_getdsize(fs) - labelskew - (ubb + bb) / 2);
@@ -818,7 +818,7 @@ make_lfs(int devfd, uint secsize, struct
printf("super-block backups (for fsck -b #) at:\n");
curw = 0;
for (i = 0; i < LFS_MAXNUMSB; i++) {
- seg_addr = fs->lfs_sboffs[i];
+ seg_addr = lfs_sb_getsboff(fs, i);
if (seg_addr == 0)
break;
@@ -837,7 +837,7 @@ make_lfs(int devfd, uint secsize, struct
/* Leave the time stamp on the alt sb, zero the rest */
if (i == 2) {
lfs_sb_settstamp(fs, 0);
- fs->lfs_cksum = lfs_sb_cksum(&(fs->lfs_dlfs));
+ lfs_sb_setcksum(fs, lfs_sb_cksum(&(fs->lfs_dlfs)));
}
if (!Nflag)
lfs_writesuper(fs, seg_addr);
Index: src/sbin/resize_lfs/resize_lfs.c
diff -u src/sbin/resize_lfs/resize_lfs.c:1.10 src/sbin/resize_lfs/resize_lfs.c:1.11
--- src/sbin/resize_lfs/resize_lfs.c:1.10 Fri Jul 24 06:56:41 2015
+++ src/sbin/resize_lfs/resize_lfs.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: resize_lfs.c,v 1.10 2015/07/24 06:56:41 dholland Exp $ */
+/* $NetBSD: resize_lfs.c,v 1.11 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 2005 The NetBSD Foundation, Inc.
* All rights reserved.
@@ -127,7 +127,7 @@ main(int argc, char **argv)
pread(devfd, buf, sboff, LFS_SBPAD);
memcpy(&fs->lfs_dlfs, buf, sizeof(struct dlfs));
if (sboff == LFS_LABELPAD && lfs_fsbtob(fs, 1) > LFS_LABELPAD)
- sboff = lfs_fsbtob(fs, (off_t)fs->lfs_sboffs[0]);
+ sboff = lfs_fsbtob(fs, (off_t)lfs_sb_getsboff(fs, 0));
else
break;
}
@@ -135,7 +135,7 @@ main(int argc, char **argv)
/* Calculate new number of segments. */
newnsegs = (newsize * secsize) / lfs_sb_getssize(fs);
- if (newnsegs == fs->lfs_nseg) {
+ if (newnsegs == lfs_sb_getnseg(fs)) {
errx(0, "the filesystem is unchanged.");
}
@@ -145,7 +145,7 @@ main(int argc, char **argv)
* Make the cleaner do this for us.
* (XXX make the kernel able to do this instead?)
*/
- for (i = fs->lfs_nseg - 1; i >= newnsegs; --i) {
+ for (i = lfs_sb_getnseg(fs) - 1; i >= newnsegs; --i) {
char cmd[128];
/* If it's already empty, don't call the cleaner */
@@ -164,7 +164,7 @@ main(int argc, char **argv)
}
if (verbose)
- printf("Successfully resized %s from %d to %lld segments\n",
- fsname, fs->lfs_nseg, (long long)newnsegs);
+ printf("Successfully resized %s from %u to %lld segments\n",
+ fsname, lfs_sb_getnseg(fs), (long long)newnsegs);
return 0;
}
Index: src/sbin/scan_ffs/scan_ffs.c
diff -u src/sbin/scan_ffs/scan_ffs.c:1.26 src/sbin/scan_ffs/scan_ffs.c:1.27
--- src/sbin/scan_ffs/scan_ffs.c:1.26 Fri Jul 24 06:56:42 2015
+++ src/sbin/scan_ffs/scan_ffs.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: scan_ffs.c,v 1.26 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: scan_ffs.c,v 1.27 2015/07/24 06:59:32 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.26 2015/07/24 06:56:42 dholland Exp $");
+__RCSID("$NetBSD: scan_ffs.c,v 1.27 2015/07/24 06:59:32 dholland Exp $");
#endif /* not lint */
#include <sys/types.h>
@@ -251,7 +251,7 @@ lfs_printpart(struct sblockinfo *sbi, in
(void)printf("offset: %" PRIu64 " size %" PRIu32
" fsid %" PRIx32 "\n", sbi->lfs_off,
lfs_sb_getsize(sbi->lfs),
- sbi->lfs->lfs_ident);
+ lfs_sb_getident(sbi->lfs));
switch (flag) {
case LABELS:
(void)printf("X: %9" PRIu64,
@@ -266,7 +266,7 @@ lfs_printpart(struct sblockinfo *sbi, in
case BLOCKS:
(void)printf("LFSv%d", sbi->lfs->lfs_version);
(void)printf(" sb at %" PRIu64, sbi->lfs_off + btodb(LFS_LABELPAD));
- (void)printf(" fsid %" PRIx32, sbi->lfs->lfs_ident);
+ (void)printf(" fsid %" PRIx32, lfs_sb_getident(sbi->lfs));
(void)printf(" size %" PRIu64 ", last mounted on %s\n",
(uint64_t)(lfs_sb_getsize(sbi->lfs) *
lfs_sb_getfsize(sbi->lfs) / 512), sbi->lfs_path);
@@ -284,8 +284,10 @@ lfs_printpart(struct sblockinfo *sbi, in
static void
lfs_scan(struct sblockinfo *sbi, int n)
{
+ size_t namesize;
+
/* Check to see if the sb checksums correctly */
- if (lfs_sb_cksum(&(sbi->lfs->lfs_dlfs)) != sbi->lfs->lfs_cksum) {
+ if (lfs_sb_cksum(&(sbi->lfs->lfs_dlfs)) != lfs_sb_getcksum(sbi->lfs)) {
if (flags & VERBOSE)
printf("LFS bad superblock at %" PRIu64 "\n",
BLK_CNT);
@@ -315,7 +317,11 @@ lfs_scan(struct sblockinfo *sbi, int n)
break;
case SECOND_SBLOCK_ADDRESS:
/* copy the path of last mount */
- (void)memcpy(sbi->lfs_path, sbi->lfs->lfs_fsmnt, MAXMNTLEN);
+ namesize = MIN(sizeof(sbi->lfs_path),
+ sizeof(sbi->lfs->lfs_dlfs.dlfs_fsmnt));
+ (void)memcpy(sbi->lfs_path, sbi->lfs->lfs_dlfs.dlfs_fsmnt,
+ namesize);
+ sbi->lfs_path[namesize - 1] = '\0';
/* print now that we have the info */
if (flags & LABELS)
lfs_printpart(sbi, LABELS, n);
Index: src/sys/ufs/lfs/lfs.h
diff -u src/sys/ufs/lfs/lfs.h:1.164 src/sys/ufs/lfs/lfs.h:1.165
--- src/sys/ufs/lfs/lfs.h:1.164 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs.h Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs.h,v 1.164 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs.h,v 1.165 2015/07/24 06:59:32 dholland Exp $ */
/* from NetBSD: dinode.h,v 1.22 2013/01/22 09:39:18 dholland Exp */
/* from NetBSD: dir.h,v 1.21 2009/07/22 04:49:19 dholland Exp */
@@ -650,7 +650,7 @@ typedef struct _cleanerinfo {
} CLEANERINFO;
#define CLEANSIZE_SU(fs) \
- ((sizeof(CLEANERINFO) + lfs_sb_getbsize(fs) - 1) >> (fs)->lfs_bshift)
+ ((sizeof(CLEANERINFO) + lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs))
/* Read in the block with the cleaner info from the ifile. */
#define LFS_CLEANERINFO(CP, F, BP) do { \
@@ -842,7 +842,7 @@ struct dlfs {
u_int32_t dlfs_sumsize; /* 332: size of summary blocks */
u_int64_t dlfs_serial; /* 336: serial number */
u_int32_t dlfs_ibsize; /* 344: size of inode blocks */
- int32_t dlfs_start; /* 348: start of segment 0 */
+ int32_t dlfs_s0addr; /* 348: start of segment 0 */
u_int64_t dlfs_tstamp; /* 352: time stamp */
#define LFS_44INODEFMT 0
#define LFS_MAXINODEFMT 0
@@ -1026,73 +1026,41 @@ 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(int32_t, s0addr);
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 */
@@ -1103,53 +1071,81 @@ LFS_DEF_SB_ACCESSOR(u_int32_t, resvseg);
#define lfs_sb_getotstamp(fs) lfs_sb_getinopf(fs)
#define lfs_sb_setotstamp(fs, val) lfs_sb_setinopf(fs, val)
+/*
+ * lfs_sboffs is an array
+ */
+static __unused inline int32_t
+lfs_sb_getsboff(struct lfs *fs, unsigned n)
+{
+#ifdef KASSERT /* ugh */
+ KASSERT(n < LFS_MAXNUMSB);
+#endif
+ return fs->lfs_dlfs.dlfs_sboffs[n];
+}
+static __unused inline void
+lfs_sb_setsboff(struct lfs *fs, unsigned n, int32_t val)
+{
+#ifdef KASSERT /* ugh */
+ KASSERT(n < LFS_MAXNUMSB);
+#endif
+ fs->lfs_dlfs.dlfs_sboffs[n] = val;
+}
+
+/*
+ * lfs_fsmnt is a string
+ */
+static __unused inline const char *
+lfs_sb_getfsmnt(struct lfs *fs)
+{
+ return fs->lfs_dlfs.dlfs_fsmnt;
+}
/* LFS_NINDIR is the number of indirects in a file system block. */
-#define LFS_NINDIR(fs) ((fs)->lfs_nindir)
+#define LFS_NINDIR(fs) (lfs_sb_getnindir(fs))
/* LFS_INOPB is the number of inodes in a secondary storage block. */
-#define LFS_INOPB(fs) ((fs)->lfs_inopb)
+#define LFS_INOPB(fs) (lfs_sb_getinopb(fs))
/* LFS_INOPF is the number of inodes in a fragment. */
-#define LFS_INOPF(fs) ((fs)->lfs_inopf)
+#define LFS_INOPF(fs) (lfs_sb_getinopf(fs))
#define lfs_blksize(fs, ip, lbn) \
- (((lbn) >= ULFS_NDADDR || (ip)->i_ffs1_size >= ((lbn) + 1) << (fs)->lfs_bshift) \
+ (((lbn) >= ULFS_NDADDR || (ip)->i_ffs1_size >= ((lbn) + 1) << lfs_sb_getbshift(fs)) \
? lfs_sb_getbsize(fs) \
: (lfs_fragroundup(fs, lfs_blkoff(fs, (ip)->i_ffs1_size))))
-#define lfs_blkoff(fs, loc) ((int)((loc) & (fs)->lfs_bmask))
+#define lfs_blkoff(fs, loc) ((int)((loc) & lfs_sb_getbmask(fs)))
#define lfs_fragoff(fs, loc) /* calculates (loc % fs->lfs_fsize) */ \
- ((int)((loc) & (fs)->lfs_ffmask))
+ ((int)((loc) & lfs_sb_getffmask(fs)))
#if defined(_KERNEL)
-#define LFS_FSBTODB(fs, b) ((b) << ((fs)->lfs_ffshift - DEV_BSHIFT))
-#define LFS_DBTOFSB(fs, b) ((b) >> ((fs)->lfs_ffshift - DEV_BSHIFT))
+#define LFS_FSBTODB(fs, b) ((b) << (lfs_sb_getffshift(fs) - DEV_BSHIFT))
+#define LFS_DBTOFSB(fs, b) ((b) >> (lfs_sb_getffshift(fs) - DEV_BSHIFT))
#else
-#define LFS_FSBTODB(fs, b) ((b) << (fs)->lfs_fsbtodb)
-#define LFS_DBTOFSB(fs, b) ((b) >> (fs)->lfs_fsbtodb)
+#define LFS_FSBTODB(fs, b) ((b) << lfs_sb_getfsbtodb(fs))
+#define LFS_DBTOFSB(fs, b) ((b) >> lfs_sb_getfsbtodb(fs))
#endif
-#define lfs_lblkno(fs, loc) ((loc) >> (fs)->lfs_bshift)
-#define lfs_lblktosize(fs, blk) ((blk) << (fs)->lfs_bshift)
+#define lfs_lblkno(fs, loc) ((loc) >> lfs_sb_getbshift(fs))
+#define lfs_lblktosize(fs, blk) ((blk) << lfs_sb_getbshift(fs))
-#define lfs_fsbtob(fs, b) ((b) << (fs)->lfs_ffshift)
-#define lfs_btofsb(fs, b) ((b) >> (fs)->lfs_ffshift)
+#define lfs_fsbtob(fs, b) ((b) << lfs_sb_getffshift(fs))
+#define lfs_btofsb(fs, b) ((b) >> lfs_sb_getffshift(fs))
#define lfs_numfrags(fs, loc) /* calculates (loc / fs->lfs_fsize) */ \
- ((loc) >> (fs)->lfs_ffshift)
+ ((loc) >> lfs_sb_getffshift(fs))
#define lfs_blkroundup(fs, size)/* calculates roundup(size, lfs_sb_getbsize(fs)) */ \
- ((off_t)(((size) + (fs)->lfs_bmask) & (~(fs)->lfs_bmask)))
+ ((off_t)(((size) + lfs_sb_getbmask(fs)) & (~lfs_sb_getbmask(fs))))
#define lfs_fragroundup(fs, size)/* calculates roundup(size, fs->lfs_fsize) */ \
- ((off_t)(((size) + (fs)->lfs_ffmask) & (~(fs)->lfs_ffmask)))
+ ((off_t)(((size) + lfs_sb_getffmask(fs)) & (~lfs_sb_getffmask(fs))))
#define lfs_fragstoblks(fs, frags)/* calculates (frags / fs->fs_frag) */ \
- ((frags) >> (fs)->lfs_fbshift)
+ ((frags) >> lfs_sb_getfbshift(fs))
#define lfs_blkstofrags(fs, blks)/* calculates (blks * fs->fs_frag) */ \
- ((blks) << (fs)->lfs_fbshift)
+ ((blks) << lfs_sb_getfbshift(fs))
#define lfs_fragnum(fs, fsb) /* calculates (fsb % fs->lfs_frag) */ \
((fsb) & ((fs)->lfs_frag - 1))
#define lfs_blknum(fs, fsb) /* calculates rounddown(fsb, fs->lfs_frag) */ \
((fsb) &~ ((fs)->lfs_frag - 1))
#define lfs_dblksize(fs, dp, lbn) \
- (((lbn) >= ULFS_NDADDR || (dp)->di_size >= ((lbn) + 1) << (fs)->lfs_bshift)\
+ (((lbn) >= ULFS_NDADDR || (dp)->di_size >= ((lbn) + 1) << lfs_sb_getbshift(fs)) \
? lfs_sb_getbsize(fs) \
: (lfs_fragroundup(fs, lfs_blkoff(fs, (dp)->di_size))))
@@ -1157,12 +1153,12 @@ LFS_DEF_SB_ACCESSOR(u_int32_t, resvseg);
lfs_lblktosize((fs), lfs_sb_getssize(fs)) : \
lfs_sb_getssize(fs))
#define lfs_segtod(fs, seg) (((fs)->lfs_version == 1 ? \
- lfs_sb_getssize(fs) << (fs)->lfs_blktodb : \
+ lfs_sb_getssize(fs) << lfs_sb_getblktodb(fs) : \
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)))
+ ((uint32_t)(((daddr) - lfs_sb_gets0addr(fs)) / lfs_segtod((fs), 1)))
#define lfs_sntod(fs, sn) /* segment number to disk address */ \
- ((daddr_t)(lfs_segtod((fs), (sn)) + (fs)->lfs_s0addr))
+ ((daddr_t)(lfs_segtod((fs), (sn)) + lfs_sb_gets0addr(fs)))
/*
* Structures used by lfs_bmapv and lfs_markv to communicate information
Index: src/sys/ufs/lfs/lfs_alloc.c
diff -u src/sys/ufs/lfs/lfs_alloc.c:1.122 src/sys/ufs/lfs/lfs_alloc.c:1.123
--- src/sys/ufs/lfs/lfs_alloc.c:1.122 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_alloc.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_alloc.c,v 1.122 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_alloc.c,v 1.123 2015/07/24 06:59:32 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.122 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_alloc.c,v 1.123 2015/07/24 06:59:32 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_quota.h"
@@ -136,7 +136,7 @@ lfs_extend_ifile(struct lfs *fs, kauth_c
ip->i_ffs1_size = ip->i_size;
uvm_vnp_setsize(vp, ip->i_size);
- maxino = ((ip->i_size >> fs->lfs_bshift) - lfs_sb_getcleansz(fs) -
+ maxino = ((ip->i_size >> lfs_sb_getbshift(fs)) - 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) *
@@ -268,7 +268,7 @@ lfs_valloc_fixed(struct lfs *fs, ino_t i
/* If the Ifile is too short to contain this inum, extend it */
while (VTOI(fs->lfs_ivnode)->i_size <= (ino /
lfs_sb_getifpb(fs) + lfs_sb_getcleansz(fs) + lfs_sb_getsegtabsz(fs))
- << fs->lfs_bshift) {
+ << lfs_sb_getbshift(fs)) {
lfs_extend_ifile(fs, NOCRED);
}
@@ -311,7 +311,7 @@ lfs_last_alloc_ino(struct lfs *fs)
{
ino_t ino, maxino;
- maxino = ((fs->lfs_ivnode->v_size >> fs->lfs_bshift) -
+ maxino = ((fs->lfs_ivnode->v_size >> lfs_sb_getbshift(fs)) -
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)
@@ -553,7 +553,7 @@ lfs_order_freelist(struct lfs *fs)
ASSERT_NO_SEGLOCK(fs);
lfs_seglock(fs, SEGM_PROT);
- maxino = ((fs->lfs_ivnode->v_size >> fs->lfs_bshift) -
+ maxino = ((fs->lfs_ivnode->v_size >> lfs_sb_getbshift(fs)) -
lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs);
fs->lfs_ino_bitmap =
malloc(((maxino + BMMASK) >> BMSHIFT) * sizeof(lfs_bm_t),
Index: src/sys/ufs/lfs/lfs_balloc.c
diff -u src/sys/ufs/lfs/lfs_balloc.c:1.82 src/sys/ufs/lfs/lfs_balloc.c:1.83
--- src/sys/ufs/lfs/lfs_balloc.c:1.82 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_balloc.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_balloc.c,v 1.82 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_balloc.c,v 1.83 2015/07/24 06:59:32 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.82 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_balloc.c,v 1.83 2015/07/24 06:59:32 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_quota.h"
@@ -501,7 +501,7 @@ lfs_register_block(struct vnode *vp, dad
ASSERT_NO_SEGLOCK(fs);
/* If no space, wait for the cleaner */
- lfs_availwait(fs, lfs_btofsb(fs, 1 << fs->lfs_bshift));
+ lfs_availwait(fs, lfs_btofsb(fs, 1 << lfs_sb_getbshift(fs)));
lbp = (struct lbnentry *)pool_get(&lfs_lbnentry_pool, PR_WAITOK);
lbp->lbn = lbn;
@@ -514,7 +514,7 @@ lfs_register_block(struct vnode *vp, dad
}
++ip->i_lfs_nbtree;
- fs->lfs_favail += lfs_btofsb(fs, (1 << fs->lfs_bshift));
+ fs->lfs_favail += lfs_btofsb(fs, (1 << lfs_sb_getbshift(fs)));
fs->lfs_pages += lfs_sb_getbsize(fs) >> PAGE_SHIFT;
++locked_fakequeue_count;
lfs_subsys_pages += lfs_sb_getbsize(fs) >> PAGE_SHIFT;
@@ -529,8 +529,8 @@ lfs_do_deregister(struct lfs *fs, struct
mutex_enter(&lfs_lock);
--ip->i_lfs_nbtree;
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));
+ if (fs->lfs_favail > lfs_btofsb(fs, (1 << lfs_sb_getbshift(fs))))
+ fs->lfs_favail -= lfs_btofsb(fs, (1 << lfs_sb_getbshift(fs)));
fs->lfs_pages -= lfs_sb_getbsize(fs) >> PAGE_SHIFT;
if (locked_fakequeue_count > 0)
--locked_fakequeue_count;
Index: src/sys/ufs/lfs/lfs_subr.c
diff -u src/sys/ufs/lfs/lfs_subr.c:1.82 src/sys/ufs/lfs/lfs_subr.c:1.83
--- src/sys/ufs/lfs/lfs_subr.c:1.82 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_subr.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_subr.c,v 1.82 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_subr.c,v 1.83 2015/07/24 06:59:32 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.82 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_subr.c,v 1.83 2015/07/24 06:59:32 dholland Exp $");
#include <sys/param.h>
#include <sys/systm.h>
@@ -120,7 +120,7 @@ lfs_setup_resblks(struct lfs *fs)
* so we can't use the pool subsystem for them.
*/
for (i = 0, j = 0; j < LFS_N_SUMMARIES; j++, i++)
- fs->lfs_resblk[i].size = fs->lfs_sumsize;
+ fs->lfs_resblk[i].size = lfs_sb_getsumsize(fs);
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++)
@@ -144,7 +144,7 @@ lfs_setup_resblks(struct lfs *fs)
"lfsclpl", &pool_allocator_nointr, IPL_NONE);
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 = ((lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs)) / sizeof(int32_t) + 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);
@@ -396,7 +396,7 @@ lfs_auto_segclean(struct lfs *fs)
* XXX - do we really need to do them all at once?
*/
waited = 0;
- for (i = 0; i < fs->lfs_nseg; i++) {
+ for (i = 0; i < lfs_sb_getnseg(fs); i++) {
if ((fs->lfs_suflags[0][i] &
(SEGUSE_ACTIVE | SEGUSE_DIRTY | SEGUSE_EMPTY)) ==
(SEGUSE_DIRTY | SEGUSE_EMPTY) &&
@@ -522,8 +522,8 @@ lfs_segunlock(struct lfs *fs)
/* If we *know* everything's on disk, write both sbs */
/* XXX should wait for this one */
if (sync)
- lfs_writesuper(fs, fs->lfs_sboffs[fs->lfs_activesb]);
- lfs_writesuper(fs, fs->lfs_sboffs[1 - fs->lfs_activesb]);
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, fs->lfs_activesb));
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 1 - fs->lfs_activesb));
if (!(fs->lfs_ivnode->v_mount->mnt_iflag & IMNT_UNMOUNT)) {
lfs_auto_segclean(fs);
/* If sync, we can clean the remainder too */
Index: src/sys/ufs/lfs/lfs_bio.c
diff -u src/sys/ufs/lfs/lfs_bio.c:1.129 src/sys/ufs/lfs/lfs_bio.c:1.130
--- src/sys/ufs/lfs/lfs_bio.c:1.129 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_bio.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_bio.c,v 1.129 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_bio.c,v 1.130 2015/07/24 06:59:32 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.129 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.130 2015/07/24 06:59:32 dholland Exp $");
#include <sys/param.h>
#include <sys/systm.h>
@@ -361,7 +361,7 @@ lfs_fits(struct lfs *fs, int fsb)
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));
+ 1) << (lfs_sb_getbshift(fs) - lfs_sb_getffshift(fs)));
if (needed >= lfs_sb_getavail(fs)) {
#ifdef DEBUG
@@ -443,7 +443,7 @@ lfs_bwrite_ext(struct buf *bp, int flags
*
* In particular the cleaner can't write blocks either.
*/
- if (fs->lfs_ronly || (fs->lfs_pflags & LFS_PF_CLEAN)) {
+ if (fs->lfs_ronly || (lfs_sb_getpflags(fs) & LFS_PF_CLEAN)) {
bp->b_oflags &= ~BO_DELWRI;
bp->b_flags |= B_READ; /* XXX is this right? --ks */
bp->b_error = 0;
Index: src/sys/ufs/lfs/lfs_inode.c
diff -u src/sys/ufs/lfs/lfs_inode.c:1.138 src/sys/ufs/lfs/lfs_inode.c:1.139
--- src/sys/ufs/lfs/lfs_inode.c:1.138 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_inode.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_inode.c,v 1.138 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_inode.c,v 1.139 2015/07/24 06:59:32 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.138 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_inode.c,v 1.139 2015/07/24 06:59:32 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_quota.h"
@@ -285,7 +285,7 @@ lfs_truncate(struct vnode *ovp, off_t le
if (ioflag & IO_SYNC) {
mutex_enter(ovp->v_interlock);
VOP_PUTPAGES(ovp,
- trunc_page(osize & fs->lfs_bmask),
+ trunc_page(osize & lfs_sb_getbmask(fs)),
round_page(eob),
PGO_CLEANIT | PGO_SYNCIO);
}
@@ -305,13 +305,13 @@ lfs_truncate(struct vnode *ovp, off_t le
return (lfs_update(ovp, NULL, NULL, 0));
} else {
error = lfs_reserve(fs, ovp, NULL,
- lfs_btofsb(fs, (ULFS_NIADDR + 2) << fs->lfs_bshift));
+ lfs_btofsb(fs, (ULFS_NIADDR + 2) << lfs_sb_getbshift(fs)));
if (error)
return (error);
error = lfs_balloc(ovp, length - 1, 1, cred,
aflags, &bp);
lfs_reserve(fs, ovp, NULL,
- -lfs_btofsb(fs, (ULFS_NIADDR + 2) << fs->lfs_bshift));
+ -lfs_btofsb(fs, (ULFS_NIADDR + 2) << lfs_sb_getbshift(fs)));
if (error)
return (error);
oip->i_ffs1_size = oip->i_size = length;
@@ -324,7 +324,7 @@ lfs_truncate(struct vnode *ovp, off_t le
}
if ((error = lfs_reserve(fs, ovp, NULL,
- lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << fs->lfs_bshift))) != 0)
+ lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)))) != 0)
return (error);
/*
@@ -351,7 +351,7 @@ lfs_truncate(struct vnode *ovp, off_t le
error = lfs_balloc(ovp, length - 1, 1, cred, aflags, &bp);
if (error) {
lfs_reserve(fs, ovp, NULL,
- -lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << fs->lfs_bshift));
+ -lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));
goto errout;
}
obufsize = bp->b_bufsize;
@@ -391,7 +391,7 @@ lfs_truncate(struct vnode *ovp, off_t le
error = ulfs_balloc_range(ovp, length - 1, 1, cred, aflags);
if (error) {
lfs_reserve(fs, ovp, NULL,
- -lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << fs->lfs_bshift));
+ -lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));
goto errout;
}
xlbn = lfs_lblkno(fs, length);
@@ -407,7 +407,7 @@ lfs_truncate(struct vnode *ovp, off_t le
((ioflag & IO_SYNC) ? PGO_SYNCIO : 0));
if (error) {
lfs_reserve(fs, ovp, NULL,
- -lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << fs->lfs_bshift));
+ -lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));
goto errout;
}
}
@@ -593,7 +593,7 @@ done:
(void) lfs_chkdq(oip, -blocksreleased, NOCRED, 0);
#endif
lfs_reserve(fs, ovp, NULL,
- -lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << fs->lfs_bshift));
+ -lfs_btofsb(fs, (2 * ULFS_NIADDR + 3) << lfs_sb_getbshift(fs)));
genfs_node_unlock(ovp);
errout:
oip->i_lfs_hiblk = lfs_lblkno(fs, oip->i_size + lfs_sb_getbsize(fs) - 1) - 1;
Index: src/sys/ufs/lfs/lfs_pages.c
diff -u src/sys/ufs/lfs/lfs_pages.c:1.2 src/sys/ufs/lfs/lfs_pages.c:1.3
--- src/sys/ufs/lfs/lfs_pages.c:1.2 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_pages.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_pages.c,v 1.2 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_pages.c,v 1.3 2015/07/24 06:59:32 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.2 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_pages.c,v 1.3 2015/07/24 06:59:32 dholland Exp $");
#ifdef _KERNEL_OPT
#include "opt_compat_netbsd.h"
@@ -278,7 +278,7 @@ check_dirty(struct lfs *fs, struct vnode
|| (curpg->flags & PG_MARKER) == 0);
if (pages_per_block > 1) {
while (curpg &&
- ((curpg->offset & fs->lfs_bmask) ||
+ ((curpg->offset & lfs_sb_getbmask(fs)) ||
curpg->offset >= vp->v_size ||
curpg->offset >= endoffset)) {
curpg = TAILQ_NEXT(curpg, listq.queue);
@@ -550,9 +550,9 @@ lfs_putpages(void *v)
*/
origoffset = ap->a_offlo;
origendoffset = ap->a_offhi;
- startoffset = origoffset & ~(fs->lfs_bmask);
- max_endoffset = (trunc_page(LLONG_MAX) >> fs->lfs_bshift)
- << fs->lfs_bshift;
+ startoffset = origoffset & ~(lfs_sb_getbmask(fs));
+ max_endoffset = (trunc_page(LLONG_MAX) >> lfs_sb_getbshift(fs))
+ << lfs_sb_getbshift(fs);
if (origendoffset == 0 || ap->a_flags & PGO_ALLPAGES) {
endoffset = max_endoffset;
Index: src/sys/ufs/lfs/lfs_rfw.c
diff -u src/sys/ufs/lfs/lfs_rfw.c:1.22 src/sys/ufs/lfs/lfs_rfw.c:1.23
--- src/sys/ufs/lfs/lfs_rfw.c:1.22 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_rfw.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_rfw.c,v 1.22 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_rfw.c,v 1.23 2015/07/24 06:59:32 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.22 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_rfw.c,v 1.23 2015/07/24 06:59:32 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_quota.h"
@@ -184,7 +184,7 @@ update_meta(struct lfs *fs, ino_t ino, i
return error;
}
- if ((error = lfs_balloc(vp, (lbn << fs->lfs_bshift), size,
+ if ((error = lfs_balloc(vp, (lbn << lfs_sb_getbshift(fs)), size,
NOCRED, 0, &bp)) != 0) {
vput(vp);
return (error);
@@ -204,14 +204,14 @@ update_meta(struct lfs *fs, ino_t ino, i
* XXX appear later to give the correct size.
*/
ip = VTOI(vp);
- if (ip->i_size <= (lbn << fs->lfs_bshift)) {
+ if (ip->i_size <= (lbn << lfs_sb_getbshift(fs))) {
u_int64_t newsize;
if (lbn < ULFS_NDADDR)
- newsize = ip->i_ffs1_size = (lbn << fs->lfs_bshift) +
+ newsize = ip->i_ffs1_size = (lbn << lfs_sb_getbshift(fs)) +
(size - lfs_sb_getfsize(fs)) + 1;
else
- newsize = ip->i_ffs1_size = (lbn << fs->lfs_bshift) + 1;
+ newsize = ip->i_ffs1_size = (lbn << lfs_sb_getbshift(fs)) + 1;
if (ip->i_size < newsize) {
ip->i_size = newsize;
@@ -268,7 +268,7 @@ update_inoblk(struct lfs *fs, daddr_t of
* Get the inode, update times and perms.
* DO NOT update disk blocks, we do that separately.
*/
- error = bread(devvp, LFS_FSBTODB(fs, offset), fs->lfs_ibsize,
+ error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getibsize(fs),
0, &dbp);
if (error) {
DLOG((DLOG_RF, "update_inoblk: bread returned %d\n", error));
@@ -368,7 +368,7 @@ check_segsum(struct lfs *fs, daddr_t off
}
/* Read in the segment summary */
- error = bread(devvp, LFS_FSBTODB(fs, offset), fs->lfs_sumsize,
+ error = bread(devvp, LFS_FSBTODB(fs, offset), lfs_sb_getsumsize(fs),
0, &bp);
if (error)
return -1;
@@ -377,7 +377,7 @@ check_segsum(struct lfs *fs, daddr_t off
ssp = (SEGSUM *)bp->b_data;
if (flags & CHECK_CKSUM) {
if (ssp->ss_sumsum != cksum(&ssp->ss_datasum,
- fs->lfs_sumsize -
+ lfs_sb_getsumsize(fs) -
sizeof(ssp->ss_sumsum))) {
DLOG((DLOG_RF, "Sumsum error at 0x%" PRIx64 "\n", offset));
offset = -1;
@@ -401,9 +401,9 @@ check_segsum(struct lfs *fs, daddr_t off
offset = -1;
goto err1;
}
- if (ssp->ss_ident != fs->lfs_ident) {
+ if (ssp->ss_ident != lfs_sb_getident(fs)) {
DLOG((DLOG_RF, "Incorrect fsid (0x%x vs 0x%x) at 0x%"
- PRIx64 "\n", ssp->ss_ident, fs->lfs_ident, offset));
+ PRIx64 "\n", ssp->ss_ident, lfs_sb_getident(fs), offset));
offset = -1;
goto err1;
}
@@ -411,11 +411,11 @@ check_segsum(struct lfs *fs, daddr_t off
if (pseg_flags)
*pseg_flags = ssp->ss_flags;
oldoffset = offset;
- offset += lfs_btofsb(fs, fs->lfs_sumsize);
+ offset += lfs_btofsb(fs, lfs_sb_getsumsize(fs));
ninos = howmany(ssp->ss_ninos, LFS_INOPB(fs));
/* XXX ondisk32 */
- iaddr = (int32_t *)((char*)bp->b_data + fs->lfs_sumsize - sizeof(int32_t));
+ iaddr = (int32_t *)((char*)bp->b_data + lfs_sb_getsumsize(fs) - sizeof(int32_t));
if (flags & CHECK_CKSUM) {
/* Count blocks */
nblocks = 0;
@@ -457,7 +457,7 @@ check_segsum(struct lfs *fs, daddr_t off
goto err2;
}
}
- offset += lfs_btofsb(fs, fs->lfs_ibsize);
+ offset += lfs_btofsb(fs, lfs_sb_getibsize(fs));
--iaddr;
--ninos;
--i; /* compensate */
@@ -503,7 +503,7 @@ check_segsum(struct lfs *fs, daddr_t off
}
/* If we're at the end of the segment, move to the next */
- if (lfs_dtosn(fs, offset + lfs_btofsb(fs, fs->lfs_sumsize + lfs_sb_getbsize(fs))) !=
+ if (lfs_dtosn(fs, offset + lfs_btofsb(fs, lfs_sb_getsumsize(fs) + lfs_sb_getbsize(fs))) !=
lfs_dtosn(fs, offset)) {
if (lfs_dtosn(fs, offset) == lfs_dtosn(fs, ssp->ss_next)) {
offset = -1;
@@ -561,7 +561,7 @@ lfs_roll_forward(struct lfs *fs, struct
* v2 filesystems don't have this problem because they use a
* monotonically increasing serial number instead of a timestamp.
*/
- do_rollforward = (!(fs->lfs_pflags & LFS_PF_CLEAN) &&
+ do_rollforward = (!(lfs_sb_getpflags(fs) & LFS_PF_CLEAN) &&
lfs_do_rfw && fs->lfs_version > 1 && p != NULL);
if (do_rollforward) {
u_int64_t nextserial;
@@ -577,7 +577,7 @@ lfs_roll_forward(struct lfs *fs, struct
PRIx64 "\n", offset));
LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, offset), bp);
if (!(sup->su_flags & SEGUSE_DIRTY))
- --fs->lfs_nclean;
+ lfs_sb_subnclean(fs, 1);
sup->su_flags |= SEGUSE_DIRTY;
LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, offset), bp);
nextserial = lfs_sb_getserial(fs) + 1;
@@ -588,7 +588,7 @@ lfs_roll_forward(struct lfs *fs, struct
LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, oldoffset),
bp);
if (!(sup->su_flags & SEGUSE_DIRTY))
- --fs->lfs_nclean;
+ lfs_sb_subnclean(fs, 1);
sup->su_flags |= SEGUSE_DIRTY;
LFS_WRITESEGENTRY(sup, fs, lfs_dtosn(fs, oldoffset),
bp);
@@ -621,7 +621,7 @@ lfs_roll_forward(struct lfs *fs, struct
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;
+ sn = (sn + 1) % lfs_sb_getnseg(fs);
if (sn == curseg)
panic("lfs_mountfs: no clean segments");
LFS_SEGENTRY(sup, fs, sn, bp);
Index: src/sys/ufs/lfs/lfs_segment.c
diff -u src/sys/ufs/lfs/lfs_segment.c:1.242 src/sys/ufs/lfs/lfs_segment.c:1.243
--- src/sys/ufs/lfs/lfs_segment.c:1.242 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_segment.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_segment.c,v 1.242 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_segment.c,v 1.243 2015/07/24 06:59:32 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.242 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_segment.c,v 1.243 2015/07/24 06:59:32 dholland Exp $");
#define _VFS_VNODE_PRIVATE /* XXX: check for VI_MARKER, this has to go */
@@ -133,7 +133,7 @@ static void lfs_cluster_callback(struct
((flags & SEGM_CLEAN) == 0 && \
((fs->lfs_nactive > LFS_MAX_ACTIVE || \
(flags & SEGM_CKP) || \
- fs->lfs_nclean < LFS_MAX_ACTIVE)))
+ lfs_sb_getnclean(fs) < LFS_MAX_ACTIVE)))
int lfs_match_fake(struct lfs *, struct buf *);
void lfs_newseg(struct lfs *);
@@ -692,7 +692,7 @@ lfs_segwrite(struct mount *mp, int flags
* last checkpoint as no longer ACTIVE.
*/
if (do_ckp || fs->lfs_doifile) {
- segleft = fs->lfs_nseg;
+ segleft = lfs_sb_getnseg(fs);
curseg = 0;
for (n = 0; n < lfs_sb_getsegtabsz(fs); n++) {
dirty = 0;
@@ -964,7 +964,7 @@ lfs_update_iaddr(struct lfs *fs, struct
*/
if (ip->i_number == LFS_IFILE_INUM) {
sn = lfs_dtosn(fs, lfs_sb_getoffset(fs));
- if (lfs_sntod(fs, sn) + lfs_btofsb(fs, fs->lfs_sumsize) ==
+ if (lfs_sntod(fs, sn) + lfs_btofsb(fs, lfs_sb_getsumsize(fs)) ==
lfs_sb_getoffset(fs)) {
LFS_SEGENTRY(sup, fs, sn, bp);
KASSERT(bp->b_oflags & BO_DELWRI);
@@ -1070,7 +1070,7 @@ lfs_writeinode(struct lfs *fs, struct se
int redo = 0;
if (sp->idp == NULL && sp->ibp == NULL &&
- (sp->seg_bytes_left < fs->lfs_ibsize ||
+ (sp->seg_bytes_left < lfs_sb_getibsize(fs) ||
sp->sum_bytes_left < sizeof(int32_t))) {
(void) lfs_writeseg(fs, sp);
continue;
@@ -1103,7 +1103,7 @@ lfs_writeinode(struct lfs *fs, struct se
if ((ip->i_number != LFS_IFILE_INUM || sp->idp == NULL) &&
sp->ibp == NULL) {
/* Allocate a new segment if necessary. */
- if (sp->seg_bytes_left < fs->lfs_ibsize ||
+ if (sp->seg_bytes_left < lfs_sb_getibsize(fs) ||
sp->sum_bytes_left < sizeof(int32_t))
(void) lfs_writeseg(fs, sp);
@@ -1112,7 +1112,7 @@ lfs_writeinode(struct lfs *fs, struct se
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);
+ LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs), 0, 0);
gotblk++;
/* Zero out inode numbers */
@@ -1123,9 +1123,9 @@ lfs_writeinode(struct lfs *fs, struct se
++sp->start_bpp;
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(int32_t);
- ndx = fs->lfs_sumsize / sizeof(int32_t) -
+ ndx = lfs_sb_getsumsize(fs) / sizeof(int32_t) -
sp->ninodes / LFS_INOPB(fs) - 1;
((int32_t *)(sp->segsum))[ndx] = daddr;
}
@@ -1207,8 +1207,8 @@ lfs_writeinode(struct lfs *fs, struct se
/* Check file size based on highest allocated block */
if (((ip->i_ffs1_mode & LFS_IFMT) == LFS_IFREG ||
(ip->i_ffs1_mode & LFS_IFMT) == LFS_IFDIR) &&
- ip->i_size > ((ip->i_lfs_hiblk + 1) << fs->lfs_bshift)) {
- cdp->di_size = (ip->i_lfs_hiblk + 1) << fs->lfs_bshift;
+ ip->i_size > ((ip->i_lfs_hiblk + 1) << lfs_sb_getbshift(fs))) {
+ cdp->di_size = (ip->i_lfs_hiblk + 1) << lfs_sb_getbshift(fs);
DLOG((DLOG_SEG, "lfs_writeinode: ino %d size %" PRId64 " -> %"
PRId64 "\n", (int)ip->i_number, ip->i_size, cdp->di_size));
}
@@ -1230,7 +1230,7 @@ lfs_writeinode(struct lfs *fs, struct se
* Check dinode held blocks against dinode size.
* This should be identical to the check in lfs_vget().
*/
- for (i = (cdp->di_size + lfs_sb_getbsize(fs) - 1) >> fs->lfs_bshift;
+ for (i = (cdp->di_size + lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs);
i < ULFS_NDADDR; i++) {
KASSERT(i >= 0);
if ((cdp->di_mode & LFS_IFMT) == LFS_IFLNK)
@@ -1541,7 +1541,7 @@ lfs_update_single(struct lfs *fs, struct
ndupino = 0;
}
#endif
- KASSERT(oldsn < fs->lfs_nseg);
+ KASSERT(oldsn < lfs_sb_getnseg(fs));
if (lbn >= 0 && lbn < ULFS_NDADDR)
osize = ip->i_lfs_fragsize[lbn];
else
@@ -1651,7 +1651,7 @@ lfs_updatemeta(struct segment *sp)
* XXX fake blocks (including fake inodes and fake indirect blocks).
*/
sp->fip->fi_lastlength = ((sp->start_bpp[nblocks - 1]->b_bcount - 1) &
- fs->lfs_bmask) + 1;
+ lfs_sb_getbmask(fs)) + 1;
/*
* Assign disk addresses, and update references to the logical
@@ -1671,7 +1671,7 @@ lfs_updatemeta(struct segment *sp)
* that the indirect block that actually ends the list
* is of a smaller size!)
*/
- if ((sbp->b_bcount & fs->lfs_bmask) && i != 0)
+ if ((sbp->b_bcount & lfs_sb_getbmask(fs)) && i != 0)
panic("lfs_updatemeta: fragment is not last block");
/*
@@ -1713,10 +1713,10 @@ lfs_rewind(struct lfs *fs, int newsn)
return 0;
/* lfs_avail eats the remaining space in this segment */
- lfs_sb_subavail(fs, fs->lfs_fsbpseg - (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
+ lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
/* Find a low-numbered segment */
- for (sn = 0; sn < fs->lfs_nseg; ++sn) {
+ for (sn = 0; sn < lfs_sb_getnseg(fs); ++sn) {
LFS_SEGENTRY(sup, fs, sn, bp);
isdirty = sup->su_flags & SEGUSE_DIRTY;
brelse(bp, 0);
@@ -1724,7 +1724,7 @@ lfs_rewind(struct lfs *fs, int newsn)
if (!isdirty)
break;
}
- if (sn == fs->lfs_nseg)
+ if (sn == lfs_sb_getnseg(fs))
panic("lfs_rewind: no clean segments");
if (newsn >= 0 && sn >= newsn)
return ENOENT;
@@ -1756,7 +1756,7 @@ lfs_initseg(struct lfs *fs)
struct buf *bp;
/* lfs_avail eats the remaining space */
- lfs_sb_subavail(fs, fs->lfs_fsbpseg - (lfs_sb_getoffset(fs) -
+ lfs_sb_subavail(fs, lfs_sb_getfsbpseg(fs) - (lfs_sb_getoffset(fs) -
lfs_sb_getcurseg(fs)));
/* Wake up any cleaning procs waiting on this file system. */
lfs_wakeup_cleaner(fs);
@@ -1765,7 +1765,7 @@ lfs_initseg(struct lfs *fs)
lfs_sb_setoffset(fs, lfs_sb_getcurseg(fs));
sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
- sp->seg_bytes_left = lfs_fsbtob(fs, fs->lfs_fsbpseg);
+ sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs));
/*
* If the segment contains a superblock, update the offset
@@ -1779,15 +1779,15 @@ lfs_initseg(struct lfs *fs)
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)) {
+ lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD)) {
lfs_sb_addoffset(fs,
- lfs_btofsb(fs, LFS_LABELPAD) - fs->lfs_s0addr);
+ lfs_btofsb(fs, LFS_LABELPAD) - lfs_sb_gets0addr(fs));
sp->seg_bytes_left -=
- LFS_LABELPAD - lfs_fsbtob(fs, fs->lfs_s0addr);
+ LFS_LABELPAD - lfs_fsbtob(fs, lfs_sb_gets0addr(fs));
}
} else {
sp->seg_number = lfs_dtosn(fs, lfs_sb_getcurseg(fs));
- sp->seg_bytes_left = lfs_fsbtob(fs, fs->lfs_fsbpseg -
+ sp->seg_bytes_left = lfs_fsbtob(fs, lfs_sb_getfsbpseg(fs) -
(lfs_sb_getoffset(fs) - lfs_sb_getcurseg(fs)));
}
lfs_sb_setlastpseg(fs, lfs_sb_getoffset(fs));
@@ -1817,7 +1817,7 @@ lfs_initseg(struct lfs *fs)
/* Get a new buffer for SEGSUM */
sbp = lfs_newbuf(fs, VTOI(fs->lfs_ivnode)->i_devvp,
- LFS_FSBTODB(fs, lfs_sb_getoffset(fs)), fs->lfs_sumsize, LFS_NB_SUMMARY);
+ LFS_FSBTODB(fs, lfs_sb_getoffset(fs)), lfs_sb_getsumsize(fs), LFS_NB_SUMMARY);
/* ... and enter it into the buffer list. */
*sp->cbpp = sbp;
@@ -1828,7 +1828,7 @@ lfs_initseg(struct lfs *fs)
/* Set point to SEGSUM, initialize it. */
ssp = sp->segsum = sbp->b_data;
- memset(ssp, 0, fs->lfs_sumsize);
+ memset(ssp, 0, lfs_sb_getsumsize(fs));
ssp->ss_next = lfs_sb_getnextseg(fs);
ssp->ss_nfinfo = ssp->ss_ninos = 0;
ssp->ss_magic = SS_MAGIC;
@@ -1839,8 +1839,8 @@ lfs_initseg(struct lfs *fs)
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);
return (repeat);
}
@@ -1855,7 +1855,7 @@ lfs_unset_inval_all(struct lfs *fs)
struct buf *bp;
int i;
- for (i = 0; i < fs->lfs_nseg; i++) {
+ for (i = 0; i < lfs_sb_getnseg(fs); i++) {
LFS_SEGENTRY(sup, fs, i, bp);
if (sup->su_flags & SEGUSE_INVAL) {
sup->su_flags &= ~SEGUSE_INVAL;
@@ -1883,13 +1883,13 @@ lfs_newseg(struct lfs *fs)
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);
+ lfs_sb_getfsmnt(fs), fs->lfs_wrappass);
fs->lfs_wrappass = 0;
break;
}
fs->lfs_wrapstatus = LFS_WRAP_WAITING;
wakeup(&fs->lfs_nowrap);
- log(LOG_NOTICE, "%s: waiting at log wrap\n", fs->lfs_fsmnt);
+ log(LOG_NOTICE, "%s: waiting at log wrap\n", lfs_sb_getfsmnt(fs));
mtsleep(&fs->lfs_wrappass, PVFS, "newseg", 10 * hz,
&lfs_lock);
}
@@ -1908,14 +1908,14 @@ lfs_newseg(struct lfs *fs)
LFS_CLEANERINFO(cip, fs, bp);
--cip->clean;
++cip->dirty;
- fs->lfs_nclean = cip->clean;
+ lfs_sb_setnclean(fs, cip->clean);
LFS_SYNC_CLEANERINFO(cip, fs, bp, 1);
lfs_sb_setlastseg(fs, lfs_sb_getcurseg(fs));
lfs_sb_setcurseg(fs, lfs_sb_getnextseg(fs));
skip_inval = 1;
- for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + fs->lfs_interleave;;) {
- sn = (sn + 1) % fs->lfs_nseg;
+ for (sn = curseg = lfs_dtosn(fs, lfs_sb_getcurseg(fs)) + lfs_sb_getinterleave(fs);;) {
+ sn = (sn + 1) % lfs_sb_getnseg(fs);
if (sn == curseg) {
if (skip_inval)
@@ -2058,7 +2058,7 @@ lfs_writeseg(struct lfs *fs, struct segm
sp->seg_number, ssp->ss_ninos * sizeof (struct ulfs1_dinode),
ssp->ss_ninos));
sup->su_nbytes += ssp->ss_ninos * sizeof (struct ulfs1_dinode);
- /* sup->su_nbytes += fs->lfs_sumsize; */
+ /* sup->su_nbytes += lfs_sb_getsumsize(fs); */
if (fs->lfs_version == 1)
sup->su_olastmod = time_second;
else
@@ -2207,17 +2207,17 @@ lfs_writeseg(struct lfs *fs, struct segm
ssp->ss_create = time_second;
lfs_sb_addserial(fs, 1);
ssp->ss_serial = lfs_sb_getserial(fs);
- ssp->ss_ident = fs->lfs_ident;
+ ssp->ss_ident = lfs_sb_getident(fs);
}
ssp->ss_datasum = lfs_cksum_fold(sum);
ssp->ss_sumsum = cksum(&ssp->ss_datasum,
- fs->lfs_sumsize - sizeof(ssp->ss_sumsum));
+ lfs_sb_getsumsize(fs) - sizeof(ssp->ss_sumsum));
mutex_enter(&lfs_lock);
- 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)));
+ lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
+ lfs_btofsb(fs, lfs_sb_getsumsize(fs))));
+ lfs_sb_adddmeta(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
+ lfs_btofsb(fs, lfs_sb_getsumsize(fs))));
mutex_exit(&lfs_lock);
/*
@@ -2243,7 +2243,7 @@ lfs_writeseg(struct lfs *fs, struct segm
cbp->b_bcount = 0;
#if defined(DEBUG) && defined(DIAGNOSTIC)
- if (bpp - sp->bpp > (fs->lfs_sumsize - SEGSUM_SIZE(fs))
+ if (bpp - sp->bpp > (lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs))
/ sizeof(int32_t)) {
panic("lfs_writeseg: real bpp overwrite");
}
@@ -2387,7 +2387,7 @@ lfs_writesuper(struct lfs *fs, daddr_t d
lfs_sb_settstamp(fs, time_second);
/* Checksum the superblock and copy it into a buffer. */
- fs->lfs_cksum = lfs_sb_cksum(&(fs->lfs_dlfs));
+ lfs_sb_setcksum(fs, lfs_sb_cksum(&(fs->lfs_dlfs)));
bp = lfs_newbuf(fs, devvp,
LFS_FSBTODB(fs, daddr), LFS_SBPAD, LFS_NB_SBLOCK);
memset((char *)bp->b_data + sizeof(struct dlfs), 0,
Index: src/sys/ufs/lfs/lfs_syscalls.c
diff -u src/sys/ufs/lfs/lfs_syscalls.c:1.161 src/sys/ufs/lfs/lfs_syscalls.c:1.162
--- src/sys/ufs/lfs/lfs_syscalls.c:1.161 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_syscalls.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_syscalls.c,v 1.161 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_syscalls.c,v 1.162 2015/07/24 06:59:32 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.161 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_syscalls.c,v 1.162 2015/07/24 06:59:32 dholland Exp $");
#ifndef LFS
# define LFS /* for prototypes in syscallargs.h */
@@ -872,12 +872,12 @@ lfs_do_segclean(struct lfs *fs, unsigned
if (sup->su_flags & SEGUSE_SUPERBLOCK)
lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_SBPAD));
if (fs->lfs_version > 1 && segnum == 0 &&
- fs->lfs_s0addr < lfs_btofsb(fs, LFS_LABELPAD))
- lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_LABELPAD) - fs->lfs_s0addr);
+ lfs_sb_gets0addr(fs) < lfs_btofsb(fs, LFS_LABELPAD))
+ lfs_sb_subavail(fs, lfs_btofsb(fs, LFS_LABELPAD) - lfs_sb_gets0addr(fs));
mutex_enter(&lfs_lock);
- lfs_sb_addbfree(fs, sup->su_nsums * lfs_btofsb(fs, fs->lfs_sumsize) +
+ lfs_sb_addbfree(fs, sup->su_nsums * lfs_btofsb(fs, lfs_sb_getsumsize(fs)) +
lfs_btofsb(fs, sup->su_ninos * lfs_sb_getibsize(fs)));
- lfs_sb_subdmeta(fs, sup->su_nsums * lfs_btofsb(fs, fs->lfs_sumsize) +
+ lfs_sb_subdmeta(fs, sup->su_nsums * lfs_btofsb(fs, lfs_sb_getsumsize(fs)) +
lfs_btofsb(fs, sup->su_ninos * lfs_sb_getibsize(fs)));
if (lfs_sb_getdmeta(fs) < 0)
lfs_sb_setdmeta(fs, 0);
@@ -888,7 +888,7 @@ lfs_do_segclean(struct lfs *fs, unsigned
LFS_CLEANERINFO(cip, fs, bp);
++cip->clean;
--cip->dirty;
- fs->lfs_nclean = cip->clean;
+ lfs_sb_setnclean(fs, cip->clean);
mutex_enter(&lfs_lock);
cip->bfree = lfs_sb_getbfree(fs);
cip->avail = lfs_sb_getavail(fs) - fs->lfs_ravail - fs->lfs_favail;
Index: src/sys/ufs/lfs/lfs_vfsops.c
diff -u src/sys/ufs/lfs/lfs_vfsops.c:1.327 src/sys/ufs/lfs/lfs_vfsops.c:1.328
--- src/sys/ufs/lfs/lfs_vfsops.c:1.327 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_vfsops.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_vfsops.c,v 1.327 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_vfsops.c,v 1.328 2015/07/24 06:59:32 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.327 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_vfsops.c,v 1.328 2015/07/24 06:59:32 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_lfs.h"
@@ -605,8 +605,8 @@ lfs_mountroot(void)
mountlist_append(mp);
ump = VFSTOULFS(mp);
fs = ump->um_lfs;
- memset(fs->lfs_fsmnt, 0, sizeof(fs->lfs_fsmnt));
- (void)copystr(mp->mnt_stat.f_mntonname, fs->lfs_fsmnt, MNAMELEN - 1, 0);
+ memset(fs->lfs_dlfs.dlfs_fsmnt, 0, sizeof(fs->lfs_dlfs.dlfs_fsmnt));
+ (void)copystr(mp->mnt_stat.f_mntonname, fs->lfs_dlfs.dlfs_fsmnt, sizeof(fs->lfs_dlfs.dlfs_fsmnt), 0);
(void)lfs_statvfs(mp, &mp->mnt_stat);
vfs_unbusy(mp, false, NULL);
setrootfstime((time_t)lfs_sb_gettstamp(VFSTOULFS(mp)->um_lfs));
@@ -795,10 +795,10 @@ lfs_mount(struct mount *mp, const char *
}
fs->lfs_ronly = 0;
- if (fs->lfs_pflags & LFS_PF_CLEAN) {
- fs->lfs_pflags &= ~LFS_PF_CLEAN;
- lfs_writesuper(fs, fs->lfs_sboffs[0]);
- lfs_writesuper(fs, fs->lfs_sboffs[1]);
+ if (lfs_sb_getpflags(fs) & LFS_PF_CLEAN) {
+ lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) & ~LFS_PF_CLEAN);
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));
}
}
if (args->fspec == NULL)
@@ -808,8 +808,9 @@ lfs_mount(struct mount *mp, const char *
error = set_statvfs_info(path, UIO_USERSPACE, args->fspec,
UIO_USERSPACE, mp->mnt_op->vfs_name, mp, l);
if (error == 0)
- (void)strncpy(fs->lfs_fsmnt, mp->mnt_stat.f_mntonname,
- sizeof(fs->lfs_fsmnt));
+ (void)strncpy(fs->lfs_dlfs.dlfs_fsmnt,
+ mp->mnt_stat.f_mntonname,
+ sizeof(fs->lfs_dlfs.dlfs_fsmnt));
return error;
fail:
@@ -952,15 +953,15 @@ lfs_mountfs(struct vnode *devvp, struct
/* Compatibility */
if (fs->lfs_version < 2) {
- fs->lfs_sumsize = LFS_V1_SUMMARY_SIZE;
+ lfs_sb_setsumsize(fs, LFS_V1_SUMMARY_SIZE);
lfs_sb_setibsize(fs, lfs_sb_getbsize(fs));
- fs->lfs_s0addr = fs->lfs_sboffs[0];
+ lfs_sb_sets0addr(fs, lfs_sb_getsboff(fs, 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, \
- MAX(MIN_RESV_SEGS, fs->lfs_minfreeseg / 2 + 1));
+ if (lfs_sb_getresvseg(fs) == 0)
+ lfs_sb_setresvseg(fs, MIN(lfs_sb_getminfreeseg(fs) - 1, \
+ MAX(MIN_RESV_SEGS, lfs_sb_getminfreeseg(fs) / 2 + 1)));
/*
* If we aren't going to be able to write meaningfully to this
@@ -1028,13 +1029,13 @@ lfs_mountfs(struct vnode *devvp, struct
/* ulfs-level information */
fs->um_flags = 0;
- fs->um_bptrtodb = fs->lfs_ffshift - DEV_BSHIFT;
+ fs->um_bptrtodb = lfs_sb_getffshift(fs) - DEV_BSHIFT;
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;
+ fs->um_nindir = lfs_sb_getnindir(fs);
+ fs->um_lognindir = ffs(lfs_sb_getnindir(fs)) - 1;
+ fs->um_maxsymlinklen = lfs_sb_getmaxsymlinklen(fs);
fs->um_dirblksiz = LFS_DIRBLKSIZ;
- fs->um_maxfilesize = fs->lfs_maxfilesize;
+ fs->um_maxfilesize = lfs_sb_getmaxfilesize(fs);
/* quota stuff */
/* XXX: these need to come from the on-disk superblock to be used */
@@ -1053,7 +1054,7 @@ lfs_mountfs(struct vnode *devvp, struct
mp->mnt_stat.f_namemax = LFS_MAXNAMLEN;
mp->mnt_stat.f_iosize = lfs_sb_getbsize(fs);
mp->mnt_flag |= MNT_LOCAL;
- mp->mnt_fs_bshift = fs->lfs_bshift;
+ mp->mnt_fs_bshift = lfs_sb_getbshift(fs);
if (fs->um_maxsymlinklen > 0)
mp->mnt_iflag |= IMNT_DTYPE;
@@ -1093,12 +1094,12 @@ lfs_mountfs(struct vnode *devvp, struct
fs->lfs_nactive = 0;
fs->lfs_suflags = malloc(2 * sizeof(u_int32_t *),
M_SEGMENT, M_WAITOK);
- fs->lfs_suflags[0] = malloc(fs->lfs_nseg * sizeof(u_int32_t),
+ fs->lfs_suflags[0] = malloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t),
M_SEGMENT, M_WAITOK);
- fs->lfs_suflags[1] = malloc(fs->lfs_nseg * sizeof(u_int32_t),
+ fs->lfs_suflags[1] = malloc(lfs_sb_getnseg(fs) * sizeof(u_int32_t),
M_SEGMENT, M_WAITOK);
- memset(fs->lfs_suflags[1], 0, fs->lfs_nseg * sizeof(u_int32_t));
- for (i = 0; i < fs->lfs_nseg; i++) {
+ memset(fs->lfs_suflags[1], 0, lfs_sb_getnseg(fs) * sizeof(u_int32_t));
+ for (i = 0; i < lfs_sb_getnseg(fs); i++) {
int changed;
LFS_SEGENTRY(sup, fs, i, bp);
@@ -1183,9 +1184,9 @@ lfs_mountfs(struct vnode *devvp, struct
/* If writing, sb is not clean; record in case of immediate crash */
if (!fs->lfs_ronly) {
- fs->lfs_pflags &= ~LFS_PF_CLEAN;
- lfs_writesuper(fs, fs->lfs_sboffs[0]);
- lfs_writesuper(fs, fs->lfs_sboffs[1]);
+ lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) & ~LFS_PF_CLEAN);
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));
}
/* Allow vget now that roll-forward is complete */
@@ -1303,9 +1304,9 @@ lfs_unmount(struct mount *mp, int mntfla
mutex_exit(vp->v_interlock);
/* Explicitly write the superblock, to update serial and pflags */
- fs->lfs_pflags |= LFS_PF_CLEAN;
- lfs_writesuper(fs, fs->lfs_sboffs[0]);
- lfs_writesuper(fs, fs->lfs_sboffs[1]);
+ lfs_sb_setpflags(fs, lfs_sb_getpflags(fs) | LFS_PF_CLEAN);
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 0));
+ lfs_writesuper(fs, lfs_sb_getsboff(fs, 1));
mutex_enter(&lfs_lock);
while (fs->lfs_iocount)
mtsleep(&fs->lfs_iocount, PRIBIO + 1, "lfs_umount", 0,
@@ -1581,7 +1582,7 @@ lfs_loadvnode(struct mount *mp, struct v
retries = 0;
again:
error = bread(ump->um_devvp, LFS_FSBTODB(fs, daddr),
- (fs->lfs_version == 1 ? lfs_sb_getbsize(fs) : fs->lfs_ibsize),
+ (fs->lfs_version == 1 ? lfs_sb_getbsize(fs) : lfs_sb_getibsize(fs)),
0, &bp);
if (error) {
lfs_deinit_vnode(ump, vp);
@@ -1767,11 +1768,11 @@ lfs_fhtovp(struct mount *mp, struct fid
return ESTALE;
fs = VFSTOULFS(mp)->um_lfs;
- if (lfh.lfid_ident != fs->lfs_ident)
+ if (lfh.lfid_ident != lfs_sb_getident(fs))
return ESTALE;
if (lfh.lfid_ino >
- ((VTOI(fs->lfs_ivnode)->i_ffs1_size >> fs->lfs_bshift) -
+ ((VTOI(fs->lfs_ivnode)->i_ffs1_size >> lfs_sb_getbshift(fs)) -
lfs_sb_getcleansz(fs) - lfs_sb_getsegtabsz(fs)) * lfs_sb_getifpb(fs))
return ESTALE;
@@ -1798,7 +1799,7 @@ lfs_vptofh(struct vnode *vp, struct fid
lfh.lfid_len = sizeof(struct lfid);
lfh.lfid_ino = ip->i_number;
lfh.lfid_gen = ip->i_gen;
- lfh.lfid_ident = ip->i_lfs->lfs_ident;
+ lfh.lfid_ident = lfs_sb_getident(ip->i_lfs);
memcpy(fhp, &lfh, sizeof(lfh));
return (0);
}
@@ -1919,7 +1920,7 @@ lfs_gop_write(struct vnode *vp, struct v
failreason = "Inode with no_gop_write";
goto tryagain;
}
- if ((pgs[0]->offset & fs->lfs_bmask) != 0) {
+ if ((pgs[0]->offset & lfs_sb_getbmask(fs)) != 0) {
failreason = "Bad page offset";
goto tryagain;
}
@@ -1968,12 +1969,12 @@ lfs_gop_write(struct vnode *vp, struct v
* We'll check later to make sure we always write entire
* blocks (or fragments).
*/
- if (startoffset & fs->lfs_bmask)
- printf("%" PRId64 " & %" PRId64 " = %" PRId64 "\n",
- startoffset, fs->lfs_bmask,
- startoffset & fs->lfs_bmask);
- KASSERT((startoffset & fs->lfs_bmask) == 0);
- if (bytes & fs->lfs_ffmask) {
+ if (startoffset & lfs_sb_getbmask(fs))
+ printf("%" PRId64 " & %" PRIu64 " = %" PRId64 "\n",
+ startoffset, lfs_sb_getbmask(fs),
+ startoffset & lfs_sb_getbmask(fs));
+ KASSERT((startoffset & lfs_sb_getbmask(fs)) == 0);
+ if (bytes & lfs_sb_getffmask(fs)) {
printf("lfs_gop_write: asked to write %ld bytes\n", (long)bytes);
panic("lfs_gop_write: non-integer blocks");
}
@@ -2043,7 +2044,7 @@ lfs_gop_write(struct vnode *vp, struct v
*/
/* If no room in the current segment, finish it up */
if (sp->sum_bytes_left < sizeof(int32_t) ||
- sp->seg_bytes_left < (1 << fs->lfs_bshift)) {
+ sp->seg_bytes_left < (1 << lfs_sb_getbshift(fs))) {
int vers;
lfs_updatemeta(sp);
@@ -2202,7 +2203,7 @@ lfs_vinit(struct mount *mp, struct vnode
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 + lfs_sb_getbsize(fs) - 1) >> fs->lfs_bshift;
+ for (i = (ip->i_size + lfs_sb_getbsize(fs) - 1) >> lfs_sb_getbshift(fs);
i < ULFS_NDADDR; i++) {
if ((vp->v_type == VBLK || vp->v_type == VCHR) &&
i == 0)
@@ -2273,12 +2274,13 @@ lfs_resize_fs(struct lfs *fs, int newnse
return EOPNOTSUPP;
/* If we're doing nothing, do it fast */
- oldnsegs = fs->lfs_nseg;
+ oldnsegs = lfs_sb_getnseg(fs);
if (newnsegs == oldnsegs)
return 0;
/* We always have to have two superblocks */
- if (newnsegs <= lfs_dtosn(fs, fs->lfs_sboffs[1]))
+ if (newnsegs <= lfs_dtosn(fs, lfs_sb_getsboff(fs, 1)))
+ /* XXX this error code is rather nonsense */
return EFBIG;
ivp = fs->lfs_ivnode;
@@ -2316,7 +2318,7 @@ lfs_resize_fs(struct lfs *fs, int newnse
/* Note old and new segment table endpoints, and old ifile size */
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;
+ ilast = ivp->v_size >> lfs_sb_getbshift(fs);
noff = nlast - olast;
/*
@@ -2388,8 +2390,8 @@ lfs_resize_fs(struct lfs *fs, int newnse
/* Zero out unused superblock offsets */
for (i = 2; i < LFS_MAXNUMSB; i++)
- if (lfs_dtosn(fs, fs->lfs_sboffs[i]) >= newnsegs)
- fs->lfs_sboffs[i] = 0x0;
+ if (lfs_dtosn(fs, lfs_sb_getsboff(fs, i)) >= newnsegs)
+ lfs_sb_setsboff(fs, i, 0x0);
/*
* Correct superblock entries that depend on fs size.
@@ -2405,39 +2407,39 @@ lfs_resize_fs(struct lfs *fs, int newnse
* XXX - we should probably adjust minfreeseg as well.
*/
gain = (newnsegs - oldnsegs);
- fs->lfs_nseg = newnsegs;
+ lfs_sb_setnseg(fs, newnsegs);
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;
+ lfs_sb_addnclean(fs, gain);
lfs_sb_addavail(fs, gain * lfs_btofsb(fs, lfs_sb_getssize(fs)));
} else {
- fs->lfs_nclean -= cgain;
+ lfs_sb_subnclean(fs, cgain);
lfs_sb_subavail(fs, cgain * lfs_btofsb(fs, lfs_sb_getssize(fs)) -
lfs_btofsb(fs, csbbytes));
}
/* Resize segment flag cache */
fs->lfs_suflags[0] = realloc(fs->lfs_suflags[0],
- fs->lfs_nseg * sizeof(u_int32_t), M_SEGMENT, M_WAITOK);
+ lfs_sb_getnseg(fs) * sizeof(u_int32_t), M_SEGMENT, M_WAITOK);
fs->lfs_suflags[1] = realloc(fs->lfs_suflags[1],
- fs->lfs_nseg * sizeof(u_int32_t), M_SEGMENT, M_WAITOK);
+ lfs_sb_getnseg(fs) * sizeof(u_int32_t), M_SEGMENT, M_WAITOK);
for (i = oldnsegs; i < newnsegs; i++)
fs->lfs_suflags[0][i] = fs->lfs_suflags[1][i] = 0x0;
/* Truncate Ifile if necessary */
if (noff < 0)
- lfs_truncate(ivp, ivp->v_size + (noff << fs->lfs_bshift), 0,
+ lfs_truncate(ivp, ivp->v_size + (noff << lfs_sb_getbshift(fs)), 0,
NOCRED);
/* Update cleaner info so the cleaner can die */
/* XXX what to do if bread fails? */
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;
+ ((CLEANERINFO *)bp->b_data)->clean = lfs_sb_getnclean(fs);
+ ((CLEANERINFO *)bp->b_data)->dirty = lfs_sb_getnseg(fs) - lfs_sb_getnclean(fs);
VOP_BWRITE(bp->b_vp, bp);
/* Let Ifile accesses proceed */
Index: src/sys/ufs/lfs/lfs_vnops.c
diff -u src/sys/ufs/lfs/lfs_vnops.c:1.274 src/sys/ufs/lfs/lfs_vnops.c:1.275
--- src/sys/ufs/lfs/lfs_vnops.c:1.274 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/lfs_vnops.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_vnops.c,v 1.274 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: lfs_vnops.c,v 1.275 2015/07/24 06:59:32 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.274 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.275 2015/07/24 06:59:32 dholland Exp $");
#ifdef _KERNEL_OPT
#include "opt_compat_netbsd.h"
@@ -1229,7 +1229,8 @@ lfs_wrapgo(struct lfs *fs, struct inode
}
if (--fs->lfs_nowrap == 0) {
- log(LOG_NOTICE, "%s: re-enabled log wrap\n", fs->lfs_fsmnt);
+ log(LOG_NOTICE, "%s: re-enabled log wrap\n",
+ lfs_sb_getfsmnt(fs));
wakeup(&fs->lfs_wrappass);
lfs_wakeup_cleaner(fs);
}
@@ -1363,7 +1364,7 @@ lfs_reclaim(void *v)
mutex_enter(&lfs_lock);
if (ip->i_flags & IN_PAGING) {
log(LOG_WARNING, "%s: reclaimed vnode is IN_PAGING\n",
- fs->lfs_fsmnt);
+ lfs_sb_getfsmnt(fs));
ip->i_flags &= ~IN_PAGING;
TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain);
}
@@ -1935,7 +1936,8 @@ segwait_common:
cv_wait(&fs->lfs_stopcv, &lfs_lock);
fs->lfs_stoplwp = curlwp;
if (fs->lfs_nowrap == 0)
- log(LOG_NOTICE, "%s: disabled log wrap\n", fs->lfs_fsmnt);
+ log(LOG_NOTICE, "%s: disabled log wrap\n",
+ lfs_sb_getfsmnt(fs));
++fs->lfs_nowrap;
if (*(int *)ap->a_data == 1
|| ap->a_command == LFCNWRAPSTOP_COMPAT) {
Index: src/sys/ufs/lfs/ulfs_inode.h
diff -u src/sys/ufs/lfs/ulfs_inode.h:1.13 src/sys/ufs/lfs/ulfs_inode.h:1.14
--- src/sys/ufs/lfs/ulfs_inode.h:1.13 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/ulfs_inode.h Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: ulfs_inode.h,v 1.13 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: ulfs_inode.h,v 1.14 2015/07/24 06:59:32 dholland Exp $ */
/* from NetBSD: inode.h,v 1.64 2012/11/19 00:36:21 jakllsch Exp */
/*
@@ -78,8 +78,8 @@ void lfs_unset_dirop(struct lfs *, struc
#define LFS_MAX_DIROP ((desiredvnodes >> 2) + (desiredvnodes >> 3))
#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) * lfs_sb_getssize(fs)) / \
+ (lfs_sb_getnclean(fs) <= lfs_sb_getresvseg(fs) ? 0 : \
+ ((lfs_sb_getnclean(fs) - lfs_sb_getresvseg(fs)) * lfs_sb_getssize(fs)) / \
(2 * SIZEOF_DIROP(fs)))
#define LFS_MAX_PAGES lfs_max_pages()
#define LFS_WAIT_PAGES lfs_wait_pages()
@@ -93,7 +93,7 @@ int lfs_max_pages(void);
#endif /* _KERNEL */
/* How starved can we be before we start holding back page writes */
-#define LFS_STARVED_FOR_SEGS(fs) ((fs)->lfs_nclean < (fs)->lfs_resvseg)
+#define LFS_STARVED_FOR_SEGS(fs) (lfs_sb_getnclean(fs) < lfs_sb_getresvseg(fs))
/*
* Reserved blocks for lfs_malloc
Index: src/sys/ufs/lfs/ulfs_quota2.c
diff -u src/sys/ufs/lfs/ulfs_quota2.c:1.19 src/sys/ufs/lfs/ulfs_quota2.c:1.20
--- src/sys/ufs/lfs/ulfs_quota2.c:1.19 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/ulfs_quota2.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: ulfs_quota2.c,v 1.19 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: ulfs_quota2.c,v 1.20 2015/07/24 06:59:32 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.19 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ulfs_quota2.c,v 1.20 2015/07/24 06:59:32 dholland Exp $");
#include <sys/buf.h>
#include <sys/param.h>
@@ -1563,7 +1563,7 @@ lfs_quota2_mount(struct mount *mp)
fs->um_flags |= ULFS_QUOTA2;
ump->umq2_bsize = lfs_sb_getbsize(fs);
- ump->umq2_bmask = fs->lfs_bmask;
+ ump->umq2_bmask = lfs_sb_getbmask(fs);
if (fs->lfs_quota_magic != Q2_HEAD_MAGIC) {
printf("%s: Invalid quota magic number\n",
mp->mnt_stat.f_mntonname);
Index: src/sys/ufs/lfs/ulfs_readwrite.c
diff -u src/sys/ufs/lfs/ulfs_readwrite.c:1.18 src/sys/ufs/lfs/ulfs_readwrite.c:1.19
--- src/sys/ufs/lfs/ulfs_readwrite.c:1.18 Fri Jul 24 06:56:42 2015
+++ src/sys/ufs/lfs/ulfs_readwrite.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: ulfs_readwrite.c,v 1.18 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: ulfs_readwrite.c,v 1.19 2015/07/24 06:59:32 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.18 2015/07/24 06:56:42 dholland Exp $");
+__KERNEL_RCSID(1, "$NetBSD: ulfs_readwrite.c,v 1.19 2015/07/24 06:59:32 dholland Exp $");
#ifdef LFS_READWRITE
#define FS struct lfs
@@ -337,7 +337,7 @@ WRITE(void *v)
goto out;
if (flags & B_SYNC) {
mutex_enter(vp->v_interlock);
- VOP_PUTPAGES(vp, trunc_page(osize & fs->fs_bmask),
+ VOP_PUTPAGES(vp, trunc_page(osize & lfs_sb_getbmask(fs)),
round_page(eob),
PGO_CLEANIT | PGO_SYNCIO);
}
@@ -443,7 +443,7 @@ WRITE(void *v)
}
if (error == 0 && ioflag & IO_SYNC) {
mutex_enter(vp->v_interlock);
- error = VOP_PUTPAGES(vp, trunc_page(origoff & fs->fs_bmask),
+ error = VOP_PUTPAGES(vp, trunc_page(origoff & lfs_sb_getbmask(fs)),
round_page(lfs_blkroundup(fs, uio->uio_offset)),
PGO_CLEANIT | PGO_SYNCIO);
}
@@ -523,7 +523,7 @@ BUFWR(struct vnode *vp, struct uio *uio,
#ifdef LFS_READWRITE
error = lfs_reserve(fs, vp, NULL,
- lfs_btofsb(fs, (ULFS_NIADDR + 1) << fs->lfs_bshift));
+ lfs_btofsb(fs, (ULFS_NIADDR + 1) << lfs_sb_getbshift(fs)));
if (error)
break;
need_unreserve = true;
@@ -557,7 +557,7 @@ BUFWR(struct vnode *vp, struct uio *uio,
#ifdef LFS_READWRITE
(void)VOP_BWRITE(bp->b_vp, bp);
lfs_reserve(fs, vp, NULL,
- -lfs_btofsb(fs, (ULFS_NIADDR + 1) << fs->lfs_bshift));
+ -lfs_btofsb(fs, (ULFS_NIADDR + 1) << lfs_sb_getbshift(fs)));
need_unreserve = false;
#else
if (ioflag & IO_SYNC)
@@ -573,7 +573,7 @@ BUFWR(struct vnode *vp, struct uio *uio,
#ifdef LFS_READWRITE
if (need_unreserve) {
lfs_reserve(fs, vp, NULL,
- -lfs_btofsb(fs, (ULFS_NIADDR + 1) << fs->lfs_bshift));
+ -lfs_btofsb(fs, (ULFS_NIADDR + 1) << lfs_sb_getbshift(fs)));
}
#endif
Index: src/usr.sbin/dumplfs/dumplfs.c
diff -u src/usr.sbin/dumplfs/dumplfs.c:1.43 src/usr.sbin/dumplfs/dumplfs.c:1.44
--- src/usr.sbin/dumplfs/dumplfs.c:1.43 Fri Jul 24 06:56:42 2015
+++ src/usr.sbin/dumplfs/dumplfs.c Fri Jul 24 06:59:32 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: dumplfs.c,v 1.43 2015/07/24 06:56:42 dholland Exp $ */
+/* $NetBSD: dumplfs.c,v 1.44 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1991, 1993
@@ -40,7 +40,7 @@ __COPYRIGHT("@(#) Copyright (c) 1991, 19
#if 0
static char sccsid[] = "@(#)dumplfs.c 8.5 (Berkeley) 5/24/95";
#else
-__RCSID("$NetBSD: dumplfs.c,v 1.43 2015/07/24 06:56:42 dholland Exp $");
+__RCSID("$NetBSD: dumplfs.c,v 1.44 2015/07/24 06:59:32 dholland Exp $");
#endif
#endif /* not lint */
@@ -189,8 +189,8 @@ main(int argc, char **argv)
/* If that wasn't the real first sb, get the real first sb */
if (lfs_sb1.lfs_version > 1 &&
- lfs_sb1.lfs_sboffs[0] > lfs_btofsb(&lfs_sb1, LFS_LABELPAD))
- get(fd, lfs_fsbtob(&lfs_sb1, lfs_sb1.lfs_sboffs[0]),
+ lfs_sb_getsboff(&lfs_sb1, 0) > lfs_btofsb(&lfs_sb1, LFS_LABELPAD))
+ get(fd, lfs_fsbtob(&lfs_sb1, lfs_sb_getsboff(&lfs_sb1, 0)),
&(lfs_sb1.lfs_dlfs), sizeof(struct dlfs));
/*
@@ -198,7 +198,7 @@ main(int argc, char **argv)
* most up to date.
*/
get(fd,
- fsbtobyte(&lfs_sb1, lfs_sb1.lfs_sboffs[1]),
+ fsbtobyte(&lfs_sb1, lfs_sb_getsboff(&lfs_sb1, 1)),
sbuf, LFS_SBPAD);
memcpy(&(lfs_sb2.lfs_dlfs), sbuf, sizeof(struct dlfs));
@@ -206,15 +206,15 @@ main(int argc, char **argv)
if (lfs_sb1.lfs_version > 1) {
if (lfs_sb_getserial(&lfs_sb1) > lfs_sb_getserial(&lfs_sb2)) {
lfs_master = &lfs_sb2;
- sbdaddr = lfs_sb1.lfs_sboffs[1];
+ sbdaddr = lfs_sb_getsboff(&lfs_sb1, 1);
} else
- sbdaddr = lfs_sb1.lfs_sboffs[0];
+ sbdaddr = lfs_sb_getsboff(&lfs_sb1, 0);
} else {
if (lfs_sb_getotstamp(&lfs_sb1) > lfs_sb_getotstamp(&lfs_sb2)) {
lfs_master = &lfs_sb2;
- sbdaddr = lfs_sb1.lfs_sboffs[1];
+ sbdaddr = lfs_sb_getsboff(&lfs_sb1, 1);
} else
- sbdaddr = lfs_sb1.lfs_sboffs[0];
+ sbdaddr = lfs_sb_getsboff(&lfs_sb1, 0);
}
} else {
/* Read the first superblock */
@@ -227,11 +227,11 @@ main(int argc, char **argv)
/* Compatibility */
if (lfs_master->lfs_version == 1) {
- lfs_master->lfs_sumsize = LFS_V1_SUMMARY_SIZE;
- lfs_master->lfs_ibsize = lfs_sb_getbsize(lfs_master);
- lfs_master->lfs_s0addr = lfs_master->lfs_sboffs[0];
+ lfs_sb_setsumsize(lfs_master, LFS_V1_SUMMARY_SIZE);
+ lfs_sb_setibsize(lfs_master, lfs_sb_getbsize(lfs_master));
+ lfs_sb_sets0addr(lfs_master, lfs_sb_getsboff(lfs_master, 0));
lfs_sb_settstamp(lfs_master, lfs_sb_getotstamp(lfs_master));
- lfs_master->lfs_fsbtodb = 0;
+ lfs_sb_setfsbtodb(lfs_master, 0);
}
(void)printf("Master Superblock at 0x%llx:\n", (long long)sbdaddr);
@@ -247,7 +247,7 @@ main(int argc, char **argv)
}
else
for (segnum = 0, seg_addr = lfs_sntod(lfs_master, 0);
- segnum < lfs_master->lfs_nseg;
+ segnum < lfs_sb_getnseg(lfs_master);
segnum++, seg_addr = lfs_sntod(lfs_master, segnum))
dump_segment(fd, segnum, seg_addr, lfs_master,
do_allsb);
@@ -507,7 +507,7 @@ dump_sum(int fd, struct lfs *lfsp, SEGSU
(long long)addr);
return -1;
}
- if (lfsp->lfs_version > 1 && sp->ss_ident != lfsp->lfs_ident) {
+ if (lfsp->lfs_version > 1 && sp->ss_ident != lfs_sb_getident(lfsp)) {
(void)printf("dumplfs: %s %d address 0x%llx\n",
"summary from a former life; segment", segnum,
(long long)addr);
@@ -661,12 +661,12 @@ dump_segment(int fd, int segnum, daddr_t
sumblock = malloc(lfs_sb_getsumsize(lfsp));
if (lfsp->lfs_version > 1 && segnum == 0) {
- if (lfs_fsbtob(lfsp, lfsp->lfs_s0addr) < LFS_LABELPAD) {
+ if (lfs_fsbtob(lfsp, lfs_sb_gets0addr(lfsp)) < LFS_LABELPAD) {
/* First segment eats the disklabel */
sum_offset += lfs_fragroundup(lfsp, LFS_LABELPAD) -
- lfs_fsbtob(lfsp, lfsp->lfs_s0addr);
+ lfs_fsbtob(lfsp, lfs_sb_gets0addr(lfsp));
addr += lfs_btofsb(lfsp, lfs_fragroundup(lfsp, LFS_LABELPAD)) -
- lfsp->lfs_s0addr;
+ lfs_sb_gets0addr(lfsp);
printf("Disklabel at 0x0\n");
}
}
@@ -771,13 +771,13 @@ dump_super(struct lfs *lfsp)
"interleave ", lfs_sb_getinterleave(lfsp),
"sumsize ", lfs_sb_getsumsize(lfsp));
(void)printf(" %s%-10d %s0x%-8jx\n",
- "seg0addr ", lfsp->lfs_s0addr,
+ "seg0addr ", lfs_sb_gets0addr(lfsp),
"maxfilesize ", (uintmax_t)lfs_sb_getmaxfilesize(lfsp));
(void)printf(" Superblock disk addresses:\n ");
for (i = 0; i < LFS_MAXNUMSB; i++) {
- (void)printf(" 0x%-8x", lfsp->lfs_sboffs[i]);
+ (void)printf(" 0x%-8x", lfs_sb_getsboff(lfsp, i));
if (i == (LFS_MAXNUMSB >> 1))
(void)printf("\n ");
}
