pass5.c revision 1.35
1 /* $NetBSD: pass5.c,v 1.35 2003/04/04 13:45:21 fvdl 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. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by the University of 18 * California, Berkeley and its contributors. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #include <sys/cdefs.h> 37 #ifndef lint 38 #if 0 39 static char sccsid[] = "@(#)pass5.c 8.9 (Berkeley) 4/28/95"; 40 #else 41 __RCSID("$NetBSD: pass5.c,v 1.35 2003/04/04 13:45:21 fvdl Exp $"); 42 #endif 43 #endif /* not lint */ 44 45 #include <sys/param.h> 46 #include <sys/time.h> 47 48 #include <ufs/ufs/dinode.h> 49 #include <ufs/ffs/fs.h> 50 #include <ufs/ffs/ffs_extern.h> 51 #include <ufs/ufs/ufs_bswap.h> 52 53 #include <err.h> 54 #include <string.h> 55 #include <malloc.h> 56 57 #include "fsutil.h" 58 #include "fsck.h" 59 #include "extern.h" 60 61 void print_bmap __P((u_char *,u_int32_t)); 62 static void dumpcg(struct cg *cg); 63 static void dumptotal(struct csum_total *cs); 64 65 void 66 pass5(void) 67 { 68 int c, blk, frags, basesize, mapsize; 69 int inomapsize, blkmapsize; 70 struct fs *fs = sblock; 71 daddr_t dbase, dmax; 72 daddr_t d; 73 long i, j, k; 74 struct csum *cs; 75 struct csum_total cstotal; 76 struct inodesc idesc[4]; 77 char buf[MAXBSIZE]; 78 struct cg *newcg = (struct cg *)buf; 79 struct cg *cg = cgrp; 80 struct inostat *info; 81 82 inoinfo(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 char *doit = 0; 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) > 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 fs->fs_cgsize = 117 fragroundup(fs, CGSIZE(fs)); 118 cg = cgrp = 119 realloc(cgrp, fs->fs_cgsize); 120 if (cg == NULL) 121 errx(EEXIT, 122 "cannot reallocate cg space"); 123 doinglevel1 = 1; 124 sbdirty(); 125 } 126 } 127 } 128 } 129 basesize = &newcg->cg_space[0] - (u_char *)(&newcg->cg_firstfield); 130 if (is_ufs2) { 131 newcg->cg_iusedoff = basesize; 132 } else { 133 /* 134 * We reserve the space for the old rotation summary 135 * tables for the benefit of old kernels, but do not 136 * maintain them in modern kernels. In time, they can 137 * go away. 138 */ 139 newcg->cg_old_btotoff = basesize; 140 newcg->cg_old_boff = newcg->cg_old_btotoff + 141 fs->fs_old_cpg * sizeof(int32_t); 142 newcg->cg_iusedoff = newcg->cg_old_boff + 143 fs->fs_old_cpg * fs->fs_old_nrpos * sizeof(u_int16_t); 144 memset(&newcg->cg_space[0], 0, newcg->cg_iusedoff - basesize); 145 } 146 inomapsize = howmany(fs->fs_ipg, CHAR_BIT); 147 newcg->cg_freeoff = newcg->cg_iusedoff + inomapsize; 148 blkmapsize = howmany(fs->fs_fpg, CHAR_BIT); 149 newcg->cg_nextfreeoff = newcg->cg_freeoff + blkmapsize; 150 if (fs->fs_contigsumsize > 0) { 151 newcg->cg_clustersumoff = newcg->cg_nextfreeoff - 152 sizeof(u_int32_t); 153 newcg->cg_clustersumoff = 154 roundup(newcg->cg_clustersumoff, sizeof(u_int32_t)); 155 newcg->cg_clusteroff = newcg->cg_clustersumoff + 156 (fs->fs_contigsumsize + 1) * sizeof(u_int32_t); 157 newcg->cg_nextfreeoff = newcg->cg_clusteroff + 158 howmany(fragstoblks(fs, fs->fs_fpg), CHAR_BIT); 159 } 160 newcg->cg_magic = CG_MAGIC; 161 mapsize = newcg->cg_nextfreeoff - newcg->cg_iusedoff; 162 memset(&idesc[0], 0, sizeof idesc); 163 for (i = 0; i < 4; i++) { 164 idesc[i].id_type = ADDR; 165 if (!is_ufs2 && doinglevel2) 166 idesc[i].id_fix = FIX; 167 } 168 memset(&cstotal, 0, sizeof(struct csum_total)); 169 dmax = blknum(fs, fs->fs_size + fs->fs_frag - 1); 170 for (d = fs->fs_size; d < dmax; d++) 171 setbmap(d); 172 for (c = 0; c < fs->fs_ncg; c++) { 173 if (got_siginfo) { 174 fprintf(stderr, 175 "%s: phase 5: cyl group %d of %d (%d%%)\n", 176 cdevname(), c, fs->fs_ncg, 177 c * 100 / fs->fs_ncg); 178 got_siginfo = 0; 179 } 180 getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize); 181 memcpy(cg, cgblk.b_un.b_cg, fs->fs_cgsize); 182 if((doswap && !needswap) || (!doswap && needswap)) 183 ffs_cg_swap(cgblk.b_un.b_cg, cg, sblock); 184 if (!cg_chkmagic(cg, 0)) 185 pfatal("CG %d: PASS5: BAD MAGIC NUMBER\n", c); 186 if(doswap) 187 cgdirty(); 188 /* 189 * While we have the disk head where we want it, 190 * write back the superblock to the spare at this 191 * cylinder group. 192 */ 193 if ((cvtlevel && sblk.b_dirty) || doswap) { 194 bwrite(fswritefd, sblk.b_un.b_buf, 195 fsbtodb(sblock, cgsblock(sblock, c)), 196 sblock->fs_sbsize); 197 } else { 198 /* 199 * Read in the current alternate superblock, 200 * and compare it to the master. If it's 201 * wrong, fix it up. 202 */ 203 getblk(&asblk, cgsblock(sblock, c), sblock->fs_sbsize); 204 if (asblk.b_errs) 205 pfatal("CG %d: UNABLE TO READ ALTERNATE " 206 "SUPERBLK\n", c); 207 else { 208 memmove(altsblock, asblk.b_un.b_fs, 209 sblock->fs_sbsize); 210 if (needswap) 211 ffs_sb_swap(asblk.b_un.b_fs, altsblock); 212 } 213 if ((asblk.b_errs || cmpsblks(sblock, altsblock)) && 214 dofix(&idesc[3], 215 "ALTERNATE SUPERBLK(S) ARE INCORRECT")) { 216 bwrite(fswritefd, sblk.b_un.b_buf, 217 fsbtodb(sblock, cgsblock(sblock, c)), 218 sblock->fs_sbsize); 219 } 220 } 221 dbase = cgbase(fs, c); 222 dmax = dbase + fs->fs_fpg; 223 if (dmax > fs->fs_size) 224 dmax = fs->fs_size; 225 newcg->cg_time = cg->cg_time; 226 newcg->cg_old_time = cg->cg_old_time; 227 newcg->cg_cgx = c; 228 newcg->cg_ndblk = dmax - dbase; 229 if (!is_ufs2) { 230 if (c == fs->fs_ncg - 1) 231 newcg->cg_old_ncyl = howmany(newcg->cg_ndblk, 232 fs->fs_fpg / fs->fs_old_cpg); 233 else 234 newcg->cg_old_ncyl = fs->fs_old_cpg; 235 newcg->cg_old_niblk = fs->fs_ipg; 236 newcg->cg_niblk = 0; 237 } 238 if (fs->fs_contigsumsize > 0) 239 newcg->cg_nclusterblks = newcg->cg_ndblk / fs->fs_frag; 240 newcg->cg_cs.cs_ndir = 0; 241 newcg->cg_cs.cs_nffree = 0; 242 newcg->cg_cs.cs_nbfree = 0; 243 newcg->cg_cs.cs_nifree = fs->fs_ipg; 244 if (cg->cg_rotor >= 0 && cg->cg_rotor < newcg->cg_ndblk) 245 newcg->cg_rotor = cg->cg_rotor; 246 else 247 newcg->cg_rotor = 0; 248 if (cg->cg_frotor >= 0 && cg->cg_frotor < newcg->cg_ndblk) 249 newcg->cg_frotor = cg->cg_frotor; 250 else 251 newcg->cg_frotor = 0; 252 if (cg->cg_irotor >= 0 && cg->cg_irotor < fs->fs_ipg) 253 newcg->cg_irotor = cg->cg_irotor; 254 else 255 newcg->cg_irotor = 0; 256 if (!is_ufs2) { 257 newcg->cg_initediblk = 0; 258 } else { 259 if ((unsigned)cg->cg_initediblk > fs->fs_ipg) 260 newcg->cg_initediblk = fs->fs_ipg; 261 else 262 newcg->cg_initediblk = cg->cg_initediblk; 263 } 264 memset(&newcg->cg_frsum[0], 0, sizeof newcg->cg_frsum); 265 memset(cg_inosused(newcg, 0), 0, (size_t)(mapsize)); 266 j = fs->fs_ipg * c; 267 for (i = 0; i < fs->fs_ipg; j++, i++) { 268 info = inoinfo(j); 269 switch (info->ino_state) { 270 271 case USTATE: 272 break; 273 274 case DSTATE: 275 case DCLEAR: 276 case DFOUND: 277 newcg->cg_cs.cs_ndir++; 278 /* fall through */ 279 280 case FSTATE: 281 case FCLEAR: 282 newcg->cg_cs.cs_nifree--; 283 setbit(cg_inosused(newcg, 0), i); 284 break; 285 286 default: 287 if (j < ROOTINO) 288 break; 289 errx(EEXIT, "BAD STATE %d FOR INODE I=%ld", 290 info->ino_state, (long)j); 291 } 292 } 293 if (c == 0) 294 for (i = 0; i < ROOTINO; i++) { 295 setbit(cg_inosused(newcg, 0), i); 296 newcg->cg_cs.cs_nifree--; 297 } 298 for (i = 0, d = dbase; 299 d < dmax; 300 d += fs->fs_frag, i += fs->fs_frag) { 301 frags = 0; 302 for (j = 0; j < fs->fs_frag; j++) { 303 if (testbmap(d + j)) 304 continue; 305 setbit(cg_blksfree(newcg, 0), i + j); 306 frags++; 307 } 308 if (frags == fs->fs_frag) { 309 newcg->cg_cs.cs_nbfree++; 310 if (fs->fs_contigsumsize > 0) 311 setbit(cg_clustersfree(newcg, 0), 312 fragstoblks(fs, i)); 313 } else if (frags > 0) { 314 newcg->cg_cs.cs_nffree += frags; 315 blk = blkmap(fs, cg_blksfree(newcg, 0), i); 316 ffs_fragacct(fs, blk, newcg->cg_frsum, 1, 0); 317 } 318 } 319 if (fs->fs_contigsumsize > 0) { 320 int32_t *sump = cg_clustersum(newcg, 0); 321 u_char *mapp = cg_clustersfree(newcg, 0); 322 int map = *mapp++; 323 int bit = 1; 324 int run = 0; 325 326 for (i = 0; i < newcg->cg_nclusterblks; i++) { 327 if ((map & bit) != 0) { 328 run++; 329 } else if (run != 0) { 330 if (run > fs->fs_contigsumsize) 331 run = fs->fs_contigsumsize; 332 sump[run]++; 333 run = 0; 334 } 335 if ((i & (NBBY - 1)) != (NBBY - 1)) { 336 bit <<= 1; 337 } else { 338 map = *mapp++; 339 bit = 1; 340 } 341 } 342 if (run != 0) { 343 if (run > fs->fs_contigsumsize) 344 run = fs->fs_contigsumsize; 345 sump[run]++; 346 } 347 } 348 cstotal.cs_nffree += newcg->cg_cs.cs_nffree; 349 cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree; 350 cstotal.cs_nifree += newcg->cg_cs.cs_nifree; 351 cstotal.cs_ndir += newcg->cg_cs.cs_ndir; 352 cs = &fs->fs_cs(fs, c); 353 if (memcmp(&newcg->cg_cs, cs, sizeof *cs) != 0) { 354 if (dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) { 355 memmove(cs, &newcg->cg_cs, sizeof *cs); 356 sbdirty(); 357 } else 358 markclean = 0; 359 } 360 if (doinglevel1) { 361 memmove(cg, newcg, (size_t)fs->fs_cgsize); 362 cgdirty(); 363 continue; 364 } 365 if (memcmp(newcg, cg, basesize) != 0) { 366 dumpcg(newcg); 367 dumpcg(cg); 368 if (dofix(&idesc[2], "SUMMARY INFORMATION BAD")) { 369 memmove(cg, newcg, (size_t)basesize); 370 cgdirty(); 371 } else 372 markclean = 0; 373 } 374 if (usedsoftdep) { 375 for (i = 0; i < inomapsize; i++) { 376 j = cg_inosused(newcg, 0)[i]; 377 if ((cg_inosused(cg, 0)[i] & j) == j) 378 continue; 379 for (k = 0; k < NBBY; k++) { 380 if ((j & (1 << k)) == 0) 381 continue; 382 if (cg_inosused(cg, 0)[i] & (1 << k)) 383 continue; 384 pwarn("ALLOCATED INODE %ld " 385 "MARKED FREE\n", 386 c * fs->fs_ipg + i * 8 + k); 387 } 388 } 389 for (i = 0; i < blkmapsize; i++) { 390 j = cg_blksfree(cg, 0)[i]; 391 if ((cg_blksfree(newcg, 0)[i] & j) == j) 392 continue; 393 for (k = 0; k < NBBY; k++) { 394 if ((j & (1 << k)) == 0) 395 continue; 396 if (cg_inosused(cg, 0)[i] & (1 << k)) 397 continue; 398 pwarn("ALLOCATED FRAG %ld " 399 "MARKED FREE\n", 400 c * fs->fs_fpg + i * 8 + k); 401 } 402 } 403 } 404 if (memcmp(cg_inosused(newcg, 0), cg_inosused(cg, 0), mapsize) 405 != 0 && dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) { 406 memmove(cg_inosused(cg, 0), cg_inosused(newcg, 0), 407 (size_t)mapsize); 408 cgdirty(); 409 } 410 } 411 if (memcmp(&cstotal, &fs->fs_cstotal, sizeof cstotal) != 0) { 412 dumptotal(&cstotal); 413 dumptotal(&fs->fs_cstotal); 414 if (dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) { 415 memmove(&fs->fs_cstotal, &cstotal, sizeof *cs); 416 fs->fs_ronly = 0; 417 fs->fs_fmod = 0; 418 sbdirty(); 419 } else 420 markclean = 0; 421 } 422 } 423 424 void 425 print_bmap(map, size) 426 u_char *map; 427 u_int32_t size; 428 { 429 int i, j; 430 431 i = 0; 432 while (i < size) { 433 printf("%u: ",i); 434 for (j = 0; j < 16; j++, i++) 435 printf("%2x ", (u_int)map[i] & 0xff); 436 printf("\n"); 437 } 438 } 439 440 static 441 void dumpcg(struct cg *cg) 442 { 443 printf("======================================\n"); 444 printf("firstfield %d\n", cg->cg_firstfield); 445 printf("magic %d\n", cg->cg_magic); 446 printf("old_time %d\n", cg->cg_old_time); 447 printf("cgx %d\n", cg->cg_cgx); 448 printf("old_ncyl %d\n", cg->cg_old_ncyl); 449 printf("old_niblk %d\n", cg->cg_old_niblk); 450 printf("ndblk %d\n", cg->cg_ndblk); 451 printf("csum.ndir %d\n", cg->cg_cs.cs_ndir); 452 printf("csum.nbfree %d\n", cg->cg_cs.cs_nbfree); 453 printf("csum.nifree %d\n", cg->cg_cs.cs_nifree); 454 printf("csum.nffree %d\n", cg->cg_cs.cs_nffree); 455 printf("rotor %d\n", cg->cg_rotor); 456 printf("frotor %d\n", cg->cg_frotor); 457 printf("irotor %d\n", cg->cg_irotor); 458 printf("%d, %d, %d, %d, %d, %d, %d, %d\n", 459 cg->cg_frsum[0], cg->cg_frsum[1], cg->cg_frsum[2], cg->cg_frsum[3], 460 cg->cg_frsum[4], cg->cg_frsum[5], cg->cg_frsum[6], cg->cg_frsum[7]); 461 printf("old_btotoff %d\n", cg->cg_old_btotoff); 462 printf("old_boff %d\n", cg->cg_old_boff); 463 printf("iusedoff %d\n", cg->cg_iusedoff); 464 printf("freeoff %d\n", cg->cg_freeoff); 465 printf("nextfreeoff %d\n", cg->cg_nextfreeoff); 466 printf("clustersumoff %d\n", cg->cg_clustersumoff); 467 printf("clusteroff %d\n", cg->cg_clusteroff); 468 printf("nclusterblks %d\n", cg->cg_nclusterblks); 469 printf("niblk %d\n", cg->cg_niblk); 470 printf("initediblk %d\n", cg->cg_initediblk); 471 472 printf("time %lld\n", cg->cg_time); 473 } 474 475 static 476 void dumptotal(struct csum_total *cs) 477 { 478 printf("===========================\n"); 479 printf("ndir %lld\n", cs->cs_ndir); 480 printf("nbfree %lld\n", cs->cs_ndir); 481 printf("nifree %lld\n", cs->cs_ndir); 482 printf("nffree %lld\n", cs->cs_ndir); 483 printf("numclusters %lld\n", cs->cs_ndir); 484 } 485
Indexes created Wed Oct 01 12:09:54 GMT 2025