xref: /netbsd-src/sbin/fsck_ext2fs/inode.c (revision 4d7e773266e3c3f48566c86c0ad52d51c6454fd1) 
1 /*	$NetBSD: inode.c,v 1.3 1997/10/09 13:19:36 bouyer Exp $	*/
2 
3 /*
4  * Copyright (c) 1997 Manuel Bouyer.
5  * Copyright (c) 1980, 1986, 1993
6  *	The Regents of the University of California.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *	This product includes software developed by the University of
19  *	California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  */
36 
37 #include <sys/cdefs.h>
38 #ifndef lint
39 #if 0
40 static char sccsid[] = "@(#)inode.c	8.5 (Berkeley) 2/8/95";
41 #else
42 __RCSID("$NetBSD: inode.c,v 1.3 1997/10/09 13:19:36 bouyer Exp $");
43 #endif
44 #endif /* not lint */
45 
46 #include <sys/param.h>
47 #include <sys/time.h>
48 #include <ufs/ext2fs/ext2fs_dinode.h>
49 #include <ufs/ext2fs/ext2fs_dir.h>
50 #include <ufs/ext2fs/ext2fs.h>
51 
52 #include <ufs/ufs/dinode.h> /* for IFMT & friends */
53 #ifndef SMALL
54 #include <pwd.h>
55 #endif
56 #include <stdio.h>
57 #include <stdlib.h>
58 #include <string.h>
59 
60 #include "fsck.h"
61 #include "fsutil.h"
62 #include "extern.h"
63 
64 /*
65  * CG is stored in fs byte order in memory, so we can't use ino_to_fsba
66  * here.
67  */
68 
69 #define fsck_ino_to_fsba(fs, x)                      \
70 	(fs2h32((fs)->e2fs_gd[ino_to_cg(fs, x)].ext2bgd_i_tables) + \
71 	(((x)-1) % (fs)->e2fs.e2fs_ipg)/(fs)->e2fs_ipb)
72 
73 
74 static ino_t startinum;
75 
76 static int iblock __P((struct inodesc *, long, u_int64_t));
77 
78 int
79 ckinode(dp, idesc)
80 	struct ext2fs_dinode *dp;
81 	struct inodesc *idesc;
82 {
83 	u_int32_t *ap;
84 	long ret, n, ndb;
85 	struct ext2fs_dinode dino;
86 	u_int64_t remsize, sizepb;
87 	mode_t mode;
88 	char pathbuf[MAXPATHLEN + 1];
89 
90 	if (idesc->id_fix != IGNORE)
91 		idesc->id_fix = DONTKNOW;
92 	idesc->id_entryno = 0;
93 	idesc->id_filesize = fs2h32(dp->e2di_size);
94 	mode = fs2h16(dp->e2di_mode) & IFMT;
95 	if (mode == IFBLK || mode == IFCHR || (mode == IFLNK &&
96 	    (fs2h32(dp->e2di_size) < EXT2_MAXSYMLINKLEN)))
97 		return (KEEPON);
98 	dino = *dp;
99 	ndb = howmany(fs2h32(dino.e2di_size), sblock.e2fs_bsize);
100 	for (ap = &dino.e2di_blocks[0]; ap < &dino.e2di_blocks[NDADDR];
101 																ap++,ndb--) {
102 		idesc->id_numfrags = 1;
103 		if (*ap == 0) {
104 			if (idesc->id_type == DATA && ndb > 0) {
105 				/* An empty block in a directory XXX */
106 				getpathname(pathbuf, idesc->id_number,
107 				    idesc->id_number);
108 				pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
109 				    pathbuf);
110 				if (reply("ADJUST LENGTH") == 1) {
111 					dp = ginode(idesc->id_number);
112 					dp->e2di_size = h2fs32((ap - &dino.e2di_blocks[0]) *
113 					    sblock.e2fs_bsize);
114 					printf(
115 					    "YOU MUST RERUN FSCK AFTERWARDS\n");
116 					rerun = 1;
117 					inodirty();
118 				}
119 			}
120 			continue;
121 		}
122 		idesc->id_blkno = fs2h32(*ap);
123 		if (idesc->id_type == ADDR)
124 			ret = (*idesc->id_func)(idesc);
125 		else
126 			ret = dirscan(idesc);
127 		if (ret & STOP)
128 			return (ret);
129 	}
130 	idesc->id_numfrags = 1;
131 	remsize = fs2h32(dino.e2di_size) - sblock.e2fs_bsize * NDADDR;
132 	sizepb = sblock.e2fs_bsize;
133 	for (ap = &dino.e2di_blocks[NDADDR], n = 1; n <= NIADDR; ap++, n++) {
134 		if (*ap) {
135 			idesc->id_blkno = fs2h32(*ap);
136 			ret = iblock(idesc, n, remsize);
137 			if (ret & STOP)
138 				return (ret);
139 		} else {
140 			if (idesc->id_type == DATA && remsize > 0) {
141 				/* An empty block in a directory XXX */
142 				getpathname(pathbuf, idesc->id_number,
143 				    idesc->id_number);
144 				pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
145 				    pathbuf);
146 				if (reply("ADJUST LENGTH") == 1) {
147 					dp = ginode(idesc->id_number);
148 					dp->e2di_size = h2fs32(fs2h32(dp->e2di_size) - remsize);
149 					remsize = 0;
150 					printf(
151 					    "YOU MUST RERUN FSCK AFTERWARDS\n");
152 					rerun = 1;
153 					inodirty();
154 					break;
155 				}
156 			}
157 		}
158 		sizepb *= NINDIR(&sblock);
159 		remsize -= sizepb;
160 	}
161 	return (KEEPON);
162 }
163 
164 static int
165 iblock(idesc, ilevel, isize)
166 	struct inodesc *idesc;
167 	long ilevel;
168 	u_int64_t isize;
169 {
170 	daddr_t *ap;
171 	daddr_t *aplim;
172 	struct bufarea *bp;
173 	int i, n, (*func) __P((struct inodesc *)), nif;
174 	u_int64_t sizepb;
175 	char buf[BUFSIZ];
176 	char pathbuf[MAXPATHLEN + 1];
177 	struct ext2fs_dinode *dp;
178 
179 	if (idesc->id_type == ADDR) {
180 		func = idesc->id_func;
181 		if (((n = (*func)(idesc)) & KEEPON) == 0)
182 			return (n);
183 	} else
184 		func = dirscan;
185 	if (chkrange(idesc->id_blkno, idesc->id_numfrags))
186 		return (SKIP);
187 	bp = getdatablk(idesc->id_blkno, sblock.e2fs_bsize);
188 	ilevel--;
189 	for (sizepb = sblock.e2fs_bsize, i = 0; i < ilevel; i++)
190 		sizepb *= NINDIR(&sblock);
191 	if (isize > sizepb * NINDIR(&sblock))
192 		nif = NINDIR(&sblock);
193 	else
194 		nif = howmany(isize, sizepb);
195 	if (idesc->id_func == pass1check &&
196 		nif < NINDIR(&sblock)) {
197 		aplim = &bp->b_un.b_indir[NINDIR(&sblock)];
198 		for (ap = &bp->b_un.b_indir[nif]; ap < aplim; ap++) {
199 			if (*ap == 0)
200 				continue;
201 			(void)sprintf(buf, "PARTIALLY TRUNCATED INODE I=%u",
202 				idesc->id_number);
203 			if (dofix(idesc, buf)) {
204 				*ap = 0;
205 				dirty(bp);
206 			}
207 		}
208 		flush(fswritefd, bp);
209 	}
210 	aplim = &bp->b_un.b_indir[nif];
211 	for (ap = bp->b_un.b_indir; ap < aplim; ap++) {
212 		if (*ap) {
213 			idesc->id_blkno = fs2h32(*ap);
214 			if (ilevel == 0)
215 				n = (*func)(idesc);
216 			else
217 				n = iblock(idesc, ilevel, isize);
218 			if (n & STOP) {
219 				bp->b_flags &= ~B_INUSE;
220 				return (n);
221 			}
222 		} else {
223 			if (idesc->id_type == DATA && isize > 0) {
224 				/* An empty block in a directory XXX */
225 				getpathname(pathbuf, idesc->id_number,
226 				    idesc->id_number);
227 				pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
228 				    pathbuf);
229 				if (reply("ADJUST LENGTH") == 1) {
230 					dp = ginode(idesc->id_number);
231 					dp->e2di_size = h2fs32(fs2h32(dp->e2di_size) - isize);
232 					isize = 0;
233 					printf(
234 					    "YOU MUST RERUN FSCK AFTERWARDS\n");
235 					rerun = 1;
236 					inodirty();
237 					bp->b_flags &= ~B_INUSE;
238 					return(STOP);
239 				}
240 			}
241 		}
242 		isize -= sizepb;
243 	}
244 	bp->b_flags &= ~B_INUSE;
245 	return (KEEPON);
246 }
247 
248 /*
249  * Check that a block in a legal block number.
250  * Return 0 if in range, 1 if out of range.
251  */
252 int
253 chkrange(blk, cnt)
254 	daddr_t blk;
255 	int cnt;
256 {
257 	int c;
258 
259 	if ((unsigned)(blk + cnt) > maxfsblock)
260 		return (1);
261 	c = dtog(&sblock, blk);
262 	if (blk < sblock.e2fs.e2fs_bpg * c + cgoverhead +
263 											sblock.e2fs.e2fs_first_dblock) {
264 		if ((blk + cnt) > sblock.e2fs.e2fs_bpg * c + cgoverhead +
265 											sblock.e2fs.e2fs_first_dblock) {
266 			if (debug) {
267 				printf("blk %d < cgdmin %d;",
268 				    blk, sblock.e2fs.e2fs_bpg * c + cgoverhead +
269 											sblock.e2fs.e2fs_first_dblock);
270 				printf(" blk + cnt %d > cgsbase %d\n",
271 				    blk + cnt, sblock.e2fs.e2fs_bpg * c + cgoverhead +
272 											sblock.e2fs.e2fs_first_dblock);
273 			}
274 			return (1);
275 		}
276 	} else {
277 		if ((blk + cnt) > sblock.e2fs.e2fs_bpg * (c + 1) + cgoverhead +
278 											sblock.e2fs.e2fs_first_dblock) {
279 			if (debug)  {
280 				printf("blk %d >= cgdmin %d;",
281 				    blk, sblock.e2fs.e2fs_bpg * c + cgoverhead +
282 											sblock.e2fs.e2fs_first_dblock);
283 				printf(" blk + cnt %d > cgdmax %d\n",
284 				    blk+cnt, sblock.e2fs.e2fs_bpg * (c + 1) + cgoverhead +
285 											sblock.e2fs.e2fs_first_dblock);
286 			}
287 			return (1);
288 		}
289 	}
290 	return (0);
291 }
292 
293 /*
294  * General purpose interface for reading inodes.
295  */
296 struct ext2fs_dinode *
297 ginode(inumber)
298 	ino_t inumber;
299 {
300 	daddr_t iblk;
301 
302 	if ((inumber < EXT2_FIRSTINO && inumber != EXT2_ROOTINO)
303 		|| inumber > maxino)
304 		errexit("bad inode number %d to ginode\n", inumber);
305 	if (startinum == 0 ||
306 	    inumber < startinum || inumber >= startinum + sblock.e2fs_ipb) {
307 		iblk = fsck_ino_to_fsba(&sblock, inumber);
308 		if (pbp != 0)
309 			pbp->b_flags &= ~B_INUSE;
310 		pbp = getdatablk(iblk, sblock.e2fs_bsize);
311 		startinum = ((inumber -1) / sblock.e2fs_ipb) * sblock.e2fs_ipb + 1;
312 	}
313 	return (&pbp->b_un.b_dinode[(inumber-1) % sblock.e2fs_ipb]);
314 }
315 
316 /*
317  * Special purpose version of ginode used to optimize first pass
318  * over all the inodes in numerical order.
319  */
320 ino_t nextino, lastinum;
321 long readcnt, readpercg, fullcnt, inobufsize, partialcnt, partialsize;
322 struct ext2fs_dinode *inodebuf;
323 
324 struct ext2fs_dinode *
325 getnextinode(inumber)
326 	ino_t inumber;
327 {
328 	long size;
329 	daddr_t dblk;
330 	static struct ext2fs_dinode *dp;
331 
332 	if (inumber != nextino++ || inumber > maxino)
333 		errexit("bad inode number %d to nextinode\n", inumber);
334 	if (inumber >= lastinum) {
335 		readcnt++;
336 		dblk = fsbtodb(&sblock, fsck_ino_to_fsba(&sblock, lastinum));
337 		if (readcnt % readpercg == 0) {
338 			size = partialsize;
339 			lastinum += partialcnt;
340 		} else {
341 			size = inobufsize;
342 			lastinum += fullcnt;
343 		}
344 		(void)bread(fsreadfd, (char *)inodebuf, dblk, size);
345 		dp = inodebuf;
346 	}
347 	return (dp++);
348 }
349 
350 void
351 resetinodebuf()
352 {
353 
354 	startinum = 0;
355 	nextino = 1;
356 	lastinum = 1;
357 	readcnt = 0;
358 	inobufsize = blkroundup(&sblock, INOBUFSIZE);
359 	fullcnt = inobufsize / sizeof(struct ext2fs_dinode);
360 	readpercg = sblock.e2fs.e2fs_ipg / fullcnt;
361 	partialcnt = sblock.e2fs.e2fs_ipg % fullcnt;
362 	partialsize = partialcnt * sizeof(struct ext2fs_dinode);
363 	if (partialcnt != 0) {
364 		readpercg++;
365 	} else {
366 		partialcnt = fullcnt;
367 		partialsize = inobufsize;
368 	}
369 	if (inodebuf == NULL &&
370 	    (inodebuf = (struct ext2fs_dinode *)malloc((unsigned)inobufsize)) ==
371 		NULL)
372 		errexit("Cannot allocate space for inode buffer\n");
373 	while (nextino < EXT2_ROOTINO)
374 		(void)getnextinode(nextino);
375 }
376 
377 void
378 freeinodebuf()
379 {
380 
381 	if (inodebuf != NULL)
382 		free((char *)inodebuf);
383 	inodebuf = NULL;
384 }
385 
386 /*
387  * Routines to maintain information about directory inodes.
388  * This is built during the first pass and used during the
389  * second and third passes.
390  *
391  * Enter inodes into the cache.
392  */
393 void
394 cacheino(dp, inumber)
395 	struct ext2fs_dinode *dp;
396 	ino_t inumber;
397 {
398 	struct inoinfo *inp;
399 	struct inoinfo **inpp;
400 	unsigned int blks;
401 
402 	blks = howmany(fs2h32(dp->e2di_size), sblock.e2fs_bsize);
403 	if (blks > NDADDR)
404 		blks = NDADDR + NIADDR;
405 	inp = (struct inoinfo *)
406 		malloc(sizeof(*inp) + (blks - 1) * sizeof(daddr_t));
407 	if (inp == NULL)
408 		return;
409 	inpp = &inphead[inumber % numdirs];
410 	inp->i_nexthash = *inpp;
411 	*inpp = inp;
412 	inp->i_child = inp->i_sibling = inp->i_parentp = 0;
413 	if (inumber == EXT2_ROOTINO)
414 		inp->i_parent = EXT2_ROOTINO;
415 	else
416 		inp->i_parent = (ino_t)0;
417 	inp->i_dotdot = (ino_t)0;
418 	inp->i_number = inumber;
419 	inp->i_isize = fs2h32(dp->e2di_size);
420 	inp->i_numblks = blks * sizeof(daddr_t);
421 	memcpy(&inp->i_blks[0], &dp->e2di_blocks[0], (size_t)inp->i_numblks);
422 	if (inplast == listmax) {
423 		listmax += 100;
424 		inpsort = (struct inoinfo **)realloc((char *)inpsort,
425 		    (unsigned)listmax * sizeof(struct inoinfo *));
426 		if (inpsort == NULL)
427 			errexit("cannot increase directory list\n");
428 	}
429 	inpsort[inplast++] = inp;
430 }
431 
432 /*
433  * Look up an inode cache structure.
434  */
435 struct inoinfo *
436 getinoinfo(inumber)
437 	ino_t inumber;
438 {
439 	struct inoinfo *inp;
440 
441 	for (inp = inphead[inumber % numdirs]; inp; inp = inp->i_nexthash) {
442 		if (inp->i_number != inumber)
443 			continue;
444 		return (inp);
445 	}
446 	errexit("cannot find inode %d\n", inumber);
447 	return ((struct inoinfo *)0);
448 }
449 
450 /*
451  * Clean up all the inode cache structure.
452  */
453 void
454 inocleanup()
455 {
456 	struct inoinfo **inpp;
457 
458 	if (inphead == NULL)
459 		return;
460 	for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--)
461 		free((char *)(*inpp));
462 	free((char *)inphead);
463 	free((char *)inpsort);
464 	inphead = inpsort = NULL;
465 }
466 
467 void
468 inodirty()
469 {
470 
471 	dirty(pbp);
472 }
473 
474 void
475 clri(idesc, type, flag)
476 	struct inodesc *idesc;
477 	char *type;
478 	int flag;
479 {
480 	struct ext2fs_dinode *dp;
481 
482 	dp = ginode(idesc->id_number);
483 	if (flag == 1) {
484 		pwarn("%s %s", type,
485 		    (dp->e2di_mode & IFMT) == IFDIR ? "DIR" : "FILE");
486 		pinode(idesc->id_number);
487 	}
488 	if (preen || reply("CLEAR") == 1) {
489 		if (preen)
490 			printf(" (CLEARED)\n");
491 		n_files--;
492 		(void)ckinode(dp, idesc);
493 		clearinode(dp);
494 		statemap[idesc->id_number] = USTATE;
495 		inodirty();
496 	}
497 }
498 
499 int
500 findname(idesc)
501 	struct inodesc *idesc;
502 {
503 	struct ext2fs_direct *dirp = idesc->id_dirp;
504 	u_int16_t namlen = fs2h16(dirp->e2d_namlen);
505 
506 	if (fs2h32(dirp->e2d_ino) != idesc->id_parent)
507 		return (KEEPON);
508 	memcpy(idesc->id_name, dirp->e2d_name, (size_t)namlen);
509 	idesc->id_name[namlen] = '\0';
510 	return (STOP|FOUND);
511 }
512 
513 int
514 findino(idesc)
515 	struct inodesc *idesc;
516 {
517 	struct ext2fs_direct *dirp = idesc->id_dirp;
518 	u_int32_t ino = fs2h32(dirp->e2d_ino);
519 
520 	if (ino == 0)
521 		return (KEEPON);
522 	if (strcmp(dirp->e2d_name, idesc->id_name) == 0 &&
523 	    (ino == EXT2_ROOTINO || ino >= EXT2_FIRSTINO)
524 		&& ino <= maxino) {
525 		idesc->id_parent = ino;
526 		return (STOP|FOUND);
527 	}
528 	return (KEEPON);
529 }
530 
531 void
532 pinode(ino)
533 	ino_t ino;
534 {
535 	struct ext2fs_dinode *dp;
536 	char *p;
537 	struct passwd *pw;
538 	time_t t;
539 
540 	printf(" I=%u ", ino);
541 	if ((ino < EXT2_FIRSTINO && ino != EXT2_ROOTINO) || ino > maxino)
542 		return;
543 	dp = ginode(ino);
544 	printf(" OWNER=");
545 #ifndef SMALL
546 	if ((pw = getpwuid((int)dp->e2di_uid)) != 0)
547 		printf("%s ", pw->pw_name);
548 	else
549 #endif
550 		printf("%u ", (unsigned)fs2h16(dp->e2di_uid));
551 	printf("MODE=%o\n", fs2h16(dp->e2di_mode));
552 	if (preen)
553 		printf("%s: ", cdevname());
554 	printf("SIZE=%u ", fs2h32(dp->e2di_size));
555 	t = fs2h32(dp->e2di_mtime);
556 	p = ctime(&t);
557 	printf("MTIME=%12.12s %4.4s ", &p[4], &p[20]);
558 }
559 
560 void
561 blkerror(ino, type, blk)
562 	ino_t ino;
563 	char *type;
564 	daddr_t blk;
565 {
566 
567 	pfatal("%d %s I=%u", blk, type, ino);
568 	printf("\n");
569 	switch (statemap[ino]) {
570 
571 	case FSTATE:
572 		statemap[ino] = FCLEAR;
573 		return;
574 
575 	case DSTATE:
576 		statemap[ino] = DCLEAR;
577 		return;
578 
579 	case FCLEAR:
580 	case DCLEAR:
581 		return;
582 
583 	default:
584 		errexit("BAD STATE %d TO BLKERR\n", statemap[ino]);
585 		/* NOTREACHED */
586 	}
587 }
588 
589 /*
590  * allocate an unused inode
591  */
592 ino_t
593 allocino(request, type)
594 	ino_t request;
595 	int type;
596 {
597 	ino_t ino;
598 	struct ext2fs_dinode *dp;
599 	time_t t;
600 
601 	if (request == 0)
602 		request = EXT2_ROOTINO;
603 	else if (statemap[request] != USTATE)
604 		return (0);
605 	for (ino = request; ino < maxino; ino++) {
606 		if ((ino > EXT2_ROOTINO) && (ino < EXT2_FIRSTINO))
607 			continue;
608 		if (statemap[ino] == USTATE)
609 			break;
610 	}
611 	if (ino == maxino)
612 		return (0);
613 	switch (type & IFMT) {
614 	case IFDIR:
615 		statemap[ino] = DSTATE;
616 		break;
617 	case IFREG:
618 	case IFLNK:
619 		statemap[ino] = FSTATE;
620 		break;
621 	default:
622 		return (0);
623 	}
624 	dp = ginode(ino);
625 	dp->e2di_blocks[0] = h2fs32(allocblk());
626 	if (dp->e2di_blocks[0] == 0) {
627 		statemap[ino] = USTATE;
628 		return (0);
629 	}
630 	dp->e2di_mode = h2fs16(type);
631 	(void)time(&t);
632 	dp->e2di_atime = h2fs32(t);
633 	dp->e2di_mtime = dp->e2di_ctime = dp->e2di_atime;
634 	dp->e2di_dtime = 0;
635 	dp->e2di_size = h2fs32(sblock.e2fs_bsize);
636 	dp->e2di_nblock = h2fs32(btodb(sblock.e2fs_bsize));
637 	n_files++;
638 	inodirty();
639 	return (ino);
640 }
641 
642 /*
643  * deallocate an inode
644  */
645 void
646 freeino(ino)
647 	ino_t ino;
648 {
649 	struct inodesc idesc;
650 	struct ext2fs_dinode *dp;
651 
652 	memset(&idesc, 0, sizeof(struct inodesc));
653 	idesc.id_type = ADDR;
654 	idesc.id_func = pass4check;
655 	idesc.id_number = ino;
656 	dp = ginode(ino);
657 	(void)ckinode(dp, &idesc);
658 	clearinode(dp);
659 	inodirty();
660 	statemap[ino] = USTATE;
661 	n_files--;
662 }
663