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 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 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 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
Indexes created Sat Sep 20 22:09:52 GMT 2025