[unix-history] / usr / src / sbin / dumplfs / dumplfs.c

/*-
 * Copyright (c) 1991 The Regents of the University of California.
 * All rights reserved.
 *
 * %sccs.include.redist.c%
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1991 The Regents of the University of California.\n\
 All rights reserved.\n";
#endif /* not lint */

#ifndef lint
static char sccsid[] = "@(#)dumplfs.c	5.8 (Berkeley) %G%";
#endif /* not lint */

#include <sys/param.h>
#include <sys/ucred.h>
#include <sys/mount.h>
#include <sys/time.h>

#include <ufs/ufs/dinode.h>
#include <ufs/lfs/lfs.h>

#include <fcntl.h>
#include <fstab.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "extern.h"

static void	addseg __P((char *));
static void	dump_cleaner_info __P((struct lfs *, void *));
static void	dump_dinode __P((struct dinode *));
static void	dump_ifile __P((int, struct lfs *, int));
static int	dump_ipage_ifile __P((int, IFILE *, int));
static int	dump_ipage_segusage __P((struct lfs *, int, IFILE *, int));
static void	dump_segment __P((int, int, daddr_t, struct lfs *, int));
static int	dump_sum __P((int, struct lfs *, SEGSUM *, int, daddr_t));
static void	dump_super __P((struct lfs *));
static void	usage __P((void));

typedef struct seglist SEGLIST;
struct seglist {
        SEGLIST *next;
	int num;
};
SEGLIST	*seglist;

int daddr_shift;
char *special;

/* Segment Usage formats */
#define print_suheader \
	(void)printf("segnum\tstatus\tnbytes\t\tlastmod\n")

#define print_suentry(i, sp) \
	(void)printf("%d\t%c%c%c\t%d\t%s", i, \
	    (((sp)->su_flags & SEGUSE_ACTIVE) ? 'A' : ' '), \
	    (((sp)->su_flags & SEGUSE_DIRTY) ? 'D' : 'C'), \
	    (((sp)->su_flags & SEGUSE_SUPERBLOCK) ? 'S' : ' '), \
	    (sp)->su_nbytes, ctime((time_t *)&(sp)->su_lastmod))

/* Ifile formats */
#define print_iheader \
	(void)printf("inum\tstatus\tversion\tdaddr\t\tfreeptr\n")
#define print_ientry(i, ip) \
	if (ip->if_daddr == LFS_UNUSED_DADDR) \
		(void)printf("%d\tFREE\t%d\t \t\t%d\n", \
		    i, ip->if_version, ip->if_nextfree); \
	else \
		(void)printf("%d\tINUSE\t%d\t%8X    \n", \
		    i, ip->if_version, ip->if_daddr)
int
main(argc, argv)
	int argc;
	char *argv[];
{
	struct lfs lfs_sb1, lfs_sb2, *lfs_master;
	daddr_t seg_addr;
	int ch, do_allsb, do_ientries, fd, segnum;

	do_allsb = 0;
	do_ientries = 0;
	while ((ch = getopt(argc, argv, "ais:")) != EOF)
		switch(ch) {
		case 'a':		/* Dump all superblocks */
			do_allsb = 1;
			break;
		case 'i':		/* Dump ifile entries */
			do_ientries = 1;
			break;
		case 's':		/* Dump out these segments */
			addseg(optarg);
			break;
		default:
			usage();
		}
	argc -= optind;
	argv += optind;

	if (argc != 1)
		usage();

	special = argv[0];
	if ((fd = open(special, O_RDONLY, 0)) < 0)
		err("%s: %s", special, strerror(errno));

	/* Read the first superblock */
	get(fd, LFS_LABELPAD, &lfs_sb1, sizeof(struct lfs));
	daddr_shift = lfs_sb1.lfs_bshift - lfs_sb1.lfs_fsbtodb;

	/*
	 * Read the second superblock and figure out which check point is
	 * most up to date.
	 */
	get(fd,
	    lfs_sb1.lfs_sboffs[1] << daddr_shift, &lfs_sb2, sizeof(struct lfs));

	lfs_master = &lfs_sb1;
	if (lfs_sb1.lfs_tstamp < lfs_sb2.lfs_tstamp)
		lfs_master = &lfs_sb2;

	(void)printf("Master Superblock:\n");
	dump_super(lfs_master);

	dump_ifile(fd, lfs_master, do_ientries);

	if (seglist != NULL)
		for (; seglist != NULL; seglist = seglist->next) {
			seg_addr = lfs_master->lfs_sboffs[0] + seglist->num *
			    (lfs_master->lfs_ssize << lfs_master->lfs_fsbtodb);
			dump_segment(fd,
			    seglist->num, seg_addr, lfs_master, do_allsb);
		}
	else
		for (segnum = 0, seg_addr = lfs_master->lfs_sboffs[0];
		    segnum < lfs_master->lfs_nseg; segnum++, seg_addr +=
		    lfs_master->lfs_ssize << lfs_master->lfs_fsbtodb)
			dump_segment(fd,
			    segnum, seg_addr, lfs_master, do_allsb);

	(void)close(fd);
	exit(0);
}

/*
 * We are reading all the blocks of an inode and dumping out the ifile table.
 * This code could be tighter, but this is a first pass at getting the stuff
 * printed out rather than making this code incredibly efficient.
 */
