usr/src/sbin/fsck/inode.c

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

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

#include <sys/param.h>
#include <ufs/ufs/dinode.h>
#include <ufs/ufs/dir.h>
#include <ufs/ffs/fs.h>
#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include "fsck.h"

static ino_t startinum;

ckinode(dp, idesc)
	struct dinode *dp;
	register struct inodesc *idesc;
{
	register daddr_t *ap;
	long ret, n, ndb, offset;
	struct dinode dino;

	if (idesc->id_fix != IGNORE)
		idesc->id_fix = DONTKNOW;
	idesc->id_entryno = 0;
	idesc->id_filesize = dp->di_size;
	if ((dp->di_mode & IFMT) == IFBLK || (dp->di_mode & IFMT) == IFCHR)
		return (KEEPON);
	dino = *dp;
	ndb = howmany(dino.di_size, sblock.fs_bsize);
	for (ap = &dino.di_db[0]; ap < &dino.di_db[NDADDR]; ap++) {
		if (--ndb == 0 && (offset = blkoff(&sblock, dino.di_size)) != 0)
			idesc->id_numfrags =
				numfrags(&sblock, fragroundup(&sblock, offset));
		else
			idesc->id_numfrags = sblock.fs_frag;
		if (*ap == 0)
			continue;
		idesc->id_blkno = *ap;
		if (idesc->id_type == ADDR)
			ret = (*idesc->id_func)(idesc);
		else
			ret = dirscan(idesc);
		if (ret & STOP)
			return (ret);
	}
	idesc->id_numfrags = sblock.fs_frag;
	for (ap = &dino.di_ib[0], n = 1; n <= NIADDR; ap++, n++) {
		if (*ap) {
			idesc->id_blkno = *ap;
			ret = iblock(idesc, n,
				dino.di_size - sblock.fs_bsize * NDADDR);
			if (ret & STOP)
				return (ret);
		}
	}
	return (KEEPON);
}

iblock(idesc, ilevel, isize)
	struct inodesc *idesc;
	register long ilevel;
	u_long isize;
{
	register daddr_t *ap;
	register daddr_t *aplim;
	int i, n, (*func)(), nif, sizepb;
	register struct bufarea *bp;
	char buf[BUFSIZ];
	extern int dirscan(), pass1check();

	if (idesc->id_type == ADDR) {
		func = idesc->id_func;
		if (((n = (*func)(idesc)) & KEEPON) == 0)
			return (n);
	} else
		func = dirscan;
	if (chkrange(idesc->id_blkno, idesc->id_numfrags))
		return (SKIP);
	bp = getdatablk(idesc->id_blkno, sblock.fs_bsize);
	ilevel--;
	for (sizepb = sblock.fs_bsize, i = 0; i < ilevel; i++)
		sizepb *= NINDIR(&sblock);
	nif = isize / sizepb + 1;
	if (nif > NINDIR(&sblock))
		nif = NINDIR(&sblock);
	if (idesc->id_func == pass1check && nif < NINDIR(&sblock)) {
		aplim = &bp->b_un.b_indir[NINDIR(&sblock)];
		for (ap = &bp->b_un.b_indir[nif]; ap < aplim; ap++) {
			if (*ap == 0)
				continue;
			(void)sprintf(buf, "PARTIALLY TRUNCATED INODE I=%lu",
				idesc->id_number);
			if (dofix(idesc, buf)) {
				*ap = 0;
				dirty(bp);
			}
		}
		flush(fswritefd, bp);
	}
	aplim = &bp->b_un.b_indir[nif];
	for (ap = bp->b_un.b_indir, i = 1; ap < aplim; ap++, i++) {
		if (*ap) {
			idesc->id_blkno = *ap;
			if (ilevel > 0)
				n = iblock(idesc, ilevel, isize - i * sizepb);
			else
				n = (*func)(idesc);
			if (n & STOP) {
				bp->b_flags &= ~B_INUSE;
				return (n);
			}
		}
	}
	bp->b_flags &= ~B_INUSE;
	return (KEEPON);
}

