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

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

/*
 * icheck
 */
#define	NB	500
#define	BITS	8
#define	MAXFN	500

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

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

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

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

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

ino_t	nrfile;
ino_t	ndfile;
ino_t	nbfile;
ino_t	ncfile;
ino_t	nmcfile;

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

daddr_t	nffree;
daddr_t	nbfree;

daddr_t	ndup;

int	nerror;

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

main(argc, argv)
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 '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, 0);
	if (fi < 0) {
		printf("cannot open %s\n", file);
		nerror |= 04;
		return;
	}
	printf("%s:\n", file);
	nrfile = 0;
	ndfile = 0;
	ncfile = 0;
	nbfile = 0;
	nmcfile = 0;

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

	ndup = 0;
#ifndef STANDALONE
	sync();
#endif
	bread(SBLOCK, (char *)&sblock, BSIZE);
	if (sblock.fs_magic != FS_MAGIC) {
		printf("%s: bad magic number\n", file);
		nerror |= 04;
		return;
	}
	for (n = 0; n < howmany(cssize(&sblock), BSIZE); n++) {
		sblock.fs_csp[n] = (struct csum *)calloc(1, BSIZE);
		bread(csaddr(&sblock) + (n * FRAG),
		      (char *)sblock.fs_csp[n], BSIZE);
	}
	ino = 0;
	n = (sblock.fs_size*FRAG + BITS-1) / BITS;
#ifdef STANDALONE
	bmap = NULL;
#else
	bmap = malloc((unsigned)n);