static void
dump_ifile(fd, lfsp, do_ientries)
	int fd;
	struct lfs *lfsp;
	int do_ientries;
{
	IFILE *ipage;
	struct dinode *dip, *dpage;
	daddr_t addr, *addrp, *dindir, *iaddrp, *indir;
	int block_limit, i, inum, j, nblocks, nsupb, psize;

	psize = lfsp->lfs_bsize;
	addr = lfsp->lfs_idaddr;

	if (!(dip = dpage = malloc(psize)))
		err("%s", strerror(errno));
	get(fd, addr << daddr_shift, dip, psize);

	for (i = 0; i < lfsp->lfs_inopb; i++, dip++)
		if (dip->di_inum == LFS_IFILE_INUM)
			break;

	if (i >= lfsp->lfs_inopb)
		err("unable to locate ifile inode");

	(void)printf("\nIFILE inode\n");
	dump_dinode(dip);

	(void)printf("\nIFILE contents\n");
	nblocks = dip->di_size >> lfsp->lfs_bshift;
	block_limit = MIN(nblocks, NDADDR);

	/* Get the direct block */
	if ((ipage = malloc(psize)) == NULL)
		err("%s", strerror(errno));
	for (inum = 0, addrp = dip->di_db, i = 0; i < block_limit;
	    i++, addrp++) {
		get(fd, *addrp << daddr_shift, ipage, psize);
		if (i < lfsp->lfs_cleansz) {
			dump_cleaner_info(lfsp, ipage);
			print_suheader;
			continue;
		} 

		if (i < (lfsp->lfs_segtabsz + lfsp->lfs_cleansz)) {
			inum = dump_ipage_segusage(lfsp, inum, ipage, 
			    lfsp->lfs_sepb);
			if (!inum)
				if(!do_ientries)
					goto e1;
				else
					print_iheader;
		} else
			inum = dump_ipage_ifile(inum, ipage, lfsp->lfs_ifpb);

	}

	if (nblocks <= NDADDR)
		goto e0;

	/* Dump out blocks off of single indirect block */
	if (!(indir = malloc(psize)))
		err("%s", strerror(errno));
	get(fd, dip->di_ib[0] << daddr_shift, indir, psize);
	block_limit = MIN(i + lfsp->lfs_nindir, nblocks);
	for (addrp = indir; i < block_limit; i++, addrp++) {
		if (*addrp == LFS_UNUSED_DADDR)
			break;
		get(fd, *addrp << daddr_shift,ipage, psize);
		if (i < lfsp->lfs_cleansz) {
			dump_cleaner_info(lfsp, ipage);
			continue;
		} else 
			i -= lfsp->lfs_cleansz;

		if (i < lfsp->lfs_segtabsz) {
			inum = dump_ipage_segusage(lfsp, inum, ipage, 
			    lfsp->lfs_sepb);
			if (!inum)
				if(!do_ientries)
					goto e1;
				else
					print_iheader;
		} else
			inum = dump_ipage_ifile(inum, ipage, lfsp->lfs_ifpb);
	}

	if (nblocks <= lfsp->lfs_nindir * lfsp->lfs_ifpb)
		goto e1;

	/* Get the double indirect block */
	if (!(dindir = malloc(psize)))
		err("%s", strerror(errno));
	get(fd, dip->di_ib[1] << daddr_shift, dindir, psize);
	for (iaddrp = dindir, j = 0; j < lfsp->lfs_nindir; j++, iaddrp++) {
		if (*iaddrp == LFS_UNUSED_DADDR)
			break;
		get(fd, *iaddrp << daddr_shift, indir, psize);
		block_limit = MIN(i + lfsp->lfs_nindir, nblocks);
		for (addrp = indir; i < block_limit; i++, addrp++) {
			if (*addrp == LFS_UNUSED_DADDR)
				break;
			get(fd, *addrp << daddr_shift, ipage, psize);
			if (i < lfsp->lfs_cleansz) {
				dump_cleaner_info(lfsp, ipage);
				continue;
			} else 
				i -= lfsp->lfs_cleansz;

			if (i < lfsp->lfs_segtabsz) {
				inum = dump_ipage_segusage(lfsp,
				    inum, ipage, lfsp->lfs_sepb);
				if (!inum)
					if(!do_ientries)
						goto e2;
					else
						print_iheader;
			} else
				inum = dump_ipage_ifile(inum,
				    ipage, lfsp->lfs_ifpb);
		}
	}
e2:	free(dindir);
e1:	free(indir);
e0:	free(dpage);
	free(ipage);
}

static int
dump_ipage_ifile(i, pp, tot)
	int i;
	IFILE *pp;
	int tot;
{
	IFILE *ip;
	int cnt, max;

	max = i + tot;

	for (ip = pp, cnt = i; cnt < max; cnt++, ip++)
		print_ientry(cnt, ip);
	return (max);
}

static int
dump_ipage_segusage(lfsp, i, pp, tot)
	struct lfs *lfsp;
	int i;
	IFILE *pp;
	int tot;
{
	SEGUSE *sp;
	int cnt, max;

	max = i + tot;
	for (sp = (SEGUSE *)pp, cnt = i;
	     cnt < lfsp->lfs_nseg && cnt < max; cnt++, sp++)
		print_suentry(cnt, sp);
	if (max >= lfsp->lfs_nseg)
		return (0);
	else
		return (max);
}

static void
dump_dinode(dip)
	struct dinode *dip;
{
	int i;

	(void)printf("%s%d\t%s%d\t%s%d\t%s%d\t%s%d\n",
		"mode  ", dip->di_mode,
		"nlink ", dip->di_nlink,
		"uid   ", dip->di_uid,
		"gid   ", dip->di_gid,
		"size  ", dip->di_size);
	(void)printf("%s%s%s%s%s%s",
		"atime ", ctime(&dip->di_atime.ts_sec),
		"mtime ", ctime(&dip->di_mtime.ts_sec),
		"ctime ", ctime(&dip->di_ctime.ts_sec));
	(void)printf("inum  %d\n", dip->di_inum);
	(void)printf("Direct Addresses\n");
	for (i = 0; i < NDADDR; i++) {
		(void)printf("\t%X", dip->di_db[i]);
		if ((i % 6) == 5)
			(void)printf("\n");
	}
	for (i = 0; i < NIADDR; i++)
		(void)printf("\t%X", dip->di_ib[i]);
	(void)printf("\n");
}