/*
 * Check that a block in a legal block number.
 * Return 0 if in range, 1 if out of range.
 */
chkrange(blk, cnt)
	daddr_t blk;
	int cnt;
{
	register int c;

	if ((unsigned)(blk + cnt) > maxfsblock)
		return (1);
	c = dtog(&sblock, blk);
	if (blk < cgdmin(&sblock, c)) {
		if ((blk + cnt) > cgsblock(&sblock, c)) {
			if (debug) {
				printf("blk %ld < cgdmin %ld;",
				    blk, cgdmin(&sblock, c));
				printf(" blk + cnt %ld > cgsbase %ld\n",
				    blk + cnt, cgsblock(&sblock, c));
			}
			return (1);
		}
	} else {
		if ((blk + cnt) > cgbase(&sblock, c+1)) {
			if (debug)  {
				printf("blk %ld >= cgdmin %ld;",
				    blk, cgdmin(&sblock, c));
				printf(" blk + cnt %ld > sblock.fs_fpg %ld\n",
				    blk+cnt, sblock.fs_fpg);
			}
			return (1);
		}
	}
	return (0);
}

/*
 * General purpose interface for reading inodes.
 */
struct dinode *
ginode(inumber)
	ino_t inumber;
{
	daddr_t iblk;

	if (inumber < ROOTINO || inumber > maxino)
		errexit("bad inode number %d to ginode\n", inumber);
	if (startinum == 0 ||
	    inumber < startinum || inumber >= startinum + INOPB(&sblock)) {
		iblk = itod(&sblock, inumber);
		if (pbp != 0)
			pbp->b_flags &= ~B_INUSE;
		pbp = getdatablk(iblk, sblock.fs_bsize);
		startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
	}
	return (&pbp->b_un.b_dinode[inumber % INOPB(&sblock)]);
}

/*
 * Special purpose version of ginode used to optimize first pass
 * over all the inodes in numerical order.
 */
ino_t nextino, lastinum;
long readcnt, readpercg, fullcnt, inobufsize, partialcnt, partialsize;
struct dinode *inodebuf;

struct dinode *
getnextinode(inumber)
	ino_t inumber;
{
	long size;
	daddr_t dblk;
	static struct dinode *dp;

	if (inumber != nextino++ || inumber > maxino)
		errexit("bad inode number %d to nextinode\n", inumber);
	if (inumber >= lastinum) {
		readcnt++;
		dblk = fsbtodb(&sblock, itod(&sblock, lastinum));
		if (readcnt % readpercg == 0) {
			size = partialsize;
			lastinum += partialcnt;
		} else {
			size = inobufsize;
			lastinum += fullcnt;
		}
		(void)bread(fsreadfd, (char *)inodebuf, dblk, size); /* ??? */
		dp = inodebuf;
	}
	return (dp++);
}

resetinodebuf()
{

	startinum = 0;
	nextino = 0;
	lastinum = 0;
	readcnt = 0;
	inobufsize = blkroundup(&sblock, INOBUFSIZE);
	fullcnt = inobufsize / sizeof(struct dinode);
	readpercg = sblock.fs_ipg / fullcnt;
	partialcnt = sblock.fs_ipg % fullcnt;
	partialsize = partialcnt * sizeof(struct dinode);
	if (partialcnt != 0) {
		readpercg++;
	} else {
		partialcnt = fullcnt;
		partialsize = inobufsize;
	}
	if (inodebuf == NULL &&
	    (inodebuf = (struct dinode *)malloc((unsigned)inobufsize)) == NULL)
		errexit("Cannot allocate space for inode buffer\n");
	while (nextino < ROOTINO)
		(void)getnextinode(nextino);
}

freeinodebuf()
{

	if (inodebuf != NULL)
		free((char *)inodebuf);
	inodebuf = NULL;
}

/*
 * Routines to maintain information about directory inodes.
 * This is built during the first pass and used during the
 * second and third passes.
 *
 * Enter inodes into the cache.
 */
