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

static	char *sccsid = "@(#)icheck.c	1.21 (Berkeley) %G%";

/*
 * icheck
 */
#define	NB	500
#define	MAXFN	500
#define	MAXNINDIR	(MAXBSIZE / sizeof (daddr_t))

#ifndef STANDALONE
#include <stdio.h>
#endif
#include "../h/param.h"
#include "../h/inode.h"
#include "../h/fs.h"

union {
	struct	fs sb;
	char pad[MAXBSIZE];
} sbun;
#define	sblock sbun.sb

union {
	struct	cg cg;
	char pad[MAXBSIZE];
} cgun;
#define	cgrp cgun.cg

struct	dinode	itab[MAXIPG];
daddr_t	blist[NB];
char	*bmap;

int	mflg;
int	sflg;
int	dflg;
int	fi;
ino_t	ino;
int	cginit;

ino_t	nrfile;
ino_t	ndfile;
ino_t	nbfile;
ino_t	ncfile;
ino_t	nlfile;

daddr_t	nblock;
daddr_t	nfrag;
daddr_t	nindir;
daddr_t	niindir;

daddr_t	nffree;
daddr_t	nbfree;

daddr_t	ndup;

int	nerror;

extern int inside[], around[];
extern unsigned char *fragtbl[];

long	atol();
#ifndef STANDALONE
char	*malloc();
char	*calloc();
#endif

main(argc, argv)
	int argc;
	char *argv[];
{
	register i;
	long n;

	blist[0] = -1;
#ifndef STANDALONE
	while (--argc) {
		argv++;
		if (**argv=='-')
		switch ((*argv)[1]) {
		case 'd':
			dflg++;
			continue;

		case 'm':
			mflg++;
			continue;

		case 's':
			sflg++;
			continue;

		case 'b':
			for(i=0; i<NB; i++) {
				n = atol(argv[1]);
				if(n == 0)
					break;
				blist[i] = n;
				argv++;
				argc--;
			}
			blist[i] = -1;
			continue;

		default:
			printf("Bad flag\n");
		}
		check(*argv);
	}
#else
	{
		static char fname[128];

		printf("File: ");
		gets(fname);
		check(fname);
	}
#endif
	return(nerror);
}

check(file)
	char *file;
{
	register i, j, c;
	daddr_t d, cgd, cbase, b;
	long n;

	fi = open(file, sflg ? 2 : 0);
	if (fi < 0) {
		perror(file);
		nerror |= 04;
		return;
	}
	printf("%s:\n", file);
	nrfile = 0;
	ndfile = 0;
	ncfile = 0;
	nbfile = 0;
	nlfile = 0;

	nblock = 0;
	nfrag = 0;
	nindir = 0;
	niindir = 0;

	ndup = 0;
#ifndef STANDALONE
	sync();
#endif
	getsb(&sblock, file);
	if (nerror)
		return;
	ino = 0;
	n = roundup(howmany(sblock.fs_size, NBBY), sizeof(short));
#ifdef STANDALONE
	bmap = NULL;
#else
	bmap = malloc((unsigned)n);
#endif
	if (bmap==NULL) {
		printf("Not enough core; duplicates unchecked\n");
		dflg++;
		if (sflg) {
			printf("No Updates\n");
			sflg = 0;
		}
	}
	ino = 0;
	cginit = 1;
	if(!dflg) {
		for (i=0; i<(unsigned)n; i++)
			bmap[i] = 0;
		for (c=0; c < sblock.fs_ncg; c++) {
			cgd = cgtod(&sblock, c);
			for (d = cgbase(&sblock, c); d < cgd; d += sblock.fs_frag)
				chk(d, "badcg", sblock.fs_bsize);
			d = cgimin(&sblock, c);
			while (cgd < d) {
				chk(cgd, "cg", sblock.fs_bsize);
				cgd += sblock.fs_frag;
			}
			d = cgdmin(&sblock, c);
			for (; cgd < d; cgd += sblock.fs_frag)
				chk(cgd, "inode", sblock.fs_bsize);
			if (c == 0) {
				d += howmany(sblock.fs_cssize, sblock.fs_bsize)
				    * sblock.fs_frag;
				for (; cgd < d; cgd += sblock.fs_frag)
					chk(cgd, "csum", sblock.fs_bsize);
			}
		}
	}
	cginit = 0;
	for (c = 0; c < sblock.fs_ncg; c++) {
		bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
		    sblock.fs_ipg * sizeof (struct dinode));
		for (j=0; j < sblock.fs_ipg; j++) {
			pass1(&itab[j]);
			ino++;
		}
	}
	ino = 0;
#ifndef STANDALONE
	sync();
#endif
	if (sflg) {
		makecg();
		close(fi);
#ifndef STANDALONE
		if (bmap)
			free(bmap);
#endif
		return;
	}
	nffree = 0;
	nbfree = 0;
	for (c = 0; c < sblock.fs_ncg; c++) {
		cbase = cgbase(&sblock, c);
		bread(fsbtodb(&sblock, cgtod(&sblock, c)), (char *)&cgrp,
			sblock.fs_cgsize);
		for (b = 0; b < sblock.fs_fpg; b += sblock.fs_frag) {
			if (isblock(&sblock, cgrp.cg_free,
			    b / sblock.fs_frag)) {
				nbfree++;
				chk(cbase+b, "block", sblock.fs_bsize);
			} else {
				for (d = 0; d < sblock.fs_frag; d++)
					if (isset(cgrp.cg_free, b+d)) {
						chk(cbase+b+d, "frag", sblock.fs_fsize);
						nffree++;
					}
			}
		}
	}
	close(fi);
#ifndef STANDALONE
	if (bmap)
		free(bmap);
#endif

	i = nrfile + ndfile + ncfile + nbfile + nlfile;
#ifndef STANDALONE
	printf("files %6u (r=%u,d=%u,b=%u,c=%u,sl=%u)\n",
		i, nrfile, ndfile, nbfile, ncfile, nlfile);
#else
	printf("files %u (r=%u,d=%u,b=%u,c=%u,sl=%u)\n",
		i, nrfile, ndfile, nbfile, ncfile, nlfile);