static int
dump_sum(fd, lfsp, sp, segnum, addr)
	struct lfs *lfsp;
	SEGSUM *sp;
	int fd, segnum;
	daddr_t addr;
{
	FINFO *fp;
	long *dp;
	int i, j;
	int ck;
	int numblocks;
	struct dinode *inop;

	if (sp->ss_sumsum != (ck = cksum(&sp->ss_datasum, 
	    LFS_SUMMARY_SIZE - sizeof(sp->ss_sumsum))))
		(void)printf("dumplfs: %s %d address %lx\n",
		    "corrupt summary block; segment", segnum, addr);

	(void)printf("Segment Summary Info\n");
	(void)printf("\t%s%X\t%s%d\t%s%d\t%s%X\t%s%X\n",
		"next     ", sp->ss_next,
		"nfinfo   ", sp->ss_nfinfo,
		"ninos    ", sp->ss_ninos,
		"sumsum   ", sp->ss_sumsum,
		"datasum  ", sp->ss_datasum );
	(void)printf("\tcreate   %s", ctime((time_t *)&sp->ss_create));

	numblocks = (sp->ss_ninos + INOPB(lfsp) - 1) / INOPB(lfsp);

	/* Dump out inode disk addresses */
	dp = (daddr_t *)sp;
	dp += LFS_SUMMARY_SIZE / sizeof(daddr_t);
	inop = malloc(1 << lfsp->lfs_bshift);
	printf("\tInode addresses:");
	for (dp--, i = 0; i < sp->ss_ninos; dp--) {
		printf("\t%X {", *dp);
		get(fd, *dp << (lfsp->lfs_bshift - lfsp->lfs_fsbtodb), inop, 
		    (1 << lfsp->lfs_bshift));
		for (j = 0; i < sp->ss_ninos && j < INOPB(lfsp); j++, i++) {
			if (j > 0) 
				(void)printf(", ");
			(void)printf("%d", inop[j].di_inum);
		}
		(void)printf("}");
		if (((i/INOPB(lfsp)) % 4) == 3)
			(void)printf("\n");
	}
	free(inop);

	printf("\n");
	for (fp = (FINFO *)(sp + 1), i = 0; i < sp->ss_nfinfo; i++) {
		numblocks += fp->fi_nblocks;
		(void)printf("File Info for file: %d version %d nblocks %d\n",
		    fp->fi_ino, fp->fi_version, fp->fi_nblocks);
		dp = &(fp->fi_blocks[0]);
		for (j = 0; j < fp->fi_nblocks; j++, dp++) {
			(void)printf("\t%d", *dp);
			if ((j % 8) == 7)
				(void)printf("\n");
		}
		if ((j % 8) != 0)
			(void)printf("\n");
		fp = (FINFO *)dp;
	}
	return (numblocks);
}

static void
dump_segment(fd, segnum, addr, lfsp, dump_sb)
	int fd, segnum;
	daddr_t addr;
	struct lfs *lfsp;
	int dump_sb;
{
	struct lfs lfs_sb, *sbp;
	SEGSUM *sump;
	char sumblock[LFS_SUMMARY_SIZE];
	int did_one, nblocks, sb;
	off_t sum_offset, super_off;

	(void)printf("\nSegment Number %d (Disk Address %X)\n",
	    addr >> (lfsp->lfs_segshift - daddr_shift), addr);
	sum_offset = (addr << (lfsp->lfs_bshift - lfsp->lfs_fsbtodb));

	sb = 0;
	did_one = 0;
	do {
		get(fd, sum_offset, sumblock, LFS_SUMMARY_SIZE);
		sump = (SEGSUM *)sumblock;
		if (sump->ss_sumsum != cksum (&sump->ss_datasum, 
			LFS_SUMMARY_SIZE - sizeof(sump->ss_sumsum))) {
			sbp = (struct lfs *)sump;
			if (sb = (sbp->lfs_magic == LFS_MAGIC)) {
				super_off = sum_offset;
				sum_offset += LFS_SBPAD;
			} else if (did_one)
				break;
			else {
				printf("Segment at %X corrupt\n", addr);
				break;
			}
		} else {
			nblocks = dump_sum(fd, lfsp, sump, segnum, addr);
			if (nblocks)
				sum_offset += LFS_SUMMARY_SIZE + 
					(nblocks << lfsp->lfs_bshift);
			else
				sum_offset = 0;
			did_one = 1;
		}
	} while (sum_offset);

	if (dump_sb && sb)  {
		get(fd, super_off, &lfs_sb, sizeof(struct lfs));
		dump_super(&lfs_sb);
	}
	return;
}

static void
dump_super(lfsp)
	struct lfs *lfsp;
{
	int i;

	(void)printf("%s%X\t%s%X\t%s%d\t%s%d\n",
		"magic    ", lfsp->lfs_magic,
		"version  ", lfsp->lfs_version,
		"size     ", lfsp->lfs_size,
		"ssize    ", lfsp->lfs_ssize);
	(void)printf("%s%d\t%s%d\t%s%d\t%s%d\n",
		"dsize    ", lfsp->lfs_dsize,
		"bsize    ", lfsp->lfs_bsize,
		"fsize    ", lfsp->lfs_fsize,
		"frag     ", lfsp->lfs_frag);

	(void)printf("%s%d\t%s%d\t%s%d\t%s%d\n",
		"minfree  ", lfsp->lfs_minfree,
		"inopb    ", lfsp->lfs_inopb,
		"ifpb     ", lfsp->lfs_ifpb,
		"nindir   ", lfsp->lfs_nindir);

	(void)printf("%s%d\t%s%d\t%s%d\t%s%d\n",
		"nseg     ", lfsp->lfs_nseg,
		"nspf     ", lfsp->lfs_nspf,
		"cleansz  ", lfsp->lfs_cleansz,
		"segtabsz ", lfsp->lfs_segtabsz);

