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