Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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.
This commit is contained in:
dholland 2015-07-24 06:59:31 +00:00
parent f59b8f4b3a
commit adca8af59e
32 changed files with 646 additions and 594 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
libexec/lfs_cleanerd/cleaner.h
View File

@ -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.

19
libexec/lfs_cleanerd/coalesce.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: coalesce.c,v 1.25 2015/07/24 06:56:41 dholland Exp $ */
/* $NetBSD: coalesce.c,v 1.26 2015/07/24 06:59:31 dholland Exp $ */
/*-
* Copyright (c) 2002, 2005 The NetBSD Foundation, Inc.
@ -49,6 +49,7 @@
#include <util.h>
#include <errno.h>
#include <err.h>
#include <assert.h>
#include <syslog.h>
@ -118,9 +119,9 @@ get_dinode(struct clfs *fs, ino_t ino)
if (daddr == 0x0)
return NULL;
bread(fs->clfs_devvp, daddr, fs->lfs_ibsize, 0, &bp);
bread(fs->clfs_devvp, daddr, lfs_sb_getibsize(fs), 0, &bp);
for (dip = (struct ulfs1_dinode *)bp->b_data;
dip < (struct ulfs1_dinode *)(bp->b_data + fs->lfs_ibsize); dip++)
dip < (struct ulfs1_dinode *)(bp->b_data + lfs_sb_getibsize(fs)); dip++)
if (dip->di_inumber == ino) {
r = (struct ulfs1_dinode *)malloc(sizeof(*r));
if (r == NULL)
@ -201,7 +202,7 @@ clean_inode(struct clfs *fs, ino_t ino)
lim.blkcnt = nb;
if (kops.ko_fcntl(fs->clfs_ifilefd, LFCNBMAPV, &lim) < 0) {
syslog(LOG_WARNING, "%s: coalesce: LFCNBMAPV: %m",
fs->lfs_fsmnt);
lfs_sb_getfsmnt(fs));
retval = COALESCE_BADBMAPV;
goto out;
}
@ -218,7 +219,7 @@ clean_inode(struct clfs *fs, ino_t ino)
if (bip[i].bi_daddr != bip[i - 1].bi_daddr + clfs_sb_getfrag(fs))
++noff;
toff += abs(bip[i].bi_daddr - bip[i - 1].bi_daddr
- clfs_sb_getfrag(fs)) >> fs->lfs_fbshift;
- clfs_sb_getfrag(fs)) >> lfs_sb_getfbshift(fs);
}
/*
@ -339,7 +340,7 @@ int clean_all_inodes(struct clfs *fs)
memset(totals, 0, sizeof(totals));
fstat(fs->clfs_ifilefd, &st);
maxino = lfs_sb_getifpb(fs) * (st.st_size >> fs->lfs_bshift) -
maxino = lfs_sb_getifpb(fs) * (st.st_size >> lfs_sb_getbshift(fs)) -
lfs_sb_getsegtabsz(fs) - lfs_sb_getcleansz(fs);
for (i = 0; i < maxino; i++) {
@ -383,14 +384,14 @@ fork_coalesce(struct clfs *fs)
*/
childpid = fork();
if (childpid < 0) {
syslog(LOG_ERR, "%s: fork to coaleasce: %m", fs->lfs_fsmnt);
syslog(LOG_ERR, "%s: fork to coaleasce: %m", lfs_sb_getfsmnt(fs));
return 0;
} else if (childpid == 0) {
syslog(LOG_NOTICE, "%s: new coalescing process, pid %d",
fs->lfs_fsmnt, getpid());
lfs_sb_getfsmnt(fs), getpid());
num = clean_all_inodes(fs);
syslog(LOG_NOTICE, "%s: coalesced %d discontiguous inodes",
fs->lfs_fsmnt, num);
lfs_sb_getfsmnt(fs), num);
exit(0);
}

108
libexec/lfs_cleanerd/lfs_cleanerd.c
View File

@ -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 &&

38
sbin/dump_lfs/lfs_inode.c
View File

@ -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;
}

6
sbin/fsck_lfs/inode.c
View File

@ -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;

87
sbin/fsck_lfs/lfs.c
View File

@ -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

4
sbin/fsck_lfs/main.c
View File