	(void)printf("%s%X\t%s%d\t%s%X\t%s%d\n",
		"segmask  ", lfsp->lfs_segmask,
		"segshift ", lfsp->lfs_segshift,
		"bmask    ", lfsp->lfs_bmask,
		"bshift   ", lfsp->lfs_bshift);

	(void)printf("%s%X\t%s%d\t%s%X\t%s%d\n",
		"ffmask   ", lfsp->lfs_ffmask,
		"ffshift  ", lfsp->lfs_ffshift,
		"fbmask   ", lfsp->lfs_fbmask,
		"fbshift  ", lfsp->lfs_fbshift);

	(void)printf("%s%d\t%s%X\n",
		"fsbtodb  ", lfsp->lfs_fsbtodb,
		"cksum    ", lfsp->lfs_cksum);

	(void)printf("Superblock disk addresses:");
	for (i = 0; i < LFS_MAXNUMSB; i++)
		(void)printf(" %X", lfsp->lfs_sboffs[i]);
	(void)printf("\n");

	(void)printf("Checkpoint Info\n");
	(void)printf("%s%d\t%s%X\t%s%d\n",
		"free     ", lfsp->lfs_free,
		"idaddr   ", lfsp->lfs_idaddr,
		"ifile    ", lfsp->lfs_ifile);
	(void)printf("%s%X\t%s%d\t%s%X\t%s%X\t%s%X\t%s%X\n",
		"bfree    ", lfsp->lfs_bfree,
		"nfiles   ", lfsp->lfs_nfiles,
		"lastseg  ", lfsp->lfs_lastseg,
		"nextseg  ", lfsp->lfs_nextseg,
		"curseg   ", lfsp->lfs_curseg,
		"offset   ", lfsp->lfs_offset);
	(void)printf("tstamp   %s", ctime((time_t *)&lfsp->lfs_tstamp));
}

static void
addseg(arg)
	char *arg;
{
	SEGLIST *p;

	if ((p = malloc(sizeof(SEGLIST))) == NULL)
		err("%s", strerror(errno));
	p->next = seglist;
	p->num = atoi(arg);
	seglist = p;
}

static void
dump_cleaner_info(lfsp, ipage)
	struct lfs *lfsp;
	void *ipage;
{
	CLEANERINFO *cip;

	cip = (CLEANERINFO *)ipage;
	(void)printf("Cleaner Info\nclean\t%d\tdirty\t%d\n",
	    cip->clean, cip->dirty);
}

static void
usage()
{
	(void)fprintf(stderr, "usage: dumplfs [-ai] [-s segnum] file\n");
	exit(1);
}
Commit	Line	Data
f9268b79 KB	1	/*-
	2	* Copyright (c) 1991 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* %sccs.include.redist.c%
	6	*/
	7
	8	#ifndef lint
	9	char copyright[] =
	10	"@(#) Copyright (c) 1991 The Regents of the University of California.\n\
	11	All rights reserved.\n";
	12	#endif /* not lint */
	13
	14	#ifndef lint
a5e802a6	15	static char sccsid[] = "@(#)dumplfs.c 5.8 (Berkeley) %G%";
f9268b79 KB	16	#endif /* not lint */
	17
	18	#include <sys/param.h>
be25f164	19	#include <sys/ucred.h>
f9268b79	20	#include <sys/mount.h>
a5e802a6	21	#include <sys/time.h>
03edad73 KB	22
	23	#include <ufs/ufs/dinode.h>
	24	#include <ufs/lfs/lfs.h>
	25
a5e802a6	26	#include <fcntl.h>
f9268b79 KB	27	#include <fstab.h>
	28	#include <errno.h>
	29	#include <unistd.h>
	30	#include <stdlib.h>
	31	#include <stdio.h>
	32	#include <string.h>
	33	#include "extern.h"
	34
dc0cf371	35	static void addseg __P((char *));
03edad73	36	static void dump_cleaner_info __P((struct lfs , void ));
f9268b79	37	static void dump_dinode __P((struct dinode *));
03edad73	38	static void dump_ifile __P((int, struct lfs *, int));
f9268b79	39	static int dump_ipage_ifile __P((int, IFILE *, int));
03edad73 KB	40	static int dump_ipage_segusage __P((struct lfs , int, IFILE , int));
03edad73 KB	41	static void dump_segment __P((int, int, daddr_t, struct lfs *, int));
811654f7	42	static int dump_sum __P((int, struct lfs , SEGSUM , int, daddr_t));
03edad73	43	static void dump_super __P((struct lfs *));
f9268b79 KB	44	static void usage __P((void));
f9268b79 KB	45
dc0cf371 KB	46	typedef struct seglist SEGLIST;
	47	struct seglist {
	48	SEGLIST *next;
	49	int num;
	50	};
	51	SEGLIST *seglist;
	52
	53	int daddr_shift;
f9268b79 KB	54	char *special;
	55
	56	/* Segment Usage formats */
	57	#define print_suheader \
	58	(void)printf("segnum\tstatus\tnbytes\t\tlastmod\n")
8d926470	59
f9268b79	60	#define print_suentry(i, sp) \
8d926470 KB	61	(void)printf("%d\t%c%c%c\t%d\t%s", i, \
	62	(((sp)->su_flags & SEGUSE_ACTIVE) ? 'A' : ' '), \
	63	(((sp)->su_flags & SEGUSE_DIRTY) ? 'D' : 'C'), \
	64	(((sp)->su_flags & SEGUSE_SUPERBLOCK) ? 'S' : ' '), \
f9268b79 KB	65	(sp)->su_nbytes, ctime((time_t *)&(sp)->su_lastmod))
	66
	67	/* Ifile formats */
	68	#define print_iheader \
