Home | History | Annotate | Line # | Download | only in fsck_lfs
inode.c revision 1.68
      1  1.68  dholland /* $NetBSD: inode.c,v 1.68 2015/09/21 01:24:23 dholland Exp $	 */
      2  1.20       agc 
      3  1.23  perseant /*-
      4  1.23  perseant  * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
      5  1.23  perseant  * All rights reserved.
      6  1.23  perseant  *
      7  1.23  perseant  * This code is derived from software contributed to The NetBSD Foundation
      8  1.23  perseant  * by Konrad E. Schroder <perseant (at) hhhh.org>.
      9  1.20       agc  *
     10  1.20       agc  * Redistribution and use in source and binary forms, with or without
     11  1.20       agc  * modification, are permitted provided that the following conditions
     12  1.20       agc  * are met:
     13  1.20       agc  * 1. Redistributions of source code must retain the above copyright
     14  1.20       agc  *    notice, this list of conditions and the following disclaimer.
     15  1.20       agc  * 2. Redistributions in binary form must reproduce the above copyright
     16  1.20       agc  *    notice, this list of conditions and the following disclaimer in the
     17  1.20       agc  *    documentation and/or other materials provided with the distribution.
     18  1.20       agc  *
     19  1.23  perseant  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  1.23  perseant  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  1.23  perseant  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  1.23  perseant  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  1.23  perseant  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  1.23  perseant  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  1.23  perseant  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  1.23  perseant  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  1.23  perseant  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  1.23  perseant  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  1.23  perseant  * POSSIBILITY OF SUCH DAMAGE.
     30  1.20       agc  */
     31   1.1  perseant 
     32   1.1  perseant /*
     33  1.23  perseant  * Copyright (c) 1980, 1986, 1993
     34  1.23  perseant  *	The Regents of the University of California.  All rights reserved.
     35   1.1  perseant  *
     36   1.1  perseant  * Redistribution and use in source and binary forms, with or without
     37   1.1  perseant  * modification, are permitted provided that the following conditions
     38   1.1  perseant  * are met:
     39   1.1  perseant  * 1. Redistributions of source code must retain the above copyright
     40   1.1  perseant  *    notice, this list of conditions and the following disclaimer.
     41   1.1  perseant  * 2. Redistributions in binary form must reproduce the above copyright
     42   1.1  perseant  *    notice, this list of conditions and the following disclaimer in the
     43   1.1  perseant  *    documentation and/or other materials provided with the distribution.
     44  1.23  perseant  * 3. Neither the name of the University nor the names of its contributors
     45   1.1  perseant  *    may be used to endorse or promote products derived from this software
     46   1.1  perseant  *    without specific prior written permission.
     47   1.1  perseant  *
     48   1.1  perseant  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     49   1.1  perseant  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     50   1.1  perseant  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     51   1.1  perseant  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     52   1.1  perseant  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     53   1.1  perseant  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     54   1.1  perseant  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     55   1.1  perseant  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     56   1.1  perseant  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     57   1.1  perseant  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     58   1.1  perseant  * SUCH DAMAGE.
     59   1.1  perseant  */
     60   1.1  perseant 
     61  1.16  perseant #include <sys/types.h>
     62   1.1  perseant #include <sys/param.h>
     63   1.1  perseant #include <sys/time.h>
     64  1.16  perseant #include <sys/buf.h>
     65  1.16  perseant #include <sys/mount.h>
     66  1.16  perseant 
     67  1.45  dholland #define vnode uvnode
     68   1.1  perseant #include <ufs/lfs/lfs.h>
     69  1.57  dholland #include <ufs/lfs/lfs_accessors.h>
     70  1.50  dholland #include <ufs/lfs/lfs_inode.h>
     71  1.16  perseant #undef vnode
     72  1.16  perseant 
     73  1.16  perseant #include <err.h>
     74   1.1  perseant #ifndef SMALL
     75   1.1  perseant #include <pwd.h>
     76   1.1  perseant #endif
     77   1.1  perseant #include <stdio.h>
     78   1.1  perseant #include <stdlib.h>
     79   1.1  perseant #include <string.h>
     80  1.36  christos #include <util.h>
     81   1.1  perseant 
     82  1.16  perseant #include "bufcache.h"
     83  1.16  perseant #include "vnode.h"
     84  1.31  christos #include "lfs_user.h"
     85  1.16  perseant 
     86   1.1  perseant #include "fsck.h"
     87   1.1  perseant #include "fsutil.h"
     88   1.1  perseant #include "extern.h"
     89   1.1  perseant 
     90  1.16  perseant static int iblock(struct inodesc *, long, u_int64_t);
     91  1.16  perseant int blksreqd(struct lfs *, int);
     92  1.16  perseant int lfs_maxino(void);
     93   1.1  perseant 
     94   1.1  perseant /*
     95  1.16  perseant  * Get a dinode of a given inum.
     96  1.16  perseant  * XXX combine this function with vget.
     97   1.1  perseant  */
     98  1.59  dholland union lfs_dinode *
     99  1.16  perseant ginode(ino_t ino)
    100   1.1  perseant {
    101  1.16  perseant 	struct uvnode *vp;
    102  1.16  perseant 	struct ubuf *bp;
    103  1.11  perseant 	IFILE *ifp;
    104  1.58  dholland 	daddr_t daddr;
    105  1.58  dholland 	unsigned segno;
    106   1.1  perseant 
    107  1.16  perseant 	vp = vget(fs, ino);
    108  1.16  perseant 	if (vp == NULL)
    109   1.6  perseant 		return NULL;
    110   1.5  perseant 
    111  1.16  perseant 	if (din_table[ino] == 0x0) {
    112  1.16  perseant 		LFS_IENTRY(ifp, fs, ino, bp);
    113  1.58  dholland 		daddr = lfs_if_getdaddr(fs, ifp);
    114  1.58  dholland 		segno = lfs_dtosn(fs, daddr);
    115  1.58  dholland 		din_table[ino] = daddr;
    116  1.59  dholland 		seg_table[segno].su_nbytes += DINOSIZE(fs);
    117  1.37        ad 		brelse(bp, 0);
    118   1.6  perseant 	}
    119  1.60  dholland 	return VTOI(vp)->i_din;
    120   1.1  perseant }
    121   1.1  perseant 
    122   1.1  perseant /*
    123  1.16  perseant  * Check validity of held blocks in an inode, recursing through all blocks.
    124   1.1  perseant  */
    125   1.1  perseant int
    126  1.59  dholland ckinode(union lfs_dinode *dp, struct inodesc *idesc)
    127   1.6  perseant {
    128  1.62  dholland 	daddr_t lbn, pbn;
    129  1.16  perseant 	long ret, n, ndb, offset;
    130  1.59  dholland 	union lfs_dinode dino;
    131  1.16  perseant 	u_int64_t remsize, sizepb;
    132  1.16  perseant 	mode_t mode;
    133  1.16  perseant 	char pathbuf[MAXPATHLEN + 1];
    134  1.16  perseant 	struct uvnode *vp, *thisvp;
    135   1.6  perseant 
    136   1.6  perseant 	if (idesc->id_fix != IGNORE)
    137   1.6  perseant 		idesc->id_fix = DONTKNOW;
    138   1.6  perseant 	idesc->id_entryno = 0;
    139  1.59  dholland 	idesc->id_filesize = lfs_dino_getsize(fs, dp);
    140  1.59  dholland 	mode = lfs_dino_getmode(fs, dp) & LFS_IFMT;
    141  1.47  dholland 	if (mode == LFS_IFBLK || mode == LFS_IFCHR ||
    142  1.59  dholland 	    (mode == LFS_IFLNK && (lfs_dino_getsize(fs, dp) < lfs_sb_getmaxsymlinklen(fs) ||
    143  1.56  dholland 		    (lfs_sb_getmaxsymlinklen(fs) == 0 &&
    144  1.59  dholland 			lfs_dino_getblocks(fs, dp) == 0))))
    145   1.6  perseant 		return (KEEPON);
    146  1.59  dholland 	/* XXX is this safe if we're 32-bit? */
    147   1.6  perseant 	dino = *dp;
    148  1.59  dholland 	ndb = howmany(lfs_dino_getsize(fs, &dino), lfs_sb_getbsize(fs));
    149   1.6  perseant 
    150  1.18      yamt 	thisvp = vget(fs, idesc->id_number);
    151  1.44  dholland 	for (lbn = 0; lbn < ULFS_NDADDR; lbn++) {
    152  1.59  dholland 		pbn = lfs_dino_getdb(fs, &dino, lbn);
    153  1.16  perseant 		if (thisvp)
    154   1.6  perseant 			idesc->id_numfrags =
    155  1.51  christos 				lfs_numfrags(fs, VTOI(thisvp)->i_lfs_fragsize[lbn]);
    156  1.16  perseant 		else {
    157  1.59  dholland 			if (--ndb == 0 && (offset = lfs_blkoff(fs, lfs_dino_getsize(fs, &dino))) != 0) {
    158  1.16  perseant 				idesc->id_numfrags =
    159  1.51  christos 			    	lfs_numfrags(fs, lfs_fragroundup(fs, offset));
    160  1.16  perseant 			} else
    161  1.55  dholland 				idesc->id_numfrags = lfs_sb_getfrag(fs);
    162  1.16  perseant 		}
    163  1.59  dholland 		if (pbn == 0) {
    164   1.6  perseant 			if (idesc->id_type == DATA && ndb >= 0) {
    165   1.6  perseant 				/* An empty block in a directory XXX */
    166  1.19    itojun 				getpathname(pathbuf, sizeof(pathbuf),
    167  1.19    itojun 				    idesc->id_number, idesc->id_number);
    168  1.32  perseant 				pfatal("DIRECTORY %s INO %lld: CONTAINS EMPTY BLOCKS [1]",
    169  1.32  perseant 				    pathbuf, (long long)idesc->id_number);
    170   1.6  perseant 				if (reply("ADJUST LENGTH") == 1) {
    171  1.16  perseant 					vp = vget(fs, idesc->id_number);
    172  1.16  perseant 					dp = VTOD(vp);
    173  1.59  dholland 					lfs_dino_setsize(fs, dp,
    174  1.59  dholland 					    lbn * lfs_sb_getbsize(fs));
    175   1.6  perseant 					printf(
    176  1.16  perseant 					    "YOU MUST RERUN FSCK AFTERWARDS\n");
    177   1.6  perseant 					rerun = 1;
    178  1.16  perseant 					inodirty(VTOI(vp));
    179  1.32  perseant 				} else
    180  1.32  perseant 					break;
    181   1.6  perseant 			}
    182   1.6  perseant 			continue;
    183   1.6  perseant 		}
    184  1.59  dholland 		idesc->id_blkno = pbn;
    185  1.59  dholland 		idesc->id_lblkno = lbn;
    186   1.6  perseant 		if (idesc->id_type == ADDR) {
    187  1.16  perseant 			ret = (*idesc->id_func) (idesc);
    188   1.6  perseant 		} else
    189   1.6  perseant 			ret = dirscan(idesc);
    190   1.6  perseant 		if (ret & STOP)
    191   1.6  perseant 			return (ret);
    192   1.6  perseant 	}
    193  1.55  dholland 	idesc->id_numfrags = lfs_sb_getfrag(fs);
    194  1.59  dholland 	remsize = lfs_dino_getsize(fs, &dino) - lfs_sb_getbsize(fs) * ULFS_NDADDR;
    195  1.55  dholland 	sizepb = lfs_sb_getbsize(fs);
    196  1.59  dholland 	for (n = 1; n <= ULFS_NIADDR; n++) {
    197  1.59  dholland 		pbn = lfs_dino_getib(fs, &dino, n-1);
    198  1.59  dholland 		if (pbn) {
    199  1.59  dholland 			idesc->id_blkno = pbn;
    200   1.6  perseant 			ret = iblock(idesc, n, remsize);
    201   1.6  perseant 			if (ret & STOP)
    202   1.6  perseant 				return (ret);
    203   1.6  perseant 		} else {
    204   1.6  perseant 			if (idesc->id_type == DATA && remsize > 0) {
    205   1.6  perseant 				/* An empty block in a directory XXX */
    206  1.19    itojun 				getpathname(pathbuf, sizeof(pathbuf),
    207  1.19    itojun 				    idesc->id_number, idesc->id_number);
    208  1.32  perseant 				pfatal("DIRECTORY %s INO %lld: CONTAINS EMPTY BLOCKS [2]",
    209  1.32  perseant 				    pathbuf, (long long)idesc->id_number);
    210   1.6  perseant 				if (reply("ADJUST LENGTH") == 1) {
    211  1.16  perseant 					vp = vget(fs, idesc->id_number);
    212  1.16  perseant 					dp = VTOD(vp);
    213  1.59  dholland 					lfs_dino_setsize(fs, dp,
    214  1.59  dholland 					    lfs_dino_getsize(fs, dp) - remsize);
    215   1.6  perseant 					remsize = 0;
    216   1.6  perseant 					printf(
    217  1.16  perseant 					    "YOU MUST RERUN FSCK AFTERWARDS\n");
    218   1.6  perseant 					rerun = 1;
    219  1.16  perseant 					inodirty(VTOI(vp));
    220   1.6  perseant 					break;
    221  1.32  perseant 				} else
    222  1.32  perseant 					break;
    223   1.6  perseant 			}
    224   1.6  perseant 		}
    225  1.51  christos 		sizepb *= LFS_NINDIR(fs);
    226   1.6  perseant 		remsize -= sizepb;
    227   1.6  perseant 	}
    228   1.6  perseant 	return (KEEPON);
    229   1.1  perseant }
    230   1.1  perseant 
    231   1.1  perseant static int
    232  1.16  perseant iblock(struct inodesc *idesc, long ilevel, u_int64_t isize)
    233   1.6  perseant {
    234  1.62  dholland 	unsigned j, maxindir;
    235  1.62  dholland 	daddr_t found;
    236  1.16  perseant 	struct ubuf *bp;
    237  1.16  perseant 	int i, n, (*func) (struct inodesc *), nif;
    238  1.16  perseant 	u_int64_t sizepb;
    239  1.16  perseant 	char pathbuf[MAXPATHLEN + 1], buf[BUFSIZ];
    240  1.16  perseant 	struct uvnode *devvp, *vp;
    241  1.16  perseant 	int diddirty = 0;
    242   1.6  perseant 
    243   1.6  perseant 	if (idesc->id_type == ADDR) {
    244   1.6  perseant 		func = idesc->id_func;
    245  1.16  perseant 		n = (*func) (idesc);
    246   1.6  perseant 		if ((n & KEEPON) == 0)
    247   1.6  perseant 			return (n);
    248   1.6  perseant 	} else
    249   1.6  perseant 		func = dirscan;
    250  1.42   mlelstv 	if (chkrange(idesc->id_blkno, idesc->id_numfrags))
    251   1.6  perseant 		return (SKIP);
    252  1.16  perseant 
    253  1.26  perseant 	devvp = fs->lfs_devvp;
    254  1.55  dholland 	bread(devvp, LFS_FSBTODB(fs, idesc->id_blkno), lfs_sb_getbsize(fs),
    255  1.53    chopps 	    0, &bp);
    256   1.6  perseant 	ilevel--;
    257  1.55  dholland 	for (sizepb = lfs_sb_getbsize(fs), i = 0; i < ilevel; i++)
    258  1.51  christos 		sizepb *= LFS_NINDIR(fs);
    259  1.51  christos 	if (isize > sizepb * LFS_NINDIR(fs))
    260  1.51  christos 		nif = LFS_NINDIR(fs);
    261   1.6  perseant 	else
    262   1.6  perseant 		nif = howmany(isize, sizepb);
    263  1.51  christos 	if (idesc->id_func == pass1check && nif < LFS_NINDIR(fs)) {
    264  1.62  dholland 		maxindir = LFS_NINDIR(fs);
    265  1.62  dholland 		for (j = nif; j < maxindir; j++) {
    266  1.62  dholland 			found = lfs_iblock_get(fs, bp->b_data, j);
    267  1.62  dholland 			if (found == 0)
    268   1.6  perseant 				continue;
    269  1.52  dholland 			(void)snprintf(buf, sizeof(buf),
    270  1.52  dholland 			    "PARTIALLY TRUNCATED INODE I=%llu",
    271  1.30  christos 			    (unsigned long long)idesc->id_number);
    272   1.6  perseant 			if (dofix(idesc, buf)) {
    273  1.62  dholland 				lfs_iblock_set(fs, bp->b_data, j, 0);
    274  1.16  perseant 				++diddirty;
    275   1.6  perseant 			}
    276   1.6  perseant 		}
    277   1.6  perseant 	}
    278  1.62  dholland 	maxindir = nif;
    279  1.62  dholland 	for (j = 0; j < maxindir; j++) {
    280  1.62  dholland 		found = lfs_iblock_get(fs, bp->b_data, j);
    281  1.62  dholland 		if (found) {
    282  1.62  dholland 			idesc->id_blkno = found;
    283  1.22      yamt 			if (ilevel == 0) {
    284  1.22      yamt 				/*
    285  1.51  christos 				 * dirscan needs lfs_lblkno.
    286  1.22      yamt 				 */
    287  1.22      yamt 				idesc->id_lblkno++;
    288  1.16  perseant 				n = (*func) (idesc);
    289  1.22      yamt 			} else {
    290   1.6  perseant 				n = iblock(idesc, ilevel, isize);
    291  1.22      yamt 			}
    292   1.6  perseant 			if (n & STOP) {
    293  1.16  perseant 				if (diddirty)
    294  1.16  perseant 					VOP_BWRITE(bp);
    295  1.16  perseant 				else
    296  1.37        ad 					brelse(bp, 0);
    297   1.6  perseant 				return (n);
    298   1.6  perseant 			}
    299   1.6  perseant 		} else {
    300   1.6  perseant 			if (idesc->id_type == DATA && isize > 0) {
    301   1.6  perseant 				/* An empty block in a directory XXX */
    302  1.19    itojun 				getpathname(pathbuf, sizeof(pathbuf),
    303  1.19    itojun 				    idesc->id_number, idesc->id_number);
    304  1.32  perseant 				pfatal("DIRECTORY %s INO %lld: CONTAINS EMPTY BLOCKS [3]",
    305  1.32  perseant 				    pathbuf, (long long)idesc->id_number);
    306   1.6  perseant 				if (reply("ADJUST LENGTH") == 1) {
    307  1.16  perseant 					vp = vget(fs, idesc->id_number);
    308  1.61  dholland 					lfs_dino_setsize(fs, VTOI(vp)->i_din,
    309  1.61  dholland 					    lfs_dino_getsize(fs,
    310  1.61  dholland 							     VTOI(vp)->i_din)
    311  1.61  dholland 					    - isize);
    312   1.6  perseant 					isize = 0;
    313   1.6  perseant 					printf(
    314  1.16  perseant 					    "YOU MUST RERUN FSCK AFTERWARDS\n");
    315   1.6  perseant 					rerun = 1;
    316  1.16  perseant 					inodirty(VTOI(vp));
    317  1.16  perseant 					if (diddirty)
    318  1.16  perseant 						VOP_BWRITE(bp);
    319  1.16  perseant 					else
    320  1.37        ad 						brelse(bp, 0);
    321   1.6  perseant 					return (STOP);
    322   1.6  perseant 				}
    323   1.6  perseant 			}
    324   1.6  perseant 		}
    325   1.6  perseant 		isize -= sizepb;
    326   1.6  perseant 	}
    327  1.16  perseant 	if (diddirty)
    328  1.16  perseant 		VOP_BWRITE(bp);
    329  1.16  perseant 	else
    330  1.37        ad 		brelse(bp, 0);
    331   1.6  perseant 	return (KEEPON);
    332   1.1  perseant }
    333  1.27  perseant 
    334   1.1  perseant /*
    335   1.1  perseant  * Check that a block in a legal block number.
    336   1.1  perseant  * Return 0 if in range, 1 if out of range.
    337   1.1  perseant  */
    338   1.1  perseant int
    339   1.6  perseant chkrange(daddr_t blk, int cnt)
    340   1.6  perseant {
    341  1.51  christos 	if (blk < lfs_sntod(fs, 0)) {
    342  1.11  perseant 		return (1);
    343  1.11  perseant 	}
    344  1.11  perseant 	if (blk > maxfsblock) {
    345  1.11  perseant 		return (1);
    346  1.11  perseant 	}
    347  1.51  christos 	if (blk + cnt < lfs_sntod(fs, 0)) {
    348   1.7  perseant 		return (1);
    349   1.7  perseant 	}
    350  1.11  perseant 	if (blk + cnt > maxfsblock) {
    351   1.6  perseant 		return (1);
    352   1.6  perseant 	}
    353   1.6  perseant 	return (0);
    354   1.1  perseant }
    355  1.27  perseant 
    356   1.1  perseant /*
    357   1.1  perseant  * Routines to maintain information about directory inodes.
    358   1.1  perseant  * This is built during the first pass and used during the
    359   1.1  perseant  * second and third passes.
    360   1.1  perseant  *
    361   1.1  perseant  * Enter inodes into the cache.
    362   1.1  perseant  */
    363   1.1  perseant void
    364  1.59  dholland cacheino(union lfs_dinode *dp, ino_t inumber)
    365   1.6  perseant {
    366  1.16  perseant 	struct inoinfo *inp;
    367  1.21    itojun 	struct inoinfo **inpp, **ninpsort;
    368  1.59  dholland 	unsigned int blks, i;
    369   1.6  perseant 
    370  1.59  dholland 	blks = howmany(lfs_dino_getsize(fs, dp), lfs_sb_getbsize(fs));
    371  1.44  dholland 	if (blks > ULFS_NDADDR)
    372  1.44  dholland 		blks = ULFS_NDADDR + ULFS_NIADDR;
    373  1.62  dholland 	inp = emalloc(sizeof(*inp) + (blks - 1) * sizeof(inp->i_blks[0]));
    374   1.6  perseant 	inpp = &inphead[inumber % numdirs];
    375   1.6  perseant 	inp->i_nexthash = *inpp;
    376   1.6  perseant 	*inpp = inp;
    377   1.6  perseant 	inp->i_child = inp->i_sibling = inp->i_parentp = 0;
    378  1.44  dholland 	if (inumber == ULFS_ROOTINO)
    379  1.44  dholland 		inp->i_parent = ULFS_ROOTINO;
    380   1.6  perseant 	else
    381  1.16  perseant 		inp->i_parent = (ino_t) 0;
    382  1.16  perseant 	inp->i_dotdot = (ino_t) 0;
    383   1.6  perseant 	inp->i_number = inumber;
    384  1.59  dholland 	inp->i_isize = lfs_dino_getsize(fs, dp);
    385  1.16  perseant 
    386  1.62  dholland 	inp->i_numblks = blks * sizeof(inp->i_blks[0]);
    387  1.59  dholland 	for (i=0; i<blks && i<ULFS_NDADDR; i++) {
    388  1.59  dholland 		inp->i_blks[i] = lfs_dino_getdb(fs, dp, i);
    389  1.59  dholland 	}
    390  1.59  dholland 	for (; i<blks; i++) {
    391  1.59  dholland 		inp->i_blks[i] = lfs_dino_getib(fs, dp, i - ULFS_NDADDR);
    392  1.59  dholland 	}
    393   1.6  perseant 	if (inplast == listmax) {
    394  1.36  christos 		ninpsort = erealloc(inpsort,
    395  1.36  christos 		    (listmax + 100) * sizeof(struct inoinfo *));
    396  1.21    itojun 		inpsort = ninpsort;
    397   1.6  perseant 		listmax += 100;
    398   1.6  perseant 	}
    399   1.6  perseant 	inpsort[inplast++] = inp;
    400   1.1  perseant }
    401   1.1  perseant 
    402   1.1  perseant /*
    403   1.1  perseant  * Look up an inode cache structure.
    404   1.1  perseant  */
    405   1.1  perseant struct inoinfo *
    406   1.6  perseant getinoinfo(ino_t inumber)
    407   1.1  perseant {
    408  1.25     perry 	struct inoinfo *inp;
    409   1.1  perseant 
    410   1.6  perseant 	for (inp = inphead[inumber % numdirs]; inp; inp = inp->i_nexthash) {
    411   1.6  perseant 		if (inp->i_number != inumber)
    412   1.6  perseant 			continue;
    413   1.6  perseant 		return (inp);
    414   1.6  perseant 	}
    415  1.54  christos 	err(EEXIT, "cannot find inode %llu", (unsigned long long)inumber);
    416  1.16  perseant 	return ((struct inoinfo *) 0);
    417   1.1  perseant }
    418   1.1  perseant 
    419   1.1  perseant /*
    420   1.1  perseant  * Clean up all the inode cache structure.
    421   1.1  perseant  */
    422   1.1  perseant void
    423  1.25     perry inocleanup(void)
    424   1.1  perseant {
    425  1.25     perry 	struct inoinfo **inpp;
    426   1.1  perseant 
    427   1.6  perseant 	if (inphead == NULL)
    428   1.6  perseant 		return;
    429   1.6  perseant 	for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--)
    430  1.16  perseant 		free((char *) (*inpp));
    431  1.16  perseant 	free((char *) inphead);
    432  1.16  perseant 	free((char *) inpsort);
    433   1.6  perseant 	inphead = inpsort = NULL;
    434   1.1  perseant }
    435   1.1  perseant 
    436   1.1  perseant void
    437  1.16  perseant inodirty(struct inode *ip)
    438   1.1  perseant {
    439  1.16  perseant 	ip->i_flag |= IN_MODIFIED;
    440   1.1  perseant }
    441   1.1  perseant 
    442   1.1  perseant void
    443  1.28  christos clri(struct inodesc * idesc, const char *type, int flag)
    444   1.6  perseant {
    445  1.16  perseant 	struct uvnode *vp;
    446   1.6  perseant 
    447  1.16  perseant 	vp = vget(fs, idesc->id_number);
    448  1.35  perseant 	if (flag & 0x1) {
    449   1.6  perseant 		pwarn("%s %s", type,
    450  1.61  dholland 		      (lfs_dino_getmode(fs, VTOI(vp)->i_din) & LFS_IFMT) == LFS_IFDIR ? "DIR" : "FILE");
    451   1.6  perseant 		pinode(idesc->id_number);
    452   1.6  perseant 	}
    453  1.35  perseant 	if ((flag & 0x2) || preen || reply("CLEAR") == 1) {
    454  1.16  perseant 		if (preen && flag != 2)
    455   1.6  perseant 			printf(" (CLEARED)\n");
    456   1.6  perseant 		n_files--;
    457  1.16  perseant 		(void) ckinode(VTOD(vp), idesc);
    458  1.24      yamt 		clearinode(idesc->id_number);
    459   1.6  perseant 		statemap[idesc->id_number] = USTATE;
    460  1.24      yamt 		vnode_destroy(vp);
    461  1.35  perseant 		return;
    462  1.24      yamt 	}
    463  1.35  perseant 	return;
    464  1.24      yamt }
    465   1.6  perseant 
    466  1.24      yamt void
    467  1.24      yamt clearinode(ino_t inumber)
    468  1.24      yamt {
    469  1.24      yamt 	struct ubuf *bp;
    470  1.24      yamt 	IFILE *ifp;
    471  1.24      yamt 	daddr_t daddr;
    472  1.24      yamt 
    473  1.24      yamt 	/* Send cleared inode to the free list */
    474  1.24      yamt 
    475  1.24      yamt 	LFS_IENTRY(ifp, fs, inumber, bp);
    476  1.58  dholland 	daddr = lfs_if_getdaddr(fs, ifp);
    477  1.33  perseant 	if (daddr == LFS_UNUSED_DADDR) {
    478  1.37        ad 		brelse(bp, 0);
    479  1.33  perseant 		return;
    480  1.33  perseant 	}
    481  1.58  dholland 	lfs_if_setdaddr(fs, ifp, LFS_UNUSED_DADDR);
    482  1.58  dholland 	lfs_if_setnextfree(fs, ifp, lfs_sb_getfreehd(fs));
    483  1.55  dholland 	lfs_sb_setfreehd(fs, inumber);
    484  1.24      yamt 	sbdirty();
    485  1.24      yamt 	VOP_BWRITE(bp);
    486   1.6  perseant 
    487  1.24      yamt 	/*
    488  1.24      yamt 	 * update segment usage.
    489  1.24      yamt 	 */
    490  1.24      yamt 	if (daddr != LFS_UNUSED_DADDR) {
    491  1.24      yamt 		SEGUSE *sup;
    492  1.51  christos 		u_int32_t oldsn = lfs_dtosn(fs, daddr);
    493  1.24      yamt 
    494  1.59  dholland 		seg_table[oldsn].su_nbytes -= DINOSIZE(fs);
    495  1.24      yamt 		LFS_SEGENTRY(sup, fs, oldsn, bp);
    496  1.59  dholland 		sup->su_nbytes -= DINOSIZE(fs);
    497  1.24      yamt 		LFS_WRITESEGENTRY(sup, fs, oldsn, bp);	/* Ifile */
    498   1.6  perseant 	}
    499   1.1  perseant }
    500   1.1  perseant 
    501   1.1  perseant int
    502  1.16  perseant findname(struct inodesc * idesc)
    503   1.1  perseant {
    504  1.68  dholland 	LFS_DIRHEADER *dirp = idesc->id_dirp;
    505  1.28  christos 	size_t len;
    506  1.28  christos 	char *buf;
    507   1.1  perseant 
    508  1.64  dholland 	if (lfs_dir_getino(fs, dirp) != idesc->id_parent)
    509   1.6  perseant 		return (KEEPON);
    510  1.63  dholland 	len = lfs_dir_getnamlen(fs, dirp) + 1;
    511  1.63  dholland 	if (len > MAXPATHLEN) {
    512  1.28  christos 		/* Truncate it but don't overflow the buffer */
    513  1.63  dholland 		/* XXX: this case doesn't null-terminate the result */
    514  1.28  christos 		len = MAXPATHLEN;
    515  1.28  christos 	}
    516  1.28  christos 	/* this is namebuf with utils.h */
    517  1.28  christos 	buf = __UNCONST(idesc->id_name);
    518  1.66  dholland 	(void)memcpy(buf, lfs_dir_nameptr(fs, dirp), len);
    519   1.6  perseant 	return (STOP | FOUND);
    520   1.1  perseant }
    521   1.1  perseant 
    522   1.1  perseant int
    523  1.16  perseant findino(struct inodesc * idesc)
    524   1.1  perseant {
    525  1.68  dholland 	LFS_DIRHEADER *dirp = idesc->id_dirp;
    526  1.64  dholland 	ino_t ino;
    527   1.1  perseant 
    528  1.64  dholland 	ino = lfs_dir_getino(fs, dirp);
    529  1.64  dholland 	if (ino == 0)
    530   1.6  perseant 		return (KEEPON);
    531  1.66  dholland 	if (strcmp(lfs_dir_nameptr(fs, dirp), idesc->id_name) == 0 &&
    532  1.64  dholland 	    ino >= ULFS_ROOTINO && ino < maxino) {
    533  1.64  dholland 		idesc->id_parent = ino;
    534   1.6  perseant 		return (STOP | FOUND);
    535   1.6  perseant 	}
    536   1.6  perseant 	return (KEEPON);
    537   1.1  perseant }
    538   1.1  perseant 
    539   1.1  perseant void
    540   1.6  perseant pinode(ino_t ino)
    541   1.1  perseant {
    542  1.59  dholland 	union lfs_dinode *dp;
    543  1.16  perseant 	struct passwd *pw;
    544   1.6  perseant 
    545  1.30  christos 	printf(" I=%llu ", (unsigned long long)ino);
    546  1.44  dholland 	if (ino < ULFS_ROOTINO || ino >= maxino)
    547   1.6  perseant 		return;
    548   1.6  perseant 	dp = ginode(ino);
    549   1.6  perseant 	if (dp) {
    550   1.6  perseant 		printf(" OWNER=");
    551   1.1  perseant #ifndef SMALL
    552  1.59  dholland 		if (Uflag && (pw = getpwuid(lfs_dino_getuid(fs, dp))) != 0)
    553   1.6  perseant 			printf("%s ", pw->pw_name);
    554   1.6  perseant 		else
    555   1.1  perseant #endif
    556  1.59  dholland 			printf("%u ", (unsigned)lfs_dino_getuid(fs, dp));
    557  1.59  dholland 		printf("MODE=%o\n", lfs_dino_getmode(fs, dp));
    558   1.6  perseant 		if (preen)
    559   1.6  perseant 			printf("%s: ", cdevname());
    560  1.59  dholland 		printf("SIZE=%ju ", (uintmax_t) lfs_dino_getsize(fs, dp));
    561  1.59  dholland 		printf("MTIME=%s ", print_mtime(lfs_dino_getmtime(fs, dp)));
    562   1.6  perseant 	}
    563   1.1  perseant }
    564   1.1  perseant 
    565   1.1  perseant void
    566  1.29  christos blkerror(ino_t ino, const char *type, daddr_t blk)
    567   1.6  perseant {
    568   1.6  perseant 
    569  1.30  christos 	pfatal("%lld %s I=%llu", (long long) blk, type,
    570  1.30  christos 	    (unsigned long long)ino);
    571   1.6  perseant 	printf("\n");
    572   1.6  perseant 	if (exitonfail)
    573   1.6  perseant 		exit(1);
    574   1.6  perseant 	switch (statemap[ino]) {
    575   1.6  perseant 
    576   1.6  perseant 	case FSTATE:
    577   1.6  perseant 		statemap[ino] = FCLEAR;
    578   1.6  perseant 		return;
    579   1.6  perseant 
    580   1.6  perseant 	case DSTATE:
    581   1.6  perseant 		statemap[ino] = DCLEAR;
    582   1.6  perseant 		return;
    583   1.6  perseant 
    584   1.6  perseant 	case FCLEAR:
    585   1.6  perseant 	case DCLEAR:
    586   1.6  perseant 		return;
    587   1.6  perseant 
    588   1.6  perseant 	default:
    589  1.54  christos 		err(EEXIT, "BAD STATE %d TO BLKERR", statemap[ino]);
    590   1.6  perseant 		/* NOTREACHED */
    591   1.6  perseant 	}
    592   1.1  perseant }
    593  1.27  perseant 
    594   1.1  perseant /*
    595   1.1  perseant  * allocate an unused inode
    596   1.1  perseant  */
    597   1.1  perseant ino_t
    598   1.6  perseant allocino(ino_t request, int type)
    599   1.6  perseant {
    600  1.16  perseant 	ino_t ino;
    601  1.59  dholland 	union lfs_dinode *dp;
    602  1.16  perseant 	time_t t;
    603  1.16  perseant 	struct uvnode *vp;
    604  1.16  perseant 	struct ubuf *bp;
    605   1.6  perseant 
    606   1.6  perseant 	if (request == 0)
    607  1.44  dholland 		request = ULFS_ROOTINO;
    608   1.6  perseant 	else if (statemap[request] != USTATE)
    609   1.6  perseant 		return (0);
    610   1.6  perseant 	for (ino = request; ino < maxino; ino++)
    611   1.6  perseant 		if (statemap[ino] == USTATE)
    612   1.6  perseant 			break;
    613   1.6  perseant 	if (ino == maxino)
    614  1.32  perseant 		extend_ifile(fs);
    615  1.32  perseant 
    616  1.47  dholland 	switch (type & LFS_IFMT) {
    617  1.47  dholland 	case LFS_IFDIR:
    618   1.6  perseant 		statemap[ino] = DSTATE;
    619   1.6  perseant 		break;
    620  1.47  dholland 	case LFS_IFREG:
    621  1.47  dholland 	case LFS_IFLNK:
    622   1.6  perseant 		statemap[ino] = FSTATE;
    623   1.6  perseant 		break;
    624   1.6  perseant 	default:
    625   1.6  perseant 		return (0);
    626   1.6  perseant 	}
    627  1.27  perseant         vp = lfs_valloc(fs, ino);
    628  1.27  perseant 	if (vp == NULL)
    629  1.27  perseant 		return (0);
    630  1.60  dholland 	dp = VTOI(vp)->i_din;
    631  1.55  dholland 	bp = getblk(vp, 0, lfs_sb_getfsize(fs));
    632  1.16  perseant 	VOP_BWRITE(bp);
    633  1.59  dholland 	lfs_dino_setmode(fs, dp, type);
    634  1.16  perseant 	(void) time(&t);
    635  1.59  dholland 	lfs_dino_setatime(fs, dp, t);
    636  1.59  dholland 	lfs_dino_setctime(fs, dp, t);
    637  1.59  dholland 	lfs_dino_setmtime(fs, dp, t);
    638  1.59  dholland 	lfs_dino_setsize(fs, dp, lfs_sb_getfsize(fs));
    639  1.59  dholland 	lfs_dino_setblocks(fs, dp, lfs_btofsb(fs, lfs_sb_getfsize(fs)));
    640   1.6  perseant 	n_files++;
    641  1.16  perseant 	inodirty(VTOI(vp));
    642  1.49  dholland 	typemap[ino] = LFS_IFTODT(type);
    643   1.6  perseant 	return (ino);
    644   1.1  perseant }
    645  1.27  perseant 
    646   1.1  perseant /*
    647   1.1  perseant  * deallocate an inode
    648   1.1  perseant  */
    649   1.1  perseant void
    650   1.6  perseant freeino(ino_t ino)
    651   1.1  perseant {
    652  1.16  perseant 	struct inodesc idesc;
    653  1.16  perseant 	struct uvnode *vp;
    654   1.1  perseant 
    655   1.6  perseant 	memset(&idesc, 0, sizeof(struct inodesc));
    656   1.6  perseant 	idesc.id_type = ADDR;
    657   1.6  perseant 	idesc.id_func = pass4check;
    658   1.6  perseant 	idesc.id_number = ino;
    659  1.16  perseant 	vp = vget(fs, ino);
    660  1.16  perseant 	(void) ckinode(VTOD(vp), &idesc);
    661  1.24      yamt 	clearinode(ino);
    662   1.6  perseant 	statemap[ino] = USTATE;
    663  1.24      yamt 	vnode_destroy(vp);
    664   1.5  perseant 
    665   1.6  perseant 	n_files--;
    666   1.1  perseant }
    667