#endif
	n = (nblock + nindir + niindir) * sblock.fs_frag + nfrag;
#ifdef STANDALONE
	printf("used %ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
		n, nindir, niindir, nblock, nfrag);
	printf("free %ld (b=%ld,f=%ld)\n", nffree + sblock.fs_frag * nbfree,
	    nbfree, nffree);
#else
	printf("used %7ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
		n, nindir, niindir, nblock, nfrag);
	printf("free %7ld (b=%ld,f=%ld)\n", nffree + sblock.fs_frag * nbfree,
	    nbfree, nffree);
#endif
	if(!dflg) {
		n = 0;
		for (d = 0; d < sblock.fs_size; d++)
			if(!duped(d, sblock.fs_fsize)) {
				if(mflg)
					printf("%ld missing\n", d);
				n++;
			}
		printf("missing%5ld\n", n);
	}
}

pass1(ip)
	register struct dinode *ip;
{
	daddr_t ind1[MAXNINDIR];
	daddr_t ind2[MAXNINDIR];
	daddr_t db, ib;
	register int i, j, k, siz;

	i = ip->di_mode & IFMT;
	if(i == 0)
		return;
	switch (i) {
	case IFCHR:
		ncfile++;
		return;
	case IFBLK:
		nbfile++;
		return;
	case IFDIR:
		ndfile++;
		break;
	case IFREG:
		nrfile++;
		break;
	case IFLNK:
		nlfile++;
		break;
	default:
		printf("bad mode %u\n", ino);
		return;
	}
	for (i = 0; i < NDADDR; i++) {
		db = ip->di_db[i];
		if (db == 0)
			continue;
		siz = dblksize(&sblock, ip, i);
		chk(db, "data (block)", siz);
		if (siz == sblock.fs_bsize)
			nblock++;
		else
			nfrag += howmany(siz, sblock.fs_fsize);
	}
	for(i = 0; i < NIADDR; i++) {
		ib = ip->di_ib[i];
		if(ib == 0)
			continue;
		if (chk(ib, "1st indirect", sblock.fs_bsize))
			continue;
		bread(fsbtodb(&sblock, ib), (char *)ind1, sblock.fs_bsize);
		nindir++;
		for (j = 0; j < NINDIR(&sblock); j++) {
			ib = ind1[j];
			if (ib == 0)
				continue;
			if (i == 0) {
				siz = dblksize(&sblock, ip, NDADDR + j);
				chk(ib, "data (large)", siz);
				if (siz == sblock.fs_bsize)
					nblock++;
				else
					nfrag += howmany(siz, sblock.fs_fsize);
				continue;
			}
			if (chk(ib, "2nd indirect", sblock.fs_bsize))
				continue;
			bread(fsbtodb(&sblock, ib), (char *)ind2,
				sblock.fs_bsize);
			niindir++;
			for (k = 0; k < NINDIR(&sblock); k++) {
				ib = ind2[k];
				if (ib == 0)
					continue;
				siz = dblksize(&sblock, ip,
				    NDADDR + NINDIR(&sblock) * (i + j) + k);
				chk(ib, "data (huge)", siz);
				if (siz == sblock.fs_bsize)
					nblock++;
				else
					nfrag += howmany(siz, sblock.fs_fsize);
			}
		}
	}
}

chk(bno, s, size)
	daddr_t bno;
	char *s;
	int size;
{
	register n, cg;
	int frags;

	cg = dtog(&sblock, bno);
	if (cginit==0 &&
	    bno<cgdmin(&sblock, cg) || bno >= sblock.fs_frag * sblock.fs_size) {
		printf("%ld bad; inode=%u, class=%s\n", bno, ino, s);
		return(1);
	}
	if (size == sblock.fs_bsize) {
		if (duped(bno, size)) {
			printf("%ld dup block; inode=%u, class=%s\n",
			    bno, ino, s);
			ndup += sblock.fs_frag;
		}
	} else {
		frags = numfrags(&sblock, size);
		for (n = 0; n < frags; n++) {
			if (duped(bno + n, sblock.fs_fsize)) {
				printf("%ld dup frag; inode=%u, class=%s\n",
				    bno, ino, s);
				ndup++;
			}
		}
	}
	for (n=0; blist[n] != -1; n++)
		if (bno == blist[n])
			printf("%ld arg; inode=%u, class=%s\n", bno, ino, s);
	return(0);
}

duped(bno, size)
	daddr_t bno;
	int size;
{
	if(dflg)
		return(0);
	if (size != sblock.fs_fsize && size != sblock.fs_bsize)
		printf("bad size %d to duped\n", size);
	if (size == sblock.fs_fsize) {
		if (isset(bmap, bno))
			return(1);
		setbit(bmap, bno);
		return (0);
	}
	if (bno % sblock.fs_frag != 0)
		printf("bad bno %d to duped\n", bno);
	if (isblock(&sblock, bmap, bno/sblock.fs_frag))
		return (1);
	setblock(&sblock, bmap, bno/sblock.fs_frag);
	return(0);
}

