?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix markup.
[netbsd-mini2440.git] / sbin / fsck_ffs / pass2.c
blob142f35a45f18e8e0428d6858df6c4117253bb91b
1 /* $NetBSD: pass2.c,v 1.44 2006/11/14 21:01:46 apb 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[] = "@(#)pass2.c 8.9 (Berkeley) 4/28/95";
36 #else
37 __RCSID("$NetBSD: pass2.c,v 1.44 2006/11/14 21:01:46 apb 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
48 #include <err.h>
49 #include <stdio.h>
50 #include <stdlib.h>
51 #include <string.h>
52
53 #include "fsck.h"
54 #include "fsutil.h"
55 #include "extern.h"
56 #include "exitvalues.h"
57
58 #define MINDIRSIZE (sizeof (struct dirtemplate))
59
60 static int blksort(const void *, const void *);
61 static int pass2check(struct inodesc *);
62
63 void
64 pass2(void)
65 {
66 union dinode *dp;
67 struct inoinfo **inpp, *inp, *pinp;
68 struct inoinfo **inpend;
69 struct inostat *rinfo, *info;
70 struct inodesc curino;
71 union dinode dino;
72 int i, maxblk;
73 char pathbuf[MAXPATHLEN + 1];
74
75 rinfo = inoinfo(ROOTINO);
76 switch (rinfo->ino_state) {
77
78 case USTATE:
79 pfatal("ROOT INODE UNALLOCATED");
80 if (reply("ALLOCATE") == 0) {
81 markclean = 0;
82 ckfini();
83 exit(FSCK_EXIT_CHECK_FAILED);
84 }
85 if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
86 errexit("CANNOT ALLOCATE ROOT INODE");
87 break;
88
89 case DCLEAR:
90 pfatal("DUPS/BAD IN ROOT INODE");
91 if (reply("REALLOCATE")) {
92 freeino(ROOTINO);
93 if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
94 errexit("CANNOT ALLOCATE ROOT INODE");
95 break;
96 }
97 markclean = 0;
98 if (reply("CONTINUE") == 0) {
99 ckfini();
100 exit(FSCK_EXIT_CHECK_FAILED);
101 }
102 break;
103
104 case FSTATE:
105 case FCLEAR:
106 pfatal("ROOT INODE NOT DIRECTORY");
107 if (reply("REALLOCATE")) {
108 freeino(ROOTINO);
109 if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
110 errexit("CANNOT ALLOCATE ROOT INODE");
111 break;
112 }
113 if (reply("FIX") == 0) {
114 markclean = 0;
115 ckfini();
116 exit(FSCK_EXIT_CHECK_FAILED);
117 }
118 dp = ginode(ROOTINO);
119 DIP_SET(dp, mode,
120 iswap16((iswap16(DIP(dp, mode)) & ~IFMT) | IFDIR));
121 inodirty();
122 break;
123
124 case DSTATE:
125 break;
126
127 default:
128 errexit("BAD STATE %d FOR ROOT INODE", rinfo->ino_state);
129 }
130 if (newinofmt) {
131 info = inoinfo(WINO);
132 info->ino_state = FSTATE;
133 info->ino_type = DT_WHT;
134 }
135 /*
136 * Sort the directory list into disk block order.
137 */
138 qsort((char *)inpsort, (size_t)inplast, sizeof *inpsort, blksort);
139 /*
140 * Check the integrity of each directory.
141 */
142 memset(&curino, 0, sizeof(struct inodesc));
143 curino.id_type = DATA;
144 curino.id_func = pass2check;
145 inpend = &inpsort[inplast];
146 for (inpp = inpsort; inpp < inpend; inpp++) {
147 if (got_siginfo) {
148 fprintf(stderr,
149 "%s: phase 2: dir %ld of %d (%d%%)\n", cdevname(),
150 (long)(inpp - inpsort), (int)inplast,
151 (int)((inpp - inpsort) * 100 / inplast));
152 got_siginfo = 0;
153 }
154 #ifdef PROGRESS
155 progress_bar(cdevname(), preen ? NULL : "phase 2",
156 (inpp - inpsort), inplast);
157 #endif /* PROGRESS */
158 inp = *inpp;
159 if (inp->i_isize == 0)
160 continue;
161 if (inp->i_isize < MINDIRSIZE) {
162 direrror(inp->i_number, "DIRECTORY TOO SHORT");
163 inp->i_isize = roundup(MINDIRSIZE, dirblksiz);
164 if (reply("FIX") == 1) {
165 dp = ginode(inp->i_number);
166 DIP_SET(dp, size, iswap64(inp->i_isize));
167 inodirty();
168 } else
169 markclean = 0;
170 } else if ((inp->i_isize & (dirblksiz - 1)) != 0) {
171 getpathname(pathbuf, sizeof(pathbuf), inp->i_number,
172 inp->i_number);
173 if (usedsoftdep)
174 pfatal("%s %s: LENGTH %lld NOT MULTIPLE OF %d",
175 "DIRECTORY", pathbuf,
176 (long long)inp->i_isize, dirblksiz);
177 else
178 pwarn("%s %s: LENGTH %lld NOT MULTIPLE OF %d",
179 "DIRECTORY", pathbuf,
180 (long long)inp->i_isize, dirblksiz);
181 if (preen)
182 printf(" (ADJUSTED)\n");
183 inp->i_isize = roundup(inp->i_isize, dirblksiz);
184 if (preen || reply("ADJUST") == 1) {
185 dp = ginode(inp->i_number);
186 DIP_SET(dp, size, iswap64(inp->i_isize));
187 inodirty();
188 } else
189 markclean = 0;
190 }
191 memset(&dino, 0, sizeof dino);
192 dp = &dino;
193 if (!is_ufs2) {
194 dp->dp1.di_mode = iswap16(IFDIR);
195 dp->dp1.di_size = iswap64(inp->i_isize);
196 maxblk = inp->i_numblks < NDADDR ? inp->i_numblks :
197 NDADDR;
198 for (i = 0; i < maxblk; i++)
199 dp->dp1.di_db[i] = inp->i_blks[i];
200 if (inp->i_numblks > NDADDR) {
201 for (i = 0; i < NIADDR; i++)
202 dp->dp1.di_ib[i] =
203 inp->i_blks[NDADDR + i];
204 }
205 } else {
206 dp->dp2.di_mode = iswap16(IFDIR);
207 dp->dp2.di_size = iswap64(inp->i_isize);
208 maxblk = inp->i_numblks < NDADDR ? inp->i_numblks :
209 NDADDR;
210 for (i = 0; i < maxblk; i++)
211 dp->dp2.di_db[i] = inp->i_blks[i];
212 if (inp->i_numblks > NDADDR) {
213 for (i = 0; i < NIADDR; i++)
214 dp->dp2.di_ib[i] =
215 inp->i_blks[NDADDR + i];
216 }
217 }
218 curino.id_number = inp->i_number;
219 curino.id_parent = inp->i_parent;
220 (void)ckinode(&dino, &curino);
221 }
222
223 /*
224 * Byte swapping in directory entries, if needed, has been done.
225 * Now rescan dirs for pass2check()
226 */
227 if (do_dirswap) {
228 do_dirswap = 0;
229 for (inpp = inpsort; inpp < inpend; inpp++) {
230 inp = *inpp;
231 if (inp->i_isize == 0)
232 continue;
233 memset(&dino, 0, sizeof dino);
234 if (!is_ufs2) {
235 dino.dp1.di_mode = iswap16(IFDIR);
236 dino.dp1.di_size = iswap64(inp->i_isize);
237 for (i = 0; i < inp->i_numblks; i++)
238 dino.dp1.di_db[i] = inp->i_blks[i];
239 } else {
240 dino.dp2.di_mode = iswap16(IFDIR);
241 dino.dp2.di_size = iswap64(inp->i_isize);
242 for (i = 0; i < inp->i_numblks; i++)
243 dino.dp2.di_db[i] = inp->i_blks[i];
244 }
245 curino.id_number = inp->i_number;
246 curino.id_parent = inp->i_parent;
247 (void)ckinode(&dino, &curino);
248 }
249 }
250
251 /*
252 * Now that the parents of all directories have been found,
253 * make another pass to verify the value of `..'
254 */
255 for (inpp = inpsort; inpp < inpend; inpp++) {
256 inp = *inpp;
257 if (inp->i_parent == 0 || inp->i_isize == 0)
258 continue;
259 if (inp->i_dotdot == inp->i_parent ||
260 inp->i_dotdot == (ino_t)-1)
261 continue;
262 info = inoinfo(inp->i_parent);
263 if (inp->i_dotdot == 0) {
264 inp->i_dotdot = inp->i_parent;
265 fileerror(inp->i_parent, inp->i_number, "MISSING '..'");
266 if (reply("FIX") == 0) {
267 markclean = 0;
268 continue;
269 }
270 (void)makeentry(inp->i_number, inp->i_parent, "..");
271 info->ino_linkcnt--;
272 continue;
273 }
274 fileerror(inp->i_parent, inp->i_number,
275 "BAD INODE NUMBER FOR '..'");
276 if (reply("FIX") == 0) {
277 markclean = 0;
278 continue;
279 }
280 inoinfo(inp->i_dotdot)->ino_linkcnt++;
281 info->ino_linkcnt--;
282 inp->i_dotdot = inp->i_parent;
283 (void)changeino(inp->i_number, "..", inp->i_parent);
284 }
285 /*
286 * Create a list of children for each directory.
287 */
288 inpend = &inpsort[inplast];
289 for (inpp = inpsort; inpp < inpend; inpp++) {
290 inp = *inpp;
291 info = inoinfo(inp->i_number);
292 inp->i_child = inp->i_sibling = 0;
293 if (info->ino_state == DFOUND)
294 info->ino_state = DSTATE;
295 }
296 for (inpp = inpsort; inpp < inpend; inpp++) {
297 inp = *inpp;
298 if (inp->i_parent == 0 ||
299 inp->i_number == ROOTINO)
300 continue;
301 pinp = getinoinfo(inp->i_parent);
302 inp->i_sibling = pinp->i_child;
303 pinp->i_child = inp;
304 }
305 /*
306 * Mark all the directories that can be found from the root.
307 */
308 propagate(ROOTINO);
309
310 #ifdef PROGRESS
311 if (!preen)
312 progress_done();
313 #endif /* PROGRESS */
314 }
315
316 static int
317 pass2check(struct inodesc *idesc)
318 {
319 struct direct *dirp = idesc->id_dirp;
320 struct inoinfo *inp;
321 struct inostat *info;
322 int n, entrysize, ret = 0;
323 union dinode *dp;
324 const char *errmsg;
325 struct direct proto;
326 char namebuf[MAXPATHLEN + 1];
327 char pathbuf[MAXPATHLEN + 1];
328
329 /*
330 * If converting, set directory entry type.
331 */
332 if (!is_ufs2 && doinglevel2 && iswap32(dirp->d_ino) > 0 &&
333 iswap32(dirp->d_ino) < maxino) {
334 dirp->d_type = inoinfo(iswap32(dirp->d_ino))->ino_type;
335 ret |= ALTERED;
336 }
337 /*
338 * check for "."
339 */
340 if (idesc->id_entryno != 0)
341 goto chk1;
342 if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
343 if (iswap32(dirp->d_ino) != idesc->id_number) {
344 direrror(idesc->id_number, "BAD INODE NUMBER FOR '.'");
345 dirp->d_ino = iswap32(idesc->id_number);
346 if (reply("FIX") == 1)
347 ret |= ALTERED;
348 else
349 markclean = 0;
350 }
351 if (newinofmt && dirp->d_type != DT_DIR) {
352 direrror(idesc->id_number, "BAD TYPE VALUE FOR '.'");
353 dirp->d_type = DT_DIR;
354 if (reply("FIX") == 1)
355 ret |= ALTERED;
356 else
357 markclean = 0;
358 }
359 goto chk1;
360 }
361 direrror(idesc->id_number, "MISSING '.'");
362 proto.d_ino = iswap32(idesc->id_number);
363 if (newinofmt)
364 proto.d_type = DT_DIR;
365 else
366 proto.d_type = 0;
367 proto.d_namlen = 1;
368 (void)strlcpy(proto.d_name, ".", sizeof(proto.d_name));
369 # if BYTE_ORDER == LITTLE_ENDIAN
370 if (!newinofmt && !needswap) {
371 # else
372 if (!newinofmt && needswap) {
373 # endif
374 u_char tmp;
375
376 tmp = proto.d_type;
377 proto.d_type = proto.d_namlen;
378 proto.d_namlen = tmp;
379 }
380 entrysize = DIRSIZ(0, &proto, 0);
381 if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") != 0) {
382 pfatal("CANNOT FIX, FIRST ENTRY IN DIRECTORY CONTAINS %s\n",
383 dirp->d_name);
384 markclean = 0;
385 } else if (iswap16(dirp->d_reclen) < entrysize) {
386 pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '.'\n");
387 markclean = 0;
388 } else if (iswap16(dirp->d_reclen) < 2 * entrysize) {
389 proto.d_reclen = dirp->d_reclen;
390 memmove(dirp, &proto, (size_t)entrysize);
391 if (reply("FIX") == 1)
392 ret |= ALTERED;
393 else
394 markclean = 0;
395 } else {
396 n = iswap16(dirp->d_reclen) - entrysize;
397 proto.d_reclen = iswap16(entrysize);
398 memmove(dirp, &proto, (size_t)entrysize);
399 idesc->id_entryno++;
400 inoinfo(iswap32(dirp->d_ino))->ino_linkcnt--;
401 dirp = (struct direct *)((char *)(dirp) + entrysize);
402 memset(dirp, 0, (size_t)n);
403 dirp->d_reclen = iswap16(n);
404 if (reply("FIX") == 1)
405 ret |= ALTERED;
406 else
407 markclean = 0;
408 }
409 chk1:
410 if (idesc->id_entryno > 1)
411 goto chk2;
412 inp = getinoinfo(idesc->id_number);
413 proto.d_ino = iswap32(inp->i_parent);
414 if (newinofmt)
415 proto.d_type = DT_DIR;
416 else
417 proto.d_type = 0;
418 proto.d_namlen = 2;
419 (void)strlcpy(proto.d_name, "..", sizeof(proto.d_name));
420 #if BYTE_ORDER == LITTLE_ENDIAN
421 if (!newinofmt && !needswap) {
422 #else
423 if (!newinofmt && needswap) {
424 #endif
425 u_char tmp;
426
427 tmp = proto.d_type;
428 proto.d_type = proto.d_namlen;
429 proto.d_namlen = tmp;
430 }
431 entrysize = DIRSIZ(0, &proto, 0);
432 if (idesc->id_entryno == 0) {
433 n = DIRSIZ(0, dirp, 0);
434 if (iswap16(dirp->d_reclen) < n + entrysize)
435 goto chk2;
436 proto.d_reclen = iswap16(iswap16(dirp->d_reclen) - n);
437 dirp->d_reclen = iswap16(n);
438 idesc->id_entryno++;
439 inoinfo(iswap32(dirp->d_ino))->ino_linkcnt--;
440 dirp = (struct direct *)((char *)(dirp) + n);
441 memset(dirp, 0, (size_t)iswap16(proto.d_reclen));
442 dirp->d_reclen = proto.d_reclen;
443 }
444 if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
445 inp->i_dotdot = iswap32(dirp->d_ino);
446 if (newinofmt && dirp->d_type != DT_DIR) {
447 direrror(idesc->id_number, "BAD TYPE VALUE FOR '..'");
448 dirp->d_type = DT_DIR;
449 if (reply("FIX") == 1)
450 ret |= ALTERED;
451 else
452 markclean = 0;
453 }
454 goto chk2;
455 }
456 if (iswap32(dirp->d_ino) != 0 && strcmp(dirp->d_name, ".") != 0) {
457 fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
458 pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
459 dirp->d_name);
460 inp->i_dotdot = (ino_t)-1;
461 markclean = 0;
462 } else if (iswap16(dirp->d_reclen) < entrysize) {
463 fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
464 pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '..'\n");
465 inp->i_dotdot = (ino_t)-1;
466 markclean = 0;
467 } else if (inp->i_parent != 0) {
468 /*
469 * We know the parent, so fix now.
470 */
471 inp->i_dotdot = inp->i_parent;
472 fileerror(inp->i_parent, idesc->id_number, "MISSING '..'");
473 proto.d_reclen = dirp->d_reclen;
474 memmove(dirp, &proto, (size_t)entrysize);
475 if (reply("FIX") == 1)
476 ret |= ALTERED;
477 else
478 markclean = 0;
479 }
480 idesc->id_entryno++;
481 if (dirp->d_ino != 0)
482 inoinfo(iswap32(dirp->d_ino))->ino_linkcnt--;
483 return (ret|KEEPON);
484 chk2:
485 if (dirp->d_ino == 0)
486 return (ret|KEEPON);
487 if (dirp->d_namlen <= 2 &&
488 dirp->d_name[0] == '.' &&
489 idesc->id_entryno >= 2) {
490 if (dirp->d_namlen == 1) {
491 direrror(idesc->id_number, "EXTRA '.' ENTRY");
492 dirp->d_ino = 0;
493 if (reply("FIX") == 1)
494 ret |= ALTERED;
495 else
496 markclean = 0;
497 return (KEEPON | ret);
498 }
499 if (dirp->d_name[1] == '.') {
500 direrror(idesc->id_number, "EXTRA '..' ENTRY");
501 dirp->d_ino = 0;
502 if (reply("FIX") == 1)
503 ret |= ALTERED;
504 else
505 markclean = 0;
506 return (KEEPON | ret);
507 }
508 }
509 idesc->id_entryno++;
510 n = 0;
511 if (iswap32(dirp->d_ino) > maxino) {
512 fileerror(idesc->id_number, dirp->d_ino, "I OUT OF RANGE");
513 n = reply("REMOVE");
514 if (n == 0)
515 markclean = 0;
516 } else if (newinofmt &&
517 ((iswap32(dirp->d_ino) == WINO && dirp->d_type != DT_WHT) ||
518 (iswap32(dirp->d_ino) != WINO && dirp->d_type == DT_WHT))) {
519 fileerror(idesc->id_number, iswap32(dirp->d_ino), "BAD WHITEOUT ENTRY");
520 dirp->d_ino = iswap32(WINO);
521 dirp->d_type = DT_WHT;
522 if (reply("FIX") == 1)
523 ret |= ALTERED;
524 else
525 markclean = 0;
526 } else {
527 again:
528 info = inoinfo(iswap32(dirp->d_ino));
529 switch (info->ino_state) {
530 case USTATE:
531 if (idesc->id_entryno <= 2)
532 break;
533 fileerror(idesc->id_number, iswap32(dirp->d_ino), "UNALLOCATED");
534 n = reply("REMOVE");
535 if (n == 0)
536 markclean = 0;
537 break;
538
539 case DCLEAR:
540 case FCLEAR:
541 if (idesc->id_entryno <= 2)
542 break;
543 if (info->ino_state == FCLEAR)
544 errmsg = "DUP/BAD";
545 else if (!preen && !usedsoftdep)
546 errmsg = "ZERO LENGTH DIRECTORY";
547 else {
548 n = 1;
549 break;
550 }
551 fileerror(idesc->id_number, iswap32(dirp->d_ino), errmsg);
552 if ((n = reply("REMOVE")) == 1)
553 break;
554 dp = ginode(iswap32(dirp->d_ino));
555 info->ino_state =
556 (iswap16(DIP(dp, mode)) & IFMT) == IFDIR ? DSTATE : FSTATE;
557 info->ino_linkcnt = iswap16(DIP(dp, nlink));
558 goto again;
559
560 case DSTATE:
561 case DFOUND:
562 inp = getinoinfo(iswap32(dirp->d_ino));
563 if (inp->i_parent != 0 && idesc->id_entryno > 2) {
564 getpathname(pathbuf, sizeof(pathbuf),
565 idesc->id_number, idesc->id_number);
566 getpathname(namebuf, sizeof(namebuf),
567 iswap32(dirp->d_ino), iswap32(dirp->d_ino));
568 pwarn("%s %s %s\n", pathbuf,
569 "IS AN EXTRANEOUS HARD LINK TO DIRECTORY",
570 namebuf);
571 if (preen)
572 printf(" (IGNORED)\n");
573 else if ((n = reply("REMOVE")) == 1)
574 break;
575 }
576 if (idesc->id_entryno > 2)
577 inp->i_parent = idesc->id_number;
578 /* fall through */
579
580 case FSTATE:
581 if (newinofmt && dirp->d_type != info->ino_type) {
582 fileerror(idesc->id_number, iswap32(dirp->d_ino),
583 "BAD TYPE VALUE");
584 dirp->d_type = info->ino_type;
585 if (reply("FIX") == 1)
586 ret |= ALTERED;
587 else
588 markclean = 0;
589 }
590 info->ino_linkcnt--;
591 break;
592
593 default:
594 errexit("BAD STATE %d FOR INODE I=%d",
595 info->ino_state, iswap32(dirp->d_ino));
596 }
597 }
598 if (n == 0)
599 return (ret|KEEPON);
600 dirp->d_ino = 0;
601 return (ret|KEEPON|ALTERED);
602 }
603
604 /*
605 * Routine to sort disk blocks.
606 */
607 static int
608 blksort(const void *arg1, const void *arg2)
609 {
610
611 return ((*(const struct inoinfo *const *)arg1)->i_blks[0] -
612 (*(const struct inoinfo *const *)arg2)->i_blks[0]);
613 }
NetBSD on the FriendlyARM MINI2440