cacheino(dp, inumber)
	register struct dinode *dp;
	ino_t inumber;
{
	register struct inoinfo *inp;
	struct inoinfo **inpp;
	unsigned int blks;

	blks = howmany(dp->di_size, sblock.fs_bsize);
	if (blks > NDADDR)
		blks = NDADDR + NIADDR;
	inp = (struct inoinfo *)
		malloc(sizeof(*inp) + (blks - 1) * sizeof(daddr_t));
	if (inp == NULL)
		return;
	inpp = &inphead[inumber % numdirs];
	inp->i_nexthash = *inpp;
	*inpp = inp;
	inp->i_parent = (ino_t)0;
	inp->i_dotdot = (ino_t)0;
	inp->i_number = inumber;
	inp->i_isize = dp->di_size;
	inp->i_numblks = blks * sizeof(daddr_t);
	bcopy((char *)&dp->di_db[0], (char *)&inp->i_blks[0],
	    (size_t)inp->i_numblks);
	if (inplast == listmax) {
		listmax += 100;
		inpsort = (struct inoinfo **)realloc((char *)inpsort,
		    (unsigned)listmax * sizeof(struct inoinfo *));
		if (inpsort == NULL)
			errexit("cannot increase directory list");
	}
	inpsort[inplast++] = inp;
}

/*
 * Look up an inode cache structure.
 */
struct inoinfo *
getinoinfo(inumber)
	ino_t inumber;
{
	register struct inoinfo *inp;

	for (inp = inphead[inumber % numdirs]; inp; inp = inp->i_nexthash) {
		if (inp->i_number != inumber)
			continue;
		return (inp);
	}
	errexit("cannot find inode %d\n", inumber);
	return ((struct inoinfo *)0);
}

/*
 * Clean up all the inode cache structure.
 */
inocleanup()
{
	register struct inoinfo **inpp;

	if (inphead == NULL)
		return;
	for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--)
		free((char *)(*inpp));
	free((char *)inphead);
	free((char *)inpsort);
	inphead = inpsort = NULL;
}

inodirty()
{

	dirty(pbp);
}

clri(idesc, type, flag)
	register struct inodesc *idesc;
	char *type;
	int flag;
{
	register struct dinode *dp;

	dp = ginode(idesc->id_number);
	if (flag == 1) {
		pwarn("%s %s", type,
		    (dp->di_mode & IFMT) == IFDIR ? "DIR" : "FILE");
		pinode(idesc->id_number);
	}
	if (preen || reply("CLEAR") == 1) {
		if (preen)
			printf(" (CLEARED)\n");
		n_files--;
		(void)ckinode(dp, idesc);
		clearinode(dp);
		statemap[idesc->id_number] = USTATE;
		inodirty();
	}
}

findname(idesc)
	struct inodesc *idesc;
{
	register struct direct *dirp = idesc->id_dirp;

	if (dirp->d_ino != idesc->id_parent)
		return (KEEPON);
	bcopy(dirp->d_name, idesc->id_name, (size_t)dirp->d_namlen + 1);
	return (STOP|FOUND);
}

findino(idesc)
	struct inodesc *idesc;
{
	register struct direct *dirp = idesc->id_dirp;

	if (dirp->d_ino == 0)
		return (KEEPON);
	if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
	    dirp->d_ino >= ROOTINO && dirp->d_ino <= maxino) {
		idesc->id_parent = dirp->d_ino;
		return (STOP|FOUND);
	}
	return (KEEPON);
}

pinode(ino)
	ino_t ino;
{
	register struct dinode *dp;
	register char *p;
	struct passwd *pw;
	char *ctime();

	printf(" I=%lu ", ino);
	if (ino < ROOTINO || ino > maxino)
		return;
	dp = ginode(ino);
	printf(" OWNER=");
	if ((pw = getpwuid((int)dp->di_uid)) != 0)
		printf("%s ", pw->pw_name);
	else
		printf("%u ", (unsigned)dp->di_uid);
	printf("MODE=%o\n", dp->di_mode);
	if (preen)
		printf("%s: ", devname);
	printf("SIZE=%lu ", dp->di_size);
	p = ctime(&dp->di_mtime);
	printf("MTIME=%12.12s %4.4s ", &p[4], &p[20]);
}