makecg()
{
	int c, blk;
	daddr_t dbase, d, dmin, dmax;
	long i, j, s;
	register struct csum *cs;
	register struct dinode *dp;

	sblock.fs_cstotal.cs_nbfree = 0;
	sblock.fs_cstotal.cs_nffree = 0;
	sblock.fs_cstotal.cs_nifree = 0;
	sblock.fs_cstotal.cs_ndir = 0;
	for (c = 0; c < sblock.fs_ncg; c++) {
		dbase = cgbase(&sblock, c);
		dmax = dbase + sblock.fs_fpg;
		if (dmax > sblock.fs_size) {
			for ( ; dmax >= sblock.fs_size; dmax--)
				clrbit(cgrp.cg_free, dmax - dbase);
			dmax++;
		}
		dmin = sblock.fs_dblkno;
		cs = &sblock.fs_cs(&sblock, c);
		cgrp.cg_time = time(0);
		cgrp.cg_magic = CG_MAGIC;
		cgrp.cg_cgx = c;
		cgrp.cg_ncyl = sblock.fs_cpg;
		cgrp.cg_niblk = sblock.fs_ipg;
		cgrp.cg_ndblk = dmax - dbase;
		cgrp.cg_cs.cs_ndir = 0;
		cgrp.cg_cs.cs_nffree = 0;
		cgrp.cg_cs.cs_nbfree = 0;
		cgrp.cg_cs.cs_nifree = 0;
		cgrp.cg_rotor = dmin;
		cgrp.cg_frotor = dmin;
		cgrp.cg_irotor = 0;
		for (i = 0; i < sblock.fs_frag; i++)
			cgrp.cg_frsum[i] = 0;
		bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
		      sblock.fs_ipg * sizeof(struct dinode));
		for (i = 0; i < sblock.fs_ipg; i++) {
			cgrp.cg_cs.cs_nifree++;
			clrbit(cgrp.cg_iused, i);
			dp = &itab[i];
			if ((dp->di_mode & IFMT) != 0) {
				if ((dp->di_mode & IFMT) == IFDIR)
					cgrp.cg_cs.cs_ndir++;
				cgrp.cg_cs.cs_nifree--;
				setbit(cgrp.cg_iused, i);
				continue;
			}
		}
		while (i < MAXIPG) {
			clrbit(cgrp.cg_iused, i);
			i++;
		}
		if (c == 0)
			for (i = 0; i < ROOTINO; i++) {
				setbit(cgrp.cg_iused, i);
				cgrp.cg_cs.cs_nifree--;
			}
		for (s = 0; s < MAXCPG; s++) {
			cgrp.cg_btot[s] = 0;
			for (i = 0; i < NRPOS; i++)
				cgrp.cg_b[s][i] = 0;
		}
		if (c == 0) {
			dmin += howmany(sblock.fs_cssize, sblock.fs_bsize) *
			    sblock.fs_frag;
		}
		for (d = 0; d < dmin; d++)
			clrbit(cgrp.cg_free, d);
		for (; (d + sblock.fs_frag) <= dmax - dbase; d += sblock.fs_frag) {
			j = 0;
			for (i = 0; i < sblock.fs_frag; i++) {
				if (!isset(bmap, dbase+d+i)) {
					setbit(cgrp.cg_free, d+i);
					j++;
				} else
					clrbit(cgrp.cg_free, d+i);
			}
			if (j == sblock.fs_frag) {
				cgrp.cg_cs.cs_nbfree++;
				cgrp.cg_btot[cbtocylno(&sblock, d)]++;
				cgrp.cg_b[cbtocylno(&sblock, d)]
				    [cbtorpos(&sblock, d)]++;
			} else if (j > 0) {
				cgrp.cg_cs.cs_nffree += j;
				blk = ((cgrp.cg_free[d / NBBY] >> (d % NBBY)) &
				       (0xff >> (NBBY - sblock.fs_frag)));
				fragacct(&sblock, blk, cgrp.cg_frsum, 1);
			}
		}
		for (j = d; d < dmax - dbase; d++) {
			if (!isset(bmap, dbase+d)) {
				setbit(cgrp.cg_free, d);
				cgrp.cg_cs.cs_nffree++;
			} else
				clrbit(cgrp.cg_free, d);
		}
		if (j != d) {
			blk = ((cgrp.cg_free[j / NBBY] >> (j % NBBY)) &
			       (0xff >> (NBBY - sblock.fs_frag)));
			fragacct(&sblock, blk, cgrp.cg_frsum, 1);
		}
		for (; d < MAXBPG(&sblock); d++)
			clrbit(cgrp.cg_free, d);
		sblock.fs_cstotal.cs_nffree += cgrp.cg_cs.cs_nffree;
		sblock.fs_cstotal.cs_nbfree += cgrp.cg_cs.cs_nbfree;
		sblock.fs_cstotal.cs_nifree += cgrp.cg_cs.cs_nifree;
		sblock.fs_cstotal.cs_ndir += cgrp.cg_cs.cs_ndir;
		*cs = cgrp.cg_cs;
		bwrite(fsbtodb(&sblock, cgtod(&sblock, c)), &cgrp,
			sblock.fs_cgsize);
	}
	for (i = 0; i < howmany(sblock.fs_cssize, sblock.fs_bsize); i++) {
		bwrite(fsbtodb(&sblock,
		    sblock.fs_csaddr + (i * sblock.fs_frag)),
		    (char *)sblock.fs_csp[i], sblock.fs_bsize);
	}
	sblock.fs_ronly = 0;
	sblock.fs_fmod = 0;
	bwrite(SBLOCK, (char *)&sblock, SBSIZE);
}

/*
 * update the frsum fields to reflect addition or deletion 
 * of some frags
 */
fragacct(fs, fragmap, fraglist, cnt)
	struct fs *fs;
	int fragmap;
	long fraglist[];
	int cnt;
{
	int inblk;
	register int field, subfield;
	register int siz, pos;

	inblk = (int)(fragtbl[fs->fs_frag][fragmap] << 1);
	fragmap <<= 1;
	for (siz = 1; siz < fs->fs_frag; siz++) {
		if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0)
			continue;
		field = around[siz];
		subfield = inside[siz];
		for (pos = siz; pos <= fs->fs_frag; pos++) {
			if ((fragmap & field) == subfield) {
				fraglist[siz] += cnt;
				pos += siz;
				field <<= siz;
				subfield <<= siz;
			}
			field <<= 1;
			subfield <<= 1;
		}
	}
}

getsb(fs, file)
	register struct fs *fs;
	char *file;
{
	int i;

	if (bread(SBLOCK, fs, SBSIZE)) {
		printf("bad super block");
		perror(file);
		nerror |= 04;
		return;
	}
	if (fs->fs_magic != FS_MAGIC) {
		printf("%s: bad magic number\n", file);
		nerror |= 04;
		return;
	}
	for (i = 0; i < howmany(fs->fs_cssize, fs->fs_bsize); i++) {
		fs->fs_csp[i] = (struct csum *)calloc(1, fs->fs_bsize);
		bread(fsbtodb(fs, fs->fs_csaddr + (i * fs->fs_frag)),
		      (char *)fs->fs_csp[i], fs->fs_bsize);
	}
}

