diff options
| author | perseant <perseant@NetBSD.org> | 2001-07-13 20:30:18 +0000 |
|---|---|---|
| committer | perseant <perseant@NetBSD.org> | 2001-07-13 20:30:18 +0000 |
| commit | 4e3fced95b79c8e2c11987fcaffc44a9fac0598c (patch) | |
| tree | 05c412fe8d7dc7217aeaaa5c01f1cf9c6d59de43 /libexec | |
| parent | c399f0522236892485e449240ad45018017edef9 (diff) | |
Merge the short-lived perseant-lfsv2 branch into the trunk.
Kernels and tools understand both v1 and v2 filesystems; newfs_lfs
generates v2 by default. Changes for the v2 layout include:
- Segments of non-PO2 size and arbitrary block offset, so these can be
matched to convenient physical characteristics of the partition (e.g.,
stripe or track size and offset).
- Address by fragment instead of by disk sector, paving the way for
non-512-byte-sector devices. In theory fragments can be as large
as you like, though in reality they must be smaller than MAXBSIZE in size.
- Use serial number and filesystem identifier to ensure that roll-forward
doesn't get old data and think it's new. Roll-forward is enabled for
v2 filesystems, though not for v1 filesystems by default.
- The inode free list is now a tailq, paving the way for undelete (undelete
is not yet implemented, but can be without further non-backwards-compatible
changes to disk structures).
- Inode atime information is kept in the Ifile, instead of on the inode;
that is, the inode is never written *just* because atime was changed.
Because of this the inodes remain near the file data on the disk, rather
than wandering all over as the disk is read repeatedly. This speeds up
repeated reads by a small but noticeable amount.
Other changes of note include:
- The ifile written by newfs_lfs can now be of arbitrary length, it is no
longer restricted to a single indirect block.
- Fixed an old bug where ctime was changed every time a vnode was created.
I need to look more closely to make sure that the times are only updated
during write(2) and friends, not after-the-fact during a segment write,
and certainly not by the cleaner.
Diffstat (limited to 'libexec')
| -rw-r--r-- | libexec/lfs_cleanerd/clean.h | 63 | ||||
| -rw-r--r-- | libexec/lfs_cleanerd/cleanerd.c | 131 | ||||
| -rw-r--r-- | libexec/lfs_cleanerd/lfs_cleanerd.8 | 11 | ||||
| -rw-r--r-- | libexec/lfs_cleanerd/library.c | 220 | ||||
| -rw-r--r-- | libexec/lfs_cleanerd/misc.c | 10 | ||||
| -rw-r--r-- | libexec/lfs_cleanerd/print.c | 49 |
6 files changed, 219 insertions, 265 deletions
diff --git a/libexec/lfs_cleanerd/clean.h b/libexec/lfs_cleanerd/clean.h index bb258dc0559..64361c91c56 100644 --- a/libexec/lfs_cleanerd/clean.h +++ b/libexec/lfs_cleanerd/clean.h @@ -1,4 +1,4 @@ -/* $NetBSD: clean.h,v 1.10 2001/02/04 22:12:47 christos Exp $ */ +/* $NetBSD: clean.h,v 1.11 2001/07/13 20:30:21 perseant Exp $ */ /*- * Copyright (c) 1992, 1993 @@ -84,7 +84,6 @@ typedef struct fs_info { CLEANERINFO *fi_cip; /* Cleaner info from ifile */ SEGUSE *fi_segusep; /* segment usage table (from ifile) */ IFILE *fi_ifilep; /* ifile table (from ifile) */ - u_long fi_daddr_shift; /* shift to get byte offset of daddr */ u_long fi_ifile_count; /* # entries in the ifile table */ off_t fi_ifile_length; /* length of the ifile */ time_t fi_fs_tstamp; /* last fs activity, per ifile */ @@ -94,34 +93,26 @@ typedef struct fs_info { * XXX: size (in bytes) of a segment * should lfs_bsize be fsbtodb(fs,1), blksize(fs), or lfs_dsize? */ -#define seg_size(fs) ((fs)->lfs_ssize << (fs)->lfs_bshift) - -/* daddr -> byte offset */ -#define datobyte(fs, da) (((off_t)(da)) << (fs)->fi_daddr_shift) -#define bytetoda(fs, byte) ((byte) >> (fs)->fi_daddr_shift) +#define seg_size(fs) fsbtob((fs), segtod((fs), 1)) #define CLEANSIZE(fsp) (fsp->fi_lfs.lfs_cleansz << fsp->fi_lfs.lfs_bshift) #define SEGTABSIZE(fsp) (fsp->fi_lfs.lfs_segtabsz << fsp->fi_lfs.lfs_bshift) -#define IFILE_ENTRY(fs, if, i) \ - ((IFILE *)((caddr_t)(if) + ((i) / (fs)->lfs_ifpb << (fs)->lfs_bshift)) \ - + (i) % (fs)->lfs_ifpb) - -#define SEGUSE_ENTRY(fs, su, i) \ - ((SEGUSE *)((caddr_t)(su) + (fs)->lfs_bsize * ((i) / (fs)->lfs_sepb)) +\ - (i) % (fs)->lfs_sepb) - -__BEGIN_DECLS -int dump_summary __P((struct lfs *, SEGSUM *, u_long, daddr_t **, daddr_t)); -int fs_getmntinfo __P((struct statfs **, char *, const char *)); -void get __P((int, off_t, void *, size_t)); -FS_INFO *get_fs_info __P((struct statfs *, int)); -int lfs_segmapv __P((FS_INFO *, int, caddr_t, BLOCK_INFO **, int *)); -int mmap_segment __P((FS_INFO *, int, caddr_t *, int)); -void munmap_segment __P((FS_INFO *, caddr_t, int)); -void reread_fs_info __P((FS_INFO *, int)); -void toss __P((void *, int *, size_t, - int (*)(const void *, const void *, const void *), void *)); +#define IFILE_ENTRY(fs, ife, i) \ + ((fs)->lfs_version == 1 ? \ + (IFILE *)((IFILE_V1 *)((caddr_t)(ife) + ((i) / (fs)->lfs_ifpb <<\ + (fs)->lfs_bshift)) + (i) % (fs)->lfs_ifpb) : \ + ((IFILE *)((caddr_t)(ife) + ((i) / (fs)->lfs_ifpb << \ + (fs)->lfs_bshift)) + (i) % (fs)->lfs_ifpb)) + +#define SEGUSE_ENTRY(fs, su, i) \ + ((fs)->lfs_version == 1 ? \ + (SEGUSE *)((SEGUSE_V1 *)((caddr_t)(su) + (fs)->lfs_bsize * \ + ((i) / (fs)->lfs_sepb)) + \ + (i) % (fs)->lfs_sepb) : \ + ((SEGUSE *)((caddr_t)(su) + (fs)->lfs_bsize * \ + ((i) / (fs)->lfs_sepb)) + \ + (i) % (fs)->lfs_sepb)) /* * USEFUL DEBUGGING FUNCTIONS: @@ -155,8 +146,20 @@ void toss __P((void *, int *, size_t, ctime((time_t *)&(sup)->su_lastmod)); \ } -void dump_super __P((struct lfs *)); -void dump_cleaner_info __P((void *)); -void print_SEGSUM __P(( struct lfs *, SEGSUM *, daddr_t)); -void print_CLEANERINFO __P((CLEANERINFO *)); +__BEGIN_DECLS +int dump_summary(struct lfs *, SEGSUM *, u_long, daddr_t **, daddr_t); +int fs_getmntinfo(struct statfs **, char *, const char *); +void get(int, off_t, void *, size_t); +FS_INFO *get_fs_info(struct statfs *, int); +int lfs_segmapv(FS_INFO *, int, caddr_t, BLOCK_INFO **, int *); +int mmap_segment(FS_INFO *, int, caddr_t *, int); +void munmap_segment(FS_INFO *, caddr_t, int); +void reread_fs_info(FS_INFO *, int); +void toss __P((void *, int *, size_t, + int (*)(const void *, const void *, const void *), void *)); + +void dump_super(struct lfs *); +void dump_cleaner_info(void *); +void print_SEGSUM(struct lfs *, SEGSUM *, daddr_t); +void print_CLEANERINFO(CLEANERINFO *); __END_DECLS diff --git a/libexec/lfs_cleanerd/cleanerd.c b/libexec/lfs_cleanerd/cleanerd.c index 988589e4a78..c55506cb88c 100644 --- a/libexec/lfs_cleanerd/cleanerd.c +++ b/libexec/lfs_cleanerd/cleanerd.c @@ -1,4 +1,4 @@ -/* $NetBSD: cleanerd.c,v 1.30 2001/02/04 22:12:47 christos Exp $ */ +/* $NetBSD: cleanerd.c,v 1.31 2001/07/13 20:30:21 perseant Exp $ */ /*- * Copyright (c) 1992, 1993 @@ -40,7 +40,7 @@ __COPYRIGHT("@(#) Copyright (c) 1992, 1993\n\ #if 0 static char sccsid[] = "@(#)cleanerd.c 8.5 (Berkeley) 6/10/95"; #else -__RCSID("$NetBSD: cleanerd.c,v 1.30 2001/02/04 22:12:47 christos Exp $"); +__RCSID("$NetBSD: cleanerd.c,v 1.31 2001/07/13 20:30:21 perseant Exp $"); #endif #endif /* not lint */ @@ -109,24 +109,24 @@ typedef struct { #define CLEAN_BYTES 0x1 /* function prototypes for system calls; not sure where they should go */ -int lfs_segwait __P((fsid_t *, struct timeval *)); -int lfs_segclean __P((fsid_t *, u_long)); -int lfs_bmapv __P((fsid_t *, BLOCK_INFO *, int)); -int lfs_markv __P((fsid_t *, BLOCK_INFO *, int)); +int lfs_segwait(fsid_t *, struct timeval *); +int lfs_segclean(fsid_t *, u_long); +int lfs_bmapv(fsid_t *, BLOCK_INFO *, int); +int lfs_markv(fsid_t *, BLOCK_INFO *, int); /* function prototypes */ -int bi_tossold __P((const void *, const void *, const void *)); -int choose_segments __P((FS_INFO *, struct seglist *, - unsigned long (*)(FS_INFO *, SEGUSE *))); -void clean_fs __P((FS_INFO *, unsigned long (*)(FS_INFO *, SEGUSE *), int, long)); -int clean_loop __P((FS_INFO *, int, long)); -int add_segment __P((FS_INFO *, struct seglist *, SEGS_AND_BLOCKS *)); -int clean_segments __P((FS_INFO *, SEGS_AND_BLOCKS *)); -unsigned long cost_benefit __P((FS_INFO *, SEGUSE *)); -int cost_compare __P((const void *, const void *)); -void sig_report __P((int)); -void just_exit __P((int)); -int main __P((int, char *[])); +int bi_tossold(const void *, const void *, const void *); +int choose_segments(FS_INFO *, struct seglist *, + unsigned long (*)(FS_INFO *, SEGUSE *)); +void clean_fs(FS_INFO *, unsigned long (*)(FS_INFO *, SEGUSE *), int, long); +int clean_loop(FS_INFO *, int, long); +int add_segment(FS_INFO *, struct seglist *, SEGS_AND_BLOCKS *); +int clean_segments(FS_INFO *, SEGS_AND_BLOCKS *); +unsigned long cost_benefit(FS_INFO *, SEGUSE *); +int cost_compare(const void *, const void *); +void sig_report(int); +void just_exit(int); +int main(int, char *[]); /* * Cleaning Cost Functions: @@ -141,9 +141,7 @@ int main __P((int, char *[])); */ unsigned long -cost_benefit(fsp, su) - FS_INFO *fsp; /* file system information */ - SEGUSE *su; +cost_benefit(FS_INFO *fsp, SEGUSE *su) { struct lfs *lfsp; struct timeval t; @@ -180,9 +178,7 @@ cost_benefit(fsp, su) } int -main(argc, argv) - int argc; - char *argv[]; +main(int argc, char **argv) { FS_INFO *fsp; struct statfs *lstatfsp; /* file system stats */ @@ -340,24 +336,21 @@ main(argc, argv) /* return the number of segments cleaned */ int -clean_loop(fsp, nsegs, options) - FS_INFO *fsp; /* file system information */ - int nsegs; - long options; +clean_loop(FS_INFO *fsp, int nsegs, long options) { struct lfs *lfsp; double loadavg[MAXLOADS]; time_t now; u_long max_free_segs; - u_long db_per_seg; + u_long fsb_per_seg; lfsp = &fsp->fi_lfs; /* * Compute the maximum possible number of free segments, given the * number of free blocks. */ - db_per_seg = fsbtodb(lfsp, lfsp->lfs_ssize); - max_free_segs = fsp->fi_cip->bfree / db_per_seg + lfsp->lfs_minfreeseg; + fsb_per_seg = segtod(lfsp, 1); + max_free_segs = fsp->fi_cip->bfree / fsb_per_seg + lfsp->lfs_minfreeseg; /* * We will clean if there are not enough free blocks or total clean @@ -366,16 +359,16 @@ clean_loop(fsp, nsegs, options) now = time((time_t *)NULL); if(debug > 1) { - syslog(LOG_DEBUG, "db_per_seg = %lu bfree = %u avail = %d," - " bfree = %u, ", db_per_seg, fsp->fi_cip->bfree, + syslog(LOG_DEBUG, "fsb_per_seg = %lu bfree = %u avail = %d," + " bfree = %u, ", fsb_per_seg, fsp->fi_cip->bfree, fsp->fi_cip->avail, fsp->fi_cip->bfree); syslog(LOG_DEBUG, "clean segs = %d, max_free_segs = %ld", fsp->fi_cip->clean, max_free_segs); } - if ((fsp->fi_cip->bfree - fsp->fi_cip->avail > db_per_seg && - fsp->fi_cip->avail < (long)db_per_seg && - fsp->fi_cip->bfree > (long)db_per_seg) || + if ((fsp->fi_cip->bfree - fsp->fi_cip->avail > fsb_per_seg && + fsp->fi_cip->avail < (long)fsb_per_seg && + fsp->fi_cip->bfree > (long)fsb_per_seg) || (fsp->fi_cip->clean < max_free_segs && (fsp->fi_cip->clean <= lfsp->lfs_minfreeseg || fsp->fi_cip->clean < max_free_segs * BUSY_LIM))) @@ -444,9 +437,9 @@ clean_loop(fsp, nsegs, options) } } if (debug > 1) { - if (fsp->fi_cip->bfree - fsp->fi_cip->avail <= db_per_seg) + if (fsp->fi_cip->bfree - fsp->fi_cip->avail <= fsb_per_seg) syslog(LOG_DEBUG, "condition 1 false"); - if (fsp->fi_cip->avail >= (long)db_per_seg) + if (fsp->fi_cip->avail >= (long)fsb_per_seg) syslog(LOG_DEBUG, "condition 2 false"); if (fsp->fi_cip->clean >= max_free_segs) syslog(LOG_DEBUG, "condition 3 false"); @@ -462,14 +455,11 @@ clean_loop(fsp, nsegs, options) void -clean_fs(fsp, cost_func, nsegs, options) - FS_INFO *fsp; /* file system information */ - unsigned long (*cost_func) __P((FS_INFO *, SEGUSE *)); - int nsegs; - long options; +clean_fs(FS_INFO *fsp, unsigned long (*cost_func)(FS_INFO *, SEGUSE *), + int nsegs, long options) { struct seglist *segs, *sp; - long int to_clean, cleaned_bytes, seg_size; + long int to_clean, cleaned_bytes; unsigned long i, j, total; struct rusage ru; fsid_t *fsidp; @@ -477,7 +467,6 @@ clean_fs(fsp, cost_func, nsegs, options) SEGS_AND_BLOCKS *sbp; fsidp = &fsp->fi_statfsp->f_fsid; - seg_size = (1 << fsp->fi_lfs.lfs_segshift); if ((segs = malloc(fsp->fi_lfs.lfs_nseg * sizeof(struct seglist))) == NULL) { @@ -589,9 +578,7 @@ clean_fs(fsp, cost_func, nsegs, options) * cost/benefit than any utilized segment. */ int -cost_compare(a, b) - const void *a; - const void *b; +cost_compare(const void *a, const void *b) { return ((struct seglist *)b)->sl_cost < ((struct seglist *)a)->sl_cost ? -1 : 1; } @@ -602,10 +589,7 @@ cost_compare(a, b) * filled in. */ int -choose_segments(fsp, seglist, cost_func) - FS_INFO *fsp; - struct seglist *seglist; - unsigned long (*cost_func) __P((FS_INFO *, SEGUSE *)); +choose_segments(FS_INFO *fsp, struct seglist *seglist, unsigned long (*cost_func)(FS_INFO *, SEGUSE *)) { struct lfs *lfsp; struct seglist *sp; @@ -663,10 +647,7 @@ choose_segments(fsp, seglist, cost_func) * in preparation for sending through lfs_markv. */ int -add_segment(fsp, slp, sbp) - FS_INFO *fsp; - struct seglist *slp; - SEGS_AND_BLOCKS *sbp; +add_segment(FS_INFO *fsp, struct seglist *slp, SEGS_AND_BLOCKS *sbp) { int id = slp->sl_id; BLOCK_INFO *tba, *_bip; @@ -684,7 +665,7 @@ add_segment(fsp, slp, sbp) lfsp = &fsp->fi_lfs; sp = SEGUSE_ENTRY(lfsp, fsp->fi_segusep, id); - seg_addr = sntoda(lfsp,id); + seg_addr = sntod(lfsp,id); error = 0; tba = NULL; @@ -718,7 +699,7 @@ add_segment(fsp, slp, sbp) "add_segment: lfs_segmapv failed for segment %d", id); goto out; } - cleaner_stats.blocks_read += fsp->fi_lfs.lfs_ssize; + cleaner_stats.blocks_read += segtod(lfsp, 1); if (debug > 1) syslog(LOG_DEBUG, "lfs_segmapv returned %d blocks", num_blocks); @@ -747,8 +728,8 @@ add_segment(fsp, slp, sbp) /* XXX KS - check for misplaced blocks */ for(i=0; i<num_blocks; i++) { if(tba[i].bi_daddr - && ((char *)(tba[i].bi_bp) - seg_buf) != (tba[i].bi_daddr - seg_addr) * DEV_BSIZE - && datosn(&(fsp->fi_lfs), tba[i].bi_daddr) == id) + && ((char *)(tba[i].bi_bp) - seg_buf) != fsbtob(lfsp, tba[i].bi_daddr - seg_addr) + && dtosn(&(fsp->fi_lfs), tba[i].bi_daddr) == id) { if(debug > 1) { syslog(LOG_DEBUG, "seg %d, ino %d lbn %d, 0x%x != 0x%lx (fixed)", @@ -756,7 +737,7 @@ add_segment(fsp, slp, sbp) tba[i].bi_inode, tba[i].bi_lbn, tba[i].bi_daddr, - (long)seg_addr + ((char *)(tba[i].bi_bp) - seg_buf)/DEV_BSIZE); + (long)seg_addr + btofsb(lfsp, (char *)(tba[i].bi_bp) - seg_buf)); } /* * XXX KS - have to be careful here about Inodes; @@ -765,7 +746,7 @@ add_segment(fsp, slp, sbp) * the *right* inode, not the first one in the block. */ if(tba[i].bi_lbn == LFS_UNUSED_LBN) { - dip = (struct dinode *)(seg_buf + (tba[i].bi_daddr - seg_addr) * DEV_BSIZE); + dip = (struct dinode *)(seg_buf + fsbtob(lfsp, tba[i].bi_daddr - seg_addr)); for(j=INOPB(lfsp)-1;j>=0;j--) { if(dip[j].di_u.inumber == tba[i].bi_inode) { tba[i].bi_bp = (char *)(dip+j); @@ -785,13 +766,12 @@ add_segment(fsp, slp, sbp) } err(1,"lost inode"); } else if (debug > 1) { - syslog(LOG_DEBUG,"Ino %d corrected to 0x%x+%d", + syslog(LOG_DEBUG,"Ino %d corrected to 0x%x", tba[i].bi_inode, - tba[i].bi_daddr, - (int)((caddr_t)(tba[i].bi_bp) - (caddr_t)(long)seg_addr) % DEV_BSIZE); + tba[i].bi_daddr); } } else { - tba[i].bi_bp = seg_buf + (tba[i].bi_daddr - seg_addr) * DEV_BSIZE; + tba[i].bi_bp = seg_buf + fsbtob(lfsp, tba[i].bi_daddr - seg_addr); } } } @@ -865,9 +845,7 @@ add_segment(fsp, slp, sbp) /* Call markv and clean up */ int -clean_segments(fsp, sbp) - FS_INFO *fsp; - SEGS_AND_BLOCKS *sbp; +clean_segments(FS_INFO *fsp, SEGS_AND_BLOCKS *sbp) { int maxblocks, clean_blocks; BLOCK_INFO *bp; @@ -878,7 +856,7 @@ clean_segments(fsp, sbp) cleaner_stats.segs_cleaned += sbp->nsegs; cleaner_stats.blocks_written += sbp->nb; - util = ((double)sbp->nb / fsp->fi_lfs.lfs_ssize); + util = ((double)sbp->nb / segtod(&fsp->fi_lfs, 1)); cleaner_stats.util_tot += util; cleaner_stats.util_sos += util * util; if (do_small) @@ -911,22 +889,18 @@ clean_segments(fsp, sbp) int -bi_tossold(client, a, b) - const void *client; - const void *a; - const void *b; +bi_tossold(const void *client, const void *a, const void *b) { const struct tossstruct *t; t = (struct tossstruct *)client; return (((BLOCK_INFO *)a)->bi_daddr == LFS_UNUSED_DADDR || - datosn(t->lfs, ((BLOCK_INFO *)a)->bi_daddr) != t->seg); + dtosn(t->lfs, ((BLOCK_INFO *)a)->bi_daddr) != t->seg); } void -sig_report(sig) - int sig; +sig_report(int sig) { double avg = 0.0; @@ -958,8 +932,7 @@ sig_report(sig) } void -just_exit(sig) - int sig; +just_exit(int sig) { exit(0); } diff --git a/libexec/lfs_cleanerd/lfs_cleanerd.8 b/libexec/lfs_cleanerd/lfs_cleanerd.8 index daf85becba4..25deb49b800 100644 --- a/libexec/lfs_cleanerd/lfs_cleanerd.8 +++ b/libexec/lfs_cleanerd/lfs_cleanerd.8 @@ -1,4 +1,4 @@ -.\" $NetBSD: lfs_cleanerd.8,v 1.8 2000/11/08 19:45:08 hubertf Exp $ +.\" $NetBSD: lfs_cleanerd.8,v 1.9 2001/07/13 20:30:22 perseant Exp $ .\" .\" Copyright (c) 1993 .\" The Regents of the University of California. All rights reserved. @@ -113,11 +113,10 @@ not usually necessary to set to a low value. .El .Sh SEE ALSO -.Xr lfs_bmapv 2 , -.Xr lfs_markv 2 , -.Xr lfs_segwait 2 , -.Xr mount_lfs 8 , -.Xr newfs_lfs 8 +.Xr mount_lfs 8 +.Xr lfs_bmapv 2 +.Xr lfs_markv 2 +.Xr lfs_segwait 2 .Sh HISTORY The .Nm diff --git a/libexec/lfs_cleanerd/library.c b/libexec/lfs_cleanerd/library.c index 6bc97054596..178021d1773 100644 --- a/libexec/lfs_cleanerd/library.c +++ b/libexec/lfs_cleanerd/library.c @@ -1,4 +1,4 @@ -/* $NetBSD: library.c,v 1.21 2001/02/04 22:12:47 christos Exp $ */ +/* $NetBSD: library.c,v 1.22 2001/07/13 20:30:22 perseant Exp $ */ /*- * Copyright (c) 1992, 1993 @@ -38,7 +38,7 @@ #if 0 static char sccsid[] = "@(#)library.c 8.3 (Berkeley) 5/24/95"; #else -__RCSID("$NetBSD: library.c,v 1.21 2001/02/04 22:12:47 christos Exp $"); +__RCSID("$NetBSD: library.c,v 1.22 2001/07/13 20:30:22 perseant Exp $"); #endif #endif /* not lint */ @@ -62,19 +62,19 @@ __RCSID("$NetBSD: library.c,v 1.21 2001/02/04 22:12:47 christos Exp $"); #include "clean.h" -void add_blocks __P((FS_INFO *, BLOCK_INFO *, int *, SEGSUM *, caddr_t, - daddr_t, daddr_t)); -void add_inodes __P((FS_INFO *, BLOCK_INFO *, int *, SEGSUM *, caddr_t, - daddr_t)); -int bi_compare __P((const void *, const void *)); -int bi_toss __P((const void *, const void *, const void *)); -void get_ifile __P((FS_INFO *, int)); -int get_superblock __P((FS_INFO *, struct lfs *)); -int pseg_valid __P((FS_INFO *, SEGSUM *, daddr_t)); -int pseg_size __P((daddr_t, FS_INFO *, SEGSUM *)); +void add_blocks(FS_INFO *, BLOCK_INFO *, int *, SEGSUM *, caddr_t, + daddr_t, daddr_t); +void add_inodes(FS_INFO *, BLOCK_INFO *, int *, SEGSUM *, caddr_t, + daddr_t); +int bi_compare(const void *, const void *); +int bi_toss(const void *, const void *, const void *); +void get_ifile(FS_INFO *, int); +int get_superblock(FS_INFO *, struct lfs *); +int pseg_valid(FS_INFO *, SEGSUM *, daddr_t); +int pseg_size(daddr_t, FS_INFO *, SEGSUM *); extern int debug; -extern u_long cksum __P((void *, size_t)); /* XXX */ +extern u_long cksum(void *, size_t); /* XXX */ static int ifile_fd; static int dev_fd; @@ -86,10 +86,7 @@ static int dev_fd; * a non-zero value is returned. */ int -fs_getmntinfo(buf, name, type) - struct statfs **buf; - char *name; - const char *type; +fs_getmntinfo(struct statfs **buf, char *name, const char *type) { /* allocate space for the filesystem info */ *buf = (struct statfs *)malloc(sizeof(struct statfs)); @@ -123,9 +120,7 @@ fs_getmntinfo(buf, name, type) * Returns an pointer to an FS_INFO structure, NULL on error. */ FS_INFO * -get_fs_info (lstatfsp, use_mmap) - struct statfs *lstatfsp; /* IN: pointer to statfs struct */ - int use_mmap; /* IN: mmap or read */ +get_fs_info (struct statfs *lstatfsp, int use_mmap) { FS_INFO *fsp; @@ -139,8 +134,6 @@ get_fs_info (lstatfsp, use_mmap) syslog(LOG_ERR, "Exiting: get_fs_info: get_superblock failed: %m"); exit(1); } - fsp->fi_daddr_shift = - fsp->fi_lfs.lfs_bshift - fsp->fi_lfs.lfs_fsbtodb; get_ifile (fsp, use_mmap); return (fsp); } @@ -151,9 +144,7 @@ get_fs_info (lstatfsp, use_mmap) * refresh the file system information (statfs) info. */ void -reread_fs_info(fsp, use_mmap) - FS_INFO *fsp; /* IN: prointer fs_infos to reread */ - int use_mmap; +reread_fs_info(FS_INFO *fsp, int use_mmap) { if (ifile_fd <= 0) { if (fstatfs(ifile_fd, fsp->fi_statfsp)) { @@ -171,12 +162,11 @@ reread_fs_info(fsp, use_mmap) * Gets the superblock from disk (possibly in face of errors) */ int -get_superblock (fsp, sbp) - FS_INFO *fsp; /* local file system info structure */ - struct lfs *sbp; +get_superblock (FS_INFO *fsp, struct lfs *sbp) { char mntfromname[MNAMELEN+1]; char buf[LFS_SBPAD]; + static off_t sboff = LFS_LABELPAD; strcpy(mntfromname, "/dev/r"); strcat(mntfromname, fsp->fi_statfsp->f_mntfromname+5); @@ -189,10 +179,26 @@ get_superblock (fsp, sbp) } else lseek(dev_fd, 0, SEEK_SET); - get(dev_fd, LFS_LABELPAD, buf, LFS_SBPAD); - memcpy(&(sbp->lfs_dlfs), buf, sizeof(struct dlfs)); + do { + get(dev_fd, sboff, buf, LFS_SBPAD); + memcpy(&(sbp->lfs_dlfs), buf, sizeof(struct dlfs)); + if (sboff == LFS_LABELPAD && fsbtob(sbp, 1) > LFS_LABELPAD) + sboff = fsbtob(sbp, (off_t)sbp->lfs_sboffs[0]); + else + break; + } while (1); + /* close (fid); */ + /* Compatibility */ + if (sbp->lfs_version < 2) { + sbp->lfs_sumsize = LFS_V1_SUMMARY_SIZE; + sbp->lfs_ibsize = sbp->lfs_bsize; + sbp->lfs_start = sbp->lfs_sboffs[0]; + sbp->lfs_tstamp = sbp->lfs_otstamp; + sbp->lfs_fsbtodb = 0; + } + return (0); } @@ -201,10 +207,7 @@ get_superblock (fsp, sbp) * fatal error on failure. */ void -get_ifile (fsp, use_mmap) - FS_INFO *fsp; - int use_mmap; - +get_ifile (FS_INFO *fsp, int use_mmap) { struct stat file_stat; struct statfs statfsbuf; @@ -306,19 +309,21 @@ redo_read: * Return the size of the partial segment, in bytes. */ int -pseg_size(pseg_addr, fsp, sp) - daddr_t pseg_addr; /* base address of the segsum */ - FS_INFO *fsp; /* Filesystem info */ - SEGSUM *sp; /* the segsum */ +pseg_size(daddr_t pseg_addr, FS_INFO *fsp, SEGSUM *sp) { int i, ssize = 0; struct lfs *lfsp; FINFO *fp; lfsp = &fsp->fi_lfs; - ssize = LFS_SUMMARY_SIZE - + howmany(sp->ss_ninos, INOPB(lfsp)) * lfsp->lfs_bsize; - for (fp = (FINFO *)(sp + 1), i = 0; i < sp->ss_nfinfo; ++i) { + ssize = lfsp->lfs_sumsize + + howmany(sp->ss_ninos, INOPB(lfsp)) * lfsp->lfs_ibsize; + + if (lfsp->lfs_version == 1) + fp = (FINFO *)(((char *)sp) + sizeof(SEGSUM_V1)); + else + fp = (FINFO *)(sp + 1); + for (i = 0; i < sp->ss_nfinfo; ++i) { ssize += (fp->fi_nblocks-1) * lfsp->lfs_bsize + fp->fi_lastlength; fp = (FINFO *)(&fp->fi_blocks[fp->fi_nblocks]); @@ -335,12 +340,7 @@ pseg_size(pseg_addr, fsp, sp) * pair will be listed at most once. */ int -lfs_segmapv(fsp, seg, seg_buf, blocks, bcount) - FS_INFO *fsp; /* pointer to local file system information */ - int seg; /* the segment number */ - caddr_t seg_buf; /* the buffer containing the segment's data */ - BLOCK_INFO **blocks; /* OUT: array of block_info for live blocks */ - int *bcount; /* OUT: number of active blocks in segment */ +lfs_segmapv(FS_INFO *fsp, int seg, caddr_t seg_buf, BLOCK_INFO **blocks, int *bcount) { BLOCK_INFO *bip, *_bip; SEGSUM *sp; @@ -360,8 +360,9 @@ lfs_segmapv(fsp, seg, seg_buf, blocks, bcount) sup = SEGUSE_ENTRY(lfsp, fsp->fi_segusep, seg); s = seg_buf + (sup->su_flags & SEGUSE_SUPERBLOCK ? LFS_SBPAD : 0); - seg_addr = sntoda(lfsp, seg); - pseg_addr = seg_addr + (sup->su_flags & SEGUSE_SUPERBLOCK ? btodb(LFS_SBPAD) : 0); + seg_addr = sntod(lfsp, seg); + pseg_addr = seg_addr + (sup->su_flags & SEGUSE_SUPERBLOCK ? + btofsb(lfsp, LFS_SBPAD) : 0); if(debug > 1) syslog(LOG_DEBUG, "\tsegment buffer at: %p\tseg_addr 0x%x", s, seg_addr); @@ -380,14 +381,19 @@ lfs_segmapv(fsp, seg, seg_buf, blocks, bcount) #ifdef DIAGNOSTIC /* Verify size of summary block */ - sumsize = sizeof(SEGSUM) + + sumsize = (lfsp->lfs_version == 1 ? sizeof(SEGSUM_V1) : + sizeof(SEGSUM)) + (sp->ss_ninos + INOPB(lfsp) - 1) / INOPB(lfsp); - for (i = 0, fip = (FINFO *)(sp + 1); i < sp->ss_nfinfo; ++i) { + if (lfsp->lfs_version == 1) + fip = (FINFO *)(((char *)sp) + sizeof(SEGSUM_V1)); + else + fip = (FINFO *)(sp + 1); + for (i = 0; i < sp->ss_nfinfo; ++i) { sumsize += sizeof(FINFO) + (fip->fi_nblocks - 1) * sizeof(daddr_t); fip = (FINFO *)(&fip->fi_blocks[fip->fi_nblocks]); } - if (sumsize > LFS_SUMMARY_SIZE) { + if (sumsize > lfsp->lfs_sumsize) { syslog(LOG_ERR, "Exiting: Segment %d summary block too big: %d\n", seg, sumsize); @@ -406,7 +412,7 @@ lfs_segmapv(fsp, seg, seg_buf, blocks, bcount) ssize = pseg_size(pseg_addr, fsp, sp); s += ssize; - pseg_addr += btodb(ssize); /* XXX was bytetoda(fsp,ssize) */ + pseg_addr += btofsb(lfsp, ssize); } if(nsegs < sup->su_nsums) { syslog(LOG_WARNING,"only %d segment summaries in seg %d (expected %d)", @@ -439,34 +445,34 @@ lfs_segmapv(fsp, seg, seg_buf, blocks, bcount) * blocks or inodes from files with new version numbers. */ void -add_blocks (fsp, bip, countp, sp, seg_buf, segaddr, psegaddr) - FS_INFO *fsp; /* pointer to super block */ - BLOCK_INFO *bip; /* Block info array */ - int *countp; /* IN/OUT: number of blocks in array */ - SEGSUM *sp; /* segment summmary pointer */ - caddr_t seg_buf; /* buffer containing segment */ - daddr_t segaddr; /* address of this segment */ - daddr_t psegaddr; /* address of this partial segment */ +add_blocks (FS_INFO *fsp, BLOCK_INFO *bip, int *countp, SEGSUM *sp, + caddr_t seg_buf, daddr_t segaddr, daddr_t psegaddr) { IFILE *ifp; FINFO *fip; caddr_t bp; daddr_t *dp, *iaddrp; - int db_per_block, i, j; - int db_frag; + int fsb_per_block, i, j; + int fsb_frag; u_long page_size; + struct lfs *lfsp; if(debug > 1) syslog(LOG_DEBUG, "FILE INFOS"); - db_per_block = fsbtodb(&fsp->fi_lfs, 1); + lfsp = &fsp->fi_lfs; + fsb_per_block = fragstofsb(lfsp, lfsp->lfs_frag); page_size = fsp->fi_lfs.lfs_bsize; - bp = seg_buf + datobyte(fsp, psegaddr - segaddr) + LFS_SUMMARY_SIZE; + bp = seg_buf + fsbtob(lfsp, psegaddr - segaddr) + lfsp->lfs_sumsize; bip += *countp; - psegaddr += bytetoda(fsp, LFS_SUMMARY_SIZE); - iaddrp = (daddr_t *)((caddr_t)sp + LFS_SUMMARY_SIZE); + psegaddr += btofsb(lfsp, lfsp->lfs_sumsize); + iaddrp = (daddr_t *)((caddr_t)sp + lfsp->lfs_sumsize); --iaddrp; - for (fip = (FINFO *)(sp + 1), i = 0; i < sp->ss_nfinfo; + if (lfsp->lfs_version == 1) + fip = (FINFO *)(((char *)sp) + sizeof(SEGSUM_V1)); + else + fip = (FINFO *)(sp + 1); + for (i = 0; i < sp->ss_nfinfo; ++i, fip = (FINFO *)(&fip->fi_blocks[fip->fi_nblocks])) { ifp = IFILE_ENTRY(&fsp->fi_lfs, fsp->fi_ifilep, fip->fi_ino); @@ -477,14 +483,17 @@ add_blocks (fsp, bip, countp, sp, seg_buf, segaddr, psegaddr) for (j = 0; j < fip->fi_nblocks; j++, dp++) { /* Skip over intervening inode blocks */ while (psegaddr == *iaddrp) { - psegaddr += db_per_block; + psegaddr += fsb_per_block; bp += page_size; --iaddrp; } bip->bi_inode = fip->fi_ino; bip->bi_lbn = *dp; bip->bi_daddr = psegaddr; - bip->bi_segcreate = (time_t)(sp->ss_create); + if (lfsp->lfs_version == 1) + bip->bi_segcreate = (time_t)(sp->ss_ident); + else + bip->bi_segcreate = (time_t)(sp->ss_create); bip->bi_bp = bp; bip->bi_version = ifp->if_version; @@ -492,21 +501,21 @@ add_blocks (fsp, bip, countp, sp, seg_buf, segaddr, psegaddr) || fip->fi_lastlength == page_size) { bip->bi_size = page_size; - psegaddr += db_per_block; + psegaddr += fsb_per_block; bp += page_size; } else { - db_frag = fragstodb(&(fsp->fi_lfs), + fsb_frag = fragstofsb(&(fsp->fi_lfs), numfrags(&(fsp->fi_lfs), fip->fi_lastlength)); if(debug > 1) { syslog(LOG_DEBUG, "lastlength, frags: %d, %d", - fip->fi_lastlength, db_frag); + fip->fi_lastlength, fsb_frag); } bip->bi_size = fip->fi_lastlength; bp += fip->fi_lastlength; - psegaddr += db_frag; + psegaddr += fsb_frag; } ++bip; ++(*countp); @@ -520,13 +529,8 @@ add_blocks (fsp, bip, countp, sp, seg_buf, segaddr, psegaddr) * actually added. */ void -add_inodes (fsp, bip, countp, sp, seg_buf, seg_addr) - FS_INFO *fsp; /* pointer to super block */ - BLOCK_INFO *bip; /* block info array */ - int *countp; /* pointer to current number of inodes */ - SEGSUM *sp; /* segsum pointer */ - caddr_t seg_buf; /* the buffer containing the segment's data */ - daddr_t seg_addr; /* disk address of seg_buf */ +add_inodes (FS_INFO *fsp, BLOCK_INFO *bip, int *countp, SEGSUM *sp, + caddr_t seg_buf, daddr_t seg_addr) { struct dinode *di = NULL; /* XXX gcc */ struct lfs *lfsp; @@ -545,12 +549,12 @@ add_inodes (fsp, bip, countp, sp, seg_buf, seg_addr) if(debug > 1) syslog(LOG_DEBUG, "INODES:"); - daddrp = (daddr_t *)((caddr_t)sp + LFS_SUMMARY_SIZE); + daddrp = (daddr_t *)((caddr_t)sp + lfsp->lfs_sumsize); for (i = 0; i < sp->ss_ninos; ++i) { if (i % INOPB(lfsp) == 0) { --daddrp; - di = (struct dinode *)(seg_buf + - ((*daddrp - seg_addr) << fsp->fi_daddr_shift)); + di = (struct dinode *)(seg_buf + fsbtob(lfsp, + *daddrp - seg_addr)); } else ++di; @@ -559,7 +563,10 @@ add_inodes (fsp, bip, countp, sp, seg_buf, seg_addr) bp->bi_inode = inum; bp->bi_daddr = *daddrp; bp->bi_bp = di; - bp->bi_segcreate = sp->ss_create; + if (lfsp->lfs_version == 1) + bp->bi_segcreate = sp->ss_ident; + else + bp->bi_segcreate = sp->ss_create; bp->bi_size = i; /* XXX KS - kludge */ if (inum == LFS_IFILE_INUM) { @@ -586,10 +593,7 @@ add_inodes (fsp, bip, countp, sp, seg_buf, seg_addr) * the partial as well as whether or not the checksum is valid. */ int -pseg_valid (fsp, ssp, addr) - FS_INFO *fsp; /* pointer to file system info */ - SEGSUM *ssp; /* pointer to segment summary block */ - daddr_t addr; /* address of the summary block on disk */ +pseg_valid (FS_INFO *fsp, SEGSUM *ssp, daddr_t addr) { int nblocks; #if 0 @@ -610,7 +614,7 @@ pseg_valid (fsp, ssp, addr) #if 0 /* check data/inode block(s) checksum too */ datap = (u_long *)malloc(nblocks * sizeof(u_long)); - p = (caddr_t)ssp + LFS_SUMMARY_SIZE; + p = (caddr_t)ssp + lfsp->lfs_sumsize; for (i = 0; i < nblocks; ++i) { datap[i] = *((u_long *)p); p += fsp->fi_lfs.lfs_bsize; @@ -630,11 +634,7 @@ pseg_valid (fsp, ssp, addr) * read a segment into a memory buffer */ int -mmap_segment (fsp, segment, segbuf, use_mmap) - FS_INFO *fsp; /* file system information */ - int segment; /* segment number */ - caddr_t *segbuf; /* pointer to buffer area */ - int use_mmap; /* mmap instead of read */ +mmap_segment (FS_INFO *fsp, int segment, caddr_t *segbuf, int use_mmap) { struct lfs *lfsp; daddr_t seg_daddr; /* base disk address of segment */ @@ -645,8 +645,8 @@ mmap_segment (fsp, segment, segbuf, use_mmap) lfsp = &fsp->fi_lfs; /* get the disk address of the beginning of the segment */ - seg_daddr = sntoda(lfsp, segment); - seg_byte = datobyte(fsp, seg_daddr); + seg_daddr = sntod(lfsp, segment); + seg_byte = fsbtob(lfsp, (off_t)seg_daddr); ssize = seg_size(lfsp); strcpy(mntfromname, "/dev/r"); @@ -697,10 +697,7 @@ mmap_segment (fsp, segment, segbuf, use_mmap) } void -munmap_segment (fsp, seg_buf, use_mmap) - FS_INFO *fsp; /* file system information */ - caddr_t seg_buf; /* pointer to buffer area */ - int use_mmap; /* mmap instead of read/write */ +munmap_segment (FS_INFO *fsp, caddr_t seg_buf, int use_mmap) { if (use_mmap) munmap (seg_buf, seg_size(&fsp->fi_lfs)); @@ -712,10 +709,7 @@ munmap_segment (fsp, seg_buf, use_mmap) * USEFUL DEBUGGING TOOLS: */ void -print_SEGSUM (lfsp, p, addr) - struct lfs *lfsp; - SEGSUM *p; - daddr_t addr; +print_SEGSUM (struct lfs *lfsp, SEGSUM *p, daddr_t addr) { if (p) (void) dump_summary(lfsp, p, DUMP_ALL, NULL, addr); @@ -724,9 +718,7 @@ print_SEGSUM (lfsp, p, addr) } int -bi_compare(a, b) - const void *a; - const void *b; +bi_compare(const void *a, const void *b) { const BLOCK_INFO *ba, *bb; int diff; @@ -757,10 +749,7 @@ bi_compare(a, b) } int -bi_toss(dummy, a, b) - const void *dummy; - const void *a; - const void *b; +bi_toss(const void *dummy, const void *a, const void *b) { const BLOCK_INFO *ba, *bb; @@ -771,12 +760,7 @@ bi_toss(dummy, a, b) } void -toss(p, nump, size, dotoss, client) - void *p; - int *nump; - size_t size; - int (*dotoss) __P((const void *, const void *, const void *)); - void *client; +toss(void *p, int *nump, size_t size, int (*dotoss)(const void *, const void *, const void *), void *client) { int i; char *p0, *p1; diff --git a/libexec/lfs_cleanerd/misc.c b/libexec/lfs_cleanerd/misc.c index 49644888346..724b231289d 100644 --- a/libexec/lfs_cleanerd/misc.c +++ b/libexec/lfs_cleanerd/misc.c @@ -1,4 +1,4 @@ -/* $NetBSD: misc.c,v 1.6 1999/03/14 11:39:28 drochner Exp $ */ +/* $NetBSD: misc.c,v 1.7 2001/07/13 20:30:22 perseant Exp $ */ /*- * Copyright (c) 1992, 1993 @@ -38,7 +38,7 @@ #if 0 static char sccsid[] = "from: @(#)misc.c 8.1 (Berkeley) 6/4/93"; #else -__RCSID("$NetBSD: misc.c,v 1.6 1999/03/14 11:39:28 drochner Exp $"); +__RCSID("$NetBSD: misc.c,v 1.7 2001/07/13 20:30:22 perseant Exp $"); #endif #endif /* not lint */ @@ -60,11 +60,7 @@ __RCSID("$NetBSD: misc.c,v 1.6 1999/03/14 11:39:28 drochner Exp $"); extern char *special; void -get(fd, off, p, len) - int fd; - off_t off; - void *p; - size_t len; +get(int fd, off_t off, void *p, size_t len) { int rbytes; diff --git a/libexec/lfs_cleanerd/print.c b/libexec/lfs_cleanerd/print.c index 3da35524f77..96352d545da 100644 --- a/libexec/lfs_cleanerd/print.c +++ b/libexec/lfs_cleanerd/print.c @@ -1,4 +1,4 @@ -/* $NetBSD: print.c,v 1.9 2001/01/04 17:29:04 lukem Exp $ */ +/* $NetBSD: print.c,v 1.10 2001/07/13 20:30:22 perseant Exp $ */ /*- * Copyright (c) 1992, 1993 @@ -38,7 +38,7 @@ #if 0 static char sccsid[] = "from: @(#)print.c 8.1 (Berkeley) 6/4/93"; #else -__RCSID("$NetBSD: print.c,v 1.9 2001/01/04 17:29:04 lukem Exp $"); +__RCSID("$NetBSD: print.c,v 1.10 2001/07/13 20:30:22 perseant Exp $"); #endif #endif /* not lint */ @@ -58,7 +58,7 @@ __RCSID("$NetBSD: print.c,v 1.9 2001/01/04 17:29:04 lukem Exp $"); #include "clean.h" extern int debug; -extern u_long cksum __P((void *, size_t)); /* XXX */ +extern u_long cksum(void *, size_t); /* XXX */ /* * Print out a summary block; return number of blocks in segment; 0 @@ -67,12 +67,7 @@ extern u_long cksum __P((void *, size_t)); /* XXX */ */ int -dump_summary(lfsp, sp, flags, iaddrp, addr) - struct lfs *lfsp; - SEGSUM *sp; - u_long flags; - daddr_t **iaddrp; - daddr_t addr; +dump_summary(struct lfs *lfsp, SEGSUM *sp, u_long flags, daddr_t **iaddrp, daddr_t addr) { int i, j, blk, numblocks, accino=0; daddr_t *dp, ddp, *idp; @@ -87,7 +82,7 @@ dump_summary(lfsp, sp, flags, iaddrp, addr) return(-1); if (sp->ss_sumsum != (ck = cksum(&sp->ss_datasum, - LFS_SUMMARY_SIZE - sizeof(sp->ss_sumsum)))) { + lfsp->lfs_sumsize - sizeof(sp->ss_sumsum)))) { free(datap); return(-1); } @@ -99,7 +94,9 @@ dump_summary(lfsp, sp, flags, iaddrp, addr) "ninos ", sp->ss_ninos, "sumsum ", sp->ss_sumsum, "datasum ", sp->ss_datasum ); - syslog(LOG_DEBUG, "\tcreate %s", ctime((time_t *)&sp->ss_create)); + syslog(LOG_DEBUG, "\tcreate %s", ctime( + (lfsp->lfs_version == 1 ? (time_t *)&sp->ss_ident : + (time_t *)&sp->ss_create))); } numblocks = (sp->ss_ninos + INOPB(lfsp) - 1) / INOPB(lfsp); @@ -108,7 +105,7 @@ dump_summary(lfsp, sp, flags, iaddrp, addr) if (flags & DUMP_INODE_ADDRS) syslog(LOG_DEBUG, " Inode addresses:"); - idp = dp = (daddr_t *)((caddr_t)sp + LFS_SUMMARY_SIZE); + idp = dp = (daddr_t *)((caddr_t)sp + lfsp->lfs_sumsize); --idp; for (--dp, i = 0; i < howmany(sp->ss_ninos,INOPB(lfsp)); --dp) { if (flags & DUMP_INODE_ADDRS) @@ -119,26 +116,30 @@ dump_summary(lfsp, sp, flags, iaddrp, addr) *iaddrp = dp; } - ddp = addr + LFS_SUMMARY_SIZE/DEV_BSIZE; - for (fp = (FINFO *)(sp + 1), i = 0; i < sp->ss_nfinfo; ++i) { + ddp = addr + btofsb(lfsp, lfsp->lfs_sumsize); + if (lfsp->lfs_version == 1) + fp = (FINFO *)(((char *)sp) + sizeof(SEGSUM_V1)); + else + fp = (FINFO *)(sp + 1); + for (i = 0; i < sp->ss_nfinfo; ++i) { /* Add any intervening Inode blocks to our checksum array */ /* printf("finfo %d: ddp=%lx, *idp=%lx\n",i,ddp,*idp); */ while(ddp == *idp) { /* printf(" [ino %lx]",ddp); */ - datap[blk++] = *(u_long*)((caddr_t)sp + (ddp-addr)*DEV_BSIZE); + datap[blk++] = *(u_long*)((caddr_t)sp + fsbtob(lfsp, ddp-addr)); --idp; - ddp += lfsp->lfs_bsize/DEV_BSIZE; + ddp += btofsb(lfsp, lfsp->lfs_ibsize); accino++; } for(j=0;j<fp->fi_nblocks;j++) { if(j==fp->fi_nblocks-1) { - size = fp->fi_lastlength/DEV_BSIZE; + size = btofsb(lfsp, fp->fi_lastlength); /* printf(" %lx:%d",ddp,size); */ } else { - size = lfsp->lfs_bsize/DEV_BSIZE; + size = btofsb(lfsp, lfsp->lfs_bsize); /* printf(" %lx/%d",ddp,size); */ } - datap[blk++] = *(u_long*)((caddr_t)sp + (ddp-addr)*DEV_BSIZE); + datap[blk++] = *(u_long*)((caddr_t)sp + fsbtob(lfsp, ddp-addr)); ddp += size; } numblocks += fp->fi_nblocks; @@ -160,7 +161,7 @@ dump_summary(lfsp, sp, flags, iaddrp, addr) while(*idp >= ddp && accino < howmany(sp->ss_ninos,INOPB(lfsp))) { ddp = *idp; /* printf(" [ino %lx]",ddp); */ - datap[blk++] = *(u_long*)((caddr_t)sp + (ddp-addr)*DEV_BSIZE); + datap[blk++] = *(u_long*)((caddr_t)sp + fsbtob(lfsp, ddp-addr)); --idp; accino++; } @@ -185,8 +186,7 @@ dump_summary(lfsp, sp, flags, iaddrp, addr) } void -dump_cleaner_info(ipage) - void *ipage; +dump_cleaner_info(void *ipage) { CLEANERINFO *cip; @@ -199,8 +199,7 @@ dump_cleaner_info(ipage) } void -dump_super(lfsp) - struct lfs *lfsp; +dump_super(struct lfs *lfsp) { int i; @@ -278,6 +277,6 @@ dump_super(lfsp) syslog(LOG_DEBUG, "%s%d\t%s%d\t%s0x%X\t%s%d\n", "nactive ", lfsp->lfs_nactive, "fmod ", lfsp->lfs_fmod, - "clean ", lfsp->lfs_clean, + "pflags ", lfsp->lfs_pflags, "ronly ", lfsp->lfs_ronly); } |
