pass5.c revision 1.20
1 /* $NetBSD: pass5.c,v 1.20 1998/08/25 19:18:15 ross 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.20 1998/08/25 19:18:15 ross 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 struct fs *fs = sblock; 68 ufs_daddr_t dbase, dmax; 69 ufs_daddr_t d; 70 long i, j; 71 struct csum *cs; 72 struct csum cstotal; 73 struct inodesc idesc[3]; 74 char buf[MAXBSIZE]; 75 struct cg *newcg = (struct cg *)buf; 76 struct ocg *ocg = (struct ocg *)buf; 77 struct cg *cg; 78 79 cg = cgrp = malloc(fs->fs_cgsize); 80 if (cg == NULL) 81 errx(EEXIT, "cannot allocate space for cylinder group"); 82 83 statemap[WINO] = USTATE; 84 memset(newcg, 0, (size_t)fs->fs_cgsize); 85 newcg->cg_niblk = fs->fs_ipg; 86 if (cvtlevel >= 3) { 87 if (fs->fs_maxcontig < 2 && fs->fs_contigsumsize > 0) { 88 if (preen) 89 pwarn("DELETING CLUSTERING MAPS\n"); 90 if (preen || reply("DELETE CLUSTERING MAPS")) { 91 fs->fs_contigsumsize = 0; 92 doinglevel1 = 1; 93 sbdirty(); 94 } 95 } 96 if (fs->fs_maxcontig > 1) { 97 char *doit = 0; 98 99 if (fs->fs_contigsumsize < 1) { 100 doit = "CREAT"; 101 } else if (fs->fs_contigsumsize < fs->fs_maxcontig && 102 fs->fs_contigsumsize < FS_MAXCONTIG) { 103 doit = "EXPAND"; 104 } 105 if (doit) { 106 i = fs->fs_contigsumsize; 107 fs->fs_contigsumsize = 108 MIN(fs->fs_maxcontig, FS_MAXCONTIG); 109 if (CGSIZE(fs) > fs->fs_bsize) { 110 pwarn("CANNOT %s CLUSTER MAPS\n", doit); 111 fs->fs_contigsumsize = i; 112 } else if (preen || 113 reply("CREATE CLUSTER MAPS")) { 114 if (preen) 115 pwarn("%sING CLUSTER MAPS\n", 116 doit); 117 fs->fs_cgsize = 118 fragroundup(fs, CGSIZE(fs)); 119 doinglevel1 = 1; 120 sbdirty(); 121 } 122 } 123 } 124 } 125 switch ((int)fs->fs_postblformat) { 126 127 case FS_42POSTBLFMT: 128 basesize = (char *)(&ocg->cg_btot[0]) - 129 (char *)(&ocg->cg_firstfield); 130 sumsize = &ocg->cg_iused[0] - (u_int8_t *)(&ocg->cg_btot[0]); 131 mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] - 132 (u_char *)&ocg->cg_iused[0]; 133 ocg->cg_magic = CG_MAGIC; 134 savednrpos = fs->fs_nrpos; 135 fs->fs_nrpos = 8; 136 break; 137 138 case FS_DYNAMICPOSTBLFMT: 139 newcg->cg_btotoff = 140 &newcg->cg_space[0] - (u_char *)(&newcg->cg_firstfield); 141 newcg->cg_boff = 142 newcg->cg_btotoff + fs->fs_cpg * sizeof(int32_t); 143 newcg->cg_iusedoff = newcg->cg_boff + 144 fs->fs_cpg * fs->fs_nrpos * sizeof(int16_t); 145 newcg->cg_freeoff = 146 newcg->cg_iusedoff + howmany(fs->fs_ipg, NBBY); 147 if (fs->fs_contigsumsize <= 0) { 148 newcg->cg_nextfreeoff = newcg->cg_freeoff + 149 howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs), NBBY); 150 } else { 151 newcg->cg_clustersumoff = newcg->cg_freeoff + 152 howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs), NBBY) - 153 sizeof(int32_t); 154 newcg->cg_clustersumoff = 155 roundup(newcg->cg_clustersumoff, sizeof(int32_t)); 156 newcg->cg_clusteroff = newcg->cg_clustersumoff + 157 (fs->fs_contigsumsize + 1) * sizeof(int32_t); 158 newcg->cg_nextfreeoff = newcg->cg_clusteroff + 159 howmany(fs->fs_cpg * fs->fs_spc / NSPB(fs), NBBY); 160 } 161 newcg->cg_magic = CG_MAGIC; 162 basesize = &newcg->cg_space[0] - 163 (u_char *)(&newcg->cg_firstfield); 164 sumsize = newcg->cg_iusedoff - newcg->cg_btotoff; 165 mapsize = newcg->cg_nextfreeoff - newcg->cg_iusedoff; 166 break; 167 168 default: 169 sumsize = 0; /* keep lint happy */ 170 errx(EEXIT, "UNKNOWN ROTATIONAL TABLE FORMAT %d", 171 fs->fs_postblformat); 172 } 173 memset(&idesc[0], 0, sizeof idesc); 174 for (i = 0; i < 3; i++) { 175 idesc[i].id_type = ADDR; 176 if (doinglevel2) 177 idesc[i].id_fix = FIX; 178 } 179 memset(&cstotal, 0, sizeof(struct csum)); 180 j = blknum(fs, fs->fs_size + fs->fs_frag - 1); 181 for (i = fs->fs_size; i < j; i++) 182 setbmap(i); 183 for (c = 0; c < fs->fs_ncg; c++) { 184 getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize); 185 memcpy(cg, cgblk.b_un.b_cg, fs->fs_cgsize); 186 if((doswap && !needswap) || (!doswap && needswap)) 187 swap_cg(cgblk.b_un.b_cg, cg); 188 if (!cg_chkmagic(cg, 0)) 189 pfatal("CG %d: BAD MAGIC NUMBER\n", c); 190 if(doswap) 191 cgdirty(); 192 dbase = cgbase(fs, c); 193 dmax = dbase + fs->fs_fpg; 194 if (dmax > fs->fs_size) 195 dmax = fs->fs_size; 196 newcg->cg_time = cg->cg_time; 197 newcg->cg_cgx = c; 198 if (c == fs->fs_ncg - 1) 199 newcg->cg_ncyl = fs->fs_ncyl % fs->fs_cpg; 200 else 201 newcg->cg_ncyl = fs->fs_cpg; 202 newcg->cg_ndblk = dmax - dbase; 203 if (fs->fs_contigsumsize > 0) 204 newcg->cg_nclusterblks = newcg->cg_ndblk / fs->fs_frag; 205 newcg->cg_cs.cs_ndir = 0; 206 newcg->cg_cs.cs_nffree = 0; 207 newcg->cg_cs.cs_nbfree = 0; 208 newcg->cg_cs.cs_nifree = fs->fs_ipg; 209 if (cg->cg_rotor < newcg->cg_ndblk) 210 newcg->cg_rotor = cg->cg_rotor; 211 else 212 newcg->cg_rotor = 0; 213 if (cg->cg_frotor < newcg->cg_ndblk) 214 newcg->cg_frotor = cg->cg_frotor; 215 else 216 newcg->cg_frotor = 0; 217 if (cg->cg_irotor < newcg->cg_niblk) 218 newcg->cg_irotor = cg->cg_irotor; 219 else 220 newcg->cg_irotor = 0; 221 memset(&newcg->cg_frsum[0], 0, sizeof newcg->cg_frsum); 222 memset(&cg_blktot(newcg, 0)[0], 0, 223 (size_t)(sumsize + mapsize)); 224 if (fs->fs_postblformat == FS_42POSTBLFMT) 225 ocg->cg_magic = CG_MAGIC; 226 j = fs->fs_ipg * c; 227 for (i = 0; i < fs->fs_ipg; j++, i++) { 228 switch (statemap[j]) { 229 230 case USTATE: 231 break; 232 233 case DSTATE: 234 case DCLEAR: 235 case DFOUND: 236 newcg->cg_cs.cs_ndir++; 237 /* fall through */ 238 239 case FSTATE: 240 case FCLEAR: 241 newcg->cg_cs.cs_nifree--; 242 setbit(cg_inosused(newcg, 0), i); 243 break; 244 245 default: 246 if (j < ROOTINO) 247 break; 248 errx(EEXIT, "BAD STATE %d FOR INODE I=%ld", 249 statemap[j], (long)j); 250 } 251 } 252 if (c == 0) 253 for (i = 0; i < ROOTINO; i++) { 254 setbit(cg_inosused(newcg, 0), i); 255 newcg->cg_cs.cs_nifree--; 256 } 257 for (i = 0, d = dbase; 258 d < dmax; 259 d += fs->fs_frag, i += fs->fs_frag) { 260 frags = 0; 261 for (j = 0; j < fs->fs_frag; j++) { 262 if (testbmap(d + j)) 263 continue; 264 setbit(cg_blksfree(newcg, 0), i + j); 265 frags++; 266 } 267 if (frags == fs->fs_frag) { 268 newcg->cg_cs.cs_nbfree++; 269 j = cbtocylno(fs, i); 270 cg_blktot(newcg, 0)[j]++; 271 cg_blks(fs, newcg, j, 0)[cbtorpos(fs, i)]++; 272 if (fs->fs_contigsumsize > 0) 273 setbit(cg_clustersfree(newcg, 0), 274 i / fs->fs_frag); 275 } else if (frags > 0) { 276 newcg->cg_cs.cs_nffree += frags; 277 blk = blkmap(fs, cg_blksfree(newcg, 0), i); 278 ffs_fragacct(fs, blk, newcg->cg_frsum, 1, 0); 279 } 280 } 281 if (fs->fs_contigsumsize > 0) { 282 int32_t *sump = cg_clustersum(newcg, 0); 283 u_char *mapp = cg_clustersfree(newcg, 0); 284 int map = *mapp++; 285 int bit = 1; 286 int run = 0; 287 288 for (i = 0; i < newcg->cg_nclusterblks; i++) { 289 if ((map & bit) != 0) { 290 run++; 291 } else if (run != 0) { 292 if (run > fs->fs_contigsumsize) 293 run = fs->fs_contigsumsize; 294 sump[run]++; 295 run = 0; 296 } 297 if ((i & (NBBY - 1)) != (NBBY - 1)) { 298 bit <<= 1; 299 } else { 300 map = *mapp++; 301 bit = 1; 302 } 303 } 304 if (run != 0) { 305 if (run > fs->fs_contigsumsize) 306 run = fs->fs_contigsumsize; 307 sump[run]++; 308 } 309 } 310 cstotal.cs_nffree += newcg->cg_cs.cs_nffree; 311 cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree; 312 cstotal.cs_nifree += newcg->cg_cs.cs_nifree; 313 cstotal.cs_ndir += newcg->cg_cs.cs_ndir; 314 cs = &fs->fs_cs(fs, c); 315 if (memcmp(&newcg->cg_cs, cs, sizeof *cs) != 0) { 316 if (dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) { 317 memmove(cs, &newcg->cg_cs, sizeof *cs); 318 sbdirty(); 319 } else 320 markclean = 0; 321 } 322 if (doinglevel1) { 323 memmove(cg, newcg, (size_t)fs->fs_cgsize); 324 cgdirty(); 325 continue; 326 } 327 if (memcmp(cg_inosused(newcg, 0), cg_inosused(cg, 0), mapsize) != 0) { 328 if (debug) { 329 printf("newcg map:\n"); 330 print_bmap(cg_inosused(newcg, 0), mapsize); 331 printf("\ncg map:\n"); 332 print_bmap(cg_inosused(cg, 0), mapsize); 333 } 334 if (dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) { 335 memmove(cg_inosused(cg, 0), cg_inosused(newcg, 0), 336 (size_t)mapsize); 337 cgdirty(); 338 } else 339 markclean = 0; 340 } 341 if (memcmp(newcg, cg, basesize) != 0 || 342 memcmp(&cg_blktot(newcg, 0)[0], 343 &cg_blktot(cg, 0)[0], sumsize) != 0) { 344 if (dofix(&idesc[2], "SUMMARY INFORMATION BAD")) { 345 memmove(cg, newcg, (size_t)basesize); 346 memmove(&cg_blktot(cg, 0)[0], 347 &cg_blktot(newcg, 0)[0], (size_t)sumsize); 348 cgdirty(); 349 } else markclean = 0; 350 } 351 352 } 353 if (fs->fs_postblformat == FS_42POSTBLFMT) 354 fs->fs_nrpos = savednrpos; 355 if (memcmp(&cstotal, &fs->fs_cstotal, sizeof *cs) != 0) { 356 if(dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) { 357 memmove(&fs->fs_cstotal, &cstotal, sizeof *cs); 358 fs->fs_ronly = 0; 359 fs->fs_fmod = 0; 360 sbdirty(); 361 } else 362 markclean = 0; 363 } 364 } 365 366 void 367 print_bmap(map, size) 368 u_char *map; 369 u_int32_t size; 370 { 371 int i, j; 372 373 i = 0; 374 while (i < size) { 375 printf("%u: ",i); 376 for (j = 0; j < 16; j++, i++) 377 printf("%2x ", (u_int)map[i] & 0xff); 378 printf("\n"); 379 } 380 } 381
Indexes created Wed Oct 01 07:09:59 GMT 2025