bwrite(blk, buf, size)
	char *buf;
	daddr_t blk;
	register size;
{
	if (lseek(fi, blk * DEV_BSIZE, 0) < 0) {
		perror("FS SEEK");
		return(1);
	}
	if (write(fi, buf, size) != size) {
		perror("FS WRITE");
		return(1);
	}
	return (0);
}

bread(bno, buf, cnt)
	daddr_t bno;
	char *buf;
{
	register i;

	lseek(fi, bno * DEV_BSIZE, 0);
	if ((i = read(fi, buf, cnt)) != cnt) {
		if (sflg) {
			printf("No Update\n");
			sflg = 0;
		}
		for(i=0; i<sblock.fs_bsize; i++)
			buf[i] = 0;
		return (1);
	}
	return (0);
}

/*
 * block operations
 */

isblock(fs, cp, h)
	struct fs *fs;
	unsigned char *cp;
	int h;
{
	unsigned char mask;

	switch (fs->fs_frag) {
	case 8:
		return (cp[h] == 0xff);
	case 4:
		mask = 0x0f << ((h & 0x1) << 2);
		return ((cp[h >> 1] & mask) == mask);
	case 2:
		mask = 0x03 << ((h & 0x3) << 1);
		return ((cp[h >> 2] & mask) == mask);
	case 1:
		mask = 0x01 << (h & 0x7);
		return ((cp[h >> 3] & mask) == mask);
	default:
		fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
		return;
	}
}

setblock(fs, cp, h)
	struct fs *fs;
	unsigned char *cp;
	int h;
{
	switch (fs->fs_frag) {
	case 8:
		cp[h] = 0xff;
		return;
	case 4:
		cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
		return;
	case 2:
		cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
		return;
	case 1:
		cp[h >> 3] |= (0x01 << (h & 0x7));
		return;
	default:
		fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);
		return;
	}
}
Commit	Line	Data
156b8f82	1	static char *sccsid = "@(#)icheck.c 1.21 (Berkeley) %G%";
955f6ff8	2
b42940ce KM	3	/*
	4	* icheck
	5	*/
	6	#define NB 500
b42940ce	7	#define MAXFN 500
c312eebd	8	#define MAXNINDIR (MAXBSIZE / sizeof (daddr_t))
b42940ce KM	9
	10	#ifndef STANDALONE
	11	#include <stdio.h>
	12	#endif
	13	#include "../h/param.h"
	14	#include "../h/inode.h"
b42940ce KM	15	#include "../h/fs.h"
b42940ce KM	16
b42940ce KM	17	union {
b42940ce KM	18	struct fs sb;
b6407c9d	19	char pad[MAXBSIZE];
b42940ce KM	20	} sbun;
	21	#define sblock sbun.sb
	22
	23	union {
	24	struct cg cg;
b6407c9d	25	char pad[MAXBSIZE];
b42940ce KM	26	} cgun;
	27	#define cgrp cgun.cg
	28
	29	struct dinode itab[MAXIPG];
b42940ce KM	30	daddr_t blist[NB];
	31	char *bmap;
	32
b42940ce	33	int mflg;
19f19804	34	int sflg;
b42940ce KM	35	int dflg;
	36	int fi;
	37	ino_t ino;
	38	int cginit;
	39
	40	ino_t nrfile;
	41	ino_t ndfile;
	42	ino_t nbfile;
	43	ino_t ncfile;
ea47352d	44	ino_t nlfile;
b42940ce KM	45
	46	daddr_t nblock;
	47	daddr_t nfrag;
b42940ce	48	daddr_t nindir;
b42940ce KM	49	daddr_t niindir;
	50
	51	daddr_t nffree;
b42940ce KM	52	daddr_t nbfree;
	53
	54	daddr_t ndup;
	55
	56	int nerror;
	57
19f19804	58	extern int inside[], around[];
b6407c9d	59	extern unsigned char *fragtbl[];
19f19804	60
b42940ce	61	long atol();
b42940ce KM	62	#ifndef STANDALONE
b42940ce KM	63	char *malloc();
19f19804	64	char *calloc();
b42940ce KM	65	#endif
	66
	67	main(argc, argv)
19f19804 KM	68	int argc;
19f19804 KM	69	char *argv[];
b42940ce KM	70	{
	71	register i;
	72	long n;
	73
	74	blist[0] = -1;
	75	#ifndef STANDALONE
	76	while (--argc) {
	77	argv++;
	78	if (**argv=='-')
	79	switch ((*argv)[1]) {
	80	case 'd':
	81	dflg++;
	82	continue;
	83
	84	case 'm':
	85	mflg++;
	86	continue;
	87
19f19804 KM	88	case 's':
	89	sflg++;
	90	continue;
	91
b42940ce KM	92	case 'b':
	93	for(i=0; i<NB; i++) {
	94	n = atol(argv[1]);
	95	if(n == 0)
	96	break;
	97	blist[i] = n;
	98	argv++;
	99	argc--;
	100	}
	101	blist[i] = -1;
	102	continue;
	103
	104	default:
	105	printf("Bad flag\n");
	106	}
	107	check(*argv);
	108	}
	109	#else
	110	{
	111	static char fname[128];
	112
	113	printf("File: ");
	114	gets(fname);
	115	check(fname);
	116	}
	117	#endif
	118	return(nerror);
	119	}
	120
	121	check(file)
