Home | History | Annotate | Line # | Download | only in fsck_ffs
inode.c revision 1.56 
      1 /*	$NetBSD: inode.c,v 1.56 2005/08/19 02:07:19 christos Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1980, 1986, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 #ifndef lint
     34 #if 0
     35 static char sccsid[] = "@(#)inode.c	8.8 (Berkeley) 4/28/95";
     36 #else
     37 __RCSID("$NetBSD: inode.c,v 1.56 2005/08/19 02:07:19 christos Exp $");
     38 #endif
     39 #endif /* not lint */
     40 
     41 #include <sys/param.h>
     42 #include <sys/time.h>
     43 
     44 #include <ufs/ufs/dinode.h>
     45 #include <ufs/ufs/dir.h>
     46 #include <ufs/ffs/fs.h>
     47 #include <ufs/ffs/ffs_extern.h>
     48 #include <ufs/ufs/ufs_bswap.h>
     49 
     50 #ifndef SMALL
     51 #include <err.h>
     52 #include <pwd.h>
     53 #endif
     54 #include <stdio.h>
     55 #include <stdlib.h>
     56 #include <string.h>
     57 #include <time.h>
     58 
     59 #include "fsck.h"
     60 #include "fsutil.h"
     61 #include "extern.h"
     62 
     63 static ino_t startinum;
     64 
     65 static int iblock(struct inodesc *, long, u_int64_t);
     66 static void swap_dinode1(union dinode *, int);
     67 static void swap_dinode2(union dinode *, int);
     68 
     69 int
     70 ckinode(union dinode *dp, struct inodesc *idesc)
     71 {
     72 	int ret, offset, i;
     73 	union dinode dino;
     74 	u_int64_t sizepb;
     75 	int64_t remsize;
     76 	daddr_t ndb;
     77 	mode_t mode;
     78 	char pathbuf[MAXPATHLEN + 1];
     79 
     80 	if (idesc->id_fix != IGNORE)
     81 		idesc->id_fix = DONTKNOW;
     82 	idesc->id_entryno = 0;
     83 	idesc->id_filesize = iswap64(DIP(dp, size));
     84 	mode = iswap16(DIP(dp, mode)) & IFMT;
     85 	if (mode == IFBLK || mode == IFCHR || (mode == IFLNK &&
     86 	    (idesc->id_filesize < sblock->fs_maxsymlinklen ||
     87 	    (isappleufs && (idesc->id_filesize < APPLEUFS_MAXSYMLINKLEN)) ||
     88 	     (sblock->fs_maxsymlinklen == 0 && DIP(dp, blocks) == 0))))
     89 		return (KEEPON);
     90 	if (is_ufs2)
     91 		dino.dp2 = dp->dp2;
     92 	else
     93 		dino.dp1 = dp->dp1;
     94 	ndb = howmany(iswap64(DIP(&dino, size)), sblock->fs_bsize);
     95 	for (i = 0; i < NDADDR; i++) {
     96 		if (--ndb == 0 &&
     97 		    (offset = blkoff(sblock, iswap64(DIP(&dino, size)))) != 0)
     98 			idesc->id_numfrags =
     99 				numfrags(sblock, fragroundup(sblock, offset));
    100 		else
    101 			idesc->id_numfrags = sblock->fs_frag;
    102 		if (DIP(&dino, db[i]) == 0) {
    103 			if (idesc->id_type == DATA && ndb >= 0) {
    104 				/* An empty block in a directory XXX */
    105 				markclean = 0;
    106 				getpathname(pathbuf, sizeof(pathbuf),
    107 				    idesc->id_number, 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 					DIP(dp, size) = iswap64(i *
    113 					    sblock->fs_bsize);
    114 					printf(
    115 					    "YOU MUST RERUN FSCK AFTERWARDS\n");
    116 					rerun = 1;
    117 					inodirty();
    118 				}
    119 			}
    120 			continue;
    121 		}
    122 		if (is_ufs2)
    123 			idesc->id_blkno = iswap64(dino.dp2.di_db[i]);
    124 		else
    125 			idesc->id_blkno = iswap32(dino.dp1.di_db[i]);
    126 		if (idesc->id_type != DATA)
    127 			ret = (*idesc->id_func)(idesc);
    128 		else
    129 			ret = dirscan(idesc);
    130 		if (ret & STOP)
    131 			return (ret);
    132 	}
    133 	idesc->id_numfrags = sblock->fs_frag;
    134 	remsize = iswap64(DIP(&dino, size)) - sblock->fs_bsize * NDADDR;
    135 	sizepb = sblock->fs_bsize;
    136 	for (i = 0; i < NIADDR; i++) {
    137 		if (DIP(&dino, ib[i])) {
    138 			if (is_ufs2)
    139 				idesc->id_blkno = iswap64(dino.dp2.di_ib[i]);
    140 			else
    141 				idesc->id_blkno = iswap32(dino.dp1.di_ib[i]);
    142 			ret = iblock(idesc, i + 1, remsize);
    143 			if (ret & STOP)
    144 				return (ret);
    145 		} else {
    146 			if (idesc->id_type == DATA && remsize > 0) {
    147 				/* An empty block in a directory XXX */
    148 				markclean = 0;
    149 				getpathname(pathbuf, sizeof(pathbuf),
    150 				    idesc->id_number, idesc->id_number);
    151 				pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
    152 				    pathbuf);
    153 				if (reply("ADJUST LENGTH") == 1) {
    154 					dp = ginode(idesc->id_number);
    155 					DIP(dp, size) =
    156 					    iswap64(iswap64(DIP(dp, size))
    157 						- remsize);
    158 					remsize = 0;
    159 					printf(
    160 					    "YOU MUST RERUN FSCK AFTERWARDS\n");
    161 					rerun = 1;
    162 					inodirty();
    163 					break;
    164 				}
    165 			}
    166 		}
    167 		sizepb *= NINDIR(sblock);
    168 		remsize -= sizepb;
    169 	}
    170 	return (KEEPON);
    171 }
    172 
    173 static int
    174 iblock(struct inodesc *idesc, long ilevel, u_int64_t isize)
    175 {
    176 	struct bufarea *bp;
    177 	int i, n, (*func) (struct inodesc *), nif;
    178 	u_int64_t sizepb;
    179 	char buf[BUFSIZ];
    180 	char pathbuf[MAXPATHLEN + 1];
    181 	union dinode *dp;
    182 
    183 	if (idesc->id_type != DATA) {
    184 		func = idesc->id_func;
    185 		if (((n = (*func)(idesc)) & KEEPON) == 0)
    186 			return (n);
    187 	} else
    188 		func = dirscan;
    189 	if (chkrange(idesc->id_blkno, idesc->id_numfrags))
    190 		return (SKIP);
    191 	bp = getdatablk(idesc->id_blkno, sblock->fs_bsize);
    192 	ilevel--;
    193 	for (sizepb = sblock->fs_bsize, i = 0; i < ilevel; i++)
    194 		sizepb *= NINDIR(sblock);
    195 	if (howmany(isize, sizepb) > NINDIR(sblock))
    196 		nif = NINDIR(sblock);
    197 	else
    198 		nif = howmany(isize, sizepb);
    199 	if (do_blkswap) { /* swap byte order of the whole blk */
    200 		if (is_ufs2) {
    201 			for (i = 0; i < nif; i++)
    202 				bp->b_un.b_indir2[i] =
    203 				    bswap64(bp->b_un.b_indir2[i]);
    204 		} else {
    205 			for (i = 0; i < nif; i++)
    206 				bp->b_un.b_indir1[i] =
    207 				    bswap32(bp->b_un.b_indir1[i]);
    208 		}
    209 		dirty(bp);
    210 		flush(fswritefd, bp);
    211 	}
    212 	if (idesc->id_func == pass1check && nif < NINDIR(sblock)) {
    213 		for (i = nif; i < NINDIR(sblock); i++) {
    214 			if (IBLK(bp, i) == 0)
    215 				continue;
    216 			(void)snprintf(buf, sizeof(buf),
    217 			    "PARTIALLY TRUNCATED INODE I=%llu",
    218 			    (unsigned long long)idesc->id_number);
    219 			if (dofix(idesc, buf)) {
    220 				IBLK(bp, i) = 0;
    221 				dirty(bp);
    222 			} else
    223 				markclean=  0;
    224 		}
    225 		flush(fswritefd, bp);
    226 	}
    227 	for (i = 0; i < nif; i++) {
    228 		if (IBLK(bp, i)) {
    229 			if (is_ufs2)
    230 				idesc->id_blkno = iswap64(bp->b_un.b_indir2[i]);
    231 			else
    232 				idesc->id_blkno = iswap32(bp->b_un.b_indir1[i]);
    233 			if (ilevel == 0)
    234 				n = (*func)(idesc);
    235 			else
    236 				n = iblock(idesc, ilevel, isize);
    237 			if (n & STOP) {
    238 				bp->b_flags &= ~B_INUSE;
    239 				return (n);
    240 			}
    241 		} else {
    242 			if (idesc->id_type == DATA && isize > 0) {
    243 				/* An empty block in a directory XXX */
    244 				markclean=  0;
    245 				getpathname(pathbuf, sizeof(pathbuf),
    246 				    idesc->id_number, idesc->id_number);
    247 				pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
    248 				    pathbuf);
    249 				if (reply("ADJUST LENGTH") == 1) {
    250 					dp = ginode(idesc->id_number);
    251 					DIP(dp, size) =
    252 					    iswap64(iswap64(DIP(dp, size))
    253 						- isize);
    254 					isize = 0;
    255 					printf(
    256 					    "YOU MUST RERUN FSCK AFTERWARDS\n");
    257 					rerun = 1;
    258 					inodirty();
    259 					bp->b_flags &= ~B_INUSE;
    260 					return(STOP);
    261 				}
    262 			}
    263 		}
    264 		isize -= sizepb;
    265 	}
    266 	bp->b_flags &= ~B_INUSE;
    267 	return (KEEPON);
    268 }
    269 
    270 /*
    271  * Check that a block in a legal block number.
    272  * Return 0 if in range, 1 if out of range.
    273  */
    274 int
    275 chkrange(daddr_t blk, int cnt)
    276 {
    277 	int c;
    278 
    279 	if (cnt <= 0 || blk <= 0 || blk > maxfsblock ||
    280 	    cnt - 1 > maxfsblock - blk)
    281 		return (1);
    282 	if (cnt > sblock->fs_frag ||
    283 	    fragnum(sblock, blk) + cnt > sblock->fs_frag) {
    284 		if (debug)
    285 			printf("bad size: blk %lld, offset %d, size %d\n",
    286 			    (long long)blk, (int)fragnum(sblock, blk), cnt);
    287 	}
    288 	c = dtog(sblock, blk);
    289 	if (blk < cgdmin(sblock, c)) {
    290 		if ((blk + cnt) > cgsblock(sblock, c)) {
    291 			if (debug) {
    292 				printf("blk %lld < cgdmin %lld;",
    293 				    (long long)blk,
    294 				    (long long)cgdmin(sblock, c));
    295 				printf(" blk + cnt %lld > cgsbase %lld\n",
    296 				    (long long)(blk + cnt),
    297 				    (long long)cgsblock(sblock, c));
    298 			}
    299 			return (1);
    300 		}
    301 	} else {
    302 		if ((blk + cnt) > cgbase(sblock, c+1)) {
    303 			if (debug)  {
    304 				printf("blk %lld >= cgdmin %lld;",
    305 				    (long long)blk,
    306 				    (long long)cgdmin(sblock, c));
    307 				printf(" blk + cnt %lld > sblock->fs_fpg %d\n",
    308 				    (long long)(blk+cnt), sblock->fs_fpg);
    309 			}
    310 			return (1);
    311 		}
    312 	}
    313 	return (0);
    314 }
    315 
    316 /*
    317  * General purpose interface for reading inodes.
    318  */
    319 union dinode *
    320 ginode(ino_t inumber)
    321 {
    322 	daddr_t iblk;
    323 	int blkoff;
    324 
    325 	if (inumber < ROOTINO || inumber > maxino)
    326 		errx(EEXIT, "bad inode number %llu to ginode",
    327 		    (unsigned long long)inumber);
    328 	if (startinum == 0 ||
    329 	    inumber < startinum || inumber >= startinum + INOPB(sblock)) {
    330 		iblk = ino_to_fsba(sblock, inumber);
    331 		if (pbp != 0)
    332 			pbp->b_flags &= ~B_INUSE;
    333 		pbp = getdatablk(iblk, sblock->fs_bsize);
    334 		startinum = (inumber / INOPB(sblock)) * INOPB(sblock);
    335 	}
    336 	if (is_ufs2) {
    337 		blkoff = (inumber % INOPB(sblock)) * DINODE2_SIZE;
    338 		return ((union dinode *)((caddr_t)pbp->b_un.b_buf + blkoff));
    339 	}
    340 	blkoff = (inumber % INOPB(sblock)) * DINODE1_SIZE;
    341 	return ((union dinode *)((caddr_t)pbp->b_un.b_buf + blkoff));
    342 }
    343 
    344 static void
    345 swap_dinode1(union dinode *dp, int n)
    346 {
    347 	int i, j;
    348 	struct ufs1_dinode *dp1;
    349 	int32_t maxsymlinklen = sblock->fs_maxsymlinklen;
    350 	if (isappleufs)
    351 		maxsymlinklen = APPLEUFS_MAXSYMLINKLEN;
    352 
    353 	dp1 = (struct ufs1_dinode *)&dp->dp1;
    354 	for (i = 0; i < n; i++, dp1++) {
    355 		ffs_dinode1_swap(dp1, dp1);
    356 		if (((iswap16(dp1->di_mode) & IFMT) != IFLNK) ||
    357 		    doinglevel2 ||
    358 		    (maxsymlinklen < 0) ||
    359 		    (iswap64(dp1->di_size) > maxsymlinklen)) {
    360 			for (j = 0; j < (NDADDR + NIADDR); j++)
    361 			    dp1->di_db[j] = bswap32(dp1->di_db[j]);
    362 		}
    363 	}
    364 }
    365 
    366 static void
    367 swap_dinode2(union dinode *dp, int n)
    368 {
    369 	int i, j;
    370 	struct ufs2_dinode *dp2;
    371 
    372 	dp2 = (struct ufs2_dinode *)&dp->dp2;
    373 	for (i = 0; i < n; i++, dp2++) {
    374 		ffs_dinode2_swap(dp2, dp2);
    375 		if ((iswap16(dp2->di_mode) & IFMT) != IFLNK) {
    376 			for (j = 0; j < (NDADDR + NIADDR + NXADDR); j++)
    377 				dp2->di_extb[j] = bswap64(dp2->di_extb[j]);
    378 		}
    379 	}
    380 }
    381 
    382 /*
    383  * Special purpose version of ginode used to optimize first pass
    384  * over all the inodes in numerical order.
    385  */
    386 ino_t nextino, lastinum, lastvalidinum;
    387 long readcnt, readpercg, fullcnt, inobufsize, partialcnt, partialsize;
    388 union dinode *inodebuf;
    389 
    390 union dinode *
    391 getnextinode(ino_t inumber)
    392 {
    393 	long size;
    394 	daddr_t dblk;
    395 	static union dinode *dp;
    396 	union dinode *ret;
    397 
    398 	if (inumber != nextino++ || inumber > lastvalidinum)
    399 		errx(EEXIT, "bad inode number %llu to nextinode",
    400 		    (unsigned long long)inumber);
    401 
    402 	if (inumber >= lastinum) {
    403 		readcnt++;
    404 		dblk = fsbtodb(sblock, ino_to_fsba(sblock, lastinum));
    405 		if (readcnt % readpercg == 0) {
    406 			size = partialsize;
    407 			lastinum += partialcnt;
    408 		} else {
    409 			size = inobufsize;
    410 			lastinum += fullcnt;
    411 		}
    412 		(void)bread(fsreadfd, (caddr_t)inodebuf, dblk, size);
    413 		if (doswap) {
    414 			if (is_ufs2)
    415 				swap_dinode2(inodebuf, lastinum - inumber);
    416 			else
    417 				swap_dinode1(inodebuf, lastinum - inumber);
    418 			bwrite(fswritefd, (char *)inodebuf, dblk, size);
    419 		}
    420 		dp = (union dinode *)inodebuf;
    421 	}
    422 	ret = dp;
    423 	dp = (union dinode *)
    424 	    ((char *)dp + (is_ufs2 ? DINODE2_SIZE : DINODE1_SIZE));
    425 	return ret;
    426 }
    427 
    428 void
    429 setinodebuf(ino_t inum)
    430 {
    431 
    432 	if (inum % sblock->fs_ipg != 0)
    433 		errx(EEXIT, "bad inode number %llu to setinodebuf",
    434 		    (unsigned long long)inum);
    435 
    436 	lastvalidinum = inum + sblock->fs_ipg - 1;
    437 	startinum = 0;
    438 	nextino = inum;
    439 	lastinum = inum;
    440 	readcnt = 0;
    441 	if (inodebuf != NULL)
    442 		return;
    443 	inobufsize = blkroundup(sblock, INOBUFSIZE);
    444 	fullcnt = inobufsize / (is_ufs2 ? DINODE2_SIZE : DINODE1_SIZE);
    445 	readpercg = sblock->fs_ipg / fullcnt;
    446 	partialcnt = sblock->fs_ipg % fullcnt;
    447 	partialsize = partialcnt * (is_ufs2 ? DINODE2_SIZE : DINODE1_SIZE);
    448 	if (partialcnt != 0) {
    449 		readpercg++;
    450 	} else {
    451 		partialcnt = fullcnt;
    452 		partialsize = inobufsize;
    453 	}
    454 	if (inodebuf == NULL &&
    455 	    (inodebuf = malloc((unsigned)inobufsize)) == NULL)
    456 		errx(EEXIT, "Cannot allocate space for inode buffer");
    457 }
    458 
    459 void
    460 freeinodebuf(void)
    461 {
    462 
    463 	if (inodebuf != NULL)
    464 		free((char *)inodebuf);
    465 	inodebuf = NULL;
    466 }
    467 
    468 /*
    469  * Routines to maintain information about directory inodes.
    470  * This is built during the first pass and used during the
    471  * second and third passes.
    472  *
    473  * Enter inodes into the cache.
    474  */
    475 void
    476 cacheino(union dinode *dp, ino_t inumber)
    477 {
    478 	struct inoinfo *inp;
    479 	struct inoinfo **inpp, **ninpsort;
    480 	unsigned int blks;
    481 	int i;
    482 	int64_t size;
    483 
    484 	size = iswap64(DIP(dp, size));
    485 	blks = howmany(size, sblock->fs_bsize);
    486 	if (blks > NDADDR)
    487 		blks = NDADDR + NIADDR;
    488 
    489 	inp = (struct inoinfo *) malloc(sizeof(*inp) + (blks - 1)
    490 					    * sizeof (int64_t));
    491 	if (inp == NULL)
    492 		return;
    493 	inpp = &inphead[inumber % dirhash];
    494 	inp->i_nexthash = *inpp;
    495 	*inpp = inp;
    496 	inp->i_child = inp->i_sibling = 0;
    497 	if (inumber == ROOTINO)
    498 		inp->i_parent = ROOTINO;
    499 	else
    500 		inp->i_parent = (ino_t)0;
    501 	inp->i_dotdot = (ino_t)0;
    502 	inp->i_number = inumber;
    503 	inp->i_isize = size;
    504 	inp->i_numblks = blks;
    505 	for (i = 0; i < (blks < NDADDR ? blks : NDADDR); i++)
    506 		inp->i_blks[i] = DIP(dp, db[i]);
    507 	if (blks > NDADDR)
    508 		for (i = 0; i < NIADDR; i++)
    509 			inp->i_blks[NDADDR + i] = DIP(dp, ib[i]);
    510 	if (inplast == listmax) {
    511 		ninpsort = (struct inoinfo **)realloc((char *)inpsort,
    512 		    (unsigned)(listmax + 100) * sizeof(struct inoinfo *));
    513 		if (inpsort == NULL)
    514 			errx(EEXIT, "cannot increase directory list");
    515 		inpsort = ninpsort;
    516 		listmax += 100;
    517 	}
    518 	inpsort[inplast++] = inp;
    519 }
    520 
    521 /*
    522  * Look up an inode cache structure.
    523  */
    524 struct inoinfo *
    525 getinoinfo(ino_t inumber)
    526 {
    527 	struct inoinfo *inp;
    528 
    529 	for (inp = inphead[inumber % dirhash]; inp; inp = inp->i_nexthash) {
    530 		if (inp->i_number != inumber)
    531 			continue;
    532 		return (inp);
    533 	}
    534 	errx(EEXIT, "cannot find inode %llu", (unsigned long long)inumber);
    535 	return ((struct inoinfo *)0);
    536 }
    537 
    538 /*
    539  * Clean up all the inode cache structure.
    540  */
    541 void
    542 inocleanup(void)
    543 {
    544 	struct inoinfo **inpp;
    545 
    546 	if (inphead == NULL)
    547 		return;
    548 	for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--)
    549 		free((char *)(*inpp));
    550 	free((char *)inphead);
    551 	free((char *)inpsort);
    552 	inphead = inpsort = NULL;
    553 }
    554 
    555 void
    556 inodirty(void)
    557 {
    558 
    559 	dirty(pbp);
    560 }
    561 
    562 void
    563 clri(struct inodesc *idesc, const char *type, int flag)
    564 {
    565 	union dinode *dp;
    566 
    567 	dp = ginode(idesc->id_number);
    568 	if (flag == 1) {
    569 		pwarn("%s %s", type,
    570 		    (iswap16(DIP(dp, mode)) & IFMT) == IFDIR ? "DIR" : "FILE");
    571 		pinode(idesc->id_number);
    572 	}
    573 	if (preen || reply("CLEAR") == 1) {
    574 		if (preen)
    575 			printf(" (CLEARED)\n");
    576 		n_files--;
    577 		(void)ckinode(dp, idesc);
    578 		clearinode(dp);
    579 		inoinfo(idesc->id_number)->ino_state = USTATE;
    580 		inodirty();
    581 	} else
    582 		markclean=  0;
    583 }
    584 
    585 int
    586 findname(struct inodesc *idesc)
    587 {
    588 	struct direct *dirp = idesc->id_dirp;
    589 	size_t len;
    590 	char *buf;
    591 
    592 	if (iswap32(dirp->d_ino) != idesc->id_parent || idesc->id_entryno < 2) {
    593 		idesc->id_entryno++;
    594 		return (KEEPON);
    595 	}
    596 	if ((len = dirp->d_namlen + 1) > MAXPATHLEN) {
    597 		/* XXX: We don't fix but we ignore */
    598 		len = MAXPATHLEN;
    599 	}
    600 	/* this is namebuf from utilities.c */
    601 	buf = __UNCONST(idesc->id_name);
    602 	(void)memcpy(buf, dirp->d_name, (size_t)dirp->d_namlen + 1);
    603 	return (STOP|FOUND);
    604 }
    605 
    606 int
    607 findino(struct inodesc *idesc)
    608 {
    609 	struct direct *dirp = idesc->id_dirp;
    610 
    611 	if (dirp->d_ino == 0)
    612 		return (KEEPON);
    613 	if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
    614 	    iswap32(dirp->d_ino) >= ROOTINO && iswap32(dirp->d_ino) <= maxino) {
    615 		idesc->id_parent = iswap32(dirp->d_ino);
    616 		return (STOP|FOUND);
    617 	}
    618 	return (KEEPON);
    619 }
    620 
    621 int
    622 clearentry(struct inodesc *idesc)
    623 {
    624 	struct direct *dirp = idesc->id_dirp;
    625 
    626 	if (dirp->d_ino != idesc->id_parent || idesc->id_entryno < 2) {
    627 		idesc->id_entryno++;
    628 		return (KEEPON);
    629 	}
    630 	dirp->d_ino = 0;
    631 	return (STOP|FOUND|ALTERED);
    632 }
    633 
    634 void
    635 pinode(ino_t ino)
    636 {
    637 	union dinode *dp;
    638 	char *p;
    639 	struct passwd *pw;
    640 	time_t t;
    641 
    642 	printf(" I=%llu ", (unsigned long long)ino);
    643 	if (ino < ROOTINO || ino > maxino)
    644 		return;
    645 	dp = ginode(ino);
    646 	printf(" OWNER=");
    647 #ifndef SMALL
    648 	if ((pw = getpwuid((int)iswap32(DIP(dp, uid)))) != 0)
    649 		printf("%s ", pw->pw_name);
    650 	else
    651 #endif
    652 		printf("%u ", (unsigned)iswap32(DIP(dp, uid)));
    653 	printf("MODE=%o\n", iswap16(DIP(dp, mode)));
    654 	if (preen)
    655 		printf("%s: ", cdevname());
    656 	printf("SIZE=%llu ", (unsigned long long)iswap64(DIP(dp, size)));
    657 	t = iswap32(DIP(dp, mtime));
    658 	p = ctime(&t);
    659 	printf("MTIME=%12.12s %4.4s ", &p[4], &p[20]);
    660 }
    661 
    662 void
    663 blkerror(ino_t ino, const char *type, daddr_t blk)
    664 {
    665 	struct inostat *info;
    666 
    667 	pfatal("%lld %s I=%llu", (long long)blk, type, (unsigned long long)ino);
    668 	printf("\n");
    669 	info = inoinfo(ino);
    670 	switch (info->ino_state) {
    671 
    672 	case FSTATE:
    673 		info->ino_state = FCLEAR;
    674 		return;
    675 
    676 	case DSTATE:
    677 		info->ino_state = DCLEAR;
    678 		return;
    679 
    680 	case FCLEAR:
    681 	case DCLEAR:
    682 		return;
    683 
    684 	default:
    685 		errx(EEXIT, "BAD STATE %d TO BLKERR", info->ino_state);
    686 		/* NOTREACHED */
    687 	}
    688 }
    689 
    690 /*
    691  * allocate an unused inode
    692  */
    693 ino_t
    694 allocino(ino_t request, int type)
    695 {
    696 	ino_t ino;
    697 	union dinode *dp;
    698 	struct ufs1_dinode *dp1;
    699 	struct ufs2_dinode *dp2;
    700 	time_t t;
    701 	struct cg *cgp = cgrp;
    702 	int cg;
    703 	struct inostat *info = NULL;
    704 
    705 	if (request == 0)
    706 		request = ROOTINO;
    707 	else if (inoinfo(request)->ino_state != USTATE)
    708 		return (0);
    709 	for (ino = request; ino < maxino; ino++) {
    710 		info = inoinfo(ino);
    711 		if (info->ino_state == USTATE)
    712 			break;
    713 	}
    714 	if (ino == maxino)
    715 		return (0);
    716 	cg = ino_to_cg(sblock, ino);
    717 	/* If necessary, extend the inoinfo array. grow exponentially */
    718 	if ((ino % sblock->fs_ipg) >= inostathead[cg].il_numalloced) {
    719 		unsigned long newalloced, i;
    720 		newalloced = MIN(sblock->fs_ipg,
    721 			MAX(2 * inostathead[cg].il_numalloced, 10));
    722 		info = calloc(newalloced, sizeof(struct inostat));
    723 		if (info == NULL) {
    724 			pwarn("cannot alloc %lu bytes to extend inoinfo\n",
    725 				sizeof(struct inostat) * newalloced);
    726 			return 0;
    727 		}
    728 		memmove(info, inostathead[cg].il_stat,
    729 			inostathead[cg].il_numalloced * sizeof(*info));
    730 		for (i = inostathead[cg].il_numalloced; i < newalloced; i++) {
    731 			info[i].ino_state = USTATE;
    732 		}
    733 		if (inostathead[cg].il_numalloced)
    734 			free(inostathead[cg].il_stat);
    735 		inostathead[cg].il_stat = info;
    736 		inostathead[cg].il_numalloced = newalloced;
    737 		info = inoinfo(ino);
    738 	}
    739 	getblk(&cgblk, cgtod(sblock, cg), sblock->fs_cgsize);
    740 	memcpy(cgp, cgblk.b_un.b_cg, sblock->fs_cgsize);
    741 	if ((doswap && !needswap) || (!doswap && needswap))
    742 		ffs_cg_swap(cgblk.b_un.b_cg, cgp, sblock);
    743 	if (!cg_chkmagic(cgp, 0))
    744 		pfatal("CG %d: ALLOCINO: BAD MAGIC NUMBER\n", cg);
    745 	if (doswap)
    746 		cgdirty();
    747 	setbit(cg_inosused(cgp, 0), ino % sblock->fs_ipg);
    748 	cgp->cg_cs.cs_nifree--;
    749 	switch (type & IFMT) {
    750 	case IFDIR:
    751 		info->ino_state = DSTATE;
    752 		cgp->cg_cs.cs_ndir++;
    753 		break;
    754 	case IFREG:
    755 	case IFLNK:
    756 		info->ino_state = FSTATE;
    757 		break;
    758 	default:
    759 		return (0);
    760 	}
    761 	cgdirty();
    762 	dp = ginode(ino);
    763 	if (is_ufs2) {
    764 		dp2 = &dp->dp2;
    765 		dp2->di_db[0] = iswap64(allocblk(1));
    766 		if (dp2->di_db[0] == 0) {
    767 			info->ino_state = USTATE;
    768 			return (0);
    769 		}
    770 		dp2->di_mode = iswap16(type);
    771 		dp2->di_flags = 0;
    772 		(void)time(&t);
    773 		dp2->di_atime = iswap64(t);
    774 		dp2->di_mtime = dp2->di_ctime = dp2->di_atime;
    775 		dp2->di_size = iswap64(sblock->fs_fsize);
    776 		dp2->di_blocks = iswap64(btodb(sblock->fs_fsize));
    777 	} else {
    778 		dp1 = &dp->dp1;
    779 		dp1->di_db[0] = iswap32(allocblk(1));
    780 		if (dp1->di_db[0] == 0) {
    781 			info->ino_state = USTATE;
    782 			return (0);
    783 		}
    784 		dp1->di_mode = iswap16(type);
    785 		dp1->di_flags = 0;
    786 		(void)time(&t);
    787 		dp1->di_atime = iswap32(t);
    788 		dp1->di_mtime = dp1->di_ctime = dp1->di_atime;
    789 		dp1->di_size = iswap64(sblock->fs_fsize);
    790 		dp1->di_blocks = iswap32(btodb(sblock->fs_fsize));
    791 	}
    792 	n_files++;
    793 	inodirty();
    794 	if (newinofmt)
    795 		info->ino_type = IFTODT(type);
    796 	return (ino);
    797 }
    798 
    799 /*
    800  * deallocate an inode
    801  */
    802 void
    803 freeino(ino_t ino)
    804 {
    805 	struct inodesc idesc;
    806 	union dinode *dp;
    807 
    808 	memset(&idesc, 0, sizeof(struct inodesc));
    809 	idesc.id_type = ADDR;
    810 	idesc.id_func = pass4check;
    811 	idesc.id_number = ino;
    812 	dp = ginode(ino);
    813 	(void)ckinode(dp, &idesc);
    814 	clearinode(dp);
    815 	inodirty();
    816 	inoinfo(ino)->ino_state = USTATE;
    817 	n_files--;
    818 }
    819