pass5.c revision 1.30
1 /* $NetBSD: pass5.c,v 1.30 2002/06/30 22:57:30 dbj 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.30 2002/06/30 22:57:30 dbj 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 63 void 64 pass5() 65 { 66 int c, blk, frags, basesize, sumsize, mapsize, savednrpos = 0; 67 int32_t savednpsect, savedinterleave; 68 int inomapsize, blkmapsize; 69 struct fs *fs = sblock; 70 ufs_daddr_t dbase, dmax; 71 ufs_daddr_t d; 72 long i, j, k; 73 struct csum *cs; 74 struct csum cstotal; 75 struct inodesc idesc[4]; 76 char buf[MAXBSIZE]; 77 struct cg *newcg = (struct cg *)buf; 78 struct ocg *ocg = (struct ocg *)buf; 79 struct cg *cg = cgrp; 80 81 statemap[WINO] = USTATE; 82 memset(newcg, 0, (size_t)fs->fs_cgsize); 83 newcg->cg_niblk = fs->fs_ipg; 84 if (cvtlevel >= 3) { 85 if (fs->fs_maxcontig < 2 && fs->fs_contigsumsize > 0) { 86 if (preen) 87 pwarn("DELETING CLUSTERING MAPS\n"); 88 if (preen || reply("DELETE CLUSTERING MAPS")) { 89 fs->fs_contigsumsize = 0; 90 doinglevel1 = 1; 91 sbdirty(); 92 } 93 } 94 if (fs->fs_maxcontig > 1) { 95 char *doit = 0; 96 97 if (fs->fs_contigsumsize < 1) { 98 doit = "CREAT"; 99 } else if (fs->fs_contigsumsize < fs->fs_maxcontig && 100 fs->fs_contigsumsize < FS_MAXCONTIG) { 101 doit = "EXPAND"; 102 } 103 if (doit) { 104 i = fs->fs_contigsumsize; 105 fs->fs_contigsumsize = 106 MIN(fs->fs_maxcontig, FS_MAXCONTIG); 107 if (CGSIZE(fs) > fs->fs_bsize) { 108 pwarn("CANNOT %s CLUSTER MAPS\n", doit); 109 fs->fs_contigsumsize = i; 110 } else if (preen || 111 reply("CREATE CLUSTER MAPS")) { 112 if (preen) 113 pwarn("%sING CLUSTER MAPS\n", 114 doit); 115 fs->fs_cgsize = 116 fragroundup(fs, CGSIZE(fs)); 117 cg = cgrp = 118 realloc(cgrp, fs->fs_cgsize); 119 if (cg == NULL) 120 errx(EEXIT, 121 "cannot reallocate cg space"); 122 doinglevel1 = 1; 123 sbdirty(); 124 } 125 } 126 } 127 } 128 switch ((int)fs->fs_postblformat) { 129 130 case FS_42POSTBLFMT: 131 basesize = (char *)(&ocg->cg_btot[0]) - 132 (char *)(&ocg->cg_firstfield); 133 sumsize = &ocg->cg_iused[0] - (u_int8_t *)(&ocg->cg_btot[0]); 134 mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] - 135 (u_char *)&ocg->cg_iused[0]; 136 blkmapsize = howmany(fs->fs_fpg, NBBY); 137 inomapsize = &ocg->cg_free[0] - (u_char *)&ocg->cg_iused[0]; 138 ocg->cg_magic = CG_MAGIC; 139 savednrpos = fs->fs_nrpos; 140 savednpsect = fs->fs_npsect; 141 savedinterleave = fs->fs_interleave; 142 fs->fs_nrpos = 8; 143 fs->fs_npsect = fs->fs_nsect; 144 fs->fs_interleave = 1; 145 break; 146 147 case FS_DYNAMICPOSTBLFMT: 148 newcg->cg_btotoff = 149 &newcg->cg_space[0] - (u_char *)(&newcg->cg_firstfield); 150 newcg->cg_boff = 151 newcg->cg_btotoff + fs->fs_cpg * sizeof(int32_t); 152 newcg->cg_iusedoff = newcg->cg_boff + 153 fs->fs_cpg * fs->fs_nrpos * sizeof(int16_t); 154 newcg->cg_freeoff = 155 newcg->cg_iusedoff + howmany(fs->fs_ipg, NBBY); 156 inomapsize = newcg->cg_freeoff - newcg->cg_iusedoff; 157 newcg->cg_nextfreeoff = newcg->cg_freeoff + 158 howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs), NBBY); 159 blkmapsize = newcg->cg_nextfreeoff - newcg->cg_freeoff; 160 if (fs->fs_contigsumsize > 0) { 161 newcg->cg_clustersumoff = newcg->cg_nextfreeoff - 162 sizeof(int32_t); 163 newcg->cg_clustersumoff = 164 roundup(newcg->cg_clustersumoff, sizeof(int32_t)); 165 newcg->cg_clusteroff = newcg->cg_clustersumoff + 166 (fs->fs_contigsumsize + 1) * sizeof(int32_t); 167 newcg->cg_nextfreeoff = newcg->cg_clusteroff + 168 howmany(fs->fs_cpg * fs->fs_spc / NSPB(fs), NBBY); 169 } 170 newcg->cg_magic = CG_MAGIC; 171 basesize = &newcg->cg_space[0] - 172 (u_char *)(&newcg->cg_firstfield); 173 sumsize = newcg->cg_iusedoff - newcg->cg_btotoff; 174 mapsize = newcg->cg_nextfreeoff - newcg->cg_iusedoff; 175 break; 176 177 default: 178 inomapsize = blkmapsize = sumsize = 0; /* keep lint happy */ 179 errx(EEXIT, "UNKNOWN ROTATIONAL TABLE FORMAT %d", 180 fs->fs_postblformat); 181 } 182 memset(&idesc[0], 0, sizeof idesc); 183 for (i = 0; i < 4; i++) { 184 idesc[i].id_type = ADDR; 185 if (doinglevel2) 186 idesc[i].id_fix = FIX; 187 } 188 memset(&cstotal, 0, sizeof(struct csum)); 189 j = blknum(fs, fs->fs_size + fs->fs_frag - 1); 190 for (i = fs->fs_size; i < j; i++) 191 setbmap(i); 192 for (c = 0; c < fs->fs_ncg; c++) { 193 if (got_siginfo) { 194 fprintf(stderr, 195 "%s: phase 5: cyl group %d of %d (%d%%)\n", 196 cdevname(), c, fs->fs_ncg, 197 c * 100 / fs->fs_ncg); 198 got_siginfo = 0; 199 } 200 getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize); 201 memcpy(cg, cgblk.b_un.b_cg, fs->fs_cgsize); 202 if((doswap && !needswap) || (!doswap && needswap)) 203 swap_cg(cgblk.b_un.b_cg, cg); 204 if (!cg_chkmagic(cg, 0)) 205 pfatal("CG %d: PASS5: BAD MAGIC NUMBER\n", c); 206 if(doswap) 207 cgdirty(); 208 /* 209 * While we have the disk head where we want it, 210 * write back the superblock to the spare at this 211 * cylinder group. 212 */ 213 if ((cvtlevel && sblk.b_dirty) || doswap) { 214 bwrite(fswritefd, sblk.b_un.b_buf, 215 fsbtodb(sblock, cgsblock(sblock, c)), 216 sblock->fs_sbsize); 217 } else { 218 /* 219 * Read in the current alternate superblock, 220 * and compare it to the master. If it's 221 * wrong, fix it up. 222 */ 223 getblk(&asblk, cgsblock(sblock, c), sblock->fs_sbsize); 224 if (asblk.b_errs) 225 pfatal("CG %d: UNABLE TO READ ALTERNATE " 226 "SUPERBLK\n", c); 227 else { 228 memmove(altsblock, asblk.b_un.b_fs, 229 sblock->fs_sbsize); 230 if (needswap) 231 ffs_sb_swap(asblk.b_un.b_fs, altsblock); 232 } 233 if ((asblk.b_errs || cmpsblks(sblock, altsblock)) && 234 dofix(&idesc[3], 235 "ALTERNATE SUPERBLK(S) ARE INCORRECT")) { 236 bwrite(fswritefd, sblk.b_un.b_buf, 237 fsbtodb(sblock, cgsblock(sblock, c)), 238 sblock->fs_sbsize); 239 } 240 } 241 dbase = cgbase(fs, c); 242 dmax = dbase + fs->fs_fpg; 243 if (dmax > fs->fs_size) 244 dmax = fs->fs_size; 245 newcg->cg_time = cg->cg_time; 246 newcg->cg_cgx = c; 247 if (c == fs->fs_ncg - 1) 248 newcg->cg_ncyl = fs->fs_ncyl % fs->fs_cpg; 249 else 250 newcg->cg_ncyl = fs->fs_cpg; 251 newcg->cg_ndblk = dmax - dbase; 252 if (fs->fs_contigsumsize > 0) 253 newcg->cg_nclusterblks = newcg->cg_ndblk / fs->fs_frag; 254 newcg->cg_cs.cs_ndir = 0; 255 newcg->cg_cs.cs_nffree = 0; 256 newcg->cg_cs.cs_nbfree = 0; 257 newcg->cg_cs.cs_nifree = fs->fs_ipg; 258 if (cg->cg_rotor >= 0 && cg->cg_rotor < newcg->cg_ndblk) 259 newcg->cg_rotor = cg->cg_rotor; 260 else 261 newcg->cg_rotor = 0; 262 if (cg->cg_frotor >= 0 && cg->cg_frotor < newcg->cg_ndblk) 263 newcg->cg_frotor = cg->cg_frotor; 264 else 265 newcg->cg_frotor = 0; 266 if (cg->cg_irotor >= 0 && cg->cg_irotor < newcg->cg_niblk) 267 newcg->cg_irotor = cg->cg_irotor; 268 else 269 newcg->cg_irotor = 0; 270 memset(&newcg->cg_frsum[0], 0, sizeof newcg->cg_frsum); 271 memset(&cg_blktot(newcg, 0)[0], 0, 272 (size_t)(sumsize + mapsize)); 273 if (fs->fs_postblformat == FS_42POSTBLFMT) 274 ocg->cg_magic = CG_MAGIC; 275 j = fs->fs_ipg * c; 276 for (i = 0; i < fs->fs_ipg; j++, i++) { 277 switch (statemap[j]) { 278 279 case USTATE: 280 break; 281 282 case DSTATE: 283 case DCLEAR: 284 case DFOUND: 285 newcg->cg_cs.cs_ndir++; 286 /* fall through */ 287 288 case FSTATE: 289 case FCLEAR: 290 newcg->cg_cs.cs_nifree--; 291 setbit(cg_inosused(newcg, 0), i); 292 break; 293 294 default: 295 if (j < ROOTINO) 296 break; 297 errx(EEXIT, "BAD STATE %d FOR INODE I=%ld", 298 statemap[j], (long)j); 299 } 300 } 301 if (c == 0) 302 for (i = 0; i < ROOTINO; i++) { 303 setbit(cg_inosused(newcg, 0), i); 304 newcg->cg_cs.cs_nifree--; 305 } 306 for (i = 0, d = dbase; 307 d < dmax; 308 d += fs->fs_frag, i += fs->fs_frag) { 309 frags = 0; 310 for (j = 0; j < fs->fs_frag; j++) { 311 if (testbmap(d + j)) 312 continue; 313 setbit(cg_blksfree(newcg, 0), i + j); 314 frags++; 315 } 316 if (frags == fs->fs_frag) { 317 newcg->cg_cs.cs_nbfree++; 318 j = cbtocylno(fs, i); 319 cg_blktot(newcg, 0)[j]++; 320 cg_blks(fs, newcg, j, 0)[cbtorpos(fs, i)]++; 321 if (fs->fs_contigsumsize > 0) 322 setbit(cg_clustersfree(newcg, 0), 323 fragstoblks(fs, i)); 324 } else if (frags > 0) { 325 newcg->cg_cs.cs_nffree += frags; 326 blk = blkmap(fs, cg_blksfree(newcg, 0), i); 327 ffs_fragacct(fs, blk, newcg->cg_frsum, 1, 0); 328 } 329 } 330 if (fs->fs_contigsumsize > 0) { 331 int32_t *sump = cg_clustersum(newcg, 0); 332 u_char *mapp = cg_clustersfree(newcg, 0); 333 int map = *mapp++; 334 int bit = 1; 335 int run = 0; 336 337 for (i = 0; i < newcg->cg_nclusterblks; i++) { 338 if ((map & bit) != 0) { 339 run++; 340 } else if (run != 0) { 341 if (run > fs->fs_contigsumsize) 342 run = fs->fs_contigsumsize; 343 sump[run]++; 344 run = 0; 345 } 346 if ((i & (NBBY - 1)) != (NBBY - 1)) { 347 bit <<= 1; 348 } else { 349 map = *mapp++; 350 bit = 1; 351 } 352 } 353 if (run != 0) { 354 if (run > fs->fs_contigsumsize) 355 run = fs->fs_contigsumsize; 356 sump[run]++; 357 } 358 } 359 cstotal.cs_nffree += newcg->cg_cs.cs_nffree; 360 cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree; 361 cstotal.cs_nifree += newcg->cg_cs.cs_nifree; 362 cstotal.cs_ndir += newcg->cg_cs.cs_ndir; 363 cs = &fs->fs_cs(fs, c); 364 if (memcmp(&newcg->cg_cs, cs, sizeof *cs) != 0) { 365 if (dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) { 366 memmove(cs, &newcg->cg_cs, sizeof *cs); 367 sbdirty(); 368 } else 369 markclean = 0; 370 } 371 if (doinglevel1) { 372 memmove(cg, newcg, (size_t)fs->fs_cgsize); 373 cgdirty(); 374 continue; 375 } 376 if (memcmp(newcg, cg, basesize) != 0 || 377 memcmp(&cg_blktot(newcg, 0)[0], 378 &cg_blktot(cg, 0)[0], sumsize) != 0) { 379 if (dofix(&idesc[2], "SUMMARY INFORMATION BAD")) { 380 memmove(cg, newcg, (size_t)basesize); 381 memmove(&cg_blktot(cg, 0)[0], 382 &cg_blktot(newcg, 0)[0], (size_t)sumsize); 383 cgdirty(); 384 } else 385 markclean = 0; 386 } 387 if (usedsoftdep) { 388 for (i = 0; i < inomapsize; i++) { 389 j = cg_inosused(newcg, 0)[i]; 390 if ((cg_inosused(cg, 0)[i] & j) == j) 391 continue; 392 for (k = 0; k < NBBY; k++) { 393 if ((j & (1 << k)) == 0) 394 continue; 395 if (cg_inosused(cg, 0)[i] & (1 << k)) 396 continue; 397 pwarn("ALLOCATED INODE %ld " 398 "MARKED FREE\n", 399 c * fs->fs_ipg + i * 8 + k); 400 } 401 } 402 for (i = 0; i < blkmapsize; i++) { 403 j = cg_blksfree(cg, 0)[i]; 404 if ((cg_blksfree(newcg, 0)[i] & j) == j) 405 continue; 406 for (k = 0; k < NBBY; k++) { 407 if ((j & (1 << k)) == 0) 408 continue; 409 if (cg_inosused(cg, 0)[i] & (1 << k)) 410 continue; 411 pwarn("ALLOCATED FRAG %ld " 412 "MARKED FREE\n", 413 c * fs->fs_fpg + i * 8 + k); 414 } 415 } 416 } 417 if (memcmp(cg_inosused(newcg, 0), cg_inosused(cg, 0), mapsize) 418 != 0 && dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) { 419 memmove(cg_inosused(cg, 0), cg_inosused(newcg, 0), 420 (size_t)mapsize); 421 cgdirty(); 422 } 423 } 424 if (fs->fs_postblformat == FS_42POSTBLFMT) { 425 fs->fs_nrpos = savednrpos; 426 fs->fs_npsect = savednpsect; 427 fs->fs_interleave = savedinterleave; 428 } 429 if (memcmp(&cstotal, &fs->fs_cstotal, sizeof *cs) != 0) { 430 if (dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) { 431 memmove(&fs->fs_cstotal, &cstotal, sizeof *cs); 432 fs->fs_ronly = 0; 433 fs->fs_fmod = 0; 434 sbdirty(); 435 } else 436 markclean = 0; 437 } 438 } 439 440 void 441 print_bmap(map, size) 442 u_char *map; 443 u_int32_t size; 444 { 445 int i, j; 446 447 i = 0; 448 while (i < size) { 449 printf("%u: ",i); 450 for (j = 0; j < 16; j++, i++) 451 printf("%2x ", (u_int)map[i] & 0xff); 452 printf("\n"); 453 } 454 } 455
Indexes created Wed Oct 01 12:09:54 GMT 2025