19f19804	122	char *file;
b42940ce KM	123	{
	124	register i, j, c;
	125	daddr_t d, cgd, cbase, b;
	126	long n;
	127
19f19804	128	fi = open(file, sflg ? 2 : 0);
b42940ce	129	if (fi < 0) {
19f19804	130	perror(file);
b42940ce KM	131	nerror \|= 04;
	132	return;
	133	}
	134	printf("%s:\n", file);
	135	nrfile = 0;
	136	ndfile = 0;
	137	ncfile = 0;
	138	nbfile = 0;
ea47352d	139	nlfile = 0;
b42940ce KM	140
	141	nblock = 0;
	142	nfrag = 0;
b42940ce	143	nindir = 0;
b42940ce KM	144	niindir = 0;
	145
	146	ndup = 0;
	147	#ifndef STANDALONE
	148	sync();
	149	#endif
b6407c9d KM	150	getsb(&sblock, file);
b6407c9d KM	151	if (nerror)
b42940ce	152	return;
b42940ce	153	ino = 0;
19f19804	154	n = roundup(howmany(sblock.fs_size, NBBY), sizeof(short));
b42940ce KM	155	#ifdef STANDALONE
	156	bmap = NULL;
	157	#else
	158	bmap = malloc((unsigned)n);
	159	#endif
	160	if (bmap==NULL) {
	161	printf("Not enough core; duplicates unchecked\n");
	162	dflg++;
19f19804 KM	163	if (sflg) {
	164	printf("No Updates\n");
	165	sflg = 0;
	166	}
b42940ce KM	167	}
	168	ino = 0;
	169	cginit = 1;
	170	if(!dflg) {
	171	for (i=0; i<(unsigned)n; i++)
	172	bmap[i] = 0;
	173	for (c=0; c < sblock.fs_ncg; c++) {
6994bf5d KM	174	cgd = cgtod(&sblock, c);
6994bf5d KM	175	for (d = cgbase(&sblock, c); d < cgd; d += sblock.fs_frag)
b6407c9d	176	chk(d, "badcg", sblock.fs_bsize);
6994bf5d	177	d = cgimin(&sblock, c);
b42940ce	178	while (cgd < d) {
b6407c9d KM	179	chk(cgd, "cg", sblock.fs_bsize);
b6407c9d KM	180	cgd += sblock.fs_frag;
b42940ce	181	}
6994bf5d	182	d = cgdmin(&sblock, c);
b6407c9d KM	183	for (; cgd < d; cgd += sblock.fs_frag)
b6407c9d KM	184	chk(cgd, "inode", sblock.fs_bsize);
b42940ce	185	if (c == 0) {
b6407c9d KM	186	d += howmany(sblock.fs_cssize, sblock.fs_bsize)
	187	* sblock.fs_frag;
	188	for (; cgd < d; cgd += sblock.fs_frag)
	189	chk(cgd, "csum", sblock.fs_bsize);
b42940ce KM	190	}
	191	}
	192	}
	193	cginit = 0;
	194	for (c = 0; c < sblock.fs_ncg; c++) {
6994bf5d	195	bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
b42940ce KM	196	sblock.fs_ipg * sizeof (struct dinode));
	197	for (j=0; j < sblock.fs_ipg; j++) {
	198	pass1(&itab[j]);
	199	ino++;
	200	}
	201	}
	202	ino = 0;
	203	#ifndef STANDALONE
	204	sync();
	205	#endif
19f19804 KM	206	if (sflg) {
	207	makecg();
	208	close(fi);
	209	#ifndef STANDALONE
	210	if (bmap)
	211	free(bmap);
	212	#endif
	213	return;
	214	}
b42940ce	215	nffree = 0;
b42940ce KM	216	nbfree = 0;
b42940ce KM	217	for (c = 0; c < sblock.fs_ncg; c++) {
6994bf5d KM	218	cbase = cgbase(&sblock, c);
6994bf5d KM	219	bread(fsbtodb(&sblock, cgtod(&sblock, c)), (char *)&cgrp,
b6407c9d KM	220	sblock.fs_cgsize);
	221	for (b = 0; b < sblock.fs_fpg; b += sblock.fs_frag) {
	222	if (isblock(&sblock, cgrp.cg_free,
	223	b / sblock.fs_frag)) {
b42940ce	224	nbfree++;
b6407c9d	225	chk(cbase+b, "block", sblock.fs_bsize);
b42940ce	226	} else {
b6407c9d	227	for (d = 0; d < sblock.fs_frag; d++)
b42940ce	228	if (isset(cgrp.cg_free, b+d)) {
b6407c9d	229	chk(cbase+b+d, "frag", sblock.fs_fsize);
b42940ce	230	nffree++;
b42940ce KM	231	}
	232	}
	233	}
	234	}
	235	close(fi);
	236	#ifndef STANDALONE
	237	if (bmap)
	238	free(bmap);
	239	#endif
	240
ea47352d	241	i = nrfile + ndfile + ncfile + nbfile + nlfile;
b42940ce	242	#ifndef STANDALONE
ea47352d KM	243	printf("files %6u (r=%u,d=%u,b=%u,c=%u,sl=%u)\n",
ea47352d KM	244	i, nrfile, ndfile, nbfile, ncfile, nlfile);
b42940ce	245	#else
ea47352d KM	246	printf("files %u (r=%u,d=%u,b=%u,c=%u,sl=%u)\n",
ea47352d KM	247	i, nrfile, ndfile, nbfile, ncfile, nlfile);
b42940ce	248	#endif
b6407c9d	249	n = (nblock + nindir + niindir) * sblock.fs_frag + nfrag;
b42940ce KM	250	#ifdef STANDALONE
	251	printf("used %ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
	252	n, nindir, niindir, nblock, nfrag);
b6407c9d	253	printf("free %ld (b=%ld,f=%ld)\n", nffree + sblock.fs_frag * nbfree,
b42940ce KM	254	nbfree, nffree);
	255	#else
	256	printf("used %7ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
	257	n, nindir, niindir, nblock, nfrag);
b6407c9d	258	printf("free %7ld (b=%ld,f=%ld)\n", nffree + sblock.fs_frag * nbfree,
b42940ce KM	259	nbfree, nffree);
	260	#endif
	261	if(!dflg) {
	262	n = 0;
955f6ff8	263	for (d = 0; d < sblock.fs_size; d++)
b6407c9d	264	if(!duped(d, sblock.fs_fsize)) {
b42940ce KM	265	if(mflg)
	266	printf("%ld missing\n", d);
	267	n++;
	268	}
	269	printf("missing%5ld\n", n);
	270	}
	271	}
	272
	273	pass1(ip)
