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