blkerror(ino, type, blk)
	ino_t ino;
	char *type;
	daddr_t blk;
{

	pfatal("%ld %s I=%lu", blk, type, ino);
	printf("\n");
	switch (statemap[ino]) {

	case FSTATE:
		statemap[ino] = FCLEAR;
		return;

	case DSTATE:
		statemap[ino] = DCLEAR;
		return;

	case FCLEAR:
	case DCLEAR:
		return;

	default:
		errexit("BAD STATE %d TO BLKERR", statemap[ino]);
		/* NOTREACHED */
	}
}

/*
 * allocate an unused inode
 */
ino_t
allocino(request, type)
	ino_t request;
	int type;
{
	register ino_t ino;
	register struct dinode *dp;

	if (request == 0)
		request = ROOTINO;
	else if (statemap[request] != USTATE)
		return (0);
	for (ino = request; ino < maxino; ino++)
		if (statemap[ino] == USTATE)
			break;
	if (ino == maxino)
		return (0);
	switch (type & IFMT) {
	case IFDIR:
		statemap[ino] = DSTATE;
		break;
	case IFREG:
	case IFLNK:
		statemap[ino] = FSTATE;
		break;
	default:
		return (0);
	}
	dp = ginode(ino);
	dp->di_db[0] = allocblk((long)1);
	if (dp->di_db[0] == 0) {
		statemap[ino] = USTATE;
		return (0);
	}
	dp->di_mode = type;
	(void)time(&dp->di_atime);
	dp->di_mtime = dp->di_ctime = dp->di_atime;
	dp->di_size = sblock.fs_fsize;
	dp->di_blocks = btodb(sblock.fs_fsize);
	n_files++;
	inodirty();
	return (ino);
}

/*
 * deallocate an inode
 */