955f6ff8	274	register struct dinode *ip;
b42940ce	275	{
b6407c9d KM	276	daddr_t ind1[MAXNINDIR];
b6407c9d KM	277	daddr_t ind2[MAXNINDIR];
07670f7d KM	278	daddr_t db, ib;
07670f7d KM	279	register int i, j, k, siz;
b42940ce KM	280
b42940ce KM	281	i = ip->di_mode & IFMT;
0947395d	282	if(i == 0)
b42940ce	283	return;
b42940ce KM	284	switch (i) {
	285	case IFCHR:
	286	ncfile++;
	287	return;
	288	case IFBLK:
	289	nbfile++;
	290	return;
	291	case IFDIR:
	292	ndfile++;
	293	break;
	294	case IFREG:
	295	nrfile++;
	296	break;
ea47352d KM	297	case IFLNK:
	298	nlfile++;
	299	break;
b42940ce KM	300	default:
	301	printf("bad mode %u\n", ino);
	302	return;
	303	}
955f6ff8 KM	304	for (i = 0; i < NDADDR; i++) {
	305	db = ip->di_db[i];
	306	if (db == 0)
b42940ce	307	continue;
b6407c9d	308	siz = dblksize(&sblock, ip, i);
07670f7d	309	chk(db, "data (block)", siz);
b6407c9d	310	if (siz == sblock.fs_bsize)
07670f7d KM	311	nblock++;
07670f7d KM	312	else
b6407c9d	313	nfrag += howmany(siz, sblock.fs_fsize);
b42940ce	314	}
955f6ff8 KM	315	for(i = 0; i < NIADDR; i++) {
	316	ib = ip->di_ib[i];
	317	if(ib == 0)
	318	continue;
b6407c9d	319	if (chk(ib, "1st indirect", sblock.fs_bsize))
b42940ce	320	continue;
b6407c9d	321	bread(fsbtodb(&sblock, ib), (char *)ind1, sblock.fs_bsize);
b42940ce	322	nindir++;
b6407c9d	323	for (j = 0; j < NINDIR(&sblock); j++) {
955f6ff8 KM	324	ib = ind1[j];
955f6ff8 KM	325	if (ib == 0)
b42940ce	326	continue;
955f6ff8	327	if (i == 0) {
b6407c9d	328	siz = dblksize(&sblock, ip, NDADDR + j);
07670f7d	329	chk(ib, "data (large)", siz);
b6407c9d	330	if (siz == sblock.fs_bsize)
07670f7d KM	331	nblock++;
07670f7d KM	332	else
b6407c9d	333	nfrag += howmany(siz, sblock.fs_fsize);
b42940ce KM	334	continue;
b42940ce KM	335	}
b6407c9d	336	if (chk(ib, "2nd indirect", sblock.fs_bsize))
955f6ff8	337	continue;
b6407c9d KM	338	bread(fsbtodb(&sblock, ib), (char *)ind2,
b6407c9d KM	339	sblock.fs_bsize);
b42940ce	340	niindir++;
b6407c9d	341	for (k = 0; k < NINDIR(&sblock); k++) {
955f6ff8 KM	342	ib = ind2[k];
955f6ff8 KM	343	if (ib == 0)
b42940ce	344	continue;
b6407c9d KM	345	siz = dblksize(&sblock, ip,
b6407c9d KM	346	NDADDR + NINDIR(&sblock) * (i + j) + k);
07670f7d	347	chk(ib, "data (huge)", siz);
b6407c9d	348	if (siz == sblock.fs_bsize)
07670f7d KM	349	nblock++;
07670f7d KM	350	else
b6407c9d	351	nfrag += howmany(siz, sblock.fs_fsize);
b42940ce	352	}
b42940ce KM	353	}
	354	}
	355	}
	356
07670f7d	357	chk(bno, s, size)
955f6ff8 KM	358	daddr_t bno;
955f6ff8 KM	359	char *s;
07670f7d	360	int size;
b42940ce KM	361	{
b42940ce KM	362	register n, cg;
3352e84a	363	int frags;
b42940ce	364
6994bf5d	365	cg = dtog(&sblock, bno);
07670f7d	366	if (cginit==0 &&
6994bf5d	367	bno<cgdmin(&sblock, cg) \|\| bno >= sblock.fs_frag * sblock.fs_size) {
b42940ce KM	368	printf("%ld bad; inode=%u, class=%s\n", bno, ino, s);
	369	return(1);
	370	}
b6407c9d	371	if (size == sblock.fs_bsize) {
07670f7d KM	372	if (duped(bno, size)) {
	373	printf("%ld dup block; inode=%u, class=%s\n",
	374	bno, ino, s);
b6407c9d	375	ndup += sblock.fs_frag;
07670f7d KM	376	}
07670f7d KM	377	} else {
3352e84a KM	378	frags = numfrags(&sblock, size);
3352e84a KM	379	for (n = 0; n < frags; n++) {
b6407c9d	380	if (duped(bno + n, sblock.fs_fsize)) {
07670f7d KM	381	printf("%ld dup frag; inode=%u, class=%s\n",
	382	bno, ino, s);
	383	ndup++;
	384	}
	385	}
b42940ce KM	386	}
	387	for (n=0; blist[n] != -1; n++)
	388	if (bno == blist[n])
	389	printf("%ld arg; inode=%u, class=%s\n", bno, ino, s);
	390	return(0);
	391	}
	392
07670f7d	393	duped(bno, size)
955f6ff8	394	daddr_t bno;
07670f7d	395	int size;
b42940ce	396	{
b42940ce KM	397	if(dflg)
b42940ce KM	398	return(0);
b6407c9d	399	if (size != sblock.fs_fsize && size != sblock.fs_bsize)
07670f7d	400	printf("bad size %d to duped\n", size);
b6407c9d	401	if (size == sblock.fs_fsize) {
955f6ff8 KM	402	if (isset(bmap, bno))
	403	return(1);
	404	setbit(bmap, bno);
	405	return (0);
	406	}
b6407c9d	407	if (bno % sblock.fs_frag != 0)
955f6ff8	408	printf("bad bno %d to duped\n", bno);
b6407c9d	409	if (isblock(&sblock, bmap, bno/sblock.fs_frag))
955f6ff8	410	return (1);
b6407c9d	411	setblock(&sblock, bmap, bno/sblock.fs_frag);
b42940ce KM	412	return(0);
	413	}
	414
