1 /* $NetBSD: pass1.c,v 1.64 2023/07/04 20:40:53 riastradh 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[] = "@(#)pass1.c 8.6 (Berkeley) 4/28/95";
36 #else
37 __RCSID("$NetBSD: pass1.c,v 1.64 2023/07/04 20:40:53 riastradh Exp $");
38 #endif
39 #endif /* not lint */
40
41 #include <sys/param.h>
42 #include <sys/stat.h>
43 #include <sys/time.h>
44
45 #include <ufs/ufs/dinode.h>
46 #include <ufs/ufs/dir.h>
47 #include <ufs/ffs/fs.h>
48 #include <ufs/ufs/ufs_bswap.h>
49 #include <ufs/ffs/ffs_extern.h>
50
51 #include <err.h>
52 #include <stdio.h>
53 #include <stdlib.h>
54 #include <string.h>
55
56 #include "fsck.h"
57 #include "extern.h"
58 #include "fsutil.h"
59 #include "exitvalues.h"
60
61 static daddr_t badblk;
62 static daddr_t dupblk;
63 static void checkinode(ino_t, struct inodesc *);
64 static ino_t lastino;
65
66 void
pass1(void)67 pass1(void)
68 {
69 ino_t inumber, inosused, ninosused, ii;
70 size_t inospace;
71 uint32_t c;
72 daddr_t i, cgd;
73 struct inodesc idesc;
74 struct cg *cgp = cgrp;
75 struct inostat *info;
76 uint8_t *cp;
77
78 /*
79 * Set file system reserved blocks in used block map.
80 */
81 for (c = 0; c < sblock->fs_ncg; c++) {
82 cgd = cgdmin(sblock, c);
83 if (c == 0)
84 i = cgbase(sblock, c);
85 else
86 i = cgsblock(sblock, c);
87 for (; i < cgd; i++)
88 setbmap(i);
89 }
90 i = sblock->fs_csaddr;
91 cgd = i + howmany(sblock->fs_cssize, sblock->fs_fsize);
92 for (; i < cgd; i++)
93 setbmap(i);
94 /*
95 * Find all allocated blocks.
96 */
97 memset(&idesc, 0, sizeof(struct inodesc));
98 idesc.id_func = pass1check;
99 n_files = n_blks = 0;
100 for (c = 0; c < sblock->fs_ncg; c++) {
101 inumber = c * sblock->fs_ipg;
102 setinodebuf(inumber);
103 getblk(&cgblk, cgtod(sblock, c), sblock->fs_cgsize);
104 memcpy(cgp, cgblk.b_un.b_cg, sblock->fs_cgsize);
105 if((doswap && !needswap) || (!doswap && needswap))
106 ffs_cg_swap(cgblk.b_un.b_cg, cgp, sblock);
107 if (is_ufs2)
108 inosused = cgp->cg_initediblk;
109 else
110 inosused = sblock->fs_ipg;
111 if (got_siginfo) {
112 fprintf(stderr,
113 "%s: phase 1: cyl group %d of %d (%d%%)\n",
114 cdevname(), c, sblock->fs_ncg,
115 c * 100 / sblock->fs_ncg);
116 got_siginfo = 0;
117 }
118 #ifdef PROGRESS
119 progress_bar(cdevname(), preen ? NULL : "phase 1",
120 c, sblock->fs_ncg);
121 #endif /* PROGRESS */
122 /*
123 * If we are using soft updates, then we can trust the
124 * cylinder group inode allocation maps to tell us which
125 * inodes are allocated. We will scan the used inode map
126 * to find the inodes that are really in use, and then
127 * read only those inodes in from disk.
128 */
129 if (preen && usedsoftdep) {
130 if (!cg_chkmagic(cgp, 0))
131 pfatal("CG %d: BAD MAGIC NUMBER\n", c);
132 cp = &cg_inosused(cgp, 0)[(inosused - 1) / CHAR_BIT];
133 for ( ; inosused > 0; inosused -= CHAR_BIT, cp--) {
134 if (*cp == 0)
135 continue;
136 for (i = 1 << (CHAR_BIT - 1); i > 0; i >>= 1) {
137 if (*cp & i)
138 break;
139 inosused--;
140 }
141 break;
142 }
143 #ifdef notdef
144 if (inosused < 0)
145 inosused = 0;
146 #endif
147 }
148 /*
149 * Allocate inoinfo structures for the allocated inodes.
150 */
151 inostathead[c].il_numalloced = inosused;
152 if (inosused == 0) {
153 inostathead[c].il_stat = 0;
154 continue;
155 }
156 inospace = inosused * sizeof(*info);
157 if (inospace / sizeof(*info) != inosused) {
158 pfatal("too many inodes %llu\n", (unsigned long long)
159 inosused);
160 exit(FSCK_EXIT_CHECK_FAILED);
161 }
162 info = malloc(inospace);
163 if (info == NULL) {
164 pfatal("cannot alloc %zu bytes for inoinfo\n",
165 inospace);
166 exit(FSCK_EXIT_CHECK_FAILED);
167 }
168 (void)memset(info, 0, inospace);
169 inostathead[c].il_stat = info;
170 /*
171 * Scan the allocated inodes.
172 */
173 for (ii = 0; ii < inosused; ii++, inumber++) {
174 if (inumber < UFS_ROOTINO) {
175 (void)getnextinode(inumber);
176 continue;
177 }
178 checkinode(inumber, &idesc);
179 }
180 lastino += 1;
181 if (inosused < (ino_t)sblock->fs_ipg || inumber == lastino)
182 continue;
183 /*
184 * If we were not able to determine in advance which inodes
185 * were in use, then reduce the size of the inoinfo structure
186 * to the size necessary to describe the inodes that we
187 * really found.
188 */
189 if (lastino < (c * (ino_t)sblock->fs_ipg))
190 ninosused = 0;
191 else
192 ninosused = lastino - (c * sblock->fs_ipg);
193 inostathead[c].il_numalloced = ninosused;
194 if (ninosused == 0) {
195 free(inostathead[c].il_stat);
196 inostathead[c].il_stat = 0;
197 continue;
198 }
199 if (ninosused != inosused) {
200 struct inostat *ninfo;
201 size_t ninospace = ninosused * sizeof(*ninfo);
202 if (ninospace / sizeof(*info) != ninosused) {
203 pfatal("too many inodes %llu\n",
204 (unsigned long long)ninosused);
205 exit(FSCK_EXIT_CHECK_FAILED);
206 }
207 ninfo = realloc(info, ninospace);
208 if (ninfo == NULL) {
209 pfatal("cannot realloc %zu bytes to %zu "
210 "for inoinfo\n", inospace, ninospace);
211 exit(FSCK_EXIT_CHECK_FAILED);
212 }
213 if (ninosused > inosused)
214 (void)memset(&ninfo[inosused], 0, ninospace - inospace);
215 inostathead[c].il_stat = ninfo;
216 }
217 }
218 #ifdef PROGRESS
219 if (!preen)
220 progress_done();
221 #endif /* PROGRESS */
222 freeinodebuf();
223 #ifndef NO_FFS_EI
224 do_blkswap = 0; /* has been done */
225 #endif
226 }
227
228 static void
checkinode(ino_t inumber,struct inodesc * idesc)229 checkinode(ino_t inumber, struct inodesc *idesc)
230 {
231 union dinode *dp;
232 struct zlncnt *zlnp;
233 daddr_t ndb;
234 int j;
235 mode_t mode;
236 u_int64_t size, kernmaxfilesize;
237 int64_t blocks;
238 char symbuf[MAXBSIZE];
239 struct inostat *info;
240
241 dp = getnextinode(inumber);
242 info = inoinfo(inumber);
243 mode = iswap16(DIP(dp, mode)) & IFMT;
244 size = iswap64(DIP(dp, size));
245 if (mode == 0) {
246 if ((is_ufs2 &&
247 (memcmp(dp->dp2.di_db, ufs2_zino.di_db,
248 UFS_NDADDR * sizeof(int64_t)) ||
249 memcmp(dp->dp2.di_ib, ufs2_zino.di_ib,
250 UFS_NIADDR * sizeof(int64_t))))
251 ||
252 (!is_ufs2 &&
253 (memcmp(dp->dp1.di_db, ufs1_zino.di_db,
254 UFS_NDADDR * sizeof(int32_t)) ||
255 memcmp(dp->dp1.di_ib, ufs1_zino.di_ib,
256 UFS_NIADDR * sizeof(int32_t))))
257 ||
258 mode || size || DIP(dp, blocks)) {
259 pfatal("PARTIALLY ALLOCATED INODE I=%llu",
260 (unsigned long long)inumber);
261 if (reply("CLEAR") == 1) {
262 dp = ginode(inumber);
263 clearinode(dp);
264 inodirty();
265 } else
266 markclean = 0;
267 }
268 info->ino_state = USTATE;
269 return;
270 }
271 lastino = inumber;
272 /* This should match the file size limit in ffs_mountfs(). */
273 if (is_ufs2)
274 kernmaxfilesize = sblock->fs_maxfilesize;
275 else
276 kernmaxfilesize = (u_int64_t)0x80000000 * sblock->fs_bsize - 1;
277 if (size > kernmaxfilesize || size + sblock->fs_bsize - 1 < size ||
278 (mode == IFDIR && size > UFS_MAXDIRSIZE)) {
279 if (debug)
280 printf("bad size %llu:",(unsigned long long)size);
281 goto unknown;
282 }
283 if (!preen && mode == IFMT && reply("HOLD BAD BLOCK") == 1) {
284 dp = ginode(inumber);
285 DIP_SET(dp, size, iswap64(sblock->fs_fsize));
286 size = sblock->fs_fsize;
287 DIP_SET(dp, mode, iswap16(IFREG|0600));
288 inodirty();
289 }
290 ndb = howmany(size, sblock->fs_bsize);
291 if (ndb < 0) {
292 if (debug)
293 printf("bad size %llu ndb %lld:",
294 (unsigned long long)size, (long long)ndb);
295 goto unknown;
296 }
297 if (mode == IFBLK || mode == IFCHR)
298 ndb++;
299 if (mode == IFLNK) {
300 /*
301 * Note that the old fastlink format always had di_blocks set
302 * to 0. Other than that we no longer use the `spare' field
303 * (which is now the extended uid) for sanity checking, the
304 * new format is the same as the old. We simply ignore the
305 * conversion altogether. - mycroft, 19MAY1994
306 */
307 if (!is_ufs2 && doinglevel2 &&
308 size > 0 && size < UFS1_MAXSYMLINKLEN &&
309 DIP(dp, blocks) != 0) {
310 if (bread(fsreadfd, symbuf,
311 FFS_FSBTODB(sblock, iswap32(DIP(dp, db[0]))),
312 (long)secsize) != 0)
313 errexit("cannot read symlink");
314 if (debug) {
315 symbuf[size] = 0;
316 printf("convert symlink %llu(%s) "
317 "of size %lld\n",
318 (unsigned long long)inumber, symbuf,
319 (unsigned long long)size);
320 }
321 dp = ginode(inumber);
322 memmove(dp->dp1.di_db, symbuf, (long)size);
323 DIP_SET(dp, blocks, 0);
324 inodirty();
325 }
326 /*
327 * Fake ndb value so direct/indirect block checks below
328 * will detect any garbage after symlink string.
329 */
330 if ((sblock->fs_maxsymlinklen < 0) ||
331 (size < (uint64_t)sblock->fs_maxsymlinklen) ||
332 (isappleufs && (size < APPLEUFS_MAXSYMLINKLEN)) ||
333 (sblock->fs_maxsymlinklen == 0 && DIP(dp, blocks) == 0)) {
334 if (is_ufs2)
335 ndb = howmany(size, sizeof(int64_t));
336 else
337 ndb = howmany(size, sizeof(int32_t));
338 if (ndb > UFS_NDADDR) {
339 j = ndb - UFS_NDADDR;
340 for (ndb = 1; j > 1; j--)
341 ndb *= FFS_NINDIR(sblock);
342 ndb += UFS_NDADDR;
343 }
344 }
345 }
346 if (ndb < UFS_NDADDR) {
347 for (j = ndb; j < UFS_NDADDR; j++)
348 if (DIP(dp, db[j]) != 0) {
349 if (debug) {
350 if (!is_ufs2)
351 printf("bad direct addr ix %d: %d [ndb %lld]\n",
352 j, iswap32(dp->dp1.di_db[j]),
353 (long long)ndb);
354 else
355 printf("bad direct addr ix %d: %lld [ndb %lld]\n",
356 j, (long long)iswap64(dp->dp2.di_db[j]),
357 (long long)ndb);
358 }
359 goto unknown;
360 }
361 }
362
363 for (j = 0, ndb -= UFS_NDADDR; ndb > 0; j++)
364 ndb /= FFS_NINDIR(sblock);
365
366 for (; j < UFS_NIADDR; j++)
367 if (DIP(dp, ib[j]) != 0) {
368 if (debug) {
369 if (!is_ufs2)
370 printf("bad indirect addr: %d\n",
371 iswap32(dp->dp1.di_ib[j]));
372 else
373 printf("bad indirect addr: %lld\n",
374 (long long)iswap64(dp->dp2.di_ib[j]));
375 }
376 goto unknown;
377 }
378 if (ftypeok(dp) == 0)
379 goto unknown;
380 n_files++;
381 info->ino_linkcnt = iswap16(DIP(dp, nlink));
382 if (info->ino_linkcnt <= 0) {
383 zlnp = (struct zlncnt *)malloc(sizeof *zlnp);
384 if (zlnp == NULL) {
385 markclean = 0;
386 pfatal("LINK COUNT TABLE OVERFLOW");
387 if (reply("CONTINUE") == 0) {
388 ckfini(1);
389 exit(FSCK_EXIT_CHECK_FAILED);
390 }
391 } else {
392 zlnp->zlncnt = inumber;
393 zlnp->next = zlnhead;
394 zlnhead = zlnp;
395 }
396 }
397 if (mode == IFDIR) {
398 if (size == 0)
399 info->ino_state = DCLEAR;
400 else
401 info->ino_state = DSTATE;
402 cacheino(dp, inumber);
403 countdirs++;
404 } else
405 info->ino_state = FSTATE;
406 info->ino_type = IFTODT(mode);
407 if (!is_ufs2 && doinglevel2 &&
408 (iswap16(dp->dp1.di_ouid) != (u_short)-1 ||
409 iswap16(dp->dp1.di_ogid) != (u_short)-1)) {
410 dp = ginode(inumber);
411 dp->dp1.di_uid = iswap32(iswap16(dp->dp1.di_ouid));
412 dp->dp1.di_ouid = iswap16(-1);
413 dp->dp1.di_gid = iswap32(iswap16(dp->dp1.di_ogid));
414 dp->dp1.di_ogid = iswap16(-1);
415 inodirty();
416 }
417 badblk = dupblk = 0;
418 idesc->id_number = inumber;
419 idesc->id_uid = iswap32(DIP(dp, uid));
420 idesc->id_gid = iswap32(DIP(dp, gid));
421 if (iswap32(DIP(dp, flags)) & SF_SNAPSHOT)
422 idesc->id_type = SNAP;
423 else
424 idesc->id_type = ADDR;
425 (void)ckinode(dp, idesc);
426 if (is_ufs2 && (!is_ufs2ea || doing2noea) &&
427 (iswap32(dp->dp2.di_extsize) != 0 ||
428 iswap64(dp->dp2.di_extb[0]) != 0 ||
429 iswap64(dp->dp2.di_extb[1]) != 0)) {
430 pfatal("NON-ZERO EXTATTR FIELDS I=%llu",
431 (unsigned long long)inumber);
432 if (!reply("CLEAR EXTATTR FIELDS AND SET PERMS TO 0")) {
433 markclean = 0;
434 return;
435 }
436 dp = ginode(inumber);
437 dp->dp2.di_extsize = iswap32(0);
438 dp->dp2.di_extb[0] = iswap64(0);
439 dp->dp2.di_extb[1] = iswap64(0);
440 dp->dp2.di_mode &= iswap16(IFMT);
441 inodirty();
442 }
443 if (is_ufs2ea && iswap32(dp->dp2.di_extsize) > 0) {
444 int ret, offset;
445 idesc->id_type = ADDR;
446 ndb = howmany(iswap32(dp->dp2.di_extsize), sblock->fs_bsize);
447 for (j = 0; j < UFS_NXADDR; j++) {
448 if (--ndb == 0 &&
449 (offset = ffs_blkoff(sblock, iswap32(dp->dp2.di_extsize))) != 0)
450 idesc->id_numfrags = ffs_numfrags(sblock,
451 ffs_fragroundup(sblock, offset));
452 else
453 idesc->id_numfrags = sblock->fs_frag;
454 if (dp->dp2.di_extb[j] == 0)
455 continue;
456 idesc->id_blkno = iswap64(dp->dp2.di_extb[j]);
457 ret = (*idesc->id_func)(idesc);
458 if (ret & STOP)
459 break;
460 }
461 }
462 idesc->id_entryno *= btodb(sblock->fs_fsize);
463 if (is_ufs2)
464 blocks = iswap64(dp->dp2.di_blocks);
465 else
466 blocks = iswap32(dp->dp1.di_blocks);
467 if (blocks != idesc->id_entryno) {
468 pwarn("INCORRECT BLOCK COUNT I=%llu (%lld should be %lld)",
469 (unsigned long long)inumber, (long long)blocks,
470 (long long)idesc->id_entryno);
471 if (preen)
472 printf(" (CORRECTED)\n");
473 else if (reply("CORRECT") == 0) {
474 markclean = 0;
475 return;
476 }
477 dp = ginode(inumber);
478 if (is_ufs2)
479 dp->dp2.di_blocks = iswap64(idesc->id_entryno);
480 else
481 dp->dp1.di_blocks = iswap32((int32_t)idesc->id_entryno);
482 inodirty();
483 }
484 if (idesc->id_type != SNAP)
485 update_uquot(inumber, idesc->id_uid, idesc->id_gid,
486 idesc->id_entryno, 1);
487 return;
488 unknown:
489 pfatal("UNKNOWN FILE TYPE I=%llu", (unsigned long long)inumber);
490 info->ino_state = FCLEAR;
491 if (reply("CLEAR") == 1) {
492 info->ino_state = USTATE;
493 dp = ginode(inumber);
494 clearinode(dp);
495 inodirty();
496 } else
497 markclean = 0;
498 }
499
500 int
pass1check(struct inodesc * idesc)501 pass1check(struct inodesc *idesc)
502 {
503 int res = KEEPON;
504 int anyout, nfrags;
505 daddr_t blkno = idesc->id_blkno;
506 struct dups *dlp;
507 struct dups *new;
508
509 if (idesc->id_type == SNAP) {
510 if (blkno == BLK_NOCOPY || blkno == BLK_SNAP)
511 return (KEEPON);
512 }
513 if ((anyout = chkrange(blkno, idesc->id_numfrags)) != 0) {
514 blkerror(idesc->id_number, "BAD", blkno);
515 if (badblk++ >= MAXBAD) {
516 pwarn("EXCESSIVE BAD BLKS I=%llu",
517 (unsigned long long)idesc->id_number);
518 if (preen)
519 printf(" (SKIPPING)\n");
520 else if (reply("CONTINUE") == 0) {
521 markclean = 0;
522 ckfini(1);
523 exit(FSCK_EXIT_CHECK_FAILED);
524 }
525 return (STOP);
526 }
527 }
528 for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
529 if (anyout && chkrange(blkno, 1)) {
530 res = SKIP;
531 } else if (!testbmap(blkno)) {
532 n_blks++;
533 setbmap(blkno);
534 } else {
535 blkerror(idesc->id_number, "DUP", blkno);
536 if (dupblk++ >= MAXDUP) {
537 pwarn("EXCESSIVE DUP BLKS I=%llu",
538 (unsigned long long)idesc->id_number);
539 if (preen)
540 printf(" (SKIPPING)\n");
541 else if (reply("CONTINUE") == 0) {
542 markclean = 0;
543 ckfini(1);
544 exit(FSCK_EXIT_CHECK_FAILED);
545 }
546 return (STOP);
547 }
548 new = (struct dups *)malloc(sizeof(struct dups));
549 if (new == NULL) {
550 markclean = 0;
551 pfatal("DUP TABLE OVERFLOW.");
552 if (reply("CONTINUE") == 0) {
553 markclean = 0;
554 ckfini(1);
555 exit(FSCK_EXIT_CHECK_FAILED);
556 }
557 return (STOP);
558 }
559 new->dup = blkno;
560 if (muldup == 0) {
561 duplist = muldup = new;
562 new->next = 0;
563 } else {
564 new->next = muldup->next;
565 muldup->next = new;
566 }
567 for (dlp = duplist; dlp != muldup; dlp = dlp->next)
568 if (dlp->dup == blkno)
569 break;
570 if (dlp == muldup && dlp->dup != blkno)
571 muldup = new;
572 }
573 /*
574 * count the number of blocks found in id_entryno
575 */
576 idesc->id_entryno++;
577 }
578 return (res);
579 }
580