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