Module Name: src
Committed By: dholland
Date: Wed Aug 12 18:26:27 UTC 2015
Modified Files:
src/libexec/lfs_cleanerd: lfs_cleanerd.c
src/sbin/fsck_lfs: lfs.c lfs_user.h pass6.c segwrite.c setup.c
src/sys/ufs/lfs: lfs.h lfs_accessors.h lfs_pages.c lfs_rfw.c
lfs_segment.c lfs_vfsops.c lfs_vnops.c
src/usr.sbin/dumplfs: dumplfs.c
Log Message:
Make 32-bit and 64-bit versions of SEGSUM.
Also fix some of the FINFO handling as it's closely entangled.
To generate a diff of this commit:
cvs rdiff -u -r1.47 -r1.48 src/libexec/lfs_cleanerd/lfs_cleanerd.c
cvs rdiff -u -r1.53 -r1.54 src/sbin/fsck_lfs/lfs.c
cvs rdiff -u -r1.7 -r1.8 src/sbin/fsck_lfs/lfs_user.h
cvs rdiff -u -r1.39 -r1.40 src/sbin/fsck_lfs/pass6.c
cvs rdiff -u -r1.38 -r1.39 src/sbin/fsck_lfs/segwrite.c
cvs rdiff -u -r1.52 -r1.53 src/sbin/fsck_lfs/setup.c
cvs rdiff -u -r1.176 -r1.177 src/sys/ufs/lfs/lfs.h
cvs rdiff -u -r1.10 -r1.11 src/sys/ufs/lfs/lfs_accessors.h
cvs rdiff -u -r1.6 -r1.7 src/sys/ufs/lfs/lfs_pages.c
cvs rdiff -u -r1.26 -r1.27 src/sys/ufs/lfs/lfs_rfw.c
cvs rdiff -u -r1.253 -r1.254 src/sys/ufs/lfs/lfs_segment.c
cvs rdiff -u -r1.337 -r1.338 src/sys/ufs/lfs/lfs_vfsops.c
cvs rdiff -u -r1.284 -r1.285 src/sys/ufs/lfs/lfs_vnops.c
cvs rdiff -u -r1.51 -r1.52 src/usr.sbin/dumplfs/dumplfs.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/libexec/lfs_cleanerd/lfs_cleanerd.c
diff -u src/libexec/lfs_cleanerd/lfs_cleanerd.c:1.47 src/libexec/lfs_cleanerd/lfs_cleanerd.c:1.48
--- src/libexec/lfs_cleanerd/lfs_cleanerd.c:1.47 Wed Aug 12 18:25:51 2015
+++ src/libexec/lfs_cleanerd/lfs_cleanerd.c Wed Aug 12 18:26:26 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_cleanerd.c,v 1.47 2015/08/12 18:25:51 dholland Exp $ */
+/* $NetBSD: lfs_cleanerd.c,v 1.48 2015/08/12 18:26:26 dholland Exp $ */
/*-
* Copyright (c) 2005 The NetBSD Foundation, Inc.
@@ -423,6 +423,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
struct ulfs1_dinode *dip;
u_int32_t ck, vers;
int fic, inoc, obic;
+ size_t sumstart;
int i;
char *cp;
@@ -438,22 +439,23 @@ parse_pseg(struct clfs *fs, daddr_t dadd
ssp = (SEGSUM *)cp;
/* XXX ondisk32 */
iaddrp = ((int32_t *)(cp + lfs_sb_getibsize(fs))) - 1;
- fip = (FINFO *)(cp + sizeof(SEGSUM));
+ fip = SEGSUM_FINFOBASE(fs, cp);
/*
* Check segment header magic and checksum
*/
- if (ssp->ss_magic != SS_MAGIC) {
+ if (lfs_ss_getmagic(fs, ssp) != SS_MAGIC) {
syslog(LOG_WARNING, "%s: sumsum magic number bad at 0x%jx:"
" read 0x%x, expected 0x%x", lfs_sb_getfsmnt(fs),
- (intmax_t)daddr, ssp->ss_magic, SS_MAGIC);
+ (intmax_t)daddr, lfs_ss_getmagic(fs, ssp), SS_MAGIC);
return 0x0;
}
- ck = cksum(&ssp->ss_datasum, lfs_sb_getsumsize(fs) - sizeof(ssp->ss_sumsum));
- if (ck != ssp->ss_sumsum) {
+ sumstart = lfs_ss_getsumstart(fs);
+ ck = cksum((char *)ssp + sumstart, lfs_sb_getsumsize(fs) - sumstart);
+ if (ck != lfs_ss_getsumsum(fs, ssp)) {
syslog(LOG_WARNING, "%s: sumsum checksum mismatch at 0x%jx:"
" read 0x%x, computed 0x%x", lfs_sb_getfsmnt(fs),
- (intmax_t)daddr, ssp->ss_sumsum, ck);
+ (intmax_t)daddr, lfs_ss_getsumsum(fs, ssp), ck);
return 0x0;
}
@@ -469,12 +471,12 @@ parse_pseg(struct clfs *fs, daddr_t dadd
* as we go.
*/
fic = inoc = 0;
- while (fic < ssp->ss_nfinfo || inoc < ssp->ss_ninos) {
+ while (fic < lfs_ss_getnfinfo(fs, ssp) || inoc < lfs_ss_getninos(fs, ssp)) {
/*
* We must have either a file block or an inode block.
* If we don't have either one, it's an error.
*/
- if (fic >= ssp->ss_nfinfo && *iaddrp != daddr) {
+ if (fic >= lfs_ss_getnfinfo(fs, ssp) && *iaddrp != daddr) {
syslog(LOG_WARNING, "%s: bad pseg at %jx (seg %d)",
lfs_sb_getfsmnt(fs), (intmax_t)odaddr, lfs_dtosn(fs, odaddr));
*bipp = bip;
@@ -484,7 +486,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
/*
* Note each inode from the inode blocks
*/
- if (inoc < ssp->ss_ninos && *iaddrp == daddr) {
+ if (inoc < lfs_ss_getninos(fs, ssp) && *iaddrp == daddr) {
cp = fd_ptrget(fs->clfs_devvp, daddr);
ck = lfs_cksum_part(cp, sizeof(u_int32_t), ck);
dip = (struct ulfs1_dinode *)cp;
@@ -519,7 +521,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
bip[*bic - 1].bi_inode = dip[i].di_inumber;
bip[*bic - 1].bi_lbn = LFS_UNUSED_LBN;
bip[*bic - 1].bi_daddr = daddr;
- bip[*bic - 1].bi_segcreate = ssp->ss_create;
+ bip[*bic - 1].bi_segcreate = lfs_ss_getcreate(fs, ssp);
bip[*bic - 1].bi_version = dip[i].di_gen;
bip[*bic - 1].bi_bp = &(dip[i]);
bip[*bic - 1].bi_size = LFS_DINODE1_SIZE;
@@ -533,7 +535,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
/*
* Note each file block from the finfo blocks
*/
- if (fic >= ssp->ss_nfinfo)
+ if (fic >= lfs_ss_getnfinfo(fs, ssp))
continue;
/* Count this finfo, whether or not we use it */
@@ -603,7 +605,7 @@ parse_pseg(struct clfs *fs, daddr_t dadd
bip[*bic + i].bi_inode = fip->fi_ino;
bip[*bic + i].bi_lbn = fip->fi_blocks[i];
bip[*bic + i].bi_daddr = daddr;
- bip[*bic + i].bi_segcreate = ssp->ss_create;
+ bip[*bic + i].bi_segcreate = lfs_ss_getcreate(fs, ssp);
bip[*bic + i].bi_version = fip->fi_version;
bip[*bic + i].bi_size = (i == fip->fi_nblocks - 1) ?
fip->fi_lastlength : lfs_sb_getbsize(fs);
@@ -617,15 +619,15 @@ parse_pseg(struct clfs *fs, daddr_t dadd
#endif
}
*bic += fip->fi_nblocks;
- fip = (FINFO *)(fip->fi_blocks + fip->fi_nblocks);
+ fip = NEXT_FINFO(fs, fip);
}
#ifndef REPAIR_ZERO_FINFO
- if (ssp->ss_datasum != ck) {
+ if (lfs_ss_getdatasum(fs, ssp) != ck) {
syslog(LOG_WARNING, "%s: data checksum bad at 0x%jx:"
" read 0x%x, computed 0x%x", lfs_sb_getfsmnt(fs),
(intmax_t)odaddr,
- ssp->ss_datasum, ck);
+ lfs_ss_getdatasum(fs, ssp), ck);
*bic = obic;
return 0x0;
}
Index: src/sbin/fsck_lfs/lfs.c
diff -u src/sbin/fsck_lfs/lfs.c:1.53 src/sbin/fsck_lfs/lfs.c:1.54
--- src/sbin/fsck_lfs/lfs.c:1.53 Wed Aug 12 18:25:52 2015
+++ src/sbin/fsck_lfs/lfs.c Wed Aug 12 18:26:26 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs.c,v 1.53 2015/08/12 18:25:52 dholland Exp $ */
+/* $NetBSD: lfs.c,v 1.54 2015/08/12 18:26:26 dholland Exp $ */
/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
* All rights reserved.
@@ -611,28 +611,29 @@ try_verify(struct lfs *osb, struct uvnod
/*
* Check for a valid segment summary belonging to our fs.
*/
- if (sp->ss_magic != SS_MAGIC ||
- sp->ss_ident != lfs_sb_getident(osb) ||
- sp->ss_serial < serial || /* XXX strengthen this */
- sp->ss_sumsum != cksum(&sp->ss_datasum, lfs_sb_getsumsize(osb) -
- sizeof(sp->ss_sumsum))) {
+ if (lfs_ss_getmagic(osb, sp) != SS_MAGIC ||
+ lfs_ss_getident(osb, sp) != lfs_sb_getident(osb) ||
+ lfs_ss_getserial(osb, sp) < serial || /* XXX strengthen this */
+ lfs_ss_getsumsum(osb, sp) !=
+ cksum((char *)sp + lfs_ss_getsumstart(osb),
+ lfs_sb_getsumsize(osb) - lfs_ss_getsumstart(osb))) {
brelse(bp, 0);
if (debug) {
- if (sp->ss_magic != SS_MAGIC)
+ if (lfs_ss_getmagic(osb, sp) != SS_MAGIC)
pwarn("pseg at 0x%jx: "
"wrong magic number\n",
(uintmax_t)daddr);
- else if (sp->ss_ident != lfs_sb_getident(osb))
+ else if (lfs_ss_getident(osb, sp) != 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_ss_getident(osb, sp),
(uintmax_t)lfs_sb_getident(osb));
- else if (sp->ss_serial >= serial)
+ else if (lfs_ss_getserial(osb, sp) >= serial)
pwarn("pseg at 0x%jx: "
"serial %d < %d\n",
(uintmax_t)daddr,
- (int)sp->ss_serial, (int)serial);
+ (int)lfs_ss_getserial(osb, sp), (int)serial);
else
pwarn("pseg at 0x%jx: "
"summary checksum wrong\n",
@@ -640,9 +641,9 @@ try_verify(struct lfs *osb, struct uvnod
}
break;
}
- if (debug && sp->ss_serial != serial)
+ if (debug && lfs_ss_getserial(osb, sp) != serial)
pwarn("warning, serial=%d ss_serial=%d\n",
- (int)serial, (int)sp->ss_serial);
+ (int)serial, (int)lfs_ss_getserial(osb, sp));
++serial;
bc = check_summary(osb, sp, daddr, debug, devvp, NULL);
if (bc == 0) {
@@ -651,14 +652,14 @@ try_verify(struct lfs *osb, struct uvnod
}
if (debug)
pwarn("summary good: 0x%x/%d\n", (uintmax_t)daddr,
- (int)sp->ss_serial);
+ (int)lfs_ss_getserial(osb, sp));
assert (bc > 0);
odaddr = daddr;
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, lfs_sb_getsumsize(osb) + lfs_sb_getbsize(osb)) - 1)) {
- daddr = sp->ss_next;
+ daddr = lfs_ss_getnext(osb, sp);
}
/*
@@ -668,9 +669,9 @@ try_verify(struct lfs *osb, struct uvnod
* to roll forward through them. Likewise, psegs written
* by a previous roll-forward attempt are not interesting.
*/
- if (sp->ss_flags & (SS_CLEAN | SS_RFW))
+ if (lfs_ss_getflags(osb, sp) & (SS_CLEAN | SS_RFW))
hitclean = 1;
- if (hitclean == 0 && (sp->ss_flags & SS_CONT) == 0)
+ if (hitclean == 0 && (lfs_ss_getflags(osb, sp) & SS_CONT) == 0)
nodirop_daddr = daddr;
brelse(bp, 0);
@@ -761,17 +762,17 @@ check_summary(struct lfs *fs, SEGSUM *sp
/* We've already checked the sumsum, just do the data bounds and sum */
/* Count the blocks. */
- nblocks = howmany(sp->ss_ninos, LFS_INOPB(fs));
+ nblocks = howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs));
bc = nblocks << (lfs_sb_getversion(fs) > 1 ? lfs_sb_getffshift(fs) : lfs_sb_getbshift(fs));
assert(bc >= 0);
- fp = (FINFO *) (sp + 1);
- for (i = 0; i < sp->ss_nfinfo; i++) {
+ fp = SEGSUM_FINFOBASE(fs, sp);
+ for (i = 0; i < lfs_ss_getnfinfo(fs, sp); i++) {
nblocks += fp->fi_nblocks;
bc += fp->fi_lastlength + ((fp->fi_nblocks - 1)
<< lfs_sb_getbshift(fs));
assert(bc >= 0);
- fp = (FINFO *) (fp->fi_blocks + fp->fi_nblocks);
+ fp = NEXT_FINFO(fs, fp);
if (((char *)fp) - (char *)sp > lfs_sb_getsumsize(fs))
return 0;
}
@@ -786,17 +787,18 @@ check_summary(struct lfs *fs, SEGSUM *sp
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++) {
- if (i >= sp->ss_nfinfo && *idp != daddr) {
+ i < lfs_ss_getnfinfo(fs, sp) || j < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)); i++) {
+ if (i >= lfs_ss_getnfinfo(fs, sp) && *idp != daddr) {
pwarn("Not enough inode blocks in pseg at 0x%" PRIx32
": found %d, wanted %d\n",
- pseg_addr, j, howmany(sp->ss_ninos, LFS_INOPB(fs)));
+ pseg_addr, j, howmany(lfs_ss_getninos(fs, sp),
+ LFS_INOPB(fs)));
if (debug)
pwarn("*idp=%x, daddr=%" PRIx32 "\n", *idp,
daddr);
break;
}
- while (j < howmany(sp->ss_ninos, LFS_INOPB(fs)) && *idp == daddr) {
+ while (j < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)) && *idp == daddr) {
bread(devvp, LFS_FSBTODB(fs, daddr), lfs_sb_getibsize(fs),
0, &bp);
datap[datac++] = ((u_int32_t *) (bp->b_data))[0];
@@ -806,7 +808,7 @@ check_summary(struct lfs *fs, SEGSUM *sp
daddr += lfs_btofsb(fs, lfs_sb_getibsize(fs));
--idp;
}
- if (i < sp->ss_nfinfo) {
+ if (i < lfs_ss_getnfinfo(fs, sp)) {
if (func)
func(daddr, fp);
for (k = 0; k < fp->fi_nblocks; k++) {
@@ -819,7 +821,7 @@ check_summary(struct lfs *fs, SEGSUM *sp
brelse(bp, 0);
daddr += lfs_btofsb(fs, len);
}
- fp = (FINFO *) (fp->fi_blocks + fp->fi_nblocks);
+ fp = NEXT_FINFO(fs, fp);
}
}
@@ -827,12 +829,13 @@ check_summary(struct lfs *fs, SEGSUM *sp
pwarn("Partial segment at 0x%jx expected %d blocks counted %d\n",
(intmax_t)pseg_addr, nblocks, datac);
}
+ /* XXX ondisk32 */
ccksum = cksum(datap, nblocks * sizeof(u_int32_t));
/* Check the data checksum */
- if (ccksum != sp->ss_datasum) {
+ if (ccksum != lfs_ss_getdatasum(fs, sp)) {
pwarn("Partial segment at 0x%jx data checksum"
" mismatch: given 0x%x, computed 0x%x\n",
- (uintmax_t)pseg_addr, sp->ss_datasum, ccksum);
+ (uintmax_t)pseg_addr, lfs_ss_getdatasum(fs, sp), ccksum);
free(datap);
return 0;
}
Index: src/sbin/fsck_lfs/lfs_user.h
diff -u src/sbin/fsck_lfs/lfs_user.h:1.7 src/sbin/fsck_lfs/lfs_user.h:1.8
--- src/sbin/fsck_lfs/lfs_user.h:1.7 Sun Jul 13 02:44:21 2014
+++ src/sbin/fsck_lfs/lfs_user.h Wed Aug 12 18:26:26 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_user.h,v 1.7 2014/07/13 02:44:21 dholland Exp $ */
+/* $NetBSD: lfs_user.h,v 1.8 2015/08/12 18:26:26 dholland Exp $ */
/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
* All rights reserved.
@@ -31,7 +31,8 @@
#include <stdarg.h>
struct lfs;
-struct segsum;
+/* XXX do these really need to be here? */
+union segsum;
struct finfo;
/*
@@ -85,7 +86,7 @@ int lfs_vop_bmap(struct uvnode *, daddr_
struct uvnode *lfs_raw_vget(struct lfs *, ino_t, int, ulfs_daddr_t);
struct lfs *lfs_init(int, daddr_t, daddr_t, int, int);
struct lfs *lfs_verify(struct lfs *, struct lfs *, struct uvnode *, int);
-int check_summary(struct lfs *, struct segsum *, ulfs_daddr_t, int, struct uvnode *, void (*)(ulfs_daddr_t, struct finfo *));
+int check_summary(struct lfs *, union segsum *, ulfs_daddr_t, int, struct uvnode *, void (*)(ulfs_daddr_t, struct finfo *));
ulfs_daddr_t try_verify(struct lfs *, struct uvnode *, ulfs_daddr_t, int);
struct ulfs1_dinode *lfs_ifind(struct lfs *, ino_t, struct ubuf *);
void call_panic(const char *, ...);
Index: src/sbin/fsck_lfs/pass6.c
diff -u src/sbin/fsck_lfs/pass6.c:1.39 src/sbin/fsck_lfs/pass6.c:1.40
--- src/sbin/fsck_lfs/pass6.c:1.39 Wed Aug 12 18:25:52 2015
+++ src/sbin/fsck_lfs/pass6.c Wed Aug 12 18:26:26 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: pass6.c,v 1.39 2015/08/12 18:25:52 dholland Exp $ */
+/* $NetBSD: pass6.c,v 1.40 2015/08/12 18:26:26 dholland Exp $ */
/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
@@ -618,8 +618,8 @@ pass6(void)
sp = (SEGSUM *)bp->b_data;
if (debug)
pwarn("sum at 0x%x: ninos=%d nfinfo=%d\n",
- (unsigned)daddr, (int)sp->ss_ninos,
- (int)sp->ss_nfinfo);
+ (unsigned)daddr, (int)lfs_ss_getninos(fs, sp),
+ (int)lfs_ss_getnfinfo(fs, sp));
/* We have verified that this is a good summary. */
LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), sbp);
@@ -636,16 +636,16 @@ pass6(void)
}
/* Find inodes, look at generation number. */
- if (sp->ss_ninos) {
+ if (lfs_ss_getninos(fs, sp)) {
LFS_SEGENTRY(sup, fs, lfs_dtosn(fs, daddr), sbp);
- sup->su_ninos += howmany(sp->ss_ninos, LFS_INOPB(fs));
+ sup->su_ninos += howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs));
VOP_BWRITE(sbp);
- lfs_sb_adddmeta(fs, lfs_btofsb(fs, howmany(sp->ss_ninos,
+ lfs_sb_adddmeta(fs, lfs_btofsb(fs, howmany(lfs_ss_getninos(fs, sp),
LFS_INOPB(fs)) *
lfs_sb_getibsize(fs)));
}
idaddrp = ((ulfs_daddr_t *)((char *)bp->b_data + lfs_sb_getsumsize(fs)));
- for (i = 0; i < howmany(sp->ss_ninos, LFS_INOPB(fs)); i++) {
+ for (i = 0; i < howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)); i++) {
ino_t *inums;
inums = ecalloc(LFS_INOPB(fs) + 1, sizeof(*inums));
@@ -697,7 +697,7 @@ pass6(void)
* loop.
*/
if (vp == NULL) {
- if (!(sp->ss_flags & SS_DIROP))
+ if (!(lfs_ss_getflags(fs, sp) & SS_DIROP))
pfatal("NEW FILE IN NON-DIROP PARTIAL SEGMENT");
else {
inums[j++] = dp->di_inumber;
@@ -712,7 +712,7 @@ pass6(void)
*/
if (vp && VTOI(vp)->i_ffs1_gen < dp->di_gen) {
remove_ino(vp, dp->di_inumber);
- if (!(sp->ss_flags & SS_DIROP))
+ if (!(lfs_ss_getflags(fs, sp) & SS_DIROP))
pfatal("NEW FILE VERSION IN NON-DIROP PARTIAL SEGMENT");
else {
inums[j++] = dp->di_inumber;
@@ -770,21 +770,21 @@ pass6(void)
bc = check_summary(fs, sp, daddr, debug, devvp, NULL);
if (bc == 0) {
pwarn("unexpected bad seg ptr at 0x%x with serial=%d\n",
- (int)daddr, (int)sp->ss_serial);
+ (int)daddr, (int)lfs_ss_getserial(fs, sp));
brelse(bp, 0);
break;
} else {
if (debug)
pwarn("good seg ptr at 0x%x with serial=%d\n",
- (int)daddr, (int)sp->ss_serial);
- lastserial = sp->ss_serial;
+ (int)daddr, (int)lfs_ss_getserial(fs, sp));
+ lastserial = lfs_ss_getserial(fs, sp);
}
odaddr = daddr;
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, lfs_sb_getsumsize(fs) + lfs_sb_getbsize(fs)) - 1)) {
- daddr = ((SEGSUM *)bp->b_data)->ss_next;
+ daddr = lfs_ss_getnext(fs, sp);
}
brelse(bp, 0);
}
@@ -845,7 +845,7 @@ pass6(void)
bc = check_summary(fs, sp, daddr, debug, devvp, pass6harvest);
if (bc == 0) {
pwarn("unexpected bad seg ptr [2] at 0x%x with serial=%d\n",
- (int)daddr, (int)sp->ss_serial);
+ (int)daddr, (int)lfs_ss_getserial(fs, sp));
brelse(bp, 0);
break;
}
@@ -856,7 +856,7 @@ pass6(void)
lfs_dtosn(fs, daddr) != lfs_dtosn(fs, daddr +
lfs_btofsb(fs, lfs_sb_getsumsize(fs) + lfs_sb_getbsize(fs)) - 1)) {
lfs_sb_subavail(fs, lfs_sntod(fs, lfs_dtosn(fs, daddr) + 1) - daddr);
- daddr = ((SEGSUM *)bp->b_data)->ss_next;
+ daddr = lfs_ss_getnext(fs, sp);
}
LFS_CLEANERINFO(cip, fs, cbp);
LFS_SYNC_CLEANERINFO(cip, fs, cbp, 0);
Index: src/sbin/fsck_lfs/segwrite.c
diff -u src/sbin/fsck_lfs/segwrite.c:1.38 src/sbin/fsck_lfs/segwrite.c:1.39
--- src/sbin/fsck_lfs/segwrite.c:1.38 Wed Aug 12 18:25:52 2015
+++ src/sbin/fsck_lfs/segwrite.c Wed Aug 12 18:26:27 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: segwrite.c,v 1.38 2015/08/12 18:25:52 dholland Exp $ */
+/* $NetBSD: segwrite.c,v 1.39 2015/08/12 18:26:27 dholland Exp $ */
/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
* All rights reserved.
@@ -152,6 +152,7 @@ lfs_segwrite(struct lfs * fs, int flags)
struct inode *ip;
struct segment *sp;
struct uvnode *vp;
+ SEGSUM *ssp;
int redo;
lfs_seglock(fs, flags | SEGM_CKP);
@@ -159,7 +160,8 @@ lfs_segwrite(struct lfs * fs, int flags)
lfs_writevnodes(fs, sp, VN_REG);
lfs_writevnodes(fs, sp, VN_DIROP);
- ((SEGSUM *) (sp->segsum))->ss_flags &= ~(SS_CONT);
+ ssp = (SEGSUM *)sp->segsum;
+ lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) & ~(SS_CONT));
do {
vp = fs->lfs_ivnode;
@@ -199,6 +201,7 @@ lfs_writefile(struct lfs * fs, struct se
struct finfo *fip;
struct inode *ip;
IFILE *ifp;
+ SEGSUM *ssp;
ip = VTOI(vp);
@@ -207,10 +210,13 @@ lfs_writefile(struct lfs * fs, struct se
(void) lfs_writeseg(fs, sp);
sp->sum_bytes_left -= FINFOSIZE;
- ++((SEGSUM *) (sp->segsum))->ss_nfinfo;
+ ssp = (SEGSUM *)sp->segsum;
+ lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) + 1);
- if (vp->v_uflag & VU_DIROP)
- ((SEGSUM *) (sp->segsum))->ss_flags |= (SS_DIROP | SS_CONT);
+ if (vp->v_uflag & VU_DIROP) {
+ lfs_ss_setflags(fs, ssp,
+ lfs_ss_getflags(fs, ssp) | (SS_DIROP | SS_CONT));
+ }
fip = sp->fip;
fip->fi_nblocks = 0;
@@ -226,12 +232,11 @@ lfs_writefile(struct lfs * fs, struct se
fip = sp->fip;
if (fip->fi_nblocks != 0) {
- sp->fip = (FINFO *) ((caddr_t) fip + FINFOSIZE +
- sizeof(ulfs_daddr_t) * (fip->fi_nblocks));
+ sp->fip = NEXT_FINFO(fs, fip);
sp->start_lbp = &sp->fip->fi_blocks[0];
} else {
sp->sum_bytes_left += FINFOSIZE;
- --((SEGSUM *) (sp->segsum))->ss_nfinfo;
+ lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) - 1);
}
}
@@ -242,6 +247,7 @@ lfs_writeinode(struct lfs * fs, struct s
struct ulfs1_dinode *cdp;
IFILE *ifp;
SEGUSE *sup;
+ SEGSUM *ssp;
daddr_t daddr;
ino_t ino;
int i, ndx, fsb = 0;
@@ -315,7 +321,8 @@ lfs_writeinode(struct lfs * fs, struct s
brelse(bp, 0);
}
/* Increment inode count in segment summary block. */
- ++((SEGSUM *) (sp->segsum))->ss_ninos;
+ ssp = (SEGSUM *)sp->segsum;
+ lfs_ss_setninos(fs, ssp, lfs_ss_getninos(fs, ssp) + 1);
/* If this page is full, set flag to allocate a new page. */
if (++sp->ninodes % LFS_INOPB(fs) == 0)
@@ -359,6 +366,7 @@ int
lfs_gatherblock(struct segment * sp, struct ubuf * bp)
{
struct lfs *fs;
+ SEGSUM *ssp;
int version;
int j, blksinblk;
@@ -378,7 +386,8 @@ lfs_gatherblock(struct segment * sp, str
sp->fip->fi_version = version;
sp->fip->fi_ino = VTOI(sp->vp)->i_number;
/* Add the current file to the segment summary. */
- ++((SEGSUM *) (sp->segsum))->ss_nfinfo;
+ ssp = (SEGSUM *)sp->segsum;
+ lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) + 1);
sp->sum_bytes_left -= FINFOSIZE;
return 1;
@@ -664,12 +673,13 @@ lfs_initseg(struct lfs * fs)
/* Set point to SEGSUM, initialize it. */
ssp = sp->segsum;
- ssp->ss_next = lfs_sb_getnextseg(fs);
- ssp->ss_nfinfo = ssp->ss_ninos = 0;
- ssp->ss_magic = SS_MAGIC;
+ lfs_ss_setnext(fs, ssp, lfs_sb_getnextseg(fs));
+ lfs_ss_setnfinfo(fs, ssp, 0);
+ lfs_ss_setninos(fs, ssp, 0);
+ lfs_ss_setmagic(fs, ssp, SS_MAGIC);
/* Set pointer to first FINFO, initialize it. */
- sp->fip = (struct finfo *) ((caddr_t) sp->segsum + SEGSUM_SIZE(fs));
+ sp->fip = SEGSUM_FINFOBASE(fs, ssp);
sp->fip->fi_nblocks = 0;
sp->start_lbp = &sp->fip->fi_blocks[0];
sp->fip->fi_lastlength = 0;
@@ -735,6 +745,7 @@ lfs_writeseg(struct lfs * fs, struct seg
int do_again, nblocks, byteoffset;
size_t el_size;
u_short ninos;
+ size_t sumstart;
struct uvnode *devvp;
/*
@@ -765,10 +776,10 @@ lfs_writeseg(struct lfs * fs, struct seg
}
ssp = (SEGSUM *) sp->segsum;
- ssp->ss_flags |= SS_RFW;
+ lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_RFW);
- ninos = (ssp->ss_ninos + LFS_INOPB(fs) - 1) / LFS_INOPB(fs);
- sup->su_nbytes += ssp->ss_ninos * LFS_DINODE1_SIZE;
+ ninos = (lfs_ss_getninos(fs, ssp) + LFS_INOPB(fs) - 1) / LFS_INOPB(fs);
+ sup->su_nbytes += lfs_ss_getninos(fs, ssp) * LFS_DINODE1_SIZE;
if (lfs_sb_getversion(fs) == 1)
sup->su_olastmod = write_time;
@@ -805,20 +816,21 @@ lfs_writeseg(struct lfs * fs, struct seg
(*bpp)->b_flags |= B_BUSY;
}
if (lfs_sb_getversion(fs) == 1)
- ssp->ss_ocreate = write_time;
+ lfs_ss_setocreate(fs, ssp, write_time);
else {
- ssp->ss_create = write_time;
+ lfs_ss_setcreate(fs, ssp, write_time);
lfs_sb_addserial(fs, 1);
- ssp->ss_serial = lfs_sb_getserial(fs);
- ssp->ss_ident = lfs_sb_getident(fs);
+ lfs_ss_setserial(fs, ssp, lfs_sb_getserial(fs));
+ lfs_ss_setident(fs, ssp, lfs_sb_getident(fs));
}
/* Set the summary block busy too */
bremfree(*(sp->bpp));
(*(sp->bpp))->b_flags |= B_BUSY;
- ssp->ss_datasum = cksum(datap, (nblocks - 1) * el_size);
- ssp->ss_sumsum =
- cksum(&ssp->ss_datasum, lfs_sb_getsumsize(fs) - sizeof(ssp->ss_sumsum));
+ lfs_ss_setdatasum(fs, ssp, cksum(datap, (nblocks - 1) * el_size));
+ sumstart = lfs_ss_getsumstart(fs);
+ lfs_ss_setsumsum(fs, ssp,
+ cksum((char *)ssp + sumstart, lfs_sb_getsumsize(fs) - sumstart));
free(datap);
datap = dp = NULL;
lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
Index: src/sbin/fsck_lfs/setup.c
diff -u src/sbin/fsck_lfs/setup.c:1.52 src/sbin/fsck_lfs/setup.c:1.53
--- src/sbin/fsck_lfs/setup.c:1.52 Sun Aug 2 18:14:16 2015
+++ src/sbin/fsck_lfs/setup.c Wed Aug 12 18:26:27 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: setup.c,v 1.52 2015/08/02 18:14:16 dholland Exp $ */
+/* $NetBSD: setup.c,v 1.53 2015/08/12 18:26:27 dholland Exp $ */
/*-
* Copyright (c) 2003 The NetBSD Foundation, Inc.
@@ -174,6 +174,7 @@ setup(const char *dev)
int i, isdirty;
long sn, curseg;
SEGUSE *sup;
+ size_t sumstart;
havesb = 0;
doskipclean = skipclean;
@@ -261,28 +262,29 @@ setup(const char *dev)
lfs_sb_getsumsize(fs),
0, &bp);
sp = (SEGSUM *)bp->b_data;
- if (sp->ss_sumsum != cksum(&sp->ss_datasum,
- lfs_sb_getsumsize(fs) -
- sizeof(sp->ss_sumsum))) {
+ sumstart = lfs_ss_getsumstart(fs);
+ if (lfs_ss_getsumsum(fs, sp) !=
+ cksum((char *)sp + sumstart,
+ lfs_sb_getsumsize(fs) - sumstart)) {
brelse(bp, 0);
if (debug)
printf("bad cksum at %jx\n",
(uintmax_t)tdaddr);
break;
}
- fp = (FINFO *)(sp + 1);
- bc = howmany(sp->ss_ninos, LFS_INOPB(fs)) <<
+ fp = SEGSUM_FINFOBASE(fs, sp);
+ bc = howmany(lfs_ss_getninos(fs, sp), LFS_INOPB(fs)) <<
(lfs_sb_getversion(fs) > 1 ? lfs_sb_getffshift(fs) :
lfs_sb_getbshift(fs));
- for (i = 0; i < sp->ss_nfinfo; i++) {
+ for (i = 0; i < lfs_ss_getnfinfo(fs, sp); i++) {
bc += fp->fi_lastlength + ((fp->fi_nblocks - 1)
<< lfs_sb_getbshift(fs));
- fp = (FINFO *)(fp->fi_blocks + fp->fi_nblocks);
+ fp = NEXT_FINFO(fs, fp);
}
tdaddr += lfs_btofsb(fs, bc) + 1;
lfs_sb_setoffset(fs, tdaddr);
- lfs_sb_setserial(fs, sp->ss_serial + 1);
+ lfs_sb_setserial(fs, lfs_ss_getserial(fs, sp) + 1);
brelse(bp, 0);
}
Index: src/sys/ufs/lfs/lfs.h
diff -u src/sys/ufs/lfs/lfs.h:1.176 src/sys/ufs/lfs/lfs.h:1.177
--- src/sys/ufs/lfs/lfs.h:1.176 Wed Aug 12 18:25:52 2015
+++ src/sys/ufs/lfs/lfs.h Wed Aug 12 18:26:27 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs.h,v 1.176 2015/08/12 18:25:52 dholland Exp $ */
+/* $NetBSD: lfs.h,v 1.177 2015/08/12 18:26:27 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 */
@@ -148,6 +148,10 @@
#ifndef _UFS_LFS_LFS_H_
#define _UFS_LFS_LFS_H_
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <stddef.h> /* for offsetof */
+#endif
+
#include <sys/rwlock.h>
#include <sys/mutex.h>
#include <sys/queue.h>
@@ -571,35 +575,38 @@ typedef union _cleanerinfo {
/*
* On-disk segment summary information
*/
+
+/* magic value for ss_magic */
+#define SS_MAGIC 0x061561
+
+/* flags for ss_flags */
+#define SS_DIROP 0x01 /* segment begins a dirop */
+#define SS_CONT 0x02 /* more partials to finish this write*/
+#define SS_CLEAN 0x04 /* written by the cleaner */
+#define SS_RFW 0x08 /* written by the roll-forward agent */
+#define SS_RECLAIM 0x10 /* written by the roll-forward agent */
+
typedef struct segsum_v1 SEGSUM_V1;
struct segsum_v1 {
u_int32_t ss_sumsum; /* 0: check sum of summary block */
u_int32_t ss_datasum; /* 4: check sum of data */
u_int32_t ss_magic; /* 8: segment summary magic number */
-#define SS_MAGIC 0x061561
int32_t ss_next; /* 12: next segment */
u_int32_t ss_create; /* 16: creation time stamp */
u_int16_t ss_nfinfo; /* 20: number of file info structures */
u_int16_t ss_ninos; /* 22: number of inodes in summary */
-
-#define SS_DIROP 0x01 /* segment begins a dirop */
-#define SS_CONT 0x02 /* more partials to finish this write*/
-#define SS_CLEAN 0x04 /* written by the cleaner */
-#define SS_RFW 0x08 /* written by the roll-forward agent */
-#define SS_RECLAIM 0x10 /* written by the roll-forward agent */
u_int16_t ss_flags; /* 24: used for directory operations */
u_int16_t ss_pad; /* 26: extra space */
/* FINFO's and inode daddr's... */
};
-typedef struct segsum SEGSUM;
-struct segsum {
+typedef struct segsum32 SEGSUM32;
+struct segsum32 {
u_int32_t ss_sumsum; /* 0: check sum of summary block */
u_int32_t ss_datasum; /* 4: check sum of data */
u_int32_t ss_magic; /* 8: segment summary magic number */
int32_t ss_next; /* 12: next segment (disk address) */
u_int32_t ss_ident; /* 16: roll-forward fsid */
-#define ss_ocreate ss_ident /* ident is where create was in v1 */
u_int16_t ss_nfinfo; /* 20: number of file info structures */
u_int16_t ss_ninos; /* 22: number of inodes in summary */
u_int16_t ss_flags; /* 24: used for directory operations */
@@ -610,6 +617,30 @@ struct segsum {
/* FINFO's and inode daddr's... */
};
+typedef struct segsum64 SEGSUM64;
+struct segsum64 {
+ u_int32_t ss_sumsum; /* 0: check sum of summary block */
+ u_int32_t ss_datasum; /* 4: check sum of data */
+ u_int32_t ss_magic; /* 8: segment summary magic number */
+ u_int32_t ss_ident; /* 12: roll-forward fsid */
+ int64_t ss_next; /* 16: next segment (disk address) */
+ u_int16_t ss_nfinfo; /* 24: number of file info structures */
+ u_int16_t ss_ninos; /* 26: number of inodes in summary */
+ u_int16_t ss_flags; /* 28: used for directory operations */
+ u_int8_t ss_pad[2]; /* 30: extra space */
+ u_int64_t ss_reclino; /* 32: inode being reclaimed */
+ u_int64_t ss_serial; /* 40: serial number */
+ u_int64_t ss_create; /* 48: time stamp */
+ /* FINFO's and inode daddr's... */
+};
+
+typedef union segsum SEGSUM;
+union segsum {
+ struct segsum64 u_64;
+ struct segsum32 u_32;
+ struct segsum_v1 u_v1;
+};
+
/*
* On-disk super block.
Index: src/sys/ufs/lfs/lfs_accessors.h
diff -u src/sys/ufs/lfs/lfs_accessors.h:1.10 src/sys/ufs/lfs/lfs_accessors.h:1.11
--- src/sys/ufs/lfs/lfs_accessors.h:1.10 Wed Aug 12 18:25:52 2015
+++ src/sys/ufs/lfs/lfs_accessors.h Wed Aug 12 18:26:27 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_accessors.h,v 1.10 2015/08/12 18:25:52 dholland Exp $ */
+/* $NetBSD: lfs_accessors.h,v 1.11 2015/08/12 18:26:27 dholland Exp $ */
/* from NetBSD: lfs.h,v 1.165 2015/07/24 06:59:32 dholland Exp */
/* from NetBSD: dinode.h,v 1.22 2013/01/22 09:39:18 dholland Exp */
@@ -145,6 +145,11 @@
#ifndef _UFS_LFS_LFS_ACCESSORS_H_
#define _UFS_LFS_LFS_ACCESSORS_H_
+#if !defined(_KERNEL) && !defined(_STANDALONE)
+#include <assert.h>
+#define KASSERT assert
+#endif
+
/*
* STRUCT_LFS is used by the libsa code to get accessors that work
* with struct salfs instead of struct lfs, and by the cleaner to
@@ -273,6 +278,21 @@
} while (0)
/*
+ * FINFO (file info) entries.
+ */
+
+/* Size of an on-disk block pointer, e.g. in an indirect block. */
+/* XXX: move to a more suitable location in this file */
+#define LFS_BLKPTRSIZE(fs) ((fs)->lfs_is64 ? sizeof(int64_t) : sizeof(int32_t))
+
+/* Full size of the provided FINFO record, including its block pointers. */
+#define FINFO_FULLSIZE(fs, fip) \
+ (FINFOSIZE + (fip)->fi_nblocks * LFS_BLKPTRSIZE(fs))
+
+#define NEXT_FINFO(fs, fip) \
+ ((FINFO *)((char *)(fip) + FINFO_FULLSIZE(fs, fip)))
+
+/*
* Index file inode entries.
*/
@@ -464,7 +484,100 @@ lfs_ci_shiftdirtytoclean(STRUCT_LFS *fs,
* On-disk segment summary information
*/
-#define SEGSUM_SIZE(fs) (lfs_sb_getversion(fs) == 1 ? sizeof(SEGSUM_V1) : sizeof(SEGSUM))
+#define SEGSUM_SIZE(fs) \
+ (fs->lfs_is64 ? sizeof(SEGSUM64) : \
+ lfs_sb_getversion(fs) > 1 ? sizeof(SEGSUM32) : sizeof(SEGSUM_V1))
+
+/*
+ * The SEGSUM structure is followed by FINFO structures. Get the pointer
+ * to the first FINFO.
+ *
+ * XXX this can't be a macro yet; this file needs to be resorted.
+ */
+#if 0
+static __unused inline FINFO *
+segsum_finfobase(STRUCT_LFS *fs, SEGSUM *ssp)
+{
+ return (FINFO *)((char *)ssp) + SEGSUM_SIZE(fs);
+}
+#else
+#define SEGSUM_FINFOBASE(fs, ssp) \
+ ((FINFO *)((char *)(ssp)) + SEGSUM_SIZE(fs));
+#endif
+
+#define LFS_DEF_SS_ACCESSOR(type, type32, field) \
+ static __unused inline type \
+ lfs_ss_get##field(STRUCT_LFS *fs, SEGSUM *ssp) \
+ { \
+ if (fs->lfs_is64) { \
+ return ssp->u_64.ss_##field; \
+ } else { \
+ return ssp->u_32.ss_##field; \
+ } \
+ } \
+ static __unused inline void \
+ lfs_ss_set##field(STRUCT_LFS *fs, SEGSUM *ssp, type val) \
+ { \
+ if (fs->lfs_is64) { \
+ type *p = &ssp->u_64.ss_##field; \
+ (void)p; \
+ ssp->u_64.ss_##field = val; \
+ } else { \
+ type32 *p = &ssp->u_32.ss_##field; \
+ (void)p; \
+ ssp->u_32.ss_##field = val; \
+ } \
+ } \
+
+LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, sumsum);
+LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, datasum);
+LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, magic);
+LFS_DEF_SS_ACCESSOR(uint32_t, uint32_t, ident);
+LFS_DEF_SS_ACCESSOR(int64_t, int32_t, next);
+LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, nfinfo);
+LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, ninos);
+LFS_DEF_SS_ACCESSOR(uint16_t, uint16_t, flags);
+LFS_DEF_SS_ACCESSOR(uint64_t, uint32_t, reclino);
+LFS_DEF_SS_ACCESSOR(uint64_t, uint64_t, serial);
+LFS_DEF_SS_ACCESSOR(uint64_t, uint64_t, create);
+
+static __unused inline size_t
+lfs_ss_getsumstart(STRUCT_LFS *fs)
+{
+ /* These are actually all the same. */
+ if (fs->lfs_is64) {
+ return offsetof(SEGSUM64, ss_datasum);
+ } else /* if (lfs_sb_getversion(fs) > 1) */ {
+ return offsetof(SEGSUM32, ss_datasum);
+ } /* else {
+ return offsetof(SEGSUM_V1, ss_datasum);
+ } */
+ /*
+ * XXX ^^^ until this file is resorted lfs_sb_getversion isn't
+ * defined yet.
+ */
+}
+
+static __unused inline uint32_t
+lfs_ss_getocreate(STRUCT_LFS *fs, SEGSUM *ssp)
+{
+ KASSERT(fs->lfs_is64 == 0);
+ /* XXX need to resort this file before we can do this */
+ //KASSERT(lfs_sb_getversion(fs) == 1);
+
+ return ssp->u_v1.ss_create;
+}
+
+static __unused inline void
+lfs_ss_setocreate(STRUCT_LFS *fs, SEGSUM *ssp, uint32_t val)
+{
+ KASSERT(fs->lfs_is64 == 0);
+ /* XXX need to resort this file before we can do this */
+ //KASSERT(lfs_sb_getversion(fs) == 1);
+
+ ssp->u_v1.ss_create = val;
+}
+
/*
* Super block.
Index: src/sys/ufs/lfs/lfs_pages.c
diff -u src/sys/ufs/lfs/lfs_pages.c:1.6 src/sys/ufs/lfs/lfs_pages.c:1.7
--- src/sys/ufs/lfs/lfs_pages.c:1.6 Sun Aug 2 18:10:08 2015
+++ src/sys/ufs/lfs/lfs_pages.c Wed Aug 12 18:26:27 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_pages.c,v 1.6 2015/08/02 18:10:08 dholland Exp $ */
+/* $NetBSD: lfs_pages.c,v 1.7 2015/08/12 18:26:27 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.6 2015/08/02 18:10:08 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_pages.c,v 1.7 2015/08/12 18:26:27 dholland Exp $");
#ifdef _KERNEL_OPT
#include "opt_compat_netbsd.h"
@@ -743,8 +743,12 @@ lfs_putpages(void *v)
* Ensure that the partial segment is marked SS_DIROP if this
* vnode is a DIROP.
*/
- if (!seglocked && vp->v_uflag & VU_DIROP)
- ((SEGSUM *)(sp->segsum))->ss_flags |= (SS_DIROP|SS_CONT);
+ if (!seglocked && vp->v_uflag & VU_DIROP) {
+ SEGSUM *ssp = sp->segsum;
+
+ lfs_ss_setflags(fs, ssp,
+ lfs_ss_getflags(fs, ssp) | (SS_DIROP|SS_CONT));
+ }
/*
* Loop over genfs_putpages until all pages are gathered.
Index: src/sys/ufs/lfs/lfs_rfw.c
diff -u src/sys/ufs/lfs/lfs_rfw.c:1.26 src/sys/ufs/lfs/lfs_rfw.c:1.27
--- src/sys/ufs/lfs/lfs_rfw.c:1.26 Wed Aug 12 18:25:52 2015
+++ src/sys/ufs/lfs/lfs_rfw.c Wed Aug 12 18:26:27 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_rfw.c,v 1.26 2015/08/12 18:25:52 dholland Exp $ */
+/* $NetBSD: lfs_rfw.c,v 1.27 2015/08/12 18:26:27 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.26 2015/08/12 18:25:52 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_rfw.c,v 1.27 2015/08/12 18:26:27 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_quota.h"
@@ -355,6 +355,7 @@ check_segsum(struct lfs *fs, daddr_t off
FINFO *fip;
SEGUSE *sup;
size_t size;
+ uint32_t datasum, foundsum;
devvp = VTOI(fs->lfs_ivnode)->i_devvp;
/*
@@ -377,57 +378,60 @@ check_segsum(struct lfs *fs, daddr_t off
/* Check summary checksum */
ssp = (SEGSUM *)bp->b_data;
if (flags & CHECK_CKSUM) {
- if (ssp->ss_sumsum != cksum(&ssp->ss_datasum,
- lfs_sb_getsumsize(fs) -
- sizeof(ssp->ss_sumsum))) {
+ size_t sumstart;
+
+ sumstart = lfs_ss_getsumstart(fs);
+ if (lfs_ss_getsumsum(fs, ssp) !=
+ cksum((char *)ssp + sumstart,
+ lfs_sb_getsumsize(fs) - sumstart)) {
DLOG((DLOG_RF, "Sumsum error at 0x%" PRIx64 "\n", offset));
offset = -1;
goto err1;
}
- if (ssp->ss_nfinfo == 0 && ssp->ss_ninos == 0) {
+ if (lfs_ss_getnfinfo(fs, ssp) == 0 &&
+ lfs_ss_getninos(fs, ssp) == 0) {
DLOG((DLOG_RF, "Empty pseg at 0x%" PRIx64 "\n", offset));
offset = -1;
goto err1;
}
- if (ssp->ss_create < lfs_sb_gettstamp(fs)) {
+ if (lfs_ss_getcreate(fs, ssp) < lfs_sb_gettstamp(fs)) {
DLOG((DLOG_RF, "Old data at 0x%" PRIx64 "\n", offset));
offset = -1;
goto err1;
}
}
if (lfs_sb_getversion(fs) > 1) {
- if (ssp->ss_serial != nextserial) {
+ if (lfs_ss_getserial(fs, ssp) != nextserial) {
DLOG((DLOG_RF, "Unexpected serial number at 0x%" PRIx64
"\n", offset));
offset = -1;
goto err1;
}
- if (ssp->ss_ident != lfs_sb_getident(fs)) {
+ if (lfs_ss_getident(fs, ssp) != lfs_sb_getident(fs)) {
DLOG((DLOG_RF, "Incorrect fsid (0x%x vs 0x%x) at 0x%"
- PRIx64 "\n", ssp->ss_ident, lfs_sb_getident(fs), offset));
+ PRIx64 "\n", lfs_ss_getident(fs, ssp),
+ lfs_sb_getident(fs), offset));
offset = -1;
goto err1;
}
}
if (pseg_flags)
- *pseg_flags = ssp->ss_flags;
+ *pseg_flags = lfs_ss_getflags(fs, ssp);
oldoffset = offset;
offset += lfs_btofsb(fs, lfs_sb_getsumsize(fs));
- ninos = howmany(ssp->ss_ninos, LFS_INOPB(fs));
+ ninos = howmany(lfs_ss_getninos(fs, ssp), LFS_INOPB(fs));
/* XXX ondisk32 */
iaddr = (int32_t *)((char*)bp->b_data + lfs_sb_getsumsize(fs) - sizeof(int32_t));
if (flags & CHECK_CKSUM) {
/* Count blocks */
nblocks = 0;
- fip = (FINFO *)((char*)bp->b_data + SEGSUM_SIZE(fs));
- for (i = 0; i < ssp->ss_nfinfo; ++i) {
+ fip = SEGSUM_FINFOBASE(fs, (SEGSUM *)bp->b_data);
+ for (i = 0; i < lfs_ss_getnfinfo(fs, ssp); ++i) {
nblocks += fip->fi_nblocks;
if (fip->fi_nblocks <= 0)
break;
- /* XXX ondisk32 */
- fip = (FINFO *)(((char *)fip) + FINFOSIZE +
- (fip->fi_nblocks * sizeof(int32_t)));
+ fip = NEXT_FINFO(fs, fip);
}
nblocks += ninos;
/* Create the sum array */
@@ -436,8 +440,8 @@ check_segsum(struct lfs *fs, daddr_t off
}
/* Handle individual blocks */
- fip = (FINFO *)((char*)bp->b_data + SEGSUM_SIZE(fs));
- for (i = 0; i < ssp->ss_nfinfo || ninos; ++i) {
+ fip = SEGSUM_FINFOBASE(fs, (SEGSUM *)bp->b_data);
+ for (i = 0; i < lfs_ss_getnfinfo(fs, ssp) || ninos; ++i) {
/* Inode block? */
if (ninos && *iaddr == offset) {
if (flags & CHECK_CKSUM) {
@@ -487,18 +491,15 @@ check_segsum(struct lfs *fs, daddr_t off
}
offset += lfs_btofsb(fs, size);
}
- /* XXX ondisk32 */
- fip = (FINFO *)(((char *)fip) + FINFOSIZE
- + fip->fi_nblocks * sizeof(int32_t));
+ fip = NEXT_FINFO(fs, fip);
}
/* Checksum the array, compare */
- if ((flags & CHECK_CKSUM) &&
- ssp->ss_datasum != cksum(datap, nblocks * sizeof(u_long)))
- {
+ datasum = lfs_ss_getdatasum(fs, ssp);
+ foundsum = cksum(datap, nblocks * sizeof(u_long));
+ if ((flags & CHECK_CKSUM) && datasum != foundsum) {
DLOG((DLOG_RF, "Datasum error at 0x%" PRIx64
" (wanted %x got %x)\n",
- offset, ssp->ss_datasum, cksum(datap, nblocks *
- sizeof(u_long))));
+ offset, datasum, foundsum));
offset = -1;
goto err2;
}
@@ -506,11 +507,11 @@ check_segsum(struct lfs *fs, daddr_t off
/* If we're at the end of the segment, move to the next */
if (lfs_dtosn(fs, offset + lfs_btofsb(fs, lfs_sb_getsumsize(fs) + lfs_sb_getbsize(fs))) !=
lfs_dtosn(fs, offset)) {
- if (lfs_dtosn(fs, offset) == lfs_dtosn(fs, ssp->ss_next)) {
+ if (lfs_dtosn(fs, offset) == lfs_dtosn(fs, lfs_ss_getnext(fs, ssp))) {
offset = -1;
goto err2;
}
- offset = ssp->ss_next;
+ offset = lfs_ss_getnext(fs, ssp);
DLOG((DLOG_RF, "LFS roll forward: moving to offset 0x%" PRIx64
" -> segment %d\n", offset, lfs_dtosn(fs,offset)));
}
Index: src/sys/ufs/lfs/lfs_segment.c
diff -u src/sys/ufs/lfs/lfs_segment.c:1.253 src/sys/ufs/lfs/lfs_segment.c:1.254
--- src/sys/ufs/lfs/lfs_segment.c:1.253 Wed Aug 12 18:25:52 2015
+++ src/sys/ufs/lfs/lfs_segment.c Wed Aug 12 18:26:27 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_segment.c,v 1.253 2015/08/12 18:25:52 dholland Exp $ */
+/* $NetBSD: lfs_segment.c,v 1.254 2015/08/12 18:26:27 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.253 2015/08/12 18:25:52 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_segment.c,v 1.254 2015/08/12 18:26:27 dholland Exp $");
#define _VFS_VNODE_PRIVATE /* XXX: check for VI_MARKER, this has to go */
@@ -622,6 +622,7 @@ lfs_segwrite(struct mount *mp, int flags
int writer_set = 0;
int dirty;
int redo;
+ SEGSUM *ssp;
int um_error;
fs = VFSTOULFS(mp)->um_lfs;
@@ -678,7 +679,9 @@ lfs_segwrite(struct mount *mp, int flags
um_error = error;
/* In case writevnodes errored out */
lfs_flush_dirops(fs);
- ((SEGSUM *)(sp->segsum))->ss_flags &= ~(SS_CONT);
+ ssp = (SEGSUM *)(sp->segsum);
+ lfs_ss_setflags(fs, ssp,
+ lfs_ss_getflags(fs, ssp) & ~(SS_CONT));
lfs_finalize_fs_seguse(fs);
}
if (do_ckp && um_error) {
@@ -847,6 +850,7 @@ lfs_writefile(struct lfs *fs, struct seg
{
struct inode *ip;
int i, frag;
+ SEGSUM *ssp;
int error;
ASSERT_SEGLOCK(fs);
@@ -855,8 +859,11 @@ lfs_writefile(struct lfs *fs, struct seg
lfs_acquire_finfo(fs, ip->i_number, ip->i_gen);
- if (vp->v_uflag & VU_DIROP)
- ((SEGSUM *)(sp->segsum))->ss_flags |= (SS_DIROP|SS_CONT);
+ if (vp->v_uflag & VU_DIROP) {
+ ssp = (SEGSUM *)sp->segsum;
+ lfs_ss_setflags(fs, ssp,
+ lfs_ss_getflags(fs, ssp) | (SS_DIROP|SS_CONT));
+ }
if (sp->seg_flags & SEGM_CLEAN) {
lfs_gather(fs, sp, vp, lfs_match_fake);
@@ -1051,6 +1058,7 @@ lfs_writeinode(struct lfs *fs, struct se
int redo_ifile = 0;
int gotblk = 0;
int count;
+ SEGSUM *ssp;
ASSERT_SEGLOCK(fs);
if (!(ip->i_flag & IN_ALLMOD) && !(vp->v_uflag & VU_DIROP))
@@ -1133,8 +1141,11 @@ lfs_writeinode(struct lfs *fs, struct se
}
/* Check VU_DIROP in case there is a new file with no data blocks */
- if (vp->v_uflag & VU_DIROP)
- ((SEGSUM *)(sp->segsum))->ss_flags |= (SS_DIROP|SS_CONT);
+ if (vp->v_uflag & VU_DIROP) {
+ ssp = (SEGSUM *)sp->segsum;
+ lfs_ss_setflags(fs, ssp,
+ lfs_ss_getflags(fs, ssp) | (SS_DIROP|SS_CONT));
+ }
/* Update the inode times and copy the inode onto the inode page. */
/* XXX kludge --- don't redirty the ifile just to put times on it */
@@ -1283,7 +1294,9 @@ lfs_writeinode(struct lfs *fs, struct se
}
/* Increment inode count in segment summary block. */
- ++((SEGSUM *)(sp->segsum))->ss_ninos;
+
+ ssp = (SEGSUM *)sp->segsum;
+ lfs_ss_setninos(fs, ssp, lfs_ss_getninos(fs, ssp) + 1);
/* If this page is full, set flag to allocate a new page. */
if (++sp->ninodes % LFS_INOPB(fs) == 0)
@@ -1830,12 +1843,13 @@ lfs_initseg(struct lfs *fs)
/* Set point to SEGSUM, initialize it. */
ssp = sp->segsum = sbp->b_data;
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;
+ lfs_ss_setnext(fs, ssp, lfs_sb_getnextseg(fs));
+ lfs_ss_setnfinfo(fs, ssp, 0);
+ lfs_ss_setninos(fs, ssp, 0);
+ lfs_ss_setmagic(fs, ssp, SS_MAGIC);
/* Set pointer to first FINFO, initialize it. */
- sp->fip = (struct finfo *)((char *)sp->segsum + SEGSUM_SIZE(fs));
+ sp->fip = SEGSUM_FINFOBASE(fs, sp->segsum);
sp->fip->fi_nblocks = 0;
sp->start_lbp = &sp->fip->fi_blocks[0];
sp->fip->fi_lastlength = 0;
@@ -1995,6 +2009,7 @@ lfs_writeseg(struct lfs *fs, struct segm
int32_t *daddrp; /* XXX ondisk32 */
int changed;
u_int32_t sum;
+ size_t sumstart;
#ifdef DEBUG
FINFO *fip;
int findex;
@@ -2011,18 +2026,18 @@ lfs_writeseg(struct lfs *fs, struct segm
* roll-forward agent.
*/
if ((nblocks = sp->cbpp - sp->bpp) == 1) {
- if ((ssp->ss_flags & (SS_DIROP | SS_CONT)) != SS_DIROP)
+ if ((lfs_ss_getflags(fs, ssp) & (SS_DIROP | SS_CONT)) != SS_DIROP)
return 0;
}
/* Note if partial segment is being written by the cleaner */
if (sp->seg_flags & SEGM_CLEAN)
- ssp->ss_flags |= SS_CLEAN;
+ lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_CLEAN);
/* Note if we are writing to reclaim */
if (sp->seg_flags & SEGM_RECLAIM) {
- ssp->ss_flags |= SS_RECLAIM;
- ssp->ss_reclino = fs->lfs_reclino;
+ lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) | SS_RECLAIM);
+ lfs_ss_setreclino(fs, ssp, fs->lfs_reclino);
}
devvp = VTOI(fs->lfs_ivnode)->i_devvp;
@@ -2044,20 +2059,20 @@ lfs_writeseg(struct lfs *fs, struct segm
#ifdef DEBUG
/* Check for zero-length and zero-version FINFO entries. */
- fip = (struct finfo *)((char *)ssp + SEGSUM_SIZE(fs));
- for (findex = 0; findex < ssp->ss_nfinfo; findex++) {
+ fip = SEGSUM_FINFOBASE(fs, ssp);
+ for (findex = 0; findex < lfs_ss_getnfinfo(fs, ssp); findex++) {
KDASSERT(fip->fi_nblocks > 0);
KDASSERT(fip->fi_version > 0);
- fip = (FINFO *)((char *)fip + FINFOSIZE +
- sizeof(int32_t) * fip->fi_nblocks);
+ fip = NEXT_FINFO(fs, fip);
}
#endif /* DEBUG */
- ninos = (ssp->ss_ninos + LFS_INOPB(fs) - 1) / LFS_INOPB(fs);
+ ninos = (lfs_ss_getninos(fs, ssp) + LFS_INOPB(fs) - 1) / LFS_INOPB(fs);
DLOG((DLOG_SU, "seg %d += %d for %d inodes\n",
- sp->seg_number, ssp->ss_ninos * sizeof (struct ulfs1_dinode),
- ssp->ss_ninos));
- sup->su_nbytes += ssp->ss_ninos * sizeof (struct ulfs1_dinode);
+ sp->seg_number,
+ lfs_ss_getninos(fs, ssp) * sizeof (struct ulfs1_dinode),
+ lfs_ss_getninos(fs, ssp)));
+ sup->su_nbytes += lfs_ss_getninos(fs, ssp) * sizeof (struct ulfs1_dinode);
/* sup->su_nbytes += lfs_sb_getsumsize(fs); */
if (lfs_sb_getversion(fs) == 1)
sup->su_olastmod = time_second;
@@ -2202,16 +2217,17 @@ lfs_writeseg(struct lfs *fs, struct segm
}
}
if (lfs_sb_getversion(fs) == 1)
- ssp->ss_ocreate = time_second;
+ lfs_ss_setocreate(fs, ssp, time_second);
else {
- ssp->ss_create = time_second;
+ lfs_ss_setcreate(fs, ssp, time_second);
lfs_sb_addserial(fs, 1);
- ssp->ss_serial = lfs_sb_getserial(fs);
- ssp->ss_ident = lfs_sb_getident(fs);
+ lfs_ss_setserial(fs, ssp, lfs_sb_getserial(fs));
+ lfs_ss_setident(fs, ssp, lfs_sb_getident(fs));
}
- ssp->ss_datasum = lfs_cksum_fold(sum);
- ssp->ss_sumsum = cksum(&ssp->ss_datasum,
- lfs_sb_getsumsize(fs) - sizeof(ssp->ss_sumsum));
+ lfs_ss_setdatasum(fs, ssp, lfs_cksum_fold(sum));
+ sumstart = lfs_ss_getsumstart(fs);
+ lfs_ss_setsumsum(fs, ssp, cksum((char *)ssp + sumstart,
+ lfs_sb_getsumsize(fs) - sumstart));
mutex_enter(&lfs_lock);
lfs_sb_subbfree(fs, (lfs_btofsb(fs, ninos * lfs_sb_getibsize(fs)) +
@@ -2766,6 +2782,7 @@ void
lfs_acquire_finfo(struct lfs *fs, ino_t ino, int vers)
{
struct segment *sp = fs->lfs_sp;
+ SEGSUM *ssp;
KASSERT(vers > 0);
@@ -2774,7 +2791,8 @@ lfs_acquire_finfo(struct lfs *fs, ino_t
(void) lfs_writeseg(fs, fs->lfs_sp);
sp->sum_bytes_left -= FINFOSIZE;
- ++((SEGSUM *)(sp->segsum))->ss_nfinfo;
+ ssp = (SEGSUM *)sp->segsum;
+ lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) + 1);
sp->fip->fi_nblocks = 0;
sp->fip->fi_ino = ino;
sp->fip->fi_version = vers;
@@ -2788,13 +2806,14 @@ void
lfs_release_finfo(struct lfs *fs)
{
struct segment *sp = fs->lfs_sp;
+ SEGSUM *ssp;
if (sp->fip->fi_nblocks != 0) {
- sp->fip = (FINFO*)((char *)sp->fip + FINFOSIZE +
- sizeof(int32_t) * sp->fip->fi_nblocks);
+ sp->fip = NEXT_FINFO(fs, sp->fip);
sp->start_lbp = &sp->fip->fi_blocks[0];
} else {
sp->sum_bytes_left += FINFOSIZE;
- --((SEGSUM *)(sp->segsum))->ss_nfinfo;
+ ssp = (SEGSUM *)sp->segsum;
+ lfs_ss_setnfinfo(fs, ssp, lfs_ss_getnfinfo(fs, ssp) - 1);
}
}
Index: src/sys/ufs/lfs/lfs_vfsops.c
diff -u src/sys/ufs/lfs/lfs_vfsops.c:1.337 src/sys/ufs/lfs/lfs_vfsops.c:1.338
--- src/sys/ufs/lfs/lfs_vfsops.c:1.337 Wed Aug 12 18:25:52 2015
+++ src/sys/ufs/lfs/lfs_vfsops.c Wed Aug 12 18:26:27 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_vfsops.c,v 1.337 2015/08/12 18:25:52 dholland Exp $ */
+/* $NetBSD: lfs_vfsops.c,v 1.338 2015/08/12 18:26:27 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.337 2015/08/12 18:25:52 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_vfsops.c,v 1.338 2015/08/12 18:26:27 dholland Exp $");
#if defined(_KERNEL_OPT)
#include "opt_lfs.h"
@@ -1878,6 +1878,7 @@ lfs_gop_write(struct vnode *vp, struct v
struct inode *ip = VTOI(vp);
struct lfs *fs = ip->i_lfs;
struct segment *sp = fs->lfs_sp;
+ SEGSUM *ssp;
UVMHIST_FUNC("lfs_gop_write"); UVMHIST_CALLED(ubchist);
const char * failreason = NULL;
@@ -1991,13 +1992,14 @@ lfs_gop_write(struct vnode *vp, struct v
* If we would, write what we have and try again. If we don't
* have anything to write, we'll have to sleep.
*/
+ ssp = (SEGSUM *)sp->segsum;
if ((kva = uvm_pagermapin(pgs, npages, UVMPAGER_MAPIN_WRITE |
- (((SEGSUM *)(sp->segsum))->ss_nfinfo < 1 ?
+ (lfs_ss_getnfinfo(fs, ssp) < 1 ?
UVMPAGER_MAPIN_WAITOK : 0))) == 0x0) {
DLOG((DLOG_PAGE, "lfs_gop_write: forcing write\n"));
#if 0
" with nfinfo=%d at offset 0x%jx\n",
- (int)((SEGSUM *)(sp->segsum))->ss_nfinfo,
+ (int)lfs_ss_getnfinfo(fs, ssp),
(uintmax_t)lfs_sb_getoffset(fs)));
#endif
lfs_updatemeta(sp);
Index: src/sys/ufs/lfs/lfs_vnops.c
diff -u src/sys/ufs/lfs/lfs_vnops.c:1.284 src/sys/ufs/lfs/lfs_vnops.c:1.285
--- src/sys/ufs/lfs/lfs_vnops.c:1.284 Wed Aug 12 18:25:04 2015
+++ src/sys/ufs/lfs/lfs_vnops.c Wed Aug 12 18:26:27 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: lfs_vnops.c,v 1.284 2015/08/12 18:25:04 dholland Exp $ */
+/* $NetBSD: lfs_vnops.c,v 1.285 2015/08/12 18:26:27 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.284 2015/08/12 18:25:04 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.285 2015/08/12 18:26:27 dholland Exp $");
#ifdef _KERNEL_OPT
#include "opt_compat_netbsd.h"
@@ -1504,8 +1504,9 @@ lfs_flush_dirops(struct lfs *fs)
{
struct inode *ip, *nip;
struct vnode *vp;
- extern int lfs_dostats;
+ extern int lfs_dostats; /* XXX this does not belong here */
struct segment *sp;
+ SEGSUM *ssp;
int flags = 0;
int error = 0;
@@ -1605,7 +1606,8 @@ lfs_flush_dirops(struct lfs *fs)
}
mutex_exit(&lfs_lock);
/* We've written all the dirops there are */
- ((SEGSUM *)(sp->segsum))->ss_flags &= ~(SS_CONT);
+ ssp = (SEGSUM *)sp->segsum;
+ lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) & ~(SS_CONT));
lfs_finalize_fs_seguse(fs);
(void) lfs_writeseg(fs, sp);
lfs_segunlock(fs);
Index: src/usr.sbin/dumplfs/dumplfs.c
diff -u src/usr.sbin/dumplfs/dumplfs.c:1.51 src/usr.sbin/dumplfs/dumplfs.c:1.52
--- src/usr.sbin/dumplfs/dumplfs.c:1.51 Wed Aug 12 18:25:52 2015
+++ src/usr.sbin/dumplfs/dumplfs.c Wed Aug 12 18:26:27 2015
@@ -1,4 +1,4 @@
-/* $NetBSD: dumplfs.c,v 1.51 2015/08/12 18:25:52 dholland Exp $ */
+/* $NetBSD: dumplfs.c,v 1.52 2015/08/12 18:26:27 dholland Exp $ */
/*-
* Copyright (c) 1991, 1993
@@ -40,7 +40,7 @@ __COPYRIGHT("@(#) Copyright (c) 1991, 19
#if 0
static char sccsid[] = "@(#)dumplfs.c 8.5 (Berkeley) 5/24/95";
#else
-__RCSID("$NetBSD: dumplfs.c,v 1.51 2015/08/12 18:25:52 dholland Exp $");
+__RCSID("$NetBSD: dumplfs.c,v 1.52 2015/08/12 18:26:27 dholland Exp $");
#endif
#endif /* not lint */
@@ -505,12 +505,15 @@ dump_sum(int fd, struct lfs *lfsp, SEGSU
struct ulfs1_dinode *inop;
size_t el_size;
u_int32_t datasum;
+ u_int32_t ssflags;
time_t t;
char *buf;
+ size_t sumstart;
- if (sp->ss_magic != SS_MAGIC ||
- sp->ss_sumsum != (ck = cksum(&sp->ss_datasum,
- lfs_sb_getsumsize(lfsp) - sizeof(sp->ss_sumsum)))) {
+ sumstart = lfs_ss_getsumstart(lfsp);
+ if (lfs_ss_getmagic(lfsp, sp) != SS_MAGIC ||
+ lfs_ss_getsumsum(lfsp, sp) != (ck = cksum((char *)sp + sumstart,
+ lfs_sb_getsumsize(lfsp) - sumstart))) {
/* Don't print "corrupt" if we're just too close to the edge */
if (lfs_dtosn(lfsp, addr + LFS_FSBTODB(lfsp, 1)) ==
lfs_dtosn(lfsp, addr))
@@ -519,7 +522,7 @@ dump_sum(int fd, struct lfs *lfsp, SEGSU
(long long)addr);
return -1;
}
- if (lfs_sb_getversion(lfsp) > 1 && sp->ss_ident != lfs_sb_getident(lfsp)) {
+ if (lfs_sb_getversion(lfsp) > 1 && lfs_ss_getident(lfsp, sp) != lfs_sb_getident(lfsp)) {
(void)printf("dumplfs: %s %d address 0x%llx\n",
"summary from a former life; segment", segnum,
(long long)addr);
@@ -527,39 +530,42 @@ dump_sum(int fd, struct lfs *lfsp, SEGSU
}
(void)printf("Segment Summary Info at 0x%llx\n", (long long)addr);
- (void)printf(" %s0x%x\t%s%d\t%s%d\t%s%c%c%c%c\n %s0x%x\t%s0x%x",
- "next ", sp->ss_next,
- "nfinfo ", sp->ss_nfinfo,
- "ninos ", sp->ss_ninos,
- "flags ", (sp->ss_flags & SS_DIROP) ? 'D' : '-',
- (sp->ss_flags & SS_CONT) ? 'C' : '-',
- (sp->ss_flags & SS_CLEAN) ? 'L' : '-',
- (sp->ss_flags & SS_RFW) ? 'R' : '-',
- "sumsum ", sp->ss_sumsum,
- "datasum ", sp->ss_datasum );
+ ssflags = lfs_ss_getflags(lfsp, sp);
+ (void)printf(" %s0x%jx\t%s%d\t%s%d\t%s%c%c%c%c\n %s0x%x\t%s0x%x",
+ "next ", (intmax_t)lfs_ss_getnext(lfsp, sp),
+ "nfinfo ", lfs_ss_getnfinfo(lfsp, sp),
+ "ninos ", lfs_ss_getninos(lfsp, sp),
+ "flags ", (ssflags & SS_DIROP) ? 'D' : '-',
+ (ssflags & SS_CONT) ? 'C' : '-',
+ (ssflags & SS_CLEAN) ? 'L' : '-',
+ (ssflags & SS_RFW) ? 'R' : '-',
+ "sumsum ", lfs_ss_getsumsum(lfsp, sp),
+ "datasum ", lfs_ss_getdatasum(lfsp, sp));
if (lfs_sb_getversion(lfsp) == 1) {
- t = sp->ss_ocreate;
+ t = lfs_ss_getocreate(lfsp, sp);
(void)printf("\tcreate %s\n", ctime(&t));
} else {
- t = sp->ss_create;
+ t = lfs_ss_getcreate(lfsp, sp);
(void)printf("\tcreate %s", ctime(&t));
- (void)printf(" roll_id %-8x", sp->ss_ident);
- (void)printf(" serial %lld\n", (long long)sp->ss_serial);
+ (void)printf(" roll_id %-8x", lfs_ss_getident(lfsp, sp));
+ (void)printf(" serial %lld\n",
+ (long long)lfs_ss_getserial(lfsp, sp));
}
/* Dump out inode disk addresses */
+ /* XXX ondisk32 */
dp = (int32_t *)sp;
dp += lfs_sb_getsumsize(lfsp) / sizeof(int32_t);
inop = malloc(lfs_sb_getbsize(lfsp));
printf(" Inode addresses:");
numbytes = 0;
numblocks = 0;
- for (dp--, i = 0; i < sp->ss_ninos; dp--) {
+ for (dp--, i = 0; i < lfs_ss_getninos(lfsp, sp); dp--) {
++numblocks;
numbytes += lfs_sb_getibsize(lfsp); /* add bytes for inode block */
printf("\t0x%x {", *dp);
get(fd, fsbtobyte(lfsp, *dp), inop, lfs_sb_getibsize(lfsp));
- for (j = 0; i < sp->ss_ninos && j < LFS_INOPB(lfsp); j++, i++) {
+ for (j = 0; i < lfs_ss_getninos(lfsp, sp) && j < LFS_INOPB(lfsp); j++, i++) {
if (j > 0)
(void)printf(", ");
(void)printf("%dv%d", inop[j].di_inumber, inop[j].di_gen);
@@ -572,11 +578,8 @@ dump_sum(int fd, struct lfs *lfsp, SEGSU
printf("\n");
- if (lfs_sb_getversion(lfsp) == 1)
- fp = (FINFO *)((SEGSUM_V1 *)sp + 1);
- else
- fp = (FINFO *)(sp + 1);
- for (i = 0; i < sp->ss_nfinfo; i++) {
+ fp = SEGSUM_FINFOBASE(lfsp, sp);
+ for (i = 0; i < lfs_ss_getnfinfo(lfsp, sp); i++) {
(void)printf(" FINFO for inode: %d version %d nblocks %d lastlength %d\n",
fp->fi_ino, fp->fi_version, fp->fi_nblocks,
fp->fi_lastlength);
@@ -619,7 +622,7 @@ dump_sum(int fd, struct lfs *lfsp, SEGSU
acc = 0;
addr += lfs_btofsb(lfsp, lfs_sb_getsumsize(lfsp));
buf = malloc(lfs_sb_getbsize(lfsp));
- for (i = 0; i < sp->ss_nfinfo; i++) {
+ for (i = 0; i < lfs_ss_getnfinfo(lfsp, sp); i++) {
while (addr == *idp) {
get(fd, fsbtobyte(lfsp, addr), buf, lfs_sb_getibsize(lfsp));
memcpy(datap + acc * el_size, buf, el_size);
@@ -650,8 +653,8 @@ dump_sum(int fd, struct lfs *lfsp, SEGSU
printf("** counted %d blocks but should have been %d\n",
acc, numblocks);
datasum = cksum(datap, numblocks * el_size);
- if (datasum != sp->ss_datasum)
- printf("** computed datasum 0x%lx does not match given datasum 0x%lx\n", (unsigned long)datasum, (unsigned long)sp->ss_datasum);
+ if (datasum != lfs_ss_getdatasum(lfsp, sp))
+ printf("** computed datasum 0x%lx does not match given datasum 0x%lx\n", (unsigned long)datasum, (unsigned long)lfs_ss_getdatasum(lfsp, sp));
free(datap);
return (numbytes);
@@ -662,6 +665,7 @@ dump_segment(int fd, int segnum, daddr_t
{
struct lfs lfs_sb, *sbp;
SEGSUM *sump;
+ size_t sumstart;
char *sumblock;
int did_one, nbytes, sb;
off_t sum_offset;
@@ -688,10 +692,12 @@ dump_segment(int fd, int segnum, daddr_t
do {
get(fd, sum_offset, sumblock, lfs_sb_getsumsize(lfsp));
sump = (SEGSUM *)sumblock;
+ sumstart = lfs_ss_getsumstart(lfsp);
if ((lfs_sb_getversion(lfsp) > 1 &&
- sump->ss_ident != lfs_sb_getident(lfsp)) ||
- sump->ss_sumsum != cksum (&sump->ss_datasum,
- lfs_sb_getsumsize(lfsp) - sizeof(sump->ss_sumsum))) {
+ lfs_ss_getident(lfsp, sump) != lfs_sb_getident(lfsp)) ||
+ lfs_ss_getsumsum(lfsp, sump) !=
+ cksum((char *)sump + sumstart,
+ lfs_sb_getsumsize(lfsp) - sumstart)) {
sbp = (struct lfs *)sump;
if ((sb = (sbp->lfs_dlfs_u.u_32.dlfs_magic == LFS_MAGIC))) {
printf("Superblock at 0x%x\n",