#endif
	if (bmap==NULL) {
		printf("Not enough core; duplicates unchecked\n");
		dflg++;
	}
	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(c, &sblock);
			for (d = cgbase(c, &sblock); d < cgd; d += FRAG)
				chk(d, "badcg", BSIZE);
			d = cgimin(c, &sblock);
			while (cgd < d) {
				chk(cgd, "cg", BSIZE);
				cgd += FRAG;
			}
			d = cgdmin(c, &sblock);
			for (; cgd < d; cgd += FRAG)
				chk(cgd, "inode", BSIZE);
			if (c == 0) {
				d += howmany(cssize(&sblock), FSIZE);
				for (; cgd < d; cgd += FRAG)
					chk(cgd, "csum", BSIZE);
			}
		}
	}
	cginit = 0;
	for (c = 0; c < sblock.fs_ncg; c++) {
		bread(cgimin(c,&sblock), (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
	bread(SBLOCK, (char *)&sblock, sizeof(sblock));
	nffree = 0;
	nbfree = 0;
	for (c = 0; c < sblock.fs_ncg; c++) {
		cbase = cgbase(c,&sblock);
		bread(cgtod(c,&sblock), (char *)&cgrp, sblock.fs_cgsize);
		for (b = 0; b < sblock.fs_fpg; b += FRAG) {
			if (isblock(cgrp.cg_free, b / FRAG)) {
				nbfree++;
				chk(cbase+b, "block", BSIZE);
			} else {
				for (d = 0; d < FRAG; d++)
					if (isset(cgrp.cg_free, b+d)) {
						chk(cbase+b+d, "frag", FSIZE);
						nffree++;
					}
			}
		}
	}
	close(fi);
#ifndef STANDALONE
	if (bmap)
		free(bmap);
#endif

	i = nrfile + ndfile + ncfile + nbfile + nmcfile;
#ifndef STANDALONE
	printf("files %6u (r=%u,d=%u,b=%u,c=%u,mc=%u)\n",
		i, nrfile, ndfile, nbfile, ncfile, nmcfile);
#else
	printf("files %u (r=%u,d=%u,b=%u,c=%u,mc=%u)\n",
		i, nrfile, ndfile, nbfile, ncfile, nmcfile);
#endif
	n = (nblock + nindir + niindir) * 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 + 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 + FRAG * nbfree,
	    nbfree, nffree);
#endif
	if(!dflg) {
		n = 0;
		for (d = 0; d < sblock.fs_size; d++)
			if(!duped(d, FSIZE)) {
				if(mflg)
					printf("%ld missing\n", d);
				n++;
			}
		printf("missing%5ld\n", n);
	}
}

pass1(ip)
	register struct dinode *ip;
{
	daddr_t ind1[NINDIR];
	daddr_t ind2[NINDIR];
	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;
	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(ip, i);
		chk(db, "data (block)", siz);
		if (siz == BSIZE)
			nblock++;
		else
			nfrag += howmany(siz, FSIZE);
	}
	for(i = 0; i < NIADDR; i++) {
		ib = ip->di_ib[i];
		if(ib == 0)
			continue;
		if (chk(ib, "1st indirect", BSIZE))
			continue;
		bread(ib, (char *)ind1, BSIZE);
		nindir++;
		for (j = 0; j < NINDIR; j++) {
			ib = ind1[j];
			if (ib == 0)
				continue;
			if (i == 0) {
				siz = dblksize(ip, NDADDR + j);
				chk(ib, "data (large)", siz);
				if (siz == BSIZE)
					nblock++;
				else
					nfrag += howmany(siz, FSIZE);
				continue;
			}
			if (chk(ib, "2nd indirect", BSIZE))
				continue;
			bread(ib, (char *)ind2, BSIZE);
			niindir++;
			for (k = 0; k < NINDIR; k++) {
				ib = ind2[k];
				if (ib == 0)
					continue;
				siz = dblksize(ip,
				    NDADDR + NINDIR * (i + j) + k);
				chk(ib, "data (huge)", siz);
				if (siz == BSIZE)
					nblock++;
				else
					nfrag += howmany(siz, FSIZE);
			}
		}
	}
}

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

	cg = dtog(bno, &sblock);
	if (cginit==0 &&
	    bno<cgdmin(cg,&sblock) || bno >= FRAG * sblock.fs_size) {
		printf("%ld bad; inode=%u, class=%s\n", bno, ino, s);
		return(1);
	}
	if (size == BSIZE) {
		if (duped(bno, size)) {
			printf("%ld dup block; inode=%u, class=%s\n",
			    bno, ino, s);
			ndup += FRAG;
		}
	} else {
		for (n = 0; n < size / FSIZE; n++) {
			if (duped(bno + n, 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 != FSIZE && size != BSIZE)
		printf("bad size %d to duped\n", size);
	if (size == FSIZE) {
		if (isset(bmap, bno))
			return(1);
		setbit(bmap, bno);
		return (0);
	}
	if (bno % FRAG != 0)
		printf("bad bno %d to duped\n", bno);
	if (isblock(bmap, bno/FRAG))
		return (1);
	setblock(bmap, bno/FRAG);
	return(0);
}

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

	lseek(fi, bno*FSIZE, 0);
	if ((i = read(fi, buf, cnt)) != cnt) {
		for(i=0; i<BSIZE; i++)
			buf[i] = 0;
	}
}
Commit	Line	Data
0947395d	1	static char *sccsid = "@(#)icheck.c 1.8 (Berkeley) %G%";
955f6ff8	2
b42940ce KM	3	/*
	4	* icheck
	5	*/
	6	#define NB 500
	7	#define BITS 8
	8	#define MAXFN 500
	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 {
	18	struct fs sb;
	19	char pad[BSIZE];
	20	} sbun;
	21	#define sblock sbun.sb
	22
	23	union {
	24	struct cg cg;
	25	char pad[BSIZE];
	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 KM	33	int mflg;
	34	int dflg;
	35	int fi;
	36	ino_t ino;
	37	int cginit;
	38
	39	ino_t nrfile;
	40	ino_t ndfile;
	41	ino_t nbfile;
	42	ino_t ncfile;
	43	ino_t nmcfile;
	44
	45	daddr_t nblock;
	46	daddr_t nfrag;
b42940ce	47	daddr_t nindir;
b42940ce KM	48	daddr_t niindir;
	49
	50	daddr_t nffree;
b42940ce KM	51	daddr_t nbfree;
	52
	53	daddr_t ndup;
	54
	55	int nerror;
	56
	57	long atol();
	58	daddr_t alloc();
	59	#ifndef STANDALONE
	60	char *malloc();
	61	#endif
	62
	63	main(argc, argv)
	64	char *argv[];
	65	{
	66	register i;
	67	long n;
	68
	69	blist[0] = -1;
	70	#ifndef STANDALONE
	71	while (--argc) {
	72	argv++;
	73	if (**argv=='-')
	74	switch ((*argv)[1]) {
	75	case 'd':
	76	dflg++;
	77	continue;
	78
	79	case 'm':
	80	mflg++;
	81	continue;
	82
b42940ce KM	83	case 'b':
	84	for(i=0; i<NB; i++) {
	85	n = atol(argv[1]);
	86	if(n == 0)
	87	break;
	88	blist[i] = n;
	89	argv++;
	90	argc--;
	91	}
	92	blist[i] = -1;
	93	continue;
	94
	95	default:
	96	printf("Bad flag\n");
	97	}
	98	check(*argv);
	99	}
	100	#else
	101	{
	102	static char fname[128];
	103
	104	printf("File: ");
	105	gets(fname);
	106	check(fname);
	107	}
	108	#endif
	109	return(nerror);
	110	}
	111
	112	check(file)
	113	char *file;
	114	{
	115	register i, j, c;
	116	daddr_t d, cgd, cbase, b;
	117	long n;
	118
c27f32bc	119	fi = open(file, 0);
b42940ce KM	120	if (fi < 0) {
	121	printf("cannot open %s\n", file);
	122	nerror \|= 04;
	123	return;
	124	}
	125	printf("%s:\n", file);
	126	nrfile = 0;
	127	ndfile = 0;
	128	ncfile = 0;
	129	nbfile = 0;
	130	nmcfile = 0;
	131
	132	nblock = 0;
	133	nfrag = 0;
b42940ce	134	nindir = 0;
b42940ce KM	135	niindir = 0;
	136
	137	ndup = 0;
	138	#ifndef STANDALONE
	139	sync();
	140	#endif
	141	bread(SBLOCK, (char *)&sblock, BSIZE);
	142	if (sblock.fs_magic != FS_MAGIC) {
	143	printf("%s: bad magic number\n", file);
	144	nerror \|= 04;
	145	return;
	146	}
743f1ef7 KM	147	for (n = 0; n < howmany(cssize(&sblock), BSIZE); n++) {
	148	sblock.fs_csp[n] = (struct csum *)calloc(1, BSIZE);
	149	bread(csaddr(&sblock) + (n * FRAG),
	150	(char *)sblock.fs_csp[n], BSIZE);
	151	}
b42940ce KM	152	ino = 0;
	153	n = (sblock.fs_size*FRAG + BITS-1) / BITS;
	154	#ifdef STANDALONE
	155	bmap = NULL;
	156	#else
	157	bmap = malloc((unsigned)n);
	158	#endif
	159	if (bmap==NULL) {
	160	printf("Not enough core; duplicates unchecked\n");
	161	dflg++;
b42940ce KM	162	}
	163	ino = 0;
	164	cginit = 1;
	165	if(!dflg) {
	166	for (i=0; i<(unsigned)n; i++)
	167	bmap[i] = 0;
	168	for (c=0; c < sblock.fs_ncg; c++) {
	169	cgd = cgtod(c, &sblock);
955f6ff8	170	for (d = cgbase(c, &sblock); d < cgd; d += FRAG)
07670f7d	171	chk(d, "badcg", BSIZE);
b42940ce KM	172	d = cgimin(c, &sblock);
b42940ce KM	173	while (cgd < d) {
07670f7d	174	chk(cgd, "cg", BSIZE);
955f6ff8	175	cgd += FRAG;
b42940ce KM	176	}
b42940ce KM	177	d = cgdmin(c, &sblock);
955f6ff8	178	for (; cgd < d; cgd += FRAG)
07670f7d	179	chk(cgd, "inode", BSIZE);
b42940ce	180	if (c == 0) {
955f6ff8 KM	181	d += howmany(cssize(&sblock), FSIZE);
955f6ff8 KM	182	for (; cgd < d; cgd += FRAG)
07670f7d	183	chk(cgd, "csum", BSIZE);
b42940ce KM	184	}
	185	}
	186	}
	187	cginit = 0;
	188	for (c = 0; c < sblock.fs_ncg; c++) {
	189	bread(cgimin(c,&sblock), (char *)itab,
	190	sblock.fs_ipg * sizeof (struct dinode));
	191	for (j=0; j < sblock.fs_ipg; j++) {
	192	pass1(&itab[j]);
	193	ino++;
	194	}
	195	}
	196	ino = 0;
	197	#ifndef STANDALONE
	198	sync();
	199	#endif
	200	bread(SBLOCK, (char *)&sblock, sizeof(sblock));
b42940ce	201	nffree = 0;
b42940ce KM	202	nbfree = 0;
	203	for (c = 0; c < sblock.fs_ncg; c++) {
	204	cbase = cgbase(c,&sblock);
	205	bread(cgtod(c,&sblock), (char *)&cgrp, sblock.fs_cgsize);
	206	for (b = 0; b < sblock.fs_fpg; b += FRAG) {
	207	if (isblock(cgrp.cg_free, b / FRAG)) {
	208	nbfree++;
07670f7d	209	chk(cbase+b, "block", BSIZE);
b42940ce KM	210	} else {
	211	for (d = 0; d < FRAG; d++)
	212	if (isset(cgrp.cg_free, b+d)) {
07670f7d	213	chk(cbase+b+d, "frag", FSIZE);
b42940ce	214	nffree++;
b42940ce KM	215	}
	216	}
	217	}
	218	}
	219	close(fi);
	220	#ifndef STANDALONE
	221	if (bmap)
	222	free(bmap);
	223	#endif
	224
	225	i = nrfile + ndfile + ncfile + nbfile + nmcfile;
	226	#ifndef STANDALONE
	227	printf("files %6u (r=%u,d=%u,b=%u,c=%u,mc=%u)\n",
	228	i, nrfile, ndfile, nbfile, ncfile, nmcfile);
	229	#else
	230	printf("files %u (r=%u,d=%u,b=%u,c=%u,mc=%u)\n",
	231	i, nrfile, ndfile, nbfile, ncfile, nmcfile);
	232	#endif
07670f7d	233	n = (nblock + nindir + niindir) * FRAG + nfrag;
b42940ce KM	234	#ifdef STANDALONE
	235	printf("used %ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
	236	n, nindir, niindir, nblock, nfrag);
07670f7d	237	printf("free %ld (b=%ld,f=%ld)\n", nffree + FRAG * nbfree,
b42940ce KM	238	nbfree, nffree);
	239	#else
	240	printf("used %7ld (i=%ld,ii=%ld,b=%ld,f=%ld)\n",
	241	n, nindir, niindir, nblock, nfrag);
07670f7d	242	printf("free %7ld (b=%ld,f=%ld)\n", nffree + FRAG * nbfree,
b42940ce KM	243	nbfree, nffree);
	244	#endif
	245	if(!dflg) {
	246	n = 0;
955f6ff8	247	for (d = 0; d < sblock.fs_size; d++)
07670f7d	248	if(!duped(d, FSIZE)) {
b42940ce KM	249	if(mflg)
	250	printf("%ld missing\n", d);
	251	n++;
	252	}
	253	printf("missing%5ld\n", n);
	254	}
	255	}
	256
	257	pass1(ip)
955f6ff8	258	register struct dinode *ip;
b42940ce	259	{
07670f7d KM	260	daddr_t ind1[NINDIR];
	261	daddr_t ind2[NINDIR];
	262	daddr_t db, ib;
	263	register int i, j, k, siz;
b42940ce KM	264
b42940ce KM	265	i = ip->di_mode & IFMT;
0947395d	266	if(i == 0)
b42940ce	267	return;
b42940ce KM	268	switch (i) {
	269	case IFCHR:
	270	ncfile++;
	271	return;
	272	case IFBLK:
	273	nbfile++;
	274	return;
	275	case IFDIR:
	276	ndfile++;
	277	break;
	278	case IFREG:
	279	nrfile++;
	280	break;
	281	default:
	282	printf("bad mode %u\n", ino);
	283	return;
	284	}
955f6ff8 KM	285	for (i = 0; i < NDADDR; i++) {
	286	db = ip->di_db[i];
	287	if (db == 0)
b42940ce	288	continue;
07670f7d KM	289	siz = dblksize(ip, i);
	290	chk(db, "data (block)", siz);
	291	if (siz == BSIZE)
	292	nblock++;
	293	else
	294	nfrag += howmany(siz, FSIZE);
b42940ce	295	}
955f6ff8 KM	296	for(i = 0; i < NIADDR; i++) {
	297	ib = ip->di_ib[i];
	298	if(ib == 0)
	299	continue;
07670f7d	300	if (chk(ib, "1st indirect", BSIZE))
b42940ce	301	continue;
07670f7d	302	bread(ib, (char *)ind1, BSIZE);
b42940ce	303	nindir++;
955f6ff8 KM	304	for (j = 0; j < NINDIR; j++) {
	305	ib = ind1[j];
	306	if (ib == 0)
b42940ce	307	continue;
955f6ff8	308	if (i == 0) {
07670f7d KM	309	siz = dblksize(ip, NDADDR + j);
	310	chk(ib, "data (large)", siz);
	311	if (siz == BSIZE)
	312	nblock++;
	313	else
	314	nfrag += howmany(siz, FSIZE);
b42940ce KM	315	continue;
b42940ce KM	316	}
07670f7d	317	if (chk(ib, "2nd indirect", BSIZE))
955f6ff8	318	continue;
07670f7d	319	bread(ib, (char *)ind2, BSIZE);
b42940ce	320	niindir++;
955f6ff8 KM	321	for (k = 0; k < NINDIR; k++) {
	322	ib = ind2[k];
	323	if (ib == 0)
b42940ce	324	continue;
07670f7d KM	325	siz = dblksize(ip,
	326	NDADDR + NINDIR * (i + j) + k);
	327	chk(ib, "data (huge)", siz);
	328	if (siz == BSIZE)
	329	nblock++;
	330	else
	331	nfrag += howmany(siz, FSIZE);
b42940ce	332	}
b42940ce KM	333	}
	334	}
	335	}
	336
07670f7d	337	chk(bno, s, size)
955f6ff8 KM	338	daddr_t bno;
955f6ff8 KM	339	char *s;
07670f7d	340	int size;
b42940ce KM	341	{
	342	register n, cg;
	343
	344	cg = dtog(bno, &sblock);
07670f7d KM	345	if (cginit==0 &&
07670f7d KM	346	bno<cgdmin(cg,&sblock) \|\| bno >= FRAG * sblock.fs_size) {
b42940ce KM	347	printf("%ld bad; inode=%u, class=%s\n", bno, ino, s);
	348	return(1);
	349	}
07670f7d KM	350	if (size == BSIZE) {
	351	if (duped(bno, size)) {
	352	printf("%ld dup block; inode=%u, class=%s\n",
	353	bno, ino, s);
	354	ndup += FRAG;
	355	}
	356	} else {
	357	for (n = 0; n < size / FSIZE; n++) {
	358	if (duped(bno + n, FSIZE)) {
	359	printf("%ld dup frag; inode=%u, class=%s\n",
	360	bno, ino, s);
	361	ndup++;
	362	}
	363	}
b42940ce KM	364	}
	365	for (n=0; blist[n] != -1; n++)
	366	if (bno == blist[n])
	367	printf("%ld arg; inode=%u, class=%s\n", bno, ino, s);
	368	return(0);
	369	}
	370
07670f7d	371	duped(bno, size)
955f6ff8	372	daddr_t bno;
07670f7d	373	int size;
b42940ce	374	{
b42940ce KM	375	if(dflg)
b42940ce KM	376	return(0);
07670f7d KM	377	if (size != FSIZE && size != BSIZE)
	378	printf("bad size %d to duped\n", size);
	379	if (size == FSIZE) {
955f6ff8 KM	380	if (isset(bmap, bno))
	381	return(1);
	382	setbit(bmap, bno);
	383	return (0);
	384	}
	385	if (bno % FRAG != 0)
	386	printf("bad bno %d to duped\n", bno);
	387	if (isblock(bmap, bno/FRAG))
	388	return (1);
	389	setblock(bmap, bno/FRAG);
b42940ce KM	390	return(0);
	391	}
	392
	393	bread(bno, buf, cnt)
955f6ff8 KM	394	daddr_t bno;
955f6ff8 KM	395	char *buf;
b42940ce KM	396	{
	397	register i;
	398
	399	lseek(fi, bno*FSIZE, 0);
	400	if ((i = read(fi, buf, cnt)) != cnt) {
b42940ce KM	401	for(i=0; i<BSIZE; i++)
	402	buf[i] = 0;
	403	}
	404	}