1 /* $NetBSD: pass5.c,v 1.58 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[] = "@(#)pass5.c 8.9 (Berkeley) 4/28/95"; 36 #else 37 __RCSID("$NetBSD: pass5.c,v 1.58 2023/07/04 20:40:53 riastradh 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/ffs/fs.h> 46 #include <ufs/ffs/ffs_extern.h> 47 #include <ufs/ufs/ufs_bswap.h> 48 49 #include <err.h> 50 #include <string.h> 51 #include <stdlib.h> 52 53 #include "fsutil.h" 54 #include "fsck.h" 55 #include "extern.h" 56 57 void print_bmap(u_char *,u_int32_t); 58 59 void 60 pass5(void) 61 { 62 int blk, frags, basesize, sumsize, mapsize, cssize; 63 uint32_t inomapsize, blkmapsize; 64 uint32_t c; 65 struct fs *fs = sblock; 66 daddr_t dbase, dmax; 67 daddr_t d; 68 uint32_t i; 69 int32_t j; 70 int k; 71 ino_t inum; 72 struct csum *cs; 73 struct csum_total cstotal; 74 struct inodesc idesc[4]; 75 char buf[MAXBSIZE]; 76 struct cg *newcg = (struct cg *)buf; 77 struct ocg *ocg = (struct ocg *)buf; 78 struct cg *cg = cgrp, *ncg; 79 struct inostat *info; 80 u_int32_t ncgsize; 81 82 inoinfo(UFS_WINO)->ino_state = USTATE; 83 memset(newcg, 0, (size_t)fs->fs_cgsize); 84 newcg->cg_niblk = fs->fs_ipg; 85 if (cvtlevel >= 3) { 86 if (fs->fs_maxcontig < 2 && fs->fs_contigsumsize > 0) { 87 if (preen) 88 pwarn("DELETING CLUSTERING MAPS\n"); 89 if (preen || reply("DELETE CLUSTERING MAPS")) { 90 fs->fs_contigsumsize = 0; 91 doinglevel1 = 1; 92 sbdirty(); 93 } 94 } 95 if (fs->fs_maxcontig > 1) { 96 const char *doit = NULL; 97 98 if (fs->fs_contigsumsize < 1) { 99 doit = "CREAT"; 100 } else if (fs->fs_contigsumsize < fs->fs_maxcontig && 101 fs->fs_contigsumsize < FS_MAXCONTIG) { 102 doit = "EXPAND"; 103 } 104 if (doit) { 105 i = fs->fs_contigsumsize; 106 fs->fs_contigsumsize = 107 MIN(fs->fs_maxcontig, FS_MAXCONTIG); 108 if (CGSIZE(fs) > (uint32_t)fs->fs_bsize) { 109 pwarn("CANNOT %s CLUSTER MAPS\n", doit); 110 fs->fs_contigsumsize = i; 111 } else if (preen || 112 reply("CREATE CLUSTER MAPS")) { 113 if (preen) 114 pwarn("%sING CLUSTER MAPS\n", 115 doit); 116 ncgsize = ffs_fragroundup(fs, CGSIZE(fs)); 117 ncg = realloc(cgrp, ncgsize); 118 if (ncg == NULL) 119 errexit( 120 "cannot reallocate cg space"); 121 cg = cgrp = ncg; 122 fs->fs_cgsize = ncgsize; 123 doinglevel1 = 1; 124 sbdirty(); 125 } 126 } 127 } 128 } 129 basesize = &newcg->cg_space[0] - (u_char *)(&newcg->cg_firstfield); 130 cssize = (u_char *)&cstotal.cs_spare[0] - (u_char *)&cstotal.cs_ndir; 131 sumsize = 0; 132 if (is_ufs2) { 133 newcg->cg_iusedoff = basesize; 134 } else { 135 /* 136 * We reserve the space for the old rotation summary 137 * tables for the benefit of old kernels, but do not 138 * maintain them in modern kernels. In time, they can 139 * go away. 140 */ 141 newcg->cg_old_btotoff = basesize; 142 newcg->cg_old_boff = newcg->cg_old_btotoff + 143 fs->fs_old_cpg * sizeof(int32_t); 144 newcg->cg_iusedoff = newcg->cg_old_boff + 145 fs->fs_old_cpg * fs->fs_old_nrpos * sizeof(u_int16_t); 146 memset(&newcg->cg_space[0], 0, newcg->cg_iusedoff - basesize); 147 } 148 inomapsize = howmany(fs->fs_ipg, CHAR_BIT); 149 newcg->cg_freeoff = newcg->cg_iusedoff + inomapsize; 150 blkmapsize = howmany(fs->fs_fpg, CHAR_BIT); 151 newcg->cg_nextfreeoff = newcg->cg_freeoff + blkmapsize; 152 if (fs->fs_contigsumsize > 0) { 153 newcg->cg_clustersumoff = newcg->cg_nextfreeoff - 154 sizeof(u_int32_t); 155 if (isappleufs) { 156 /* Apple PR2216969 gives rationale for this change. 157 * I believe they were mistaken, but we need to 158 * duplicate it for compatibility. -- dbj (at) NetBSD.org 159 */ 160 newcg->cg_clustersumoff += sizeof(u_int32_t); 161 } 162 newcg->cg_clustersumoff = 163 roundup(newcg->cg_clustersumoff, sizeof(u_int32_t)); 164 newcg->cg_clusteroff = newcg->cg_clustersumoff + 165 (fs->fs_contigsumsize + 1) * sizeof(u_int32_t); 166 newcg->cg_nextfreeoff = newcg->cg_clusteroff + 167 howmany(ffs_fragstoblks(fs, fs->fs_fpg), CHAR_BIT); 168 } 169 newcg->cg_magic = CG_MAGIC; 170 mapsize = newcg->cg_nextfreeoff - newcg->cg_iusedoff; 171 if (!is_ufs2 && ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0)) { 172 switch ((int)fs->fs_old_postblformat) { 173 174 case FS_42POSTBLFMT: 175 basesize = (char *)(&ocg->cg_btot[0]) - 176 (char *)(&ocg->cg_firstfield); 177 sumsize = &ocg->cg_iused[0] - (u_int8_t *)(&ocg->cg_btot[0]); 178 mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] - 179 (u_char *)&ocg->cg_iused[0]; 180 blkmapsize = howmany(fs->fs_fpg, NBBY); 181 inomapsize = &ocg->cg_free[0] - (u_char *)&ocg->cg_iused[0]; 182 ocg->cg_magic = CG_MAGIC; 183 newcg->cg_magic = 0; 184 break; 185 186 case FS_DYNAMICPOSTBLFMT: 187 sumsize = newcg->cg_iusedoff - newcg->cg_old_btotoff; 188 break; 189 190 default: 191 errexit("UNKNOWN ROTATIONAL TABLE FORMAT %d", 192 fs->fs_old_postblformat); 193 } 194 } 195 memset(&idesc[0], 0, sizeof idesc); 196 for (i = 0; i < 4; i++) { 197 idesc[i].id_type = ADDR; 198 if (!is_ufs2 && doinglevel2) 199 idesc[i].id_fix = FIX; 200 } 201 memset(&cstotal, 0, sizeof(struct csum_total)); 202 dmax = ffs_blknum(fs, fs->fs_size + fs->fs_frag - 1); 203 for (d = fs->fs_size; d < dmax; d++) 204 setbmap(d); 205 for (c = 0; c < fs->fs_ncg; c++) { 206 if (got_siginfo) { 207 fprintf(stderr, 208 "%s: phase 5: cyl group %d of %d (%d%%)\n", 209 cdevname(), c, fs->fs_ncg, 210 c * 100 / fs->fs_ncg); 211 got_siginfo = 0; 212 } 213 #ifdef PROGRESS 214 progress_bar(cdevname(), preen ? NULL : "phase 5", 215 c, fs->fs_ncg); 216 #endif /* PROGRESS */ 217 getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize); 218 memcpy(cg, cgblk.b_un.b_cg, fs->fs_cgsize); 219 if((doswap && !needswap) || (!doswap && needswap)) 220 ffs_cg_swap(cgblk.b_un.b_cg, cg, sblock); 221 if (!doinglevel1 && !cg_chkmagic(cg, 0)) 222 pfatal("CG %d: PASS5: BAD MAGIC NUMBER\n", c); 223 if(doswap) 224 cgdirty(); 225 /* 226 * While we have the disk head where we want it, 227 * write back the superblock to the spare at this 228 * cylinder group. 229 */ 230 if ((cvtlevel && sblk.b_dirty) || doswap || doing2ea || doing2noea) { 231 bwrite(fswritefd, sblk.b_un.b_buf, 232 FFS_FSBTODB(sblock, cgsblock(sblock, c)), 233 sblock->fs_sbsize); 234 } else { 235 int alt_ufs2ea = 0; 236 237 /* 238 * Read in the current alternate superblock, 239 * and compare it to the master. If it's 240 * wrong, fix it up. 241 */ 242 getblk(&asblk, cgsblock(sblock, c), sblock->fs_sbsize); 243 if (asblk.b_errs) 244 pfatal("CG %d: UNABLE TO READ ALTERNATE " 245 "SUPERBLK\n", c); 246 else { 247 memmove(altsblock, asblk.b_un.b_fs, 248 sblock->fs_sbsize); 249 if (needswap) 250 ffs_sb_swap(asblk.b_un.b_fs, altsblock); 251 if (altsblock->fs_magic == FS_UFS2EA_MAGIC) { 252 altsblock->fs_magic = FS_UFS2_MAGIC; 253 alt_ufs2ea = 1; 254 } 255 } 256 sb_oldfscompat_write(sblock, sblocksave); 257 if ((asblk.b_errs || cmpsblks(sblock, altsblock) || 258 is_ufs2ea != alt_ufs2ea) && 259 dofix(&idesc[3], 260 "ALTERNATE SUPERBLK(S) ARE INCORRECT")) { 261 bwrite(fswritefd, sblk.b_un.b_buf, 262 FFS_FSBTODB(sblock, cgsblock(sblock, c)), 263 sblock->fs_sbsize); 264 } 265 sb_oldfscompat_read(sblock, 0); 266 } 267 dbase = cgbase(fs, c); 268 dmax = dbase + fs->fs_fpg; 269 if (dmax > fs->fs_size) 270 dmax = fs->fs_size; 271 if (is_ufs2 || (fs->fs_old_flags & FS_FLAGS_UPDATED)) 272 newcg->cg_time = cg->cg_time; 273 newcg->cg_old_time = cg->cg_old_time; 274 newcg->cg_cgx = c; 275 newcg->cg_ndblk = dmax - dbase; 276 if (!is_ufs2) { 277 if (c == fs->fs_ncg - 1) { 278 /* Avoid fighting old fsck for this value. Its never used 279 * outside of this check anyway. 280 */ 281 if ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) 282 newcg->cg_old_ncyl = fs->fs_old_ncyl % fs->fs_old_cpg; 283 else 284 newcg->cg_old_ncyl = howmany(newcg->cg_ndblk, 285 fs->fs_fpg / fs->fs_old_cpg); 286 } else 287 newcg->cg_old_ncyl = fs->fs_old_cpg; 288 newcg->cg_old_niblk = fs->fs_ipg; 289 newcg->cg_niblk = 0; 290 } 291 if (fs->fs_contigsumsize > 0) 292 newcg->cg_nclusterblks = newcg->cg_ndblk / fs->fs_frag; 293 newcg->cg_cs.cs_ndir = 0; 294 newcg->cg_cs.cs_nffree = 0; 295 newcg->cg_cs.cs_nbfree = 0; 296 newcg->cg_cs.cs_nifree = fs->fs_ipg; 297 if (cg->cg_rotor < newcg->cg_ndblk) 298 newcg->cg_rotor = cg->cg_rotor; 299 else 300 newcg->cg_rotor = 0; 301 if (cg->cg_frotor < newcg->cg_ndblk) 302 newcg->cg_frotor = cg->cg_frotor; 303 else 304 newcg->cg_frotor = 0; 305 if (cg->cg_irotor < fs->fs_ipg) 306 newcg->cg_irotor = cg->cg_irotor; 307 else 308 newcg->cg_irotor = 0; 309 if (!is_ufs2) { 310 newcg->cg_initediblk = 0; 311 } else { 312 if ((unsigned)cg->cg_initediblk > (unsigned)fs->fs_ipg) 313 newcg->cg_initediblk = fs->fs_ipg; 314 else 315 newcg->cg_initediblk = cg->cg_initediblk; 316 } 317 memset(&newcg->cg_frsum[0], 0, sizeof newcg->cg_frsum); 318 memset(&old_cg_blktot(newcg, 0)[0], 0, (size_t)(sumsize)); 319 memset(cg_inosused(newcg, 0), 0, (size_t)(mapsize)); 320 if (!is_ufs2 && ((fs->fs_old_flags & FS_FLAGS_UPDATED) == 0) && 321 fs->fs_old_postblformat == FS_42POSTBLFMT) 322 ocg->cg_magic = CG_MAGIC; 323 inum = fs->fs_ipg * c; 324 for (i = 0; i < fs->fs_ipg; inum++, i++) { 325 info = inoinfo(inum); 326 switch (info->ino_state) { 327 328 case USTATE: 329 break; 330 331 case DSTATE: 332 case DCLEAR: 333 case DFOUND: 334 newcg->cg_cs.cs_ndir++; 335 /* fall through */ 336 337 case FSTATE: 338 case FCLEAR: 339 newcg->cg_cs.cs_nifree--; 340 setbit(cg_inosused(newcg, 0), i); 341 break; 342 343 default: 344 if (inum < UFS_ROOTINO) 345 break; 346 errexit("BAD STATE %d FOR INODE I=%ju", 347 info->ino_state, (uintmax_t)inum); 348 } 349 } 350 if (c == 0) 351 for (i = 0; i < UFS_ROOTINO; i++) { 352 setbit(cg_inosused(newcg, 0), i); 353 newcg->cg_cs.cs_nifree--; 354 } 355 for (i = 0, d = dbase; 356 d < dmax; 357 d += fs->fs_frag, i += fs->fs_frag) { 358 frags = 0; 359 for (j = 0; j < fs->fs_frag; j++) { 360 if (testbmap(d + j)) 361 continue; 362 setbit(cg_blksfree(newcg, 0), i + j); 363 frags++; 364 } 365 if (frags == fs->fs_frag) { 366 newcg->cg_cs.cs_nbfree++; 367 if (sumsize) { 368 j = old_cbtocylno(fs, i); 369 old_cg_blktot(newcg, 0)[j]++; 370 old_cg_blks(fs, newcg, j, 0)[old_cbtorpos(fs, i)]++; 371 } 372 if (fs->fs_contigsumsize > 0) 373 setbit(cg_clustersfree(newcg, 0), 374 ffs_fragstoblks(fs, i)); 375 } else if (frags > 0) { 376 newcg->cg_cs.cs_nffree += frags; 377 blk = blkmap(fs, cg_blksfree(newcg, 0), i); 378 ffs_fragacct(fs, blk, newcg->cg_frsum, 1, 0); 379 } 380 } 381 if (fs->fs_contigsumsize > 0) { 382 int32_t *sump = cg_clustersum(newcg, 0); 383 u_char *mapp = cg_clustersfree(newcg, 0); 384 int map = *mapp++; 385 int bit = 1; 386 int run = 0; 387 388 for (i = 0; i < newcg->cg_nclusterblks; i++) { 389 if ((map & bit) != 0) { 390 run++; 391 } else if (run != 0) { 392 if (run > fs->fs_contigsumsize) 393 run = fs->fs_contigsumsize; 394 sump[run]++; 395 run = 0; 396 } 397 if ((i & (NBBY - 1)) != (NBBY - 1)) { 398 bit <<= 1; 399 } else { 400 map = *mapp++; 401 bit = 1; 402 } 403 } 404 if (run != 0) { 405 if (run > fs->fs_contigsumsize) 406 run = fs->fs_contigsumsize; 407 sump[run]++; 408 } 409 } 410 cstotal.cs_nffree += newcg->cg_cs.cs_nffree; 411 cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree; 412 cstotal.cs_nifree += newcg->cg_cs.cs_nifree; 413 cstotal.cs_ndir += newcg->cg_cs.cs_ndir; 414 cs = &fs->fs_cs(fs, c); 415 if (memcmp(&newcg->cg_cs, cs, sizeof *cs) != 0) { 416 if (debug) { 417 printf("cg %d: nffree: %d/%d nbfree %d/%d" 418 " nifree %d/%d ndir %d/%d\n", 419 c, cs->cs_nffree,newcg->cg_cs.cs_nffree, 420 cs->cs_nbfree,newcg->cg_cs.cs_nbfree, 421 cs->cs_nifree,newcg->cg_cs.cs_nifree, 422 cs->cs_ndir,newcg->cg_cs.cs_ndir); 423 } 424 if (dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) { 425 memmove(cs, &newcg->cg_cs, sizeof *cs); 426 sbdirty(); 427 } else 428 markclean = 0; 429 } 430 if (doinglevel1) { 431 memmove(cg, newcg, (size_t)fs->fs_cgsize); 432 cgdirty(); 433 continue; 434 } 435 if ((memcmp(newcg, cg, basesize) != 0) || 436 (memcmp(&old_cg_blktot(newcg, 0)[0], 437 &old_cg_blktot(cg, 0)[0], sumsize) != 0)) { 438 if (dofix(&idesc[2], "SUMMARY INFORMATION BAD")) { 439 memmove(cg, newcg, (size_t)basesize); 440 memmove(&old_cg_blktot(cg, 0)[0], 441 &old_cg_blktot(newcg, 0)[0], (size_t)sumsize); 442 cgdirty(); 443 } else 444 markclean = 0; 445 } 446 if (usedsoftdep) { 447 for (i = 0; i < inomapsize; i++) { 448 j = cg_inosused(newcg, 0)[i]; 449 if ((cg_inosused(cg, 0)[i] & j) == j) 450 continue; 451 for (k = 0; k < NBBY; k++) { 452 if ((j & (1 << k)) == 0) 453 continue; 454 if (cg_inosused(cg, 0)[i] & (1 << k)) 455 continue; 456 pwarn("ALLOCATED INODE %u " 457 "MARKED FREE\n", 458 c * fs->fs_ipg + i * 8 + k); 459 } 460 } 461 for (i = 0; i < blkmapsize; i++) { 462 j = cg_blksfree(cg, 0)[i]; 463 if ((cg_blksfree(newcg, 0)[i] & j) == j) 464 continue; 465 for (k = 0; k < NBBY; k++) { 466 if ((j & (1 << k)) == 0) 467 continue; 468 if (cg_inosused(cg, 0)[i] & (1 << k)) 469 continue; 470 pwarn("ALLOCATED FRAG %u " 471 "MARKED FREE\n", 472 c * fs->fs_fpg + i * 8 + k); 473 } 474 } 475 } 476 if (memcmp(cg_inosused(newcg, 0), cg_inosused(cg, 0), mapsize) 477 != 0 && dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) { 478 memmove(cg_inosused(cg, 0), cg_inosused(newcg, 0), 479 (size_t)mapsize); 480 cgdirty(); 481 } 482 } 483 if (memcmp(&cstotal, &fs->fs_cstotal, cssize) != 0) { 484 if (debug) { 485 printf("total: nffree: %lld/%lld nbfree %lld/%lld" 486 " nifree %lld/%lld ndir %lld/%lld\n", 487 (long long int)fs->fs_cstotal.cs_nffree, 488 (long long int)cstotal.cs_nffree, 489 (long long int)fs->fs_cstotal.cs_nbfree, 490 (long long int)cstotal.cs_nbfree, 491 (long long int)fs->fs_cstotal.cs_nifree, 492 (long long int)cstotal.cs_nifree, 493 (long long int)fs->fs_cstotal.cs_ndir, 494 (long long int)cstotal.cs_ndir); 495 } 496 if (dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) { 497 memmove(&fs->fs_cstotal, &cstotal, sizeof cstotal); 498 fs->fs_ronly = 0; 499 fs->fs_fmod = 0; 500 sbdirty(); 501 } else 502 markclean = 0; 503 } 504 #ifdef PROGRESS 505 if (!preen) 506 progress_done(); 507 #endif /* PROGRESS */ 508 } 509 510 void 511 print_bmap(u_char *map, uint32_t size) 512 { 513 uint32_t i, j; 514 515 i = 0; 516 while (i < size) { 517 printf("%u: ",i); 518 for (j = 0; j < 16; j++, i++) 519 printf("%2x ", (u_int)map[i] & 0xff); 520 printf("\n"); 521 } 522 } 523
Indexes created Wed Oct 01 07:09:59 GMT 2025