a3262c84	69	(void)printf("inum\tstatus\tversion\tdaddr\t\tfreeptr\n")
f9268b79 KB	70	#define print_ientry(i, ip) \
f9268b79 KB	71	if (ip->if_daddr == LFS_UNUSED_DADDR) \
a3262c84	72	(void)printf("%d\tFREE\t%d\t \t\t%d\n", \
f9268b79 KB	73	i, ip->if_version, ip->if_nextfree); \
f9268b79 KB	74	else \
a3262c84 KB	75	(void)printf("%d\tINUSE\t%d\t%8X \n", \
a3262c84 KB	76	i, ip->if_version, ip->if_daddr)
f9268b79	77	int
03edad73	78	main(argc, argv)
f9268b79 KB	79	int argc;
	80	char *argv[];
	81	{
03edad73	82	struct lfs lfs_sb1, lfs_sb2, *lfs_master;
dc0cf371 KB	83	daddr_t seg_addr;
dc0cf371 KB	84	int ch, do_allsb, do_ientries, fd, segnum;
f9268b79 KB	85
	86	do_allsb = 0;
	87	do_ientries = 0;
dc0cf371	88	while ((ch = getopt(argc, argv, "ais:")) != EOF)
f9268b79	89	switch(ch) {
dc0cf371 KB	90	case 'a': /* Dump all superblocks */
	91	do_allsb = 1;
	92	break;
f9268b79 KB	93	case 'i': /* Dump ifile entries */
	94	do_ientries = 1;
	95	break;
dc0cf371 KB	96	case 's': /* Dump out these segments */
dc0cf371 KB	97	addseg(optarg);
f9268b79 KB	98	break;
	99	default:
	100	usage();
	101	}
	102	argc -= optind;
	103	argv += optind;
	104
	105	if (argc != 1)
	106	usage();
	107
	108	special = argv[0];
	109	if ((fd = open(special, O_RDONLY, 0)) < 0)
	110	err("%s: %s", special, strerror(errno));
	111
	112	/* Read the first superblock */
03edad73	113	get(fd, LFS_LABELPAD, &lfs_sb1, sizeof(struct lfs));
f9268b79 KB	114	daddr_shift = lfs_sb1.lfs_bshift - lfs_sb1.lfs_fsbtodb;
	115
	116	/*
	117	* Read the second superblock and figure out which check point is
	118	* most up to date.
	119	*/
03edad73 KB	120	get(fd,
03edad73 KB	121	lfs_sb1.lfs_sboffs[1] << daddr_shift, &lfs_sb2, sizeof(struct lfs));
dc0cf371	122
f9268b79 KB	123	lfs_master = &lfs_sb1;
	124	if (lfs_sb1.lfs_tstamp < lfs_sb2.lfs_tstamp)
	125	lfs_master = &lfs_sb2;
	126
	127	(void)printf("Master Superblock:\n");
	128	dump_super(lfs_master);
	129
	130	dump_ifile(fd, lfs_master, do_ientries);
	131
dc0cf371 KB	132	if (seglist != NULL)
	133	for (; seglist != NULL; seglist = seglist->next) {
	134	seg_addr = lfs_master->lfs_sboffs[0] + seglist->num *
	135	(lfs_master->lfs_ssize << lfs_master->lfs_fsbtodb);
	136	dump_segment(fd,
	137	seglist->num, seg_addr, lfs_master, do_allsb);
	138	}
	139	else
	140	for (segnum = 0, seg_addr = lfs_master->lfs_sboffs[0];
	141	segnum < lfs_master->lfs_nseg; segnum++, seg_addr +=
	142	lfs_master->lfs_ssize << lfs_master->lfs_fsbtodb)
	143	dump_segment(fd,
	144	segnum, seg_addr, lfs_master, do_allsb);
	145
f9268b79 KB	146	(void)close(fd);
	147	exit(0);
	148	}
	149
	150	/*
	151	* We are reading all the blocks of an inode and dumping out the ifile table.
03edad73	152	* This code could be tighter, but this is a first pass at getting the stuff
f9268b79 KB	153	* printed out rather than making this code incredibly efficient.
	154	*/
	155	static void
	156	dump_ifile(fd, lfsp, do_ientries)
	157	int fd;