@ -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");
/*

6
sbin/fsck_lfs/pass1.c
View File

@ -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;

38
sbin/fsck_lfs/pass5.c
View File

@ -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) {

62
sbin/fsck_lfs/pass6.c
View File

@ -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);

32
sbin/fsck_lfs/segwrite.c
View File

@ -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,

82
sbin/fsck_lfs/setup.c
View File

@ -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)

12
sbin/fsck_lfs/utilities.c
View File

@ -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)

150
sbin/newfs_lfs/make_lfs.c
View File

@ -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);

12
sbin/resize_lfs/resize_lfs.c
View File

@ -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;
}

18
sbin/scan_ffs/scan_ffs.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: scan_ffs.c,v 1.26 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: scan_ffs.c,v 1.27 2015/07/24 06:59:32 dholland Exp $ */
/*
* Copyright (c) 2005-2007 Juan Romero Pardines
@ -33,7 +33,7 @@
#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: scan_ffs.c,v 1.26 2015/07/24 06:56:42 dholland Exp $");
__RCSID("$NetBSD: scan_ffs.c,v 1.27 2015/07/24 06:59:32 dholland Exp $");
#endif /* not lint */
#include <sys/types.h>
@ -251,7 +251,7 @@ lfs_printpart(struct sblockinfo *sbi, 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);

114
sys/ufs/lfs/lfs.h
View File

@ -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

12
sys/ufs/lfs/lfs_alloc.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_alloc.c,v 1.122 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_alloc.c,v 1.123 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003, 2007 The NetBSD Foundation, Inc.
@ -60,7 +60,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_alloc.c,v 1.122 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_alloc.c,v 1.123 2015/07/24 06:59:32 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_quota.h"
@ -136,7 +136,7 @@ lfs_extend_ifile(struct lfs *fs, kauth_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),