freeino(ino)
	ino_t ino;
{
	struct inodesc idesc;
	extern int pass4check();
	struct dinode *dp;

	bzero((char *)&idesc, sizeof(struct inodesc));
	idesc.id_type = ADDR;
	idesc.id_func = pass4check;
	idesc.id_number = ino;
	dp = ginode(ino);
	(void)ckinode(dp, &idesc);
	clearinode(dp);
	inodirty();
	statemap[ino] = USTATE;
	n_files--;
}
Commit	Line	Data
	1	/*
	2	* Copyright (c) 1980, 1986 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* %sccs.include.redist.c%
	6	*/
	7
	8	#ifndef lint
	9	static char sccsid[] = "@(#)inode.c 5.19 (Berkeley) %G%";
	10	#endif /* not lint */
	11
	12	#include <sys/param.h>
	13	#include <ufs/ufs/dinode.h>
	14	#include <ufs/ufs/dir.h>
	15	#include <ufs/ffs/fs.h>
	16	#include <pwd.h>
	17	#include <stdlib.h>
	18	#include <string.h>
	19	#include "fsck.h"
	20
	21	static ino_t startinum;
	22
	23	ckinode(dp, idesc)
	24	struct dinode *dp;
	25	register struct inodesc *idesc;
	26	{
	27	register daddr_t *ap;
	28	long ret, n, ndb, offset;
	29	struct dinode dino;
	30
	31	if (idesc->id_fix != IGNORE)
	32	idesc->id_fix = DONTKNOW;
	33	idesc->id_entryno = 0;
	34	idesc->id_filesize = dp->di_size;
	35	if ((dp->di_mode & IFMT) == IFBLK \|\| (dp->di_mode & IFMT) == IFCHR)
	36	return (KEEPON);
	37	dino = *dp;
	38	ndb = howmany(dino.di_size, sblock.fs_bsize);
	39	for (ap = &dino.di_db[0]; ap < &dino.di_db[NDADDR]; ap++) {
	40	if (--ndb == 0 && (offset = blkoff(&sblock, dino.di_size)) != 0)
	41	idesc->id_numfrags =
	42	numfrags(&sblock, fragroundup(&sblock, offset));
	43	else
	44	idesc->id_numfrags = sblock.fs_frag;
	45	if (*ap == 0)
	46	continue;
	47	idesc->id_blkno = *ap;
	48	if (idesc->id_type == ADDR)
	49	ret = (*idesc->id_func)(idesc);
	50	else
	51	ret = dirscan(idesc);
	52	if (ret & STOP)
	53	return (ret);
	54	}
	55	idesc->id_numfrags = sblock.fs_frag;
	56	for (ap = &dino.di_ib[0], n = 1; n <= NIADDR; ap++, n++) {
	57	if (*ap) {
	58	idesc->id_blkno = *ap;
	59	ret = iblock(idesc, n,
	60	dino.di_size - sblock.fs_bsize * NDADDR);
	61	if (ret & STOP)
	62	return (ret);
	63	}
	64	}
	65	return (KEEPON);
	66	}
	67
	68	iblock(idesc, ilevel, isize)
	69	struct inodesc *idesc;
	70	register long ilevel;
	71	u_long isize;
	72	{
	73	register daddr_t *ap;
	74	register daddr_t *aplim;
	75	int i, n, (*func)(), nif, sizepb;
	76	register struct bufarea *bp;
	77	char buf[BUFSIZ];
	78	extern int dirscan(), pass1check();
	79
	80	if (idesc->id_type == ADDR) {
	81	func = idesc->id_func;
	82	if (((n = (*func)(idesc)) & KEEPON) == 0)
	83	return (n);
	84	} else
	85	func = dirscan;
	86	if (chkrange(idesc->id_blkno, idesc->id_numfrags))
	87	return (SKIP);
	88	bp = getdatablk(idesc->id_blkno, sblock.fs_bsize);
	89	ilevel--;
	90	for (sizepb = sblock.fs_bsize, i = 0; i < ilevel; i++)
	91	sizepb *= NINDIR(&sblock);
	92	nif = isize / sizepb + 1;
	93	if (nif > NINDIR(&sblock))
	94	nif = NINDIR(&sblock);
	95	if (idesc->id_func == pass1check && nif < NINDIR(&sblock)) {
	96	aplim = &bp->b_un.b_indir[NINDIR(&sblock)];
	97	for (ap = &bp->b_un.b_indir[nif]; ap < aplim; ap++) {
	98	if (*ap == 0)
	99	continue;
	100	(void)sprintf(buf, "PARTIALLY TRUNCATED INODE I=%lu",
	101	idesc->id_number);
	102	if (dofix(idesc, buf)) {
	103	*ap = 0;
	104	dirty(bp);
	105	}
	106	}
	107	flush(fswritefd, bp);
	108	}
	109	aplim = &bp->b_un.b_indir[nif];
	110	for (ap = bp->b_un.b_indir, i = 1; ap < aplim; ap++, i++) {
	111	if (*ap) {
	112	idesc->id_blkno = *ap;
	113	if (ilevel > 0)
	114	n = iblock(idesc, ilevel, isize - i * sizepb);
	115	else
	116	n = (*func)(idesc);
	117	if (n & STOP) {
	118	bp->b_flags &= ~B_INUSE;
	119	return (n);
	120	}
	121	}
	122	}
	123	bp->b_flags &= ~B_INUSE;
	124	return (KEEPON);
	125	}
	126
	127	/*
	128	* Check that a block in a legal block number.
	129	* Return 0 if in range, 1 if out of range.
	130	*/
	131	chkrange(blk, cnt)
	132	daddr_t blk;
	133	int cnt;
	134	{
	135	register int c;
	136
	137	if ((unsigned)(blk + cnt) > maxfsblock)
	138	return (1);
	139	c = dtog(&sblock, blk);
	140	if (blk < cgdmin(&sblock, c)) {
	141	if ((blk + cnt) > cgsblock(&sblock, c)) {
	142	if (debug) {
	143	printf("blk %ld < cgdmin %ld;",
	144	blk, cgdmin(&sblock, c));
	145	printf(" blk + cnt %ld > cgsbase %ld\n",
	146	blk + cnt, cgsblock(&sblock, c));
	147	}
	148	return (1);
	149	}
	150	} else {
	151	if ((blk + cnt) > cgbase(&sblock, c+1)) {
	152	if (debug) {
	153	printf("blk %ld >= cgdmin %ld;",
	154	blk, cgdmin(&sblock, c));
	155	printf(" blk + cnt %ld > sblock.fs_fpg %ld\n",
	156	blk+cnt, sblock.fs_fpg);
	157	}
	158	return (1);
	159	}
	160	}
	161	return (0);
	162	}
	163
	164	/*
	165	* General purpose interface for reading inodes.
	166	*/
	167	struct dinode *
	168	ginode(inumber)
	169	ino_t inumber;
	170	{
	171	daddr_t iblk;
	172
	173	if (inumber < ROOTINO \|\| inumber > maxino)
	174	errexit("bad inode number %d to ginode\n", inumber);
	175	if (startinum == 0 \|\|
	176	inumber < startinum \|\| inumber >= startinum + INOPB(&sblock)) {
	177	iblk = itod(&sblock, inumber);
	178	if (pbp != 0)
	179	pbp->b_flags &= ~B_INUSE;
	180	pbp = getdatablk(iblk, sblock.fs_bsize);
	181	startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
	182	}
	183	return (&pbp->b_un.b_dinode[inumber % INOPB(&sblock)]);
	184	}
	185
	186	/*
	187	* Special purpose version of ginode used to optimize first pass
	188	* over all the inodes in numerical order.
	189	*/
	190	ino_t nextino, lastinum;
	191	long readcnt, readpercg, fullcnt, inobufsize, partialcnt, partialsize;
	192	struct dinode *inodebuf;
	193
	194	struct dinode *
	195	getnextinode(inumber)
	196	ino_t inumber;
	197	{
	198	long size;
	199	daddr_t dblk;
	200	static struct dinode *dp;
	201
	202	if (inumber != nextino++ \|\| inumber > maxino)
	203	errexit("bad inode number %d to nextinode\n", inumber);
	204	if (inumber >= lastinum) {
	205	readcnt++;
	206	dblk = fsbtodb(&sblock, itod(&sblock, lastinum));
	207	if (readcnt % readpercg == 0) {
	208	size = partialsize;
	209	lastinum += partialcnt;
	210	} else {
	211	size = inobufsize;
	212	lastinum += fullcnt;
	213	}
	214	(void)bread(fsreadfd, (char )inodebuf, dblk, size); / ??? */
	215	dp = inodebuf;
	216	}
	217	return (dp++);
	218	}
	219
	220	resetinodebuf()
	221	{
	222
	223	startinum = 0;
	224	nextino = 0;
	225	lastinum = 0;
	226	readcnt = 0;
	227	inobufsize = blkroundup(&sblock, INOBUFSIZE);
	228	fullcnt = inobufsize / sizeof(struct dinode);
	229	readpercg = sblock.fs_ipg / fullcnt;
	230	partialcnt = sblock.fs_ipg % fullcnt;
	231	partialsize = partialcnt * sizeof(struct dinode);
	232	if (partialcnt != 0) {
	233	readpercg++;
	234	} else {
	235	partialcnt = fullcnt;
	236	partialsize = inobufsize;
	237	}
	238	if (inodebuf == NULL &&
	239	(inodebuf = (struct dinode *)malloc((unsigned)inobufsize)) == NULL)
	240	errexit("Cannot allocate space for inode buffer\n");
	241	while (nextino < ROOTINO)
	242	(void)getnextinode(nextino);
	243	}
	244
	245	freeinodebuf()
	246	{
	247
	248	if (inodebuf != NULL)
	249	free((char *)inodebuf);
	250	inodebuf = NULL;
	251	}
	252
	253	/*
	254	* Routines to maintain information about directory inodes.
	255	* This is built during the first pass and used during the
	256	* second and third passes.
	257	*
	258	* Enter inodes into the cache.
	259	*/
	260	cacheino(dp, inumber)
	261	register struct dinode *dp;
	262	ino_t inumber;
	263	{
	264	register struct inoinfo *inp;
	265	struct inoinfo **inpp;
	266	unsigned int blks;
	267
	268	blks = howmany(dp->di_size, sblock.fs_bsize);
	269	if (blks > NDADDR)
	270	blks = NDADDR + NIADDR;
	271	inp = (struct inoinfo *)
	272	malloc(sizeof(inp) + (blks - 1) sizeof(daddr_t));
	273	if (inp == NULL)
	274	return;
	275	inpp = &inphead[inumber % numdirs];
	276	inp->i_nexthash = *inpp;
	277	*inpp = inp;
	278	inp->i_parent = (ino_t)0;
	279	inp->i_dotdot = (ino_t)0;
	280	inp->i_number = inumber;
	281	inp->i_isize = dp->di_size;
	282	inp->i_numblks = blks * sizeof(daddr_t);
	283	bcopy((char )&dp->di_db[0], (char )&inp->i_blks[0],
	284	(size_t)inp->i_numblks);
	285	if (inplast == listmax) {
	286	listmax += 100;
	287	inpsort = (struct inoinfo *)realloc((char )inpsort,
	288	(unsigned)listmax * sizeof(struct inoinfo *));
	289	if (inpsort == NULL)
	290	errexit("cannot increase directory list");
	291	}
	292	inpsort[inplast++] = inp;
	293	}
	294
	295	/*
	296	* Look up an inode cache structure.
	297	*/
	298	struct inoinfo *
	299	getinoinfo(inumber)
	300	ino_t inumber;
	301	{
	302	register struct inoinfo *inp;
	303
	304	for (inp = inphead[inumber % numdirs]; inp; inp = inp->i_nexthash) {
	305	if (inp->i_number != inumber)
	306	continue;
	307	return (inp);
	308	}
	309	errexit("cannot find inode %d\n", inumber);
	310	return ((struct inoinfo *)0);
	311	}
	312
	313	/*
	314	* Clean up all the inode cache structure.
	315	*/
	316	inocleanup()
	317	{
	318	register struct inoinfo **inpp;
	319
	320	if (inphead == NULL)
	321	return;
	322	for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--)
	323	free((char )(inpp));
	324	free((char *)inphead);
	325	free((char *)inpsort);
	326	inphead = inpsort = NULL;
	327	}
	328
	329	inodirty()
	330	{
	331
	332	dirty(pbp);
	333	}
	334
	335	clri(idesc, type, flag)
	336	register struct inodesc *idesc;
	337	char *type;
	338	int flag;
	339	{
	340	register struct dinode *dp;
	341
	342	dp = ginode(idesc->id_number);
	343	if (flag == 1) {
	344	pwarn("%s %s", type,
	345	(dp->di_mode & IFMT) == IFDIR ? "DIR" : "FILE");
	346	pinode(idesc->id_number);
	347	}
	348	if (preen \|\| reply("CLEAR") == 1) {
	349	if (preen)
	350	printf(" (CLEARED)\n");
	351	n_files--;
	352	(void)ckinode(dp, idesc);
	353	clearinode(dp);
	354	statemap[idesc->id_number] = USTATE;
	355	inodirty();
	356	}
	357	}
	358
	359	findname(idesc)
	360	struct inodesc *idesc;
	361	{
	362	register struct direct *dirp = idesc->id_dirp;
	363
	364	if (dirp->d_ino != idesc->id_parent)
	365	return (KEEPON);
	366	bcopy(dirp->d_name, idesc->id_name, (size_t)dirp->d_namlen + 1);
	367	return (STOP\|FOUND);
	368	}
	369
	370	findino(idesc)
	371	struct inodesc *idesc;
	372	{
	373	register struct direct *dirp = idesc->id_dirp;
	374
	375	if (dirp->d_ino == 0)
	376	return (KEEPON);
	377	if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
	378	dirp->d_ino >= ROOTINO && dirp->d_ino <= maxino) {
	379	idesc->id_parent = dirp->d_ino;
	380	return (STOP\|FOUND);
	381	}
	382	return (KEEPON);
	383	}
	384
	385	pinode(ino)
	386	ino_t ino;
	387	{
	388	register struct dinode *dp;
	389	register char *p;
	390	struct passwd *pw;
	391	char *ctime();
	392
	393	printf(" I=%lu ", ino);
	394	if (ino < ROOTINO \|\| ino > maxino)
	395	return;
	396	dp = ginode(ino);
	397	printf(" OWNER=");
	398	if ((pw = getpwuid((int)dp->di_uid)) != 0)
	399	printf("%s ", pw->pw_name);
	400	else
	401	printf("%u ", (unsigned)dp->di_uid);
	402	printf("MODE=%o\n", dp->di_mode);
	403	if (preen)
	404	printf("%s: ", devname);
	405	printf("SIZE=%lu ", dp->di_size);
	406	p = ctime(&dp->di_mtime);
	407	printf("MTIME=%12.12s %4.4s ", &p[4], &p[20]);
	408	}
	409
	410	blkerror(ino, type, blk)
	411	ino_t ino;
	412	char *type;
	413	daddr_t blk;
	414	{
	415
	416	pfatal("%ld %s I=%lu", blk, type, ino);
	417	printf("\n");
	418	switch (statemap[ino]) {
	419
	420	case FSTATE:
	421	statemap[ino] = FCLEAR;
	422	return;
	423
	424	case DSTATE:
	425	statemap[ino] = DCLEAR;
	426	return;
	427
	428	case FCLEAR:
	429	case DCLEAR:
	430	return;
	431
	432	default:
	433	errexit("BAD STATE %d TO BLKERR", statemap[ino]);
	434	/* NOTREACHED */
	435	}
	436	}
	437
	438	/*
	439	* allocate an unused inode
	440	*/
	441	ino_t
	442	allocino(request, type)
	443	ino_t request;
	444	int type;
	445	{
	446	register ino_t ino;
	447	register struct dinode *dp;
	448
	449	if (request == 0)
	450	request = ROOTINO;
	451	else if (statemap[request] != USTATE)
	452	return (0);
	453	for (ino = request; ino < maxino; ino++)
	454	if (statemap[ino] == USTATE)
	455	break;
	456	if (ino == maxino)
	457	return (0);
	458	switch (type & IFMT) {
	459	case IFDIR:
	460	statemap[ino] = DSTATE;
	461	break;
	462	case IFREG:
	463	case IFLNK:
	464	statemap[ino] = FSTATE;
	465	break;
	466	default:
	467	return (0);
	468	}
	469	dp = ginode(ino);
	470	dp->di_db[0] = allocblk((long)1);
	471	if (dp->di_db[0] == 0) {
	472	statemap[ino] = USTATE;
	473	return (0);
	474	}
	475	dp->di_mode = type;
	476	(void)time(&dp->di_atime);
	477	dp->di_mtime = dp->di_ctime = dp->di_atime;
	478	dp->di_size = sblock.fs_fsize;
	479	dp->di_blocks = btodb(sblock.fs_fsize);
	480	n_files++;
	481	inodirty();
	482	return (ino);
	483	}
	484
	485	/*
	486	* deallocate an inode
	487	*/
	488	freeino(ino)
	489	ino_t ino;
	490	{
	491	struct inodesc idesc;
	492	extern int pass4check();
	493	struct dinode *dp;
	494
	495	bzero((char *)&idesc, sizeof(struct inodesc));
	496	idesc.id_type = ADDR;
	497	idesc.id_func = pass4check;
	498	idesc.id_number = ino;
	499	dp = ginode(ino);
	500	(void)ckinode(dp, &idesc);
	501	clearinode(dp);
	502	inodirty();
	503	statemap[ino] = USTATE;
	504	n_files--;
	505	}