19f19804 KM	415	makecg()
	416	{
	417	int c, blk;
	418	daddr_t dbase, d, dmin, dmax;
	419	long i, j, s;
	420	register struct csum *cs;
	421	register struct dinode *dp;
	422
	423	sblock.fs_cstotal.cs_nbfree = 0;
	424	sblock.fs_cstotal.cs_nffree = 0;
	425	sblock.fs_cstotal.cs_nifree = 0;
	426	sblock.fs_cstotal.cs_ndir = 0;
19f19804	427	for (c = 0; c < sblock.fs_ncg; c++) {
6994bf5d	428	dbase = cgbase(&sblock, c);
19f19804	429	dmax = dbase + sblock.fs_fpg;
8f99f49c KM	430	if (dmax > sblock.fs_size) {
8f99f49c KM	431	for ( ; dmax >= sblock.fs_size; dmax--)
2e9860b5	432	clrbit(cgrp.cg_free, dmax - dbase);
8f99f49c KM	433	dmax++;
8f99f49c KM	434	}
2e9860b5	435	dmin = sblock.fs_dblkno;
b6407c9d	436	cs = &sblock.fs_cs(&sblock, c);
19f19804 KM	437	cgrp.cg_time = time(0);
	438	cgrp.cg_magic = CG_MAGIC;
	439	cgrp.cg_cgx = c;
	440	cgrp.cg_ncyl = sblock.fs_cpg;
	441	cgrp.cg_niblk = sblock.fs_ipg;
	442	cgrp.cg_ndblk = dmax - dbase;
	443	cgrp.cg_cs.cs_ndir = 0;
	444	cgrp.cg_cs.cs_nffree = 0;
	445	cgrp.cg_cs.cs_nbfree = 0;
	446	cgrp.cg_cs.cs_nifree = 0;
	447	cgrp.cg_rotor = dmin;
	448	cgrp.cg_frotor = dmin;
	449	cgrp.cg_irotor = 0;
b6407c9d	450	for (i = 0; i < sblock.fs_frag; i++)
19f19804	451	cgrp.cg_frsum[i] = 0;
6994bf5d	452	bread(fsbtodb(&sblock, cgimin(&sblock, c)), (char *)itab,
19f19804 KM	453	sblock.fs_ipg * sizeof(struct dinode));
19f19804 KM	454	for (i = 0; i < sblock.fs_ipg; i++) {
bf4c734c KM	455	cgrp.cg_cs.cs_nifree++;
bf4c734c KM	456	clrbit(cgrp.cg_iused, i);
19f19804	457	dp = &itab[i];
19f19804 KM	458	if ((dp->di_mode & IFMT) != 0) {
	459	if ((dp->di_mode & IFMT) == IFDIR)
	460	cgrp.cg_cs.cs_ndir++;
bf4c734c	461	cgrp.cg_cs.cs_nifree--;
19f19804 KM	462	setbit(cgrp.cg_iused, i);
	463	continue;
	464	}
19f19804 KM	465	}
	466	while (i < MAXIPG) {
	467	clrbit(cgrp.cg_iused, i);
	468	i++;
	469	}
8e5c1c7c KM	470	if (c == 0)
	471	for (i = 0; i < ROOTINO; i++) {
	472	setbit(cgrp.cg_iused, i);
	473	cgrp.cg_cs.cs_nifree--;
	474	}
43f6367c KM	475	for (s = 0; s < MAXCPG; s++) {
43f6367c KM	476	cgrp.cg_btot[s] = 0;
19f19804 KM	477	for (i = 0; i < NRPOS; i++)
19f19804 KM	478	cgrp.cg_b[s][i] = 0;
43f6367c	479	}
19f19804	480	if (c == 0) {
b6407c9d KM	481	dmin += howmany(sblock.fs_cssize, sblock.fs_bsize) *
b6407c9d KM	482	sblock.fs_frag;
19f19804 KM	483	}
	484	for (d = 0; d < dmin; d++)
	485	clrbit(cgrp.cg_free, d);
b6407c9d	486	for (; (d + sblock.fs_frag) <= dmax - dbase; d += sblock.fs_frag) {
19f19804	487	j = 0;
b6407c9d	488	for (i = 0; i < sblock.fs_frag; i++) {
19f19804 KM	489	if (!isset(bmap, dbase+d+i)) {
	490	setbit(cgrp.cg_free, d+i);
	491	j++;
	492	} else
	493	clrbit(cgrp.cg_free, d+i);
	494	}
b6407c9d	495	if (j == sblock.fs_frag) {
19f19804	496	cgrp.cg_cs.cs_nbfree++;
43f6367c	497	cgrp.cg_btot[cbtocylno(&sblock, d)]++;
aca50d72 KM	498	cgrp.cg_b[cbtocylno(&sblock, d)]
aca50d72 KM	499	[cbtorpos(&sblock, d)]++;
19f19804 KM	500	} else if (j > 0) {
	501	cgrp.cg_cs.cs_nffree += j;
	502	blk = ((cgrp.cg_free[d / NBBY] >> (d % NBBY)) &
b6407c9d KM	503	(0xff >> (NBBY - sblock.fs_frag)));
b6407c9d KM	504	fragacct(&sblock, blk, cgrp.cg_frsum, 1);
19f19804 KM	505	}
	506	}
	507	for (j = d; d < dmax - dbase; d++) {
	508	if (!isset(bmap, dbase+d)) {
	509	setbit(cgrp.cg_free, d);
	510	cgrp.cg_cs.cs_nffree++;
	511	} else
	512	clrbit(cgrp.cg_free, d);
	513	}
	514	if (j != d) {
	515	blk = ((cgrp.cg_free[j / NBBY] >> (j % NBBY)) &
b6407c9d KM	516	(0xff >> (NBBY - sblock.fs_frag)));
b6407c9d KM	517	fragacct(&sblock, blk, cgrp.cg_frsum, 1);
19f19804	518	}
b6407c9d	519	for (; d < MAXBPG(&sblock); d++)
19f19804 KM	520	clrbit(cgrp.cg_free, d);
	521	sblock.fs_cstotal.cs_nffree += cgrp.cg_cs.cs_nffree;
	522	sblock.fs_cstotal.cs_nbfree += cgrp.cg_cs.cs_nbfree;
	523	sblock.fs_cstotal.cs_nifree += cgrp.cg_cs.cs_nifree;
	524	sblock.fs_cstotal.cs_ndir += cgrp.cg_cs.cs_ndir;
	525	*cs = cgrp.cg_cs;
6994bf5d	526	bwrite(fsbtodb(&sblock, cgtod(&sblock, c)), &cgrp,
b6407c9d	527	sblock.fs_cgsize);
19f19804	528	}
b6407c9d KM	529	for (i = 0; i < howmany(sblock.fs_cssize, sblock.fs_bsize); i++) {
	530	bwrite(fsbtodb(&sblock,
	531	sblock.fs_csaddr + (i * sblock.fs_frag)),
	532	(char *)sblock.fs_csp[i], sblock.fs_bsize);
19f19804 KM	533	}
	534	sblock.fs_ronly = 0;
	535	sblock.fs_fmod = 0;
c312eebd	536	bwrite(SBLOCK, (char *)&sblock, SBSIZE);
19f19804 KM	537	}
	538
	539	/*
	540	* update the frsum fields to reflect addition or deletion
	541	* of some frags
	542	*/