12
sys/ufs/lfs/lfs_balloc.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_balloc.c,v 1.82 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_balloc.c,v 1.83 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@ -60,7 +60,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_balloc.c,v 1.82 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_balloc.c,v 1.83 2015/07/24 06:59:32 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_quota.h"
@ -501,7 +501,7 @@ lfs_register_block(struct vnode *vp, 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;

8
sys/ufs/lfs/lfs_bio.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_bio.c,v 1.129 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_bio.c,v 1.130 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003, 2008 The NetBSD Foundation, Inc.
@ -60,7 +60,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.129 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_bio.c,v 1.130 2015/07/24 06:59:32 dholland Exp $");
#include <sys/param.h>
#include <sys/systm.h>
@ -361,7 +361,7 @@ lfs_fits(struct lfs *fs, int fsb)
needed = fsb + lfs_btofsb(fs, lfs_sb_getsumsize(fs)) +
((howmany(lfs_sb_getuinodes(fs) + 1, LFS_INOPB(fs)) +
lfs_sb_getsegtabsz(fs) +
1) << (fs->lfs_bshift - fs->lfs_ffshift));
1) << (lfs_sb_getbshift(fs) - lfs_sb_getffshift(fs)));
if (needed >= lfs_sb_getavail(fs)) {
#ifdef DEBUG
@ -443,7 +443,7 @@ lfs_bwrite_ext(struct buf *bp, int flags)
*
* In particular the cleaner can't write blocks either.
*/
if (fs->lfs_ronly || (fs->lfs_pflags & LFS_PF_CLEAN)) {
if (fs->lfs_ronly || (lfs_sb_getpflags(fs) & LFS_PF_CLEAN)) {
bp->b_oflags &= ~BO_DELWRI;
bp->b_flags |= B_READ; /* XXX is this right? --ks */
bp->b_error = 0;

20
sys/ufs/lfs/lfs_inode.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_inode.c,v 1.138 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_inode.c,v 1.139 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@ -60,7 +60,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_inode.c,v 1.138 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_inode.c,v 1.139 2015/07/24 06:59:32 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_quota.h"
@ -285,7 +285,7 @@ lfs_truncate(struct vnode *ovp, off_t 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;

12
sys/ufs/lfs/lfs_pages.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_pages.c,v 1.2 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_pages.c,v 1.3 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@ -60,7 +60,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_pages.c,v 1.2 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_pages.c,v 1.3 2015/07/24 06:59:32 dholland Exp $");
#ifdef _KERNEL_OPT
#include "opt_compat_netbsd.h"
@ -278,7 +278,7 @@ check_dirty(struct lfs *fs, struct vnode *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;

38
sys/ufs/lfs/lfs_rfw.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_rfw.c,v 1.22 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_rfw.c,v 1.23 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@ -30,7 +30,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_rfw.c,v 1.22 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_rfw.c,v 1.23 2015/07/24 06:59:32 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_quota.h"
@ -184,7 +184,7 @@ update_meta(struct lfs *fs, ino_t ino, 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);

88
sys/ufs/lfs/lfs_segment.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_segment.c,v 1.242 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_segment.c,v 1.243 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@ -60,7 +60,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_segment.c,v 1.242 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_segment.c,v 1.243 2015/07/24 06:59:32 dholland Exp $");
#define _VFS_VNODE_PRIVATE /* XXX: check for VI_MARKER, this has to go */
@ -133,7 +133,7 @@ static void lfs_cluster_callback(struct 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,

14
sys/ufs/lfs/lfs_subr.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_subr.c,v 1.82 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_subr.c,v 1.83 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@ -60,7 +60,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_subr.c,v 1.82 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_subr.c,v 1.83 2015/07/24 06:59:32 dholland Exp $");
#include <sys/param.h>
#include <sys/systm.h>
@ -120,7 +120,7 @@ lfs_setup_resblks(struct lfs *fs)
* so we can't use the pool subsystem for them.
*/
for (i = 0, j = 0; j < LFS_N_SUMMARIES; j++, i++)
fs->lfs_resblk[i].size = fs->lfs_sumsize;
fs->lfs_resblk[i].size = lfs_sb_getsumsize(fs);
for (j = 0; j < LFS_N_SBLOCKS; j++, i++)
fs->lfs_resblk[i].size = LFS_SBPAD;
for (j = 0; j < LFS_N_IBLOCKS; j++, i++)
@ -144,7 +144,7 @@ lfs_setup_resblks(struct lfs *fs)
"lfsclpl", &pool_allocator_nointr, IPL_NONE);
pool_init(&fs->lfs_segpool, sizeof(struct segment), 0, 0, 0,
"lfssegpool", &pool_allocator_nointr, IPL_NONE);
maxbpp = ((fs->lfs_sumsize - SEGSUM_SIZE(fs)) / sizeof(int32_t) + 2);
maxbpp = ((lfs_sb_getsumsize(fs) - SEGSUM_SIZE(fs)) / sizeof(int32_t) + 2);
maxbpp = MIN(maxbpp, lfs_segsize(fs) / lfs_sb_getfsize(fs) + 2);
pool_init(&fs->lfs_bpppool, maxbpp * sizeof(struct buf *), 0, 0, 0,
"lfsbpppl", &pool_allocator_nointr, IPL_NONE);
@ -396,7 +396,7 @@ lfs_auto_segclean(struct lfs *fs)
* XXX - do we really need to do them all at once?
*/
waited = 0;
for (i = 0; i < fs->lfs_nseg; i++) {
for (i = 0; i < lfs_sb_getnseg(fs); i++) {
if ((fs->lfs_suflags[0][i] &
(SEGUSE_ACTIVE | SEGUSE_DIRTY | SEGUSE_EMPTY)) ==
(SEGUSE_DIRTY | SEGUSE_EMPTY) &&
@ -522,8 +522,8 @@ lfs_segunlock(struct lfs *fs)
/* If we *know* everything's on disk, write both sbs */
/* XXX should wait for this one */
if (sync)
lfs_writesuper(fs, fs->lfs_sboffs[fs->lfs_activesb]);
lfs_writesuper(fs, fs->lfs_sboffs[1 - fs->lfs_activesb]);
lfs_writesuper(fs, lfs_sb_getsboff(fs, fs->lfs_activesb));
lfs_writesuper(fs, lfs_sb_getsboff(fs, 1 - fs->lfs_activesb));
if (!(fs->lfs_ivnode->v_mount->mnt_iflag & IMNT_UNMOUNT)) {
lfs_auto_segclean(fs);
/* If sync, we can clean the remainder too */

14
sys/ufs/lfs/lfs_syscalls.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_syscalls.c,v 1.161 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_syscalls.c,v 1.162 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003, 2007, 2007, 2008
@ -61,7 +61,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_syscalls.c,v 1.161 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_syscalls.c,v 1.162 2015/07/24 06:59:32 dholland Exp $");
#ifndef LFS
# define LFS /* for prototypes in syscallargs.h */
@ -872,12 +872,12 @@ lfs_do_segclean(struct lfs *fs, unsigned 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;

116
sys/ufs/lfs/lfs_vfsops.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_vfsops.c,v 1.327 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_vfsops.c,v 1.328 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003, 2007, 2007
@ -61,7 +61,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_vfsops.c,v 1.327 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_vfsops.c,v 1.328 2015/07/24 06:59:32 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_lfs.h"
@ -605,8 +605,8 @@ lfs_mountroot(void)
mountlist_append(mp);
ump = VFSTOULFS(mp);
fs = ump->um_lfs;
memset(fs->lfs_fsmnt, 0, sizeof(fs->lfs_fsmnt));
(void)copystr(mp->mnt_stat.f_mntonname, fs->lfs_fsmnt, MNAMELEN - 1, 0);
memset(fs->lfs_dlfs.dlfs_fsmnt, 0, sizeof(fs->lfs_dlfs.dlfs_fsmnt));
(void)copystr(mp->mnt_stat.f_mntonname, fs->lfs_dlfs.dlfs_fsmnt, sizeof(fs->lfs_dlfs.dlfs_fsmnt), 0);
(void)lfs_statvfs(mp, &mp->mnt_stat);
vfs_unbusy(mp, false, NULL);
setrootfstime((time_t)lfs_sb_gettstamp(VFSTOULFS(mp)->um_lfs));
@ -795,10 +795,10 @@ lfs_mount(struct mount *mp, const char *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 */

12
sys/ufs/lfs/lfs_vnops.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: lfs_vnops.c,v 1.274 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: lfs_vnops.c,v 1.275 2015/07/24 06:59:32 dholland Exp $ */
/*-
* Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc.
@ -125,7 +125,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.274 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.275 2015/07/24 06:59:32 dholland Exp $");
#ifdef _KERNEL_OPT
#include "opt_compat_netbsd.h"
@ -1229,7 +1229,8 @@ lfs_wrapgo(struct lfs *fs, struct inode *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) {

8
sys/ufs/lfs/ulfs_inode.h
View File

@ -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

6
sys/ufs/lfs/ulfs_quota2.c
View File

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

14
sys/ufs/lfs/ulfs_readwrite.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: ulfs_readwrite.c,v 1.18 2015/07/24 06:56:42 dholland Exp $ */
/* $NetBSD: ulfs_readwrite.c,v 1.19 2015/07/24 06:59:32 dholland Exp $ */
/* from NetBSD: ufs_readwrite.c,v 1.105 2013/01/22 09:39:18 dholland Exp */
/*-
@ -33,7 +33,7 @@
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(1, "$NetBSD: ulfs_readwrite.c,v 1.18 2015/07/24 06:56:42 dholland Exp $");
__KERNEL_RCSID(1, "$NetBSD: ulfs_readwrite.c,v 1.19 2015/07/24 06:59:32 dholland Exp $");
#ifdef LFS_READWRITE
#define FS struct lfs
@ -337,7 +337,7 @@ WRITE(void *v)
goto out;
if (flags & B_SYNC) {
mutex_enter(vp->v_interlock);
VOP_PUTPAGES(vp, trunc_page(osize & fs->fs_bmask),
VOP_PUTPAGES(vp, trunc_page(osize & lfs_sb_getbmask(fs)),
round_page(eob),
PGO_CLEANIT | PGO_SYNCIO);
}
@ -443,7 +443,7 @@ WRITE(void *v)
}
if (error == 0 && ioflag & IO_SYNC) {
mutex_enter(vp->v_interlock);
error = VOP_PUTPAGES(vp, trunc_page(origoff & fs->fs_bmask),
error = VOP_PUTPAGES(vp, trunc_page(origoff & lfs_sb_getbmask(fs)),
round_page(lfs_blkroundup(fs, uio->uio_offset)),
PGO_CLEANIT | PGO_SYNCIO);
}
@ -523,7 +523,7 @@ BUFWR(struct vnode *vp, struct uio *uio, 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

40
usr.sbin/dumplfs/dumplfs.c
View File

@ -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 ");
}