03edad73	158	struct lfs *lfsp;
f9268b79 KB	159	int do_ientries;
	160	{
	161	IFILE *ipage;
	162	struct dinode dip, dpage;
03edad73 KB	163	daddr_t addr, addrp, dindir, iaddrp, indir;
03edad73 KB	164	int block_limit, i, inum, j, nblocks, nsupb, psize;
f9268b79 KB	165
	166	psize = lfsp->lfs_bsize;
	167	addr = lfsp->lfs_idaddr;
f9268b79 KB	168
	169	if (!(dip = dpage = malloc(psize)))
	170	err("%s", strerror(errno));
	171	get(fd, addr << daddr_shift, dip, psize);
	172
	173	for (i = 0; i < lfsp->lfs_inopb; i++, dip++)
	174	if (dip->di_inum == LFS_IFILE_INUM)
	175	break;
	176
	177	if (i >= lfsp->lfs_inopb)
	178	err("unable to locate ifile inode");
	179
	180	(void)printf("\nIFILE inode\n");
	181	dump_dinode(dip);
dc0cf371	182
f9268b79	183	(void)printf("\nIFILE contents\n");
f9268b79 KB	184	nblocks = dip->di_size >> lfsp->lfs_bshift;
	185	block_limit = MIN(nblocks, NDADDR);
	186
	187	/* Get the direct block */
	188	if ((ipage = malloc(psize)) == NULL)
	189	err("%s", strerror(errno));
	190	for (inum = 0, addrp = dip->di_db, i = 0; i < block_limit;
	191	i++, addrp++) {
	192	get(fd, *addrp << daddr_shift, ipage, psize);
03edad73 KB	193	if (i < lfsp->lfs_cleansz) {
03edad73 KB	194	dump_cleaner_info(lfsp, ipage);
a3262c84	195	print_suheader;
03edad73	196	continue;
a3262c84	197	}
f9268b79	198
a3262c84	199	if (i < (lfsp->lfs_segtabsz + lfsp->lfs_cleansz)) {
03edad73 KB	200	inum = dump_ipage_segusage(lfsp, inum, ipage,
03edad73 KB	201	lfsp->lfs_sepb);
f9268b79 KB	202	if (!inum)
f9268b79 KB	203	if(!do_ientries)
03edad73	204	goto e1;
f9268b79 KB	205	else
	206	print_iheader;
	207	} else
	208	inum = dump_ipage_ifile(inum, ipage, lfsp->lfs_ifpb);
03edad73	209
f9268b79 KB	210	}
	211
	212	if (nblocks <= NDADDR)
	213	goto e0;
	214
	215	/* Dump out blocks off of single indirect block */
	216	if (!(indir = malloc(psize)))
	217	err("%s", strerror(errno));
	218	get(fd, dip->di_ib[0] << daddr_shift, indir, psize);
	219	block_limit = MIN(i + lfsp->lfs_nindir, nblocks);
	220	for (addrp = indir; i < block_limit; i++, addrp++) {
	221	if (*addrp == LFS_UNUSED_DADDR)
	222	break;
	223	get(fd, *addrp << daddr_shift,ipage, psize);
03edad73 KB	224	if (i < lfsp->lfs_cleansz) {
	225	dump_cleaner_info(lfsp, ipage);
	226	continue;
	227	} else
	228	i -= lfsp->lfs_cleansz;
	229
f9268b79	230	if (i < lfsp->lfs_segtabsz) {
03edad73 KB	231	inum = dump_ipage_segusage(lfsp, inum, ipage,
03edad73 KB	232	lfsp->lfs_sepb);
f9268b79 KB	233	if (!inum)
	234	if(!do_ientries)
	235	goto e1;
	236	else
	237	print_iheader;
	238	} else
	239	inum = dump_ipage_ifile(inum, ipage, lfsp->lfs_ifpb);
	240	}
	241
	242	if (nblocks <= lfsp->lfs_nindir * lfsp->lfs_ifpb)
	243	goto e1;
dc0cf371	244
f9268b79 KB	245	/* Get the double indirect block */
	246	if (!(dindir = malloc(psize)))
	247	err("%s", strerror(errno));
	248	get(fd, dip->di_ib[1] << daddr_shift, dindir, psize);
	249	for (iaddrp = dindir, j = 0; j < lfsp->lfs_nindir; j++, iaddrp++) {
	250	if (*iaddrp == LFS_UNUSED_DADDR)
	251	break;
	252	get(fd, *iaddrp << daddr_shift, indir, psize);
	253	block_limit = MIN(i + lfsp->lfs_nindir, nblocks);
	254	for (addrp = indir; i < block_limit; i++, addrp++) {
	255	if (*addrp == LFS_UNUSED_DADDR)
	256	break;
	257	get(fd, *addrp << daddr_shift, ipage, psize);
03edad73 KB	258	if (i < lfsp->lfs_cleansz) {
	259	dump_cleaner_info(lfsp, ipage);
	260	continue;
	261	} else
	262	i -= lfsp->lfs_cleansz;
	263
f9268b79 KB	264	if (i < lfsp->lfs_segtabsz) {
f9268b79 KB	265	inum = dump_ipage_segusage(lfsp,
03edad73	266	inum, ipage, lfsp->lfs_sepb);
f9268b79 KB	267	if (!inum)
	268	if(!do_ientries)
	269	goto e2;
	270	else
	271	print_iheader;
	272	} else
	273	inum = dump_ipage_ifile(inum,
	274	ipage, lfsp->lfs_ifpb);
	275	}
	276	}
	277	e2: free(dindir);
	278	e1: free(indir);
	279	e0: free(dpage);
	280	free(ipage);
	281	}
	282
	283	static int
	284	dump_ipage_ifile(i, pp, tot)
	285	int i;
	286	IFILE *pp;
	287	int tot;
	288	{
	289	IFILE *ip;
	290	int cnt, max;
	291
	292	max = i + tot;
	293
	294	for (ip = pp, cnt = i; cnt < max; cnt++, ip++)
	295	print_ientry(cnt, ip);
	296	return (max);
	297	}
	298
	299	static int
	300	dump_ipage_segusage(lfsp, i, pp, tot)
03edad73	301	struct lfs *lfsp;
f9268b79 KB	302	int i;
	303	IFILE *pp;
	304	int tot;
	305	{
dc0cf371	306	SEGUSE *sp;
f9268b79 KB	307	int cnt, max;
	308
	309	max = i + tot;
dc0cf371	310	for (sp = (SEGUSE *)pp, cnt = i;
f9268b79 KB	311	cnt < lfsp->lfs_nseg && cnt < max; cnt++, sp++)
	312	print_suentry(cnt, sp);
	313	if (max >= lfsp->lfs_nseg)
	314	return (0);
	315	else
	316	return (max);
	317	}
	318
	319	static void
	320	dump_dinode(dip)
	321	struct dinode *dip;
	322	{
	323	int i;
	324
	325	(void)printf("%s%d\t%s%d\t%s%d\t%s%d\t%s%d\n",
	326	"mode ", dip->di_mode,
	327	"nlink ", dip->di_nlink,
	328	"uid ", dip->di_uid,
	329	"gid ", dip->di_gid,
	330	"size ", dip->di_size);
	331	(void)printf("%s%s%s%s%s%s",
a5e802a6 KB	332	"atime ", ctime(&dip->di_atime.ts_sec),
	333	"mtime ", ctime(&dip->di_mtime.ts_sec),
	334	"ctime ", ctime(&dip->di_ctime.ts_sec));
f9268b79 KB	335	(void)printf("inum %d\n", dip->di_inum);
	336	(void)printf("Direct Addresses\n");
	337	for (i = 0; i < NDADDR; i++) {
	338	(void)printf("\t%X", dip->di_db[i]);
	339	if ((i % 6) == 5)
	340	(void)printf("\n");
	341	}
	342	for (i = 0; i < NIADDR; i++)
	343	(void)printf("\t%X", dip->di_ib[i]);
	344	(void)printf("\n");
	345	}
	346
	347	static int