b6407c9d KM	543	fragacct(fs, fragmap, fraglist, cnt)
b6407c9d KM	544	struct fs *fs;
19f19804 KM	545	int fragmap;
	546	long fraglist[];
	547	int cnt;
	548	{
	549	int inblk;
	550	register int field, subfield;
	551	register int siz, pos;
	552
b6407c9d	553	inblk = (int)(fragtbl[fs->fs_frag][fragmap] << 1);
19f19804	554	fragmap <<= 1;
b6407c9d	555	for (siz = 1; siz < fs->fs_frag; siz++) {
156b8f82	556	if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0)
19f19804 KM	557	continue;
	558	field = around[siz];
	559	subfield = inside[siz];
b6407c9d	560	for (pos = siz; pos <= fs->fs_frag; pos++) {
19f19804 KM	561	if ((fragmap & field) == subfield) {
	562	fraglist[siz] += cnt;
	563	pos += siz;
	564	field <<= siz;
	565	subfield <<= siz;
	566	}
	567	field <<= 1;
	568	subfield <<= 1;
	569	}
	570	}
	571	}
	572
b6407c9d KM	573	getsb(fs, file)
	574	register struct fs *fs;
	575	char *file;
	576	{
	577	int i;
	578
c312eebd	579	if (bread(SBLOCK, fs, SBSIZE)) {
b6407c9d KM	580	printf("bad super block");
	581	perror(file);
	582	nerror \|= 04;
	583	return;
	584	}
	585	if (fs->fs_magic != FS_MAGIC) {
	586	printf("%s: bad magic number\n", file);
	587	nerror \|= 04;
	588	return;
	589	}
	590	for (i = 0; i < howmany(fs->fs_cssize, fs->fs_bsize); i++) {
	591	fs->fs_csp[i] = (struct csum *)calloc(1, fs->fs_bsize);
	592	bread(fsbtodb(fs, fs->fs_csaddr + (i * fs->fs_frag)),
	593	(char *)fs->fs_csp[i], fs->fs_bsize);
	594	}
	595	}
	596
19f19804 KM	597	bwrite(blk, buf, size)
	598	char *buf;
	599	daddr_t blk;
	600	register size;
	601	{
b6407c9d	602	if (lseek(fi, blk * DEV_BSIZE, 0) < 0) {
19f19804 KM	603	perror("FS SEEK");
	604	return(1);
	605	}
	606	if (write(fi, buf, size) != size) {
	607	perror("FS WRITE");
	608	return(1);
	609	}
b6407c9d	610	return (0);
19f19804 KM	611	}
19f19804 KM	612
b42940ce	613	bread(bno, buf, cnt)
955f6ff8 KM	614	daddr_t bno;
955f6ff8 KM	615	char *buf;
b42940ce KM	616	{
	617	register i;
	618
b6407c9d	619	lseek(fi, bno * DEV_BSIZE, 0);
b42940ce	620	if ((i = read(fi, buf, cnt)) != cnt) {
19f19804 KM	621	if (sflg) {
	622	printf("No Update\n");
	623	sflg = 0;
	624	}
b6407c9d	625	for(i=0; i<sblock.fs_bsize; i++)
b42940ce	626	buf[i] = 0;
b6407c9d KM	627	return (1);
	628	}
	629	return (0);
	630	}
	631
	632	/*
	633	* block operations
	634	*/
	635
	636	isblock(fs, cp, h)
	637	struct fs *fs;
	638	unsigned char *cp;
	639	int h;
	640	{
	641	unsigned char mask;
	642
	643	switch (fs->fs_frag) {
	644	case 8:
	645	return (cp[h] == 0xff);
	646	case 4:
	647	mask = 0x0f << ((h & 0x1) << 2);
	648	return ((cp[h >> 1] & mask) == mask);
	649	case 2:
	650	mask = 0x03 << ((h & 0x3) << 1);
	651	return ((cp[h >> 2] & mask) == mask);
	652	case 1:
	653	mask = 0x01 << (h & 0x7);
	654	return ((cp[h >> 3] & mask) == mask);
	655	default:
	656	fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
	657	return;
	658	}
	659	}
	660
	661	setblock(fs, cp, h)
	662	struct fs *fs;
	663	unsigned char *cp;
	664	int h;
	665	{
	666	switch (fs->fs_frag) {
	667	case 8:
	668	cp[h] = 0xff;
	669	return;
	670	case 4:
	671	cp[h >> 1] \|= (0x0f << ((h & 0x1) << 2));
	672	return;
	673	case 2:
	674	cp[h >> 2] \|= (0x03 << ((h & 0x3) << 1));
	675	return;
	676	case 1:
	677	cp[h >> 3] \|= (0x01 << (h & 0x7));
	678	return;
	679	default:
	680	fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);
	681	return;
b42940ce KM	682	}
b42940ce KM	683	}