xref: /freebsd/sbin/fsck_ffs/pass2.c (revision 39beb93c3f8bdbf72a61fda42300b5ebed7390c8)
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  * 4. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29 
30 #if 0
31 #ifndef lint
32 static const char sccsid[] = "@(#)pass2.c	8.9 (Berkeley) 4/28/95";
33 #endif /* not lint */
34 #endif
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD$");
37 
38 #include <sys/param.h>
39 
40 #include <ufs/ufs/dinode.h>
41 #include <ufs/ufs/dir.h>
42 #include <ufs/ffs/fs.h>
43 
44 #include <err.h>
45 #include <stdint.h>
46 #include <string.h>
47 
48 #include "fsck.h"
49 
50 #define MINDIRSIZE	(sizeof (struct dirtemplate))
51 
52 static int blksort(const void *, const void *);
53 static int pass2check(struct inodesc *);
54 
55 void
56 pass2(void)
57 {
58 	union dinode *dp;
59 	struct inoinfo **inpp, *inp;
60 	struct inoinfo **inpend;
61 	struct inodesc curino;
62 	union dinode dino;
63 	int i;
64 	char pathbuf[MAXPATHLEN + 1];
65 
66 	switch (inoinfo(ROOTINO)->ino_state) {
67 
68 	case USTATE:
69 		pfatal("ROOT INODE UNALLOCATED");
70 		if (reply("ALLOCATE") == 0) {
71 			ckfini(0);
72 			exit(EEXIT);
73 		}
74 		if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
75 			errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
76 		break;
77 
78 	case DCLEAR:
79 		pfatal("DUPS/BAD IN ROOT INODE");
80 		if (reply("REALLOCATE")) {
81 			freeino(ROOTINO);
82 			if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
83 				errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
84 			break;
85 		}
86 		if (reply("CONTINUE") == 0) {
87 			ckfini(0);
88 			exit(EEXIT);
89 		}
90 		break;
91 
92 	case FSTATE:
93 	case FCLEAR:
94 	case FZLINK:
95 		pfatal("ROOT INODE NOT DIRECTORY");
96 		if (reply("REALLOCATE")) {
97 			freeino(ROOTINO);
98 			if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
99 				errx(EEXIT, "CANNOT ALLOCATE ROOT INODE");
100 			break;
101 		}
102 		if (reply("FIX") == 0) {
103 			ckfini(0);
104 			exit(EEXIT);
105 		}
106 		dp = ginode(ROOTINO);
107 		DIP_SET(dp, di_mode, DIP(dp, di_mode) & ~IFMT);
108 		DIP_SET(dp, di_mode, DIP(dp, di_mode) | IFDIR);
109 		inodirty();
110 		break;
111 
112 	case DSTATE:
113 	case DZLINK:
114 		break;
115 
116 	default:
117 		errx(EEXIT, "BAD STATE %d FOR ROOT INODE",
118 		    inoinfo(ROOTINO)->ino_state);
119 	}
120 	inoinfo(ROOTINO)->ino_state = DFOUND;
121 	inoinfo(WINO)->ino_state = FSTATE;
122 	inoinfo(WINO)->ino_type = DT_WHT;
123 	/*
124 	 * Sort the directory list into disk block order.
125 	 */
126 	qsort((char *)inpsort, (size_t)inplast, sizeof *inpsort, blksort);
127 	/*
128 	 * Check the integrity of each directory.
129 	 */
130 	memset(&curino, 0, sizeof(struct inodesc));
131 	curino.id_type = DATA;
132 	curino.id_func = pass2check;
133 	inpend = &inpsort[inplast];
134 	for (inpp = inpsort; inpp < inpend; inpp++) {
135 		if (got_siginfo) {
136 			printf("%s: phase 2: dir %td of %d (%d%%)\n", cdevname,
137 			    inpp - inpsort, (int)inplast,
138 			    (int)((inpp - inpsort) * 100 / inplast));
139 			got_siginfo = 0;
140 		}
141 		if (got_sigalarm) {
142 			setproctitle("%s p2 %d%%", cdevname,
143 			    (int)((inpp - inpsort) * 100 / inplast));
144 			got_sigalarm = 0;
145 		}
146 		inp = *inpp;
147 		if (inp->i_isize == 0)
148 			continue;
149 		if (inp->i_isize < MINDIRSIZE) {
150 			direrror(inp->i_number, "DIRECTORY TOO SHORT");
151 			inp->i_isize = roundup(MINDIRSIZE, DIRBLKSIZ);
152 			if (reply("FIX") == 1) {
153 				dp = ginode(inp->i_number);
154 				DIP_SET(dp, di_size, inp->i_isize);
155 				inodirty();
156 			}
157 		} else if ((inp->i_isize & (DIRBLKSIZ - 1)) != 0) {
158 			getpathname(pathbuf, inp->i_number, inp->i_number);
159 			if (usedsoftdep)
160 				pfatal("%s %s: LENGTH %jd NOT MULTIPLE OF %d",
161 					"DIRECTORY", pathbuf,
162 					(intmax_t)inp->i_isize, DIRBLKSIZ);
163 			else
164 				pwarn("%s %s: LENGTH %jd NOT MULTIPLE OF %d",
165 					"DIRECTORY", pathbuf,
166 					(intmax_t)inp->i_isize, DIRBLKSIZ);
167 			if (preen)
168 				printf(" (ADJUSTED)\n");
169 			inp->i_isize = roundup(inp->i_isize, DIRBLKSIZ);
170 			if (preen || reply("ADJUST") == 1) {
171 				dp = ginode(inp->i_number);
172 				DIP_SET(dp, di_size,
173 				    roundup(inp->i_isize, DIRBLKSIZ));
174 				inodirty();
175 			}
176 		}
177 		dp = &dino;
178 		memset(dp, 0, sizeof(struct ufs2_dinode));
179 		DIP_SET(dp, di_mode, IFDIR);
180 		DIP_SET(dp, di_size, inp->i_isize);
181 		for (i = 0;
182 		     i < (inp->i_numblks<NDADDR ? inp->i_numblks : NDADDR);
183 		     i++)
184 			DIP_SET(dp, di_db[i], inp->i_blks[i]);
185 		if (inp->i_numblks > NDADDR)
186 			for (i = 0; i < NIADDR; i++)
187 				DIP_SET(dp, di_ib[i], inp->i_blks[NDADDR + i]);
188 		curino.id_number = inp->i_number;
189 		curino.id_parent = inp->i_parent;
190 		(void)ckinode(dp, &curino);
191 	}
192 	/*
193 	 * Now that the parents of all directories have been found,
194 	 * make another pass to verify the value of `..'
195 	 */
196 	for (inpp = inpsort; inpp < inpend; inpp++) {
197 		inp = *inpp;
198 		if (inp->i_parent == 0 || inp->i_isize == 0)
199 			continue;
200 		if (inoinfo(inp->i_parent)->ino_state == DFOUND &&
201 		    INO_IS_DUNFOUND(inp->i_number))
202 			inoinfo(inp->i_number)->ino_state = DFOUND;
203 		if (inp->i_dotdot == inp->i_parent ||
204 		    inp->i_dotdot == (ino_t)-1)
205 			continue;
206 		if (inp->i_dotdot == 0) {
207 			inp->i_dotdot = inp->i_parent;
208 			fileerror(inp->i_parent, inp->i_number, "MISSING '..'");
209 			if (reply("FIX") == 0)
210 				continue;
211 			(void)makeentry(inp->i_number, inp->i_parent, "..");
212 			inoinfo(inp->i_parent)->ino_linkcnt--;
213 			continue;
214 		}
215 		fileerror(inp->i_parent, inp->i_number,
216 		    "BAD INODE NUMBER FOR '..'");
217 		if (reply("FIX") == 0)
218 			continue;
219 		inoinfo(inp->i_dotdot)->ino_linkcnt++;
220 		inoinfo(inp->i_parent)->ino_linkcnt--;
221 		inp->i_dotdot = inp->i_parent;
222 		(void)changeino(inp->i_number, "..", inp->i_parent);
223 	}
224 	/*
225 	 * Mark all the directories that can be found from the root.
226 	 */
227 	propagate();
228 }
229 
230 static int
231 pass2check(struct inodesc *idesc)
232 {
233 	struct direct *dirp = idesc->id_dirp;
234 	struct inoinfo *inp;
235 	int n, entrysize, ret = 0;
236 	union dinode *dp;
237 	const char *errmsg;
238 	struct direct proto;
239 	char namebuf[MAXPATHLEN + 1];
240 	char pathbuf[MAXPATHLEN + 1];
241 
242 	/*
243 	 * check for "."
244 	 */
245 	if (dirp->d_ino > maxino)
246 		goto chk2;
247 	if (idesc->id_entryno != 0)
248 		goto chk1;
249 	if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
250 		if (dirp->d_ino != idesc->id_number) {
251 			direrror(idesc->id_number, "BAD INODE NUMBER FOR '.'");
252 			dirp->d_ino = idesc->id_number;
253 			if (reply("FIX") == 1)
254 				ret |= ALTERED;
255 		}
256 		if (dirp->d_type != DT_DIR) {
257 			direrror(idesc->id_number, "BAD TYPE VALUE FOR '.'");
258 			dirp->d_type = DT_DIR;
259 			if (reply("FIX") == 1)
260 				ret |= ALTERED;
261 		}
262 		goto chk1;
263 	}
264 	direrror(idesc->id_number, "MISSING '.'");
265 	proto.d_ino = idesc->id_number;
266 	proto.d_type = DT_DIR;
267 	proto.d_namlen = 1;
268 	(void)strcpy(proto.d_name, ".");
269 	entrysize = DIRSIZ(0, &proto);
270 	if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") != 0) {
271 		pfatal("CANNOT FIX, FIRST ENTRY IN DIRECTORY CONTAINS %s\n",
272 			dirp->d_name);
273 	} else if (dirp->d_reclen < entrysize) {
274 		pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '.'\n");
275 	} else if (dirp->d_reclen < 2 * entrysize) {
276 		proto.d_reclen = dirp->d_reclen;
277 		memmove(dirp, &proto, (size_t)entrysize);
278 		if (reply("FIX") == 1)
279 			ret |= ALTERED;
280 	} else {
281 		n = dirp->d_reclen - entrysize;
282 		proto.d_reclen = entrysize;
283 		memmove(dirp, &proto, (size_t)entrysize);
284 		idesc->id_entryno++;
285 		inoinfo(dirp->d_ino)->ino_linkcnt--;
286 		dirp = (struct direct *)((char *)(dirp) + entrysize);
287 		memset(dirp, 0, (size_t)n);
288 		dirp->d_reclen = n;
289 		if (reply("FIX") == 1)
290 			ret |= ALTERED;
291 	}
292 chk1:
293 	if (idesc->id_entryno > 1)
294 		goto chk2;
295 	inp = getinoinfo(idesc->id_number);
296 	proto.d_ino = inp->i_parent;
297 	proto.d_type = DT_DIR;
298 	proto.d_namlen = 2;
299 	(void)strcpy(proto.d_name, "..");
300 	entrysize = DIRSIZ(0, &proto);
301 	if (idesc->id_entryno == 0) {
302 		n = DIRSIZ(0, dirp);
303 		if (dirp->d_reclen < n + entrysize)
304 			goto chk2;
305 		proto.d_reclen = dirp->d_reclen - n;
306 		dirp->d_reclen = n;
307 		idesc->id_entryno++;
308 		inoinfo(dirp->d_ino)->ino_linkcnt--;
309 		dirp = (struct direct *)((char *)(dirp) + n);
310 		memset(dirp, 0, (size_t)proto.d_reclen);
311 		dirp->d_reclen = proto.d_reclen;
312 	}
313 	if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
314 		inp->i_dotdot = dirp->d_ino;
315 		if (dirp->d_type != DT_DIR) {
316 			direrror(idesc->id_number, "BAD TYPE VALUE FOR '..'");
317 			dirp->d_type = DT_DIR;
318 			if (reply("FIX") == 1)
319 				ret |= ALTERED;
320 		}
321 		goto chk2;
322 	}
323 	if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) {
324 		fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
325 		pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
326 			dirp->d_name);
327 		inp->i_dotdot = (ino_t)-1;
328 	} else if (dirp->d_reclen < entrysize) {
329 		fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
330 		pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '..'\n");
331 		inp->i_dotdot = (ino_t)-1;
332 	} else if (inp->i_parent != 0) {
333 		/*
334 		 * We know the parent, so fix now.
335 		 */
336 		inp->i_dotdot = inp->i_parent;
337 		fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
338 		proto.d_reclen = dirp->d_reclen;
339 		memmove(dirp, &proto, (size_t)entrysize);
340 		if (reply("FIX") == 1)
341 			ret |= ALTERED;
342 	}
343 	idesc->id_entryno++;
344 	if (dirp->d_ino != 0)
345 		inoinfo(dirp->d_ino)->ino_linkcnt--;
346 	return (ret|KEEPON);
347 chk2:
348 	if (dirp->d_ino == 0)
349 		return (ret|KEEPON);
350 	if (dirp->d_namlen <= 2 &&
351 	    dirp->d_name[0] == '.' &&
352 	    idesc->id_entryno >= 2) {
353 		if (dirp->d_namlen == 1) {
354 			direrror(idesc->id_number, "EXTRA '.' ENTRY");
355 			dirp->d_ino = 0;
356 			if (reply("FIX") == 1)
357 				ret |= ALTERED;
358 			return (KEEPON | ret);
359 		}
360 		if (dirp->d_name[1] == '.') {
361 			direrror(idesc->id_number, "EXTRA '..' ENTRY");
362 			dirp->d_ino = 0;
363 			if (reply("FIX") == 1)
364 				ret |= ALTERED;
365 			return (KEEPON | ret);
366 		}
367 	}
368 	idesc->id_entryno++;
369 	n = 0;
370 	if (dirp->d_ino > maxino) {
371 		fileerror(idesc->id_number, dirp->d_ino, "I OUT OF RANGE");
372 		n = reply("REMOVE");
373 	} else if (((dirp->d_ino == WINO && dirp->d_type != DT_WHT) ||
374 		    (dirp->d_ino != WINO && dirp->d_type == DT_WHT))) {
375 		fileerror(idesc->id_number, dirp->d_ino, "BAD WHITEOUT ENTRY");
376 		dirp->d_ino = WINO;
377 		dirp->d_type = DT_WHT;
378 		if (reply("FIX") == 1)
379 			ret |= ALTERED;
380 	} else {
381 again:
382 		switch (inoinfo(dirp->d_ino)->ino_state) {
383 		case USTATE:
384 			if (idesc->id_entryno <= 2)
385 				break;
386 			fileerror(idesc->id_number, dirp->d_ino, "UNALLOCATED");
387 			n = reply("REMOVE");
388 			break;
389 
390 		case DCLEAR:
391 		case FCLEAR:
392 			if (idesc->id_entryno <= 2)
393 				break;
394 			if (inoinfo(dirp->d_ino)->ino_state == FCLEAR)
395 				errmsg = "DUP/BAD";
396 			else if (!preen && !usedsoftdep)
397 				errmsg = "ZERO LENGTH DIRECTORY";
398 			else {
399 				n = 1;
400 				break;
401 			}
402 			fileerror(idesc->id_number, dirp->d_ino, errmsg);
403 			if ((n = reply("REMOVE")) == 1)
404 				break;
405 			dp = ginode(dirp->d_ino);
406 			inoinfo(dirp->d_ino)->ino_state =
407 			   (DIP(dp, di_mode) & IFMT) == IFDIR ? DSTATE : FSTATE;
408 			inoinfo(dirp->d_ino)->ino_linkcnt = DIP(dp, di_nlink);
409 			goto again;
410 
411 		case DSTATE:
412 		case DZLINK:
413 			if (inoinfo(idesc->id_number)->ino_state == DFOUND)
414 				inoinfo(dirp->d_ino)->ino_state = DFOUND;
415 			/* FALLTHROUGH */
416 
417 		case DFOUND:
418 			inp = getinoinfo(dirp->d_ino);
419 			if (inp->i_parent != 0 && idesc->id_entryno > 2) {
420 				getpathname(pathbuf, idesc->id_number,
421 				    idesc->id_number);
422 				getpathname(namebuf, dirp->d_ino, dirp->d_ino);
423 				pwarn("%s%s%s %s %s\n", pathbuf,
424 				    (strcmp(pathbuf, "/") == 0 ? "" : "/"),
425 				    dirp->d_name,
426 				    "IS AN EXTRANEOUS HARD LINK TO DIRECTORY",
427 				    namebuf);
428 				if (cursnapshot != 0)
429 					break;
430 				if (preen) {
431 					printf(" (REMOVED)\n");
432 					n = 1;
433 					break;
434 				}
435 				if ((n = reply("REMOVE")) == 1)
436 					break;
437 			}
438 			if (idesc->id_entryno > 2)
439 				inp->i_parent = idesc->id_number;
440 			/* FALLTHROUGH */
441 
442 		case FSTATE:
443 		case FZLINK:
444 			if (dirp->d_type != inoinfo(dirp->d_ino)->ino_type) {
445 				fileerror(idesc->id_number, dirp->d_ino,
446 				    "BAD TYPE VALUE");
447 				dirp->d_type = inoinfo(dirp->d_ino)->ino_type;
448 				if (reply("FIX") == 1)
449 					ret |= ALTERED;
450 			}
451 			inoinfo(dirp->d_ino)->ino_linkcnt--;
452 			break;
453 
454 		default:
455 			errx(EEXIT, "BAD STATE %d FOR INODE I=%d",
456 			    inoinfo(dirp->d_ino)->ino_state, dirp->d_ino);
457 		}
458 	}
459 	if (n == 0)
460 		return (ret|KEEPON);
461 	dirp->d_ino = 0;
462 	return (ret|KEEPON|ALTERED);
463 }
464 
465 /*
466  * Routine to sort disk blocks.
467  */
468 static int
469 blksort(const void *arg1, const void *arg2)
470 {
471 
472 	return ((*(struct inoinfo * const *)arg1)->i_blks[0] -
473 		(*(struct inoinfo * const *)arg2)->i_blks[0]);
474 }
475