811654f7	348	dump_sum(fd, lfsp, sp, segnum, addr)
03edad73	349	struct lfs *lfsp;
f9268b79	350	SEGSUM *sp;
811654f7	351	int fd, segnum;
dc0cf371	352	daddr_t addr;
f9268b79 KB	353	{
f9268b79 KB	354	FINFO *fp;
dc0cf371	355	long *dp;
03edad73	356	int i, j;
dc0cf371	357	int ck;
03edad73	358	int numblocks;
811654f7	359	struct dinode *inop;
dc0cf371	360
03edad73 KB	361	if (sp->ss_sumsum != (ck = cksum(&sp->ss_datasum,
03edad73 KB	362	LFS_SUMMARY_SIZE - sizeof(sp->ss_sumsum))))
dc0cf371 KB	363	(void)printf("dumplfs: %s %d address %lx\n",
dc0cf371 KB	364	"corrupt summary block; segment", segnum, addr);
f9268b79 KB	365
f9268b79 KB	366	(void)printf("Segment Summary Info\n");
03edad73	367	(void)printf("\t%s%X\t%s%d\t%s%d\t%s%X\t%s%X\n",
f9268b79	368	"next ", sp->ss_next,
f9268b79 KB	369	"nfinfo ", sp->ss_nfinfo,
f9268b79 KB	370	"ninos ", sp->ss_ninos,
03edad73 KB	371	"sumsum ", sp->ss_sumsum,
03edad73 KB	372	"datasum ", sp->ss_datasum );
f9268b79 KB	373	(void)printf("\tcreate %s", ctime((time_t *)&sp->ss_create));
f9268b79 KB	374
03edad73 KB	375	numblocks = (sp->ss_ninos + INOPB(lfsp) - 1) / INOPB(lfsp);
	376
	377	/* Dump out inode disk addresses */
	378	dp = (daddr_t *)sp;
	379	dp += LFS_SUMMARY_SIZE / sizeof(daddr_t);
811654f7	380	inop = malloc(1 << lfsp->lfs_bshift);
03edad73	381	printf("\tInode addresses:");
811654f7 CS	382	for (dp--, i = 0; i < sp->ss_ninos; dp--) {
	383	printf("\t%X {", *dp);
	384	get(fd, *dp << (lfsp->lfs_bshift - lfsp->lfs_fsbtodb), inop,
	385	(1 << lfsp->lfs_bshift));
	386	for (j = 0; i < sp->ss_ninos && j < INOPB(lfsp); j++, i++) {
	387	if (j > 0)
	388	(void)printf(", ");
	389	(void)printf("%d", inop[j].di_inum);
	390	}
	391	(void)printf("}");
	392	if (((i/INOPB(lfsp)) % 4) == 3)
	393	(void)printf("\n");
	394	}
	395	free(inop);
03edad73 KB	396
03edad73 KB	397	printf("\n");
f9268b79	398	for (fp = (FINFO *)(sp + 1), i = 0; i < sp->ss_nfinfo; i++) {
03edad73	399	numblocks += fp->fi_nblocks;
f9268b79 KB	400	(void)printf("File Info for file: %d version %d nblocks %d\n",
	401	fp->fi_ino, fp->fi_version, fp->fi_nblocks);
	402	dp = &(fp->fi_blocks[0]);
	403	for (j = 0; j < fp->fi_nblocks; j++, dp++) {
	404	(void)printf("\t%d", *dp);
	405	if ((j % 8) == 7)
	406	(void)printf("\n");
	407	}
	408	if ((j % 8) != 0)
	409	(void)printf("\n");
	410	fp = (FINFO *)dp;
	411	}
03edad73	412	return (numblocks);
f9268b79 KB	413	}
f9268b79 KB	414
03edad73	415	static void
dc0cf371 KB	416	dump_segment(fd, segnum, addr, lfsp, dump_sb)
dc0cf371 KB	417	int fd, segnum;
f9268b79	418	daddr_t addr;
03edad73	419	struct lfs *lfsp;
f9268b79 KB	420	int dump_sb;
f9268b79 KB	421	{
03edad73	422	struct lfs lfs_sb, *sbp;
f9268b79 KB	423	SEGSUM *sump;
f9268b79 KB	424	char sumblock[LFS_SUMMARY_SIZE];
03edad73 KB	425	int did_one, nblocks, sb;
03edad73 KB	426	off_t sum_offset, super_off;
f9268b79	427
dc0cf371	428	(void)printf("\nSegment Number %d (Disk Address %X)\n",
f9268b79	429	addr >> (lfsp->lfs_segshift - daddr_shift), addr);
03edad73	430	sum_offset = (addr << (lfsp->lfs_bshift - lfsp->lfs_fsbtodb));
dc0cf371	431
f9268b79	432	sb = 0;
03edad73	433	did_one = 0;
f9268b79 KB	434	do {
	435	get(fd, sum_offset, sumblock, LFS_SUMMARY_SIZE);
	436	sump = (SEGSUM *)sumblock;
03edad73 KB	437	if (sump->ss_sumsum != cksum (&sump->ss_datasum,
	438	LFS_SUMMARY_SIZE - sizeof(sump->ss_sumsum))) {
	439	sbp = (struct lfs *)sump;
	440	if (sb = (sbp->lfs_magic == LFS_MAGIC)) {
	441	super_off = sum_offset;
	442	sum_offset += LFS_SBPAD;
	443	} else if (did_one)
	444	break;
	445	else {
	446	printf("Segment at %X corrupt\n", addr);
	447	break;
	448	}
	449	} else {
811654f7	450	nblocks = dump_sum(fd, lfsp, sump, segnum, addr);
03edad73	451	if (nblocks)
811654f7 CS	452	sum_offset += LFS_SUMMARY_SIZE +
811654f7 CS	453	(nblocks << lfsp->lfs_bshift);
03edad73 KB	454	else
	455	sum_offset = 0;
	456	did_one = 1;
	457	}
f9268b79	458	} while (sum_offset);
03edad73	459
f9268b79	460	if (dump_sb && sb) {
03edad73	461	get(fd, super_off, &lfs_sb, sizeof(struct lfs));
f9268b79 KB	462	dump_super(&lfs_sb);
f9268b79 KB	463	}
03edad73	464	return;
f9268b79 KB	465	}
f9268b79 KB	466
dc0cf371	467	static void
f9268b79	468	dump_super(lfsp)
03edad73	469	struct lfs *lfsp;
f9268b79 KB	470	{
	471	int i;
	472
	473	(void)printf("%s%X\t%s%X\t%s%d\t%s%d\n",
	474	"magic ", lfsp->lfs_magic,
	475	"version ", lfsp->lfs_version,
	476	"size ", lfsp->lfs_size,
	477	"ssize ", lfsp->lfs_ssize);
	478	(void)printf("%s%d\t%s%d\t%s%d\t%s%d\n",
	479	"dsize ", lfsp->lfs_dsize,
	480	"bsize ", lfsp->lfs_bsize,
	481	"fsize ", lfsp->lfs_fsize,
	482	"frag ", lfsp->lfs_frag);
	483
	484	(void)printf("%s%d\t%s%d\t%s%d\t%s%d\n",
	485	"minfree ", lfsp->lfs_minfree,
	486	"inopb ", lfsp->lfs_inopb,
	487	"ifpb ", lfsp->lfs_ifpb,
	488	"nindir ", lfsp->lfs_nindir);
	489
03edad73	490	(void)printf("%s%d\t%s%d\t%s%d\t%s%d\n",
f9268b79 KB	491	"nseg ", lfsp->lfs_nseg,
f9268b79 KB	492	"nspf ", lfsp->lfs_nspf,
03edad73	493	"cleansz ", lfsp->lfs_cleansz,
f9268b79 KB	494	"segtabsz ", lfsp->lfs_segtabsz);
	495
	496	(void)printf("%s%X\t%s%d\t%s%X\t%s%d\n",
	497	"segmask ", lfsp->lfs_segmask,
	498	"segshift ", lfsp->lfs_segshift,
	499	"bmask ", lfsp->lfs_bmask,
	500	"bshift ", lfsp->lfs_bshift);
	501
	502	(void)printf("%s%X\t%s%d\t%s%X\t%s%d\n",
	503	"ffmask ", lfsp->lfs_ffmask,
	504	"ffshift ", lfsp->lfs_ffshift,
	505	"fbmask ", lfsp->lfs_fbmask,
	506	"fbshift ", lfsp->lfs_fbshift);
	507
dc0cf371	508	(void)printf("%s%d\t%s%X\n",
f9268b79 KB	509	"fsbtodb ", lfsp->lfs_fsbtodb,
	510	"cksum ", lfsp->lfs_cksum);
	511
	512	(void)printf("Superblock disk addresses:");
	513	for (i = 0; i < LFS_MAXNUMSB; i++)
	514	(void)printf(" %X", lfsp->lfs_sboffs[i]);
	515	(void)printf("\n");
	516
	517	(void)printf("Checkpoint Info\n");
dc0cf371	518	(void)printf("%s%d\t%s%X\t%s%d\n",
f9268b79 KB	519	"free ", lfsp->lfs_free,
f9268b79 KB	520	"idaddr ", lfsp->lfs_idaddr,
dc0cf371	521	"ifile ", lfsp->lfs_ifile);
03edad73	522	(void)printf("%s%X\t%s%d\t%s%X\t%s%X\t%s%X\t%s%X\n",
dc0cf371 KB	523	"bfree ", lfsp->lfs_bfree,
	524	"nfiles ", lfsp->lfs_nfiles,
	525	"lastseg ", lfsp->lfs_lastseg,
03edad73 KB	526	"nextseg ", lfsp->lfs_nextseg,
	527	"curseg ", lfsp->lfs_curseg,
	528	"offset ", lfsp->lfs_offset);
f9268b79 KB	529	(void)printf("tstamp %s", ctime((time_t *)&lfsp->lfs_tstamp));
	530	}
	531
dc0cf371 KB	532	static void
	533	addseg(arg)
	534	char *arg;
	535	{
	536	SEGLIST *p;
	537
	538	if ((p = malloc(sizeof(SEGLIST))) == NULL)
	539	err("%s", strerror(errno));
	540	p->next = seglist;
	541	p->num = atoi(arg);
	542	seglist = p;
	543	}
	544
03edad73 KB	545	static void
	546	dump_cleaner_info(lfsp, ipage)
	547	struct lfs *lfsp;
	548	void *ipage;
	549	{
8d926470 KB	550	CLEANERINFO *cip;
	551
	552	cip = (CLEANERINFO *)ipage;
	553	(void)printf("Cleaner Info\nclean\t%d\tdirty\t%d\n",
	554	cip->clean, cip->dirty);
03edad73 KB	555	}
03edad73 KB	556
f9268b79 KB	557	static void
	558	usage()
	559	{
dc0cf371	560	(void)fprintf(stderr, "usage: dumplfs [-ai] [-s segnum] file\n");
f9268b79 KB	561	exit(1);
f9268b79 KB	562	}