From adca8af59ebb37d5de331395ba17720ebf50f721 Mon Sep 17 00:00:00 2001 From: dholland Date: Fri, 24 Jul 2015 06:59:31 +0000 Subject: [PATCH] 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. --- libexec/lfs_cleanerd/cleaner.h | 38 ++++++- libexec/lfs_cleanerd/coalesce.c | 19 ++-- libexec/lfs_cleanerd/lfs_cleanerd.c | 108 ++++++++++---------- sbin/dump_lfs/lfs_inode.c | 38 +++---- sbin/fsck_lfs/inode.c | 6 +- sbin/fsck_lfs/lfs.c | 87 ++++++++-------- sbin/fsck_lfs/main.c | 4 +- sbin/fsck_lfs/pass1.c | 6 +- sbin/fsck_lfs/pass5.c | 38 +++---- sbin/fsck_lfs/pass6.c | 62 ++++++------ sbin/fsck_lfs/segwrite.c | 32 +++--- sbin/fsck_lfs/setup.c | 82 +++++++-------- sbin/fsck_lfs/utilities.c | 12 +-- sbin/newfs_lfs/make_lfs.c | 150 ++++++++++++++-------------- sbin/resize_lfs/resize_lfs.c | 12 +-- sbin/scan_ffs/scan_ffs.c | 18 ++-- sys/ufs/lfs/lfs.h | 114 ++++++++++----------- sys/ufs/lfs/lfs_alloc.c | 12 +-- sys/ufs/lfs/lfs_balloc.c | 12 +-- sys/ufs/lfs/lfs_bio.c | 8 +- sys/ufs/lfs/lfs_inode.c | 20 ++-- sys/ufs/lfs/lfs_pages.c | 12 +-- sys/ufs/lfs/lfs_rfw.c | 38 +++---- sys/ufs/lfs/lfs_segment.c | 88 ++++++++-------- sys/ufs/lfs/lfs_subr.c | 14 +-- sys/ufs/lfs/lfs_syscalls.c | 14 +-- sys/ufs/lfs/lfs_vfsops.c | 116 ++++++++++----------- sys/ufs/lfs/lfs_vnops.c | 12 ++- sys/ufs/lfs/ulfs_inode.h | 8 +- sys/ufs/lfs/ulfs_quota2.c | 6 +- sys/ufs/lfs/ulfs_readwrite.c | 14 +-- usr.sbin/dumplfs/dumplfs.c | 40 ++++---- 32 files changed, 646 insertions(+), 594 deletions(-) diff --git a/libexec/lfs_cleanerd/cleaner.h b/libexec/lfs_cleanerd/cleaner.h index b102f893861e..4a9e227966f7 100644 --- a/libexec/lfs_cleanerd/cleaner.h +++ b/libexec/lfs_cleanerd/cleaner.h @@ -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. diff --git a/libexec/lfs_cleanerd/coalesce.c b/libexec/lfs_cleanerd/coalesce.c index 9917b4ea7a38..067e67d26e64 100644 --- a/libexec/lfs_cleanerd/coalesce.c +++ b/libexec/lfs_cleanerd/coalesce.c @@ -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 #include #include +#include #include @@ -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); } diff --git a/libexec/lfs_cleanerd/lfs_cleanerd.c b/libexec/lfs_cleanerd/lfs_cleanerd.c index 3f3547e4fccb..5a730d0d947a 100644 --- a/libexec/lfs_cleanerd/lfs_cleanerd.c +++ b/libexec/lfs_cleanerd/lfs_cleanerd.c @@ -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 *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)); - 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 *fsname) 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, ino_t ino, struct ubuf **bpp) 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 daddr, BLOCK_INFO **bipp, int *bic) */ 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 daddr, BLOCK_INFO **bipp, int *bic) */ 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 daddr, BLOCK_INFO **bipp, int *bic) */ 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 daddr, BLOCK_INFO **bipp, int *bic) 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 daddr, BLOCK_INFO **bipp, int *bic) 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 daddr, BLOCK_INFO **bipp, int *bic) 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 daddr, BLOCK_INFO **bipp, int *bic) #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, BLOCK_INFO **bipp, int *bic) 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_INFO **bipp, int *bic, int *sizep) 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 sn) 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 sn) 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 sn) */ 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 *cip) } /* 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 *cip) 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 *cip) 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 *cip) 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 *cip) /* 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 *cip) 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 *cip) 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, CLEANERINFO *cip) * 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, CLEANERINFO *cip) * 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, CLEANERINFO *cip) 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, CLEANERINFO *cip) /* 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 && diff --git a/sbin/dump_lfs/lfs_inode.c b/sbin/dump_lfs/lfs_inode.c index 799034f5e6f7..b94e2ed696f1 100644 --- a/sbin/dump_lfs/lfs_inode.c +++ b/sbin/dump_lfs/lfs_inode.c @@ -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, 1991, 1993, 1994\ #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; } diff --git a/sbin/fsck_lfs/inode.c b/sbin/fsck_lfs/inode.c index 9f2e61adba8e..bbd9268d88bd 100644 --- a/sbin/fsck_lfs/inode.c +++ b/sbin/fsck_lfs/inode.c @@ -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 inodesc *idesc) 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; diff --git a/sbin/fsck_lfs/lfs.c b/sbin/fsck_lfs/lfs.c index a0c683e00d37..3b808bfe67db 100644 --- a/sbin/fsck_lfs/lfs.c +++ b/sbin/fsck_lfs/lfs.c @@ -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 uvnode * vp, daddr_t bn, struct indir * ap, 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 uvnode * vp, daddr_t bn, struct indir * ap, 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, int fd, ulfs_daddr_t daddr) /* 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, daddr_t idaddr, int dummy_read, int debug) 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, daddr_t idaddr, int dummy_read, int debug) /* 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 uvnode *devvp, ulfs_daddr_t goal, int debug) * 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 uvnode *devvp, ulfs_daddr_t goal, int debug) * 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 uvnode *devvp, ulfs_daddr_t goal, int debug) (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, ulfs_daddr_t pseg_addr, int debug, /* 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, ulfs_daddr_t pseg_addr, int debug, 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 diff --git a/sbin/fsck_lfs/main.c b/sbin/fsck_lfs/main.c index 2c2cff11ab6c..dff94a4eb33b 100644 --- a/sbin/fsck_lfs/main.c +++ b/sbin/fsck_lfs/main.c @@ -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 *mntpt, long auxdata, int child) * 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"); /* diff --git a/sbin/fsck_lfs/pass1.c b/sbin/fsck_lfs/pass1.c index 6f6765f8a51e..77fd2f760a3e 100644 --- a/sbin/fsck_lfs/pass1.c +++ b/sbin/fsck_lfs/pass1.c @@ -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 * idesc) * 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; diff --git a/sbin/fsck_lfs/pass5.c b/sbin/fsck_lfs/pass5.c index e7fe4e916936..766d0cb6ac8f 100644 --- a/sbin/fsck_lfs/pass5.c +++ b/sbin/fsck_lfs/pass5.c @@ -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) { diff --git a/sbin/fsck_lfs/pass6.c b/sbin/fsck_lfs/pass6.c index f259304de0a0..e96ae69d5bfb 100644 --- a/sbin/fsck_lfs/pass6.c +++ b/sbin/fsck_lfs/pass6.c @@ -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, daddr_t lbn, ulfs_daddr_t ndaddr, int size) } /* 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); diff --git a/sbin/fsck_lfs/segwrite.c b/sbin/fsck_lfs/segwrite.c index 5959cf097d7a..9ad0d650a103 100644 --- a/sbin/fsck_lfs/segwrite.c +++ b/sbin/fsck_lfs/segwrite.c @@ -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 segment * sp, struct inode * ip) 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 segment * sp, struct inode * ip) 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 segment * sp) 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 segment * sp) 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_daddr_t daddr) 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, diff --git a/sbin/fsck_lfs/setup.c b/sbin/fsck_lfs/setup.c index 3491ed2ca32f..5467ca37f8c8 100644 --- a/sbin/fsck_lfs/setup.c +++ b/sbin/fsck_lfs/setup.c @@ -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) diff --git a/sbin/fsck_lfs/utilities.c b/sbin/fsck_lfs/utilities.c index e197c3ab17e9..52da26c04cb0 100644 --- a/sbin/fsck_lfs/utilities.c +++ b/sbin/fsck_lfs/utilities.c @@ -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) diff --git a/sbin/newfs_lfs/make_lfs.c b/sbin/newfs_lfs/make_lfs.c index b873ad473f51..31a8e3511c0c 100644 --- a/sbin/newfs_lfs/make_lfs.c +++ b/sbin/newfs_lfs/make_lfs.c @@ -1,4 +1,4 @@ -/* $NetBSD: make_lfs.c,v 1.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_dinode *dip, int nfrags, struct lfs *fs) 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 dkwedge_info *dkw, int minfree, 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 dkwedge_info *dkw, int minfree, 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 dkwedge_info *dkw, int minfree, * 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 dkwedge_info *dkw, int minfree, */ 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 dkwedge_info *dkw, int minfree, * and segment usage table, and half a block per segment that can't * be written due to fragmentation. */ - lfs_sb_setdsize(fs, (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 dkwedge_info *dkw, int minfree, 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 dkwedge_info *dkw, int minfree, 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 dkwedge_info *dkw, int minfree, 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 dkwedge_info *dkw, int minfree, 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 dkwedge_info *dkw, int minfree, * 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 dkwedge_info *dkw, int minfree, /* * 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 dkwedge_info *dkw, int minfree, */ 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 dkwedge_info *dkw, int minfree, 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 dkwedge_info *dkw, int minfree, 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 dkwedge_info *dkw, int minfree, /* 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); diff --git a/sbin/resize_lfs/resize_lfs.c b/sbin/resize_lfs/resize_lfs.c index 5b74c68fdd5e..0b725be3bce7 100644 --- a/sbin/resize_lfs/resize_lfs.c +++ b/sbin/resize_lfs/resize_lfs.c @@ -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; } diff --git a/sbin/scan_ffs/scan_ffs.c b/sbin/scan_ffs/scan_ffs.c index bd7a9830741e..ccf8e51554d6 100644 --- a/sbin/scan_ffs/scan_ffs.c +++ b/sbin/scan_ffs/scan_ffs.c @@ -1,4 +1,4 @@ -/* $NetBSD: scan_ffs.c,v 1.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 #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 @@ -251,7 +251,7 @@ lfs_printpart(struct sblockinfo *sbi, int flag, int n) (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, int flag, int n) 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, int flag, int n) 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); diff --git a/sys/ufs/lfs/lfs.h b/sys/ufs/lfs/lfs.h index f56e46f63dde..89671483b96e 100644 --- a/sys/ufs/lfs/lfs.h +++ b/sys/ufs/lfs/lfs.h @@ -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 diff --git a/sys/ufs/lfs/lfs_alloc.c b/sys/ufs/lfs/lfs_alloc.c index a7e7c6fa6529..a877b5dfbf03 100644 --- a/sys/ufs/lfs/lfs_alloc.c +++ b/sys/ufs/lfs/lfs_alloc.c @@ -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 -__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_cred_t cred) 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 ino, int vers) /* 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), diff --git a/sys/ufs/lfs/lfs_balloc.c b/sys/ufs/lfs/lfs_balloc.c index d967e892cdc0..75498b9a7840 100644 --- a/sys/ufs/lfs/lfs_balloc.c +++ b/sys/ufs/lfs/lfs_balloc.c @@ -1,4 +1,4 @@ -/* $NetBSD: lfs_balloc.c,v 1.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 -__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, daddr_t lbn) 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, daddr_t lbn) } ++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 inode *ip, struct lbnentry *lbp) 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; diff --git a/sys/ufs/lfs/lfs_bio.c b/sys/ufs/lfs/lfs_bio.c index 54193f56bdae..0d68e5320383 100644 --- a/sys/ufs/lfs/lfs_bio.c +++ b/sys/ufs/lfs/lfs_bio.c @@ -1,4 +1,4 @@ -/* $NetBSD: lfs_bio.c,v 1.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 -__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 #include @@ -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; diff --git a/sys/ufs/lfs/lfs_inode.c b/sys/ufs/lfs/lfs_inode.c index c646fe8e6080..3893be97fafd 100644 --- a/sys/ufs/lfs/lfs_inode.c +++ b/sys/ufs/lfs/lfs_inode.c @@ -1,4 +1,4 @@ -/* $NetBSD: lfs_inode.c,v 1.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 -__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 length, int ioflag, kauth_cred_t cred) 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 length, int ioflag, kauth_cred_t cred) 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 length, int ioflag, kauth_cred_t cred) } 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 length, int ioflag, kauth_cred_t cred) 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 length, int ioflag, kauth_cred_t cred) 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 length, int ioflag, kauth_cred_t cred) ((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; diff --git a/sys/ufs/lfs/lfs_pages.c b/sys/ufs/lfs/lfs_pages.c index efc5b88d85b8..a577e52c5a41 100644 --- a/sys/ufs/lfs/lfs_pages.c +++ b/sys/ufs/lfs/lfs_pages.c @@ -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 -__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 *vp, || (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; diff --git a/sys/ufs/lfs/lfs_rfw.c b/sys/ufs/lfs/lfs_rfw.c index 64f1b97e3a0a..685e1e620584 100644 --- a/sys/ufs/lfs/lfs_rfw.c +++ b/sys/ufs/lfs/lfs_rfw.c @@ -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 -__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, int vers, daddr_t lbn, 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, int vers, daddr_t lbn, * 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 offset, kauth_cred_t cred, * 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 offset, u_int64_t nextserial, } /* 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 offset, u_int64_t nextserial, 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 offset, u_int64_t nextserial, 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 offset, u_int64_t nextserial, 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 offset, u_int64_t nextserial, 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 offset, u_int64_t nextserial, } /* 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 mount *mp, struct lwp *l) * 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 mount *mp, struct lwp *l) 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 mount *mp, struct lwp *l) 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 mount *mp, struct lwp *l) 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); diff --git a/sys/ufs/lfs/lfs_segment.c b/sys/ufs/lfs/lfs_segment.c index 9261d934b8bb..4dbbacc1a9b8 100644 --- a/sys/ufs/lfs/lfs_segment.c +++ b/sys/ufs/lfs/lfs_segment.c @@ -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 -__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 buf *); ((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 segment *sp, struct inode *ip, daddr_t n */ 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 segment *sp, struct inode *ip) 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 segment *sp, struct inode *ip) 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 segment *sp, struct inode *ip) 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 segment *sp, struct inode *ip) ++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 segment *sp, struct inode *ip) /* 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 segment *sp, struct inode *ip) * 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 segment *sp, 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 segment *sp) 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 segment *sp) 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 segment *sp) 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 daddr) 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, diff --git a/sys/ufs/lfs/lfs_subr.c b/sys/ufs/lfs/lfs_subr.c index a05ada063c78..5b1877adfc63 100644 --- a/sys/ufs/lfs/lfs_subr.c +++ b/sys/ufs/lfs/lfs_subr.c @@ -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 -__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 #include @@ -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 */ diff --git a/sys/ufs/lfs/lfs_syscalls.c b/sys/ufs/lfs/lfs_syscalls.c index e5cb6125c4c2..e180abf46ba2 100644 --- a/sys/ufs/lfs/lfs_syscalls.c +++ b/sys/ufs/lfs/lfs_syscalls.c @@ -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 -__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 long segnum) 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 long segnum) 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; diff --git a/sys/ufs/lfs/lfs_vfsops.c b/sys/ufs/lfs/lfs_vfsops.c index cf4841c36142..812dc7fd8e3a 100644 --- a/sys/ufs/lfs/lfs_vfsops.c +++ b/sys/ufs/lfs/lfs_vfsops.c @@ -1,4 +1,4 @@ -/* $NetBSD: lfs_vfsops.c,v 1.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 -__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 *path, void *data, size_t *data_len) } 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 *path, void *data, size_t *data_len) 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 mount *mp, struct lwp *l) /* 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 mount *mp, struct lwp *l) /* 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 mount *mp, struct lwp *l) 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 mount *mp, struct lwp *l) 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 mount *mp, struct lwp *l) /* 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 mntflags) 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 vnode *vp, 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 *fhp, struct vnode **vpp) 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 *fhp, size_t *fh_size) 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 vm_page **pgs, int npages, 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 vm_page **pgs, int npages, * 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 vm_page **pgs, int npages, */ /* 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 **vpp) 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 newnsegs) 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 newnsegs) /* 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 newnsegs) /* 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 newnsegs) * 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 */ diff --git a/sys/ufs/lfs/lfs_vnops.c b/sys/ufs/lfs/lfs_vnops.c index 29c38639dc4f..b401a7599ead 100644 --- a/sys/ufs/lfs/lfs_vnops.c +++ b/sys/ufs/lfs/lfs_vnops.c @@ -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 -__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 *ip, int waitfor) } 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) { diff --git a/sys/ufs/lfs/ulfs_inode.h b/sys/ufs/lfs/ulfs_inode.h index 47cfb1730172..e9f9b9a0ba34 100644 --- a/sys/ufs/lfs/ulfs_inode.h +++ b/sys/ufs/lfs/ulfs_inode.h @@ -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 *, struct vnode *, const char *); #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 diff --git a/sys/ufs/lfs/ulfs_quota2.c b/sys/ufs/lfs/ulfs_quota2.c index 6496f0dd7bb3..4e475142c6b1 100644 --- a/sys/ufs/lfs/ulfs_quota2.c +++ b/sys/ufs/lfs/ulfs_quota2.c @@ -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 -__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 #include @@ -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); diff --git a/sys/ufs/lfs/ulfs_readwrite.c b/sys/ufs/lfs/ulfs_readwrite.c index 3ff5a2b9bb2f..53a549c74f33 100644 --- a/sys/ufs/lfs/ulfs_readwrite.c +++ b/sys/ufs/lfs/ulfs_readwrite.c @@ -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 -__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, int ioflag, kauth_cred_t cred) #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, int ioflag, kauth_cred_t cred) #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, int ioflag, kauth_cred_t cred) #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 diff --git a/usr.sbin/dumplfs/dumplfs.c b/usr.sbin/dumplfs/dumplfs.c index 961395105e42..8afb995f5ae2 100644 --- a/usr.sbin/dumplfs/dumplfs.c +++ b/usr.sbin/dumplfs/dumplfs.c @@ -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, 1993\ #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, SEGSUM *sp, int segnum, daddr_t addr) (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 addr, struct lfs *lfsp, int dump_sb) 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 "); }