![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mkfs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc / onewfs|
Return to mkfs.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc / onewfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char sccsid[] = "@(#)mkfs.c 6.6 (Berkeley) 4/24/88"; ! 9: #endif not lint ! 10: ! 11: /* ! 12: * make file system for cylinder-group style file systems ! 13: */ ! 14: ! 15: #ifndef STANDALONE ! 16: #include <stdio.h> ! 17: #include <a.out.h> ! 18: #endif ! 19: ! 20: #include <sys/param.h> ! 21: #include <sys/inode.h> ! 22: #include <sys/fs.h> ! 23: #include <sys/dir.h> ! 24: #include <sys/disklabel.h> ! 25: ! 26: #define UMASK 0755 ! 27: #define MAXINOPB (MAXBSIZE / sizeof(struct dinode)) ! 28: #define POWEROF2(num) (((num) & ((num) - 1)) == 0) ! 29: ! 30: /* ! 31: * variables set up by front end. ! 32: */ ! 33: extern int Nflag; /* run mkfs without writing file system */ ! 34: extern int fssize; /* file system size */ ! 35: extern int ntracks; /* # tracks/cylinder */ ! 36: extern int nsectors; /* # sectors/track */ ! 37: extern int nphyssectors; /* # sectors/track including spares */ ! 38: extern int secpercyl; /* sectors per cylinder */ ! 39: extern int sectorsize; /* bytes/sector */ ! 40: extern int rpm; /* revolutions/minute of drive */ ! 41: extern int interleave; /* hardware sector interleave */ ! 42: extern int trackskew; /* sector 0 skew, per track */ ! 43: extern int headswitch; /* head switch time, usec */ ! 44: extern int trackseek; /* track-to-track seek, usec */ ! 45: extern int fsize; /* fragment size */ ! 46: extern int bsize; /* block size */ ! 47: extern int cpg; /* cylinders/cylinder group */ ! 48: extern int cpgflg; /* cylinders/cylinder group flag was given */ ! 49: extern int minfree; /* free space threshold */ ! 50: extern int opt; /* optimization preference (space or time) */ ! 51: extern int density; /* number of bytes per inode */ ! 52: extern int maxcontig; /* max contiguous blocks to allocate */ ! 53: extern int rotdelay; /* rotational delay between blocks */ ! 54: extern int maxbpg; /* maximum blocks per file in a cyl group */ ! 55: extern int bbsize; /* boot block size */ ! 56: extern int sbsize; /* superblock size */ ! 57: ! 58: union { ! 59: struct fs fs; ! 60: char pad[MAXBSIZE]; ! 61: } fsun; ! 62: #define sblock fsun.fs ! 63: struct csum *fscs; ! 64: ! 65: union { ! 66: struct cg cg; ! 67: char pad[MAXBSIZE]; ! 68: } cgun; ! 69: #define acg cgun.cg ! 70: ! 71: struct dinode zino[MAXIPG]; ! 72: ! 73: int fsi, fso; ! 74: time_t utime; ! 75: daddr_t alloc(); ! 76: ! 77: mkfs(pp, fsys, fi, fo) ! 78: struct partition *pp; ! 79: char *fsys; ! 80: int fi, fo; ! 81: { ! 82: register long i, mincpc, mincpg, inospercg; ! 83: long cylno, rpos, blk, j, warn = 0; ! 84: long used, mincpgcnt, bpcg; ! 85: long mapcramped, inodecramped; ! 86: ! 87: #ifndef STANDALONE ! 88: time(&utime); ! 89: #endif ! 90: fsi = fi; ! 91: fso = fo; ! 92: /* ! 93: * Validate the given file system size. ! 94: * Verify that its last block can actually be accessed. ! 95: */ ! 96: if (fssize <= 0) ! 97: printf("preposterous size %d\n", fssize), exit(1); ! 98: wtfs(fssize - 1, sectorsize, (char *)&sblock); ! 99: /* ! 100: * collect and verify the sector and track info ! 101: */ ! 102: sblock.fs_nsect = nsectors; ! 103: sblock.fs_ntrak = ntracks; ! 104: if (sblock.fs_ntrak <= 0) ! 105: printf("preposterous ntrak %d\n", sblock.fs_ntrak), exit(1); ! 106: if (sblock.fs_nsect <= 0) ! 107: printf("preposterous nsect %d\n", sblock.fs_nsect), exit(1); ! 108: /* ! 109: * collect and verify the block and fragment sizes ! 110: */ ! 111: sblock.fs_bsize = bsize; ! 112: sblock.fs_fsize = fsize; ! 113: if (!POWEROF2(sblock.fs_bsize)) { ! 114: printf("block size must be a power of 2, not %d\n", ! 115: sblock.fs_bsize); ! 116: exit(1); ! 117: } ! 118: if (!POWEROF2(sblock.fs_fsize)) { ! 119: printf("fragment size must be a power of 2, not %d\n", ! 120: sblock.fs_fsize); ! 121: exit(1); ! 122: } ! 123: if (sblock.fs_fsize < sectorsize) { ! 124: printf("fragment size %d is too small, minimum is %d\n", ! 125: sblock.fs_fsize, sectorsize); ! 126: exit(1); ! 127: } ! 128: if (sblock.fs_bsize < MINBSIZE) { ! 129: printf("block size %d is too small, minimum is %d\n", ! 130: sblock.fs_bsize, MINBSIZE); ! 131: exit(1); ! 132: } ! 133: if (sblock.fs_bsize < sblock.fs_fsize) { ! 134: printf("block size (%d) cannot be smaller than fragment size (%d)\n", ! 135: sblock.fs_bsize, sblock.fs_fsize); ! 136: exit(1); ! 137: } ! 138: sblock.fs_bmask = ~(sblock.fs_bsize - 1); ! 139: sblock.fs_fmask = ~(sblock.fs_fsize - 1); ! 140: for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1) ! 141: sblock.fs_bshift++; ! 142: for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1) ! 143: sblock.fs_fshift++; ! 144: sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize); ! 145: for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1) ! 146: sblock.fs_fragshift++; ! 147: if (sblock.fs_frag > MAXFRAG) { ! 148: printf("fragment size %d is too small, minimum with block size %d is %d\n", ! 149: sblock.fs_fsize, sblock.fs_bsize, ! 150: sblock.fs_bsize / MAXFRAG); ! 151: exit(1); ! 152: } ! 153: sblock.fs_nindir = sblock.fs_bsize / sizeof(daddr_t); ! 154: sblock.fs_inopb = sblock.fs_bsize / sizeof(struct dinode); ! 155: sblock.fs_nspf = sblock.fs_fsize / sectorsize; ! 156: for (sblock.fs_fsbtodb = 0, i = NSPF(&sblock); i > 1; i >>= 1) ! 157: sblock.fs_fsbtodb++; ! 158: sblock.fs_sblkno = ! 159: roundup(howmany(bbsize + sbsize, sblock.fs_fsize), sblock.fs_frag); ! 160: sblock.fs_cblkno = (daddr_t)(sblock.fs_sblkno + ! 161: roundup(howmany(sbsize, sblock.fs_fsize), sblock.fs_frag)); ! 162: sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag; ! 163: sblock.fs_cgoffset = roundup( ! 164: howmany(sblock.fs_nsect, NSPF(&sblock)), sblock.fs_frag); ! 165: for (sblock.fs_cgmask = 0xffffffff, i = sblock.fs_ntrak; i > 1; i >>= 1) ! 166: sblock.fs_cgmask <<= 1; ! 167: if (!POWEROF2(sblock.fs_ntrak)) ! 168: sblock.fs_cgmask <<= 1; ! 169: /* ! 170: * Validate specified/determined secpercyl ! 171: * and calculate minimum cylinders per group. ! 172: */ ! 173: sblock.fs_spc = secpercyl; ! 174: for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc; ! 175: sblock.fs_cpc > 1 && (i & 1) == 0; ! 176: sblock.fs_cpc >>= 1, i >>= 1) ! 177: /* void */; ! 178: mincpc = sblock.fs_cpc; ! 179: if (mincpc > MAXCPG) { ! 180: printf("Maximum frag size with %d sectors per cylinder is %d\n", ! 181: sblock.fs_spc, sblock.fs_fsize / (mincpc / MAXCPG)); ! 182: exit(1); ! 183: } ! 184: bpcg = sblock.fs_spc * sectorsize; ! 185: inospercg = roundup(bpcg / sizeof(struct dinode), INOPB(&sblock)); ! 186: if (inospercg > MAXIPG) ! 187: inospercg = MAXIPG; ! 188: used = (sblock.fs_iblkno + inospercg / INOPF(&sblock)) * NSPF(&sblock); ! 189: mincpgcnt = howmany(sblock.fs_cgoffset * (~sblock.fs_cgmask) + used, ! 190: sblock.fs_spc); ! 191: mincpg = roundup(mincpgcnt, mincpc); ! 192: /* ! 193: * Insure that cylinder group with mincpg has enough space ! 194: * for block maps ! 195: */ ! 196: mapcramped = 0; ! 197: while (mincpg * sblock.fs_spc > MAXBPG(&sblock) * NSPB(&sblock)) { ! 198: mapcramped = 1; ! 199: if (sblock.fs_bsize < MAXBSIZE) { ! 200: sblock.fs_bsize <<= 1; ! 201: if ((i & 1) == 0) { ! 202: i >>= 1; ! 203: } else { ! 204: sblock.fs_cpc <<= 1; ! 205: mincpc <<= 1; ! 206: mincpg = roundup(mincpgcnt, mincpc); ! 207: } ! 208: sblock.fs_frag <<= 1; ! 209: sblock.fs_fragshift += 1; ! 210: if (sblock.fs_frag <= MAXFRAG) ! 211: continue; ! 212: } ! 213: if (sblock.fs_fsize == sblock.fs_bsize) { ! 214: printf("There is no block size that"); ! 215: printf(" can support this disk\n"); ! 216: exit(1); ! 217: } ! 218: sblock.fs_frag >>= 1; ! 219: sblock.fs_fragshift -= 1; ! 220: sblock.fs_fsize <<= 1; ! 221: sblock.fs_nspf <<= 1; ! 222: } ! 223: /* ! 224: * Insure that cylinder group with mincpg has enough space for inodes ! 225: */ ! 226: inodecramped = 0; ! 227: used *= sectorsize; ! 228: inospercg = (mincpg * bpcg - used) / density; ! 229: while (inospercg > MAXIPG) { ! 230: inodecramped = 1; ! 231: if (mincpc == 1 || sblock.fs_frag == 1 || ! 232: sblock.fs_bsize == MINBSIZE) ! 233: break; ! 234: printf("With a block size of %d %s %d\n", sblock.fs_bsize, ! 235: "minimum bytes per inode is", ! 236: (mincpg * bpcg - used) / MAXIPG + 1); ! 237: sblock.fs_bsize >>= 1; ! 238: sblock.fs_frag >>= 1; ! 239: sblock.fs_fragshift -= 1; ! 240: mincpc >>= 1; ! 241: i = roundup(mincpgcnt, mincpc); ! 242: if (i * sblock.fs_spc > MAXBPG(&sblock) * NSPB(&sblock)) { ! 243: sblock.fs_bsize <<= 1; ! 244: break; ! 245: } ! 246: mincpg = i; ! 247: inospercg = (mincpg * bpcg - used) / density; ! 248: } ! 249: if (inodecramped) { ! 250: if (inospercg > MAXIPG) { ! 251: printf("Minimum bytes per inode is %d\n", ! 252: (mincpg * bpcg - used) / MAXIPG + 1); ! 253: } else if (!mapcramped) { ! 254: printf("With %d bytes per inode, ", density); ! 255: printf("minimum cylinders per group is %d\n", mincpg); ! 256: } ! 257: } ! 258: if (mapcramped) { ! 259: printf("With %d sectors per cylinder, ", sblock.fs_spc); ! 260: printf("minimum cylinders per group is %d\n", mincpg); ! 261: } ! 262: if (inodecramped || mapcramped) { ! 263: if (sblock.fs_bsize != bsize) ! 264: printf("%s to be changed from %d to %d\n", ! 265: "This requires the block size", ! 266: bsize, sblock.fs_bsize); ! 267: if (sblock.fs_fsize != fsize) ! 268: printf("\t%s to be changed from %d to %d\n", ! 269: "and the fragment size", ! 270: bsize, sblock.fs_bsize); ! 271: exit(1); ! 272: } ! 273: /* ! 274: * Calculate the number of cylinders per group ! 275: */ ! 276: sblock.fs_cpg = cpg; ! 277: if (sblock.fs_cpg % mincpc != 0) { ! 278: printf("%s groups must have a multiple of %d cylinders\n", ! 279: cpgflg ? "Cylinder" : "Warning: cylinder", mincpc); ! 280: sblock.fs_cpg = roundup(sblock.fs_cpg, mincpc); ! 281: } ! 282: /* ! 283: * Must insure there is enough space to hold block map ! 284: */ ! 285: sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock); ! 286: while (sblock.fs_fpg > MAXBPG(&sblock) * sblock.fs_frag) { ! 287: mapcramped = 1; ! 288: sblock.fs_cpg -= mincpc; ! 289: sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock); ! 290: } ! 291: /* ! 292: * Must insure there is enough space for inodes ! 293: */ ! 294: inospercg = (sblock.fs_cpg * bpcg - used) / density; ! 295: while (inospercg > MAXIPG) { ! 296: inodecramped = 1; ! 297: sblock.fs_cpg -= mincpc; ! 298: sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock); ! 299: inospercg = (sblock.fs_cpg * bpcg - used) / density; ! 300: } ! 301: if ((sblock.fs_cpg * sblock.fs_spc) % NSPB(&sblock) != 0) { ! 302: printf("newfs: panic (fs_cpg * fs_spc) % NSPF != 0"); ! 303: exit(2); ! 304: } ! 305: if (sblock.fs_cpg < mincpg) { ! 306: printf("cylinder groups must have at least %d cylinders\n", ! 307: mincpg); ! 308: exit(1); ! 309: } else if (sblock.fs_cpg > MAXCPG) { ! 310: printf("cylinder groups are limited to %d cylinders\n", MAXCPG); ! 311: exit(1); ! 312: } else if (sblock.fs_cpg != cpg) { ! 313: if (!cpgflg) ! 314: printf("Warning: "); ! 315: if (mapcramped && inodecramped) ! 316: printf("Block size and bytes per inode restrict"); ! 317: else if (mapcramped) ! 318: printf("Block size restricts"); ! 319: else ! 320: printf("Bytes per inode restrict"); ! 321: printf(" cylinders per group to %d.\n", sblock.fs_cpg); ! 322: if (cpgflg) ! 323: exit(1); ! 324: } ! 325: sblock.fs_cgsize = fragroundup(&sblock, ! 326: sizeof(struct cg) + howmany(sblock.fs_fpg, NBBY)); ! 327: /* ! 328: * Now have size for file system and nsect and ntrak. ! 329: * Determine number of cylinders and blocks in the file system. ! 330: */ ! 331: sblock.fs_size = fssize = dbtofsb(&sblock, fssize); ! 332: sblock.fs_ncyl = fssize * NSPF(&sblock) / sblock.fs_spc; ! 333: if (fssize * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) { ! 334: sblock.fs_ncyl++; ! 335: warn = 1; ! 336: } ! 337: if (sblock.fs_ncyl < 1) { ! 338: printf("file systems must have at least one cylinder\n"); ! 339: exit(1); ! 340: } ! 341: /* ! 342: * determine feasability/values of rotational layout tables ! 343: */ ! 344: sblock.fs_interleave = interleave; ! 345: sblock.fs_trackskew = trackskew; ! 346: sblock.fs_npsect = nphyssectors; ! 347: if (sblock.fs_ntrak == 1) { ! 348: sblock.fs_cpc = 0; ! 349: goto next; ! 350: } ! 351: if (sblock.fs_spc * sblock.fs_cpc > MAXBPC * NSPB(&sblock) || ! 352: sblock.fs_nsect > (1 << NBBY) * NSPB(&sblock)) { ! 353: printf("%s %s %d %s %d.%s", ! 354: "Warning: insufficient space in super block for\n", ! 355: "rotational layout tables with nsect", sblock.fs_nsect, ! 356: "and ntrak", sblock.fs_ntrak, ! 357: "\nFile system performance may be impaired.\n"); ! 358: sblock.fs_cpc = 0; ! 359: goto next; ! 360: } ! 361: /* ! 362: * calculate the available blocks for each rotational position ! 363: */ ! 364: for (cylno = 0; cylno < MAXCPG; cylno++) ! 365: for (rpos = 0; rpos < NRPOS; rpos++) ! 366: sblock.fs_postbl[cylno][rpos] = -1; ! 367: blk = sblock.fs_spc * sblock.fs_cpc / NSPF(&sblock); ! 368: for (i = 0; i < blk; i += sblock.fs_frag) ! 369: /* void */; ! 370: for (i -= sblock.fs_frag; i >= 0; i -= sblock.fs_frag) { ! 371: cylno = cbtocylno(&sblock, i); ! 372: rpos = cbtorpos(&sblock, i); ! 373: blk = i / sblock.fs_frag; ! 374: if (sblock.fs_postbl[cylno][rpos] == -1) ! 375: sblock.fs_rotbl[blk] = 0; ! 376: else ! 377: sblock.fs_rotbl[blk] = ! 378: sblock.fs_postbl[cylno][rpos] - blk; ! 379: sblock.fs_postbl[cylno][rpos] = blk; ! 380: } ! 381: next: ! 382: /* ! 383: * Compute/validate number of cylinder groups. ! 384: */ ! 385: sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg; ! 386: if (sblock.fs_ncyl % sblock.fs_cpg) ! 387: sblock.fs_ncg++; ! 388: /* ! 389: * Compute number of inode blocks per cylinder group. ! 390: */ ! 391: sblock.fs_ipg = roundup(inospercg, INOPB(&sblock)); ! 392: if (sblock.fs_ipg > MAXIPG) { ! 393: printf("newfs: panic fs_ipg > MAXIPG"); ! 394: exit(3); ! 395: } ! 396: sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock); ! 397: i = MIN(~sblock.fs_cgmask, sblock.fs_ncg - 1); ! 398: if (cgdmin(&sblock, i) - cgbase(&sblock, i) >= sblock.fs_fpg) { ! 399: printf("inode blocks/cyl group (%d) >= data blocks (%d)\n", ! 400: cgdmin(&sblock, i) - cgbase(&sblock, i) / sblock.fs_frag, ! 401: sblock.fs_fpg / sblock.fs_frag); ! 402: printf("number of cylinders per cylinder group (%d) %s.\n", ! 403: sblock.fs_ncg, "must be increased"); ! 404: exit(1); ! 405: } ! 406: j = sblock.fs_ncg - 1; ! 407: if ((i = fssize - j * sblock.fs_fpg) < sblock.fs_fpg && ! 408: cgdmin(&sblock, j) - cgbase(&sblock, j) > i) { ! 409: printf("Warning: inode blocks/cyl group (%d) >= data blocks (%d) in last\n", ! 410: (cgdmin(&sblock, j) - cgbase(&sblock, j)) / sblock.fs_frag, ! 411: i / sblock.fs_frag); ! 412: printf(" cylinder group. This implies %d sector(s) cannot be allocated.\n", ! 413: i * NSPF(&sblock)); ! 414: sblock.fs_ncg--; ! 415: sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg; ! 416: sblock.fs_size = fssize = sblock.fs_ncyl * sblock.fs_spc / ! 417: NSPF(&sblock); ! 418: warn = 0; ! 419: } ! 420: if (warn) { ! 421: printf("Warning: %d sector(s) in last cylinder unallocated\n", ! 422: sblock.fs_spc - ! 423: (fssize * NSPF(&sblock) - (sblock.fs_ncyl - 1) ! 424: * sblock.fs_spc)); ! 425: } ! 426: /* ! 427: * fill in remaining fields of the super block ! 428: */ ! 429: sblock.fs_csaddr = cgdmin(&sblock, 0); ! 430: sblock.fs_cssize = ! 431: fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum)); ! 432: i = sblock.fs_bsize / sizeof(struct csum); ! 433: sblock.fs_csmask = ~(i - 1); ! 434: for (sblock.fs_csshift = 0; i > 1; i >>= 1) ! 435: sblock.fs_csshift++; ! 436: i = sizeof(struct fs) + ! 437: howmany(sblock.fs_spc * sblock.fs_cpc, NSPB(&sblock)); ! 438: sblock.fs_sbsize = fragroundup(&sblock, i); ! 439: fscs = (struct csum *)calloc(1, sblock.fs_cssize); ! 440: sblock.fs_magic = FS_MAGIC; ! 441: sblock.fs_rotdelay = rotdelay; ! 442: sblock.fs_minfree = minfree; ! 443: sblock.fs_maxcontig = maxcontig; ! 444: sblock.fs_headswitch = headswitch; ! 445: sblock.fs_trkseek = trackseek; ! 446: sblock.fs_maxbpg = maxbpg; ! 447: sblock.fs_rps = rpm / 60; ! 448: sblock.fs_optim = opt; ! 449: sblock.fs_cgrotor = 0; ! 450: sblock.fs_cstotal.cs_ndir = 0; ! 451: sblock.fs_cstotal.cs_nbfree = 0; ! 452: sblock.fs_cstotal.cs_nifree = 0; ! 453: sblock.fs_cstotal.cs_nffree = 0; ! 454: sblock.fs_fmod = 0; ! 455: sblock.fs_ronly = 0; ! 456: /* ! 457: * Dump out summary information about file system. ! 458: */ ! 459: printf("%s:\t%d sectors in %d cylinders of %d tracks, %d sectors\n", ! 460: fsys, sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl, ! 461: sblock.fs_ntrak, sblock.fs_nsect); ! 462: printf("\t%.1fMb in %d cyl groups (%d c/g, %.2fMb/g, %d i/g)\n", ! 463: (float)sblock.fs_size * sblock.fs_fsize * 1e-6, sblock.fs_ncg, ! 464: sblock.fs_cpg, (float)sblock.fs_fpg * sblock.fs_fsize * 1e-6, ! 465: sblock.fs_ipg); ! 466: /* ! 467: * Now build the cylinders group blocks and ! 468: * then print out indices of cylinder groups. ! 469: */ ! 470: printf("super-block backups (for fsck -b#) at:"); ! 471: for (cylno = 0; cylno < sblock.fs_ncg; cylno++) { ! 472: initcg(cylno); ! 473: if (cylno % 9 == 0) ! 474: printf("\n"); ! 475: printf(" %d,", fsbtodb(&sblock, cgsblock(&sblock, cylno))); ! 476: } ! 477: printf("\n"); ! 478: if (Nflag) ! 479: exit(0); ! 480: /* ! 481: * Now construct the initial file system, ! 482: * then write out the super-block. ! 483: */ ! 484: fsinit(); ! 485: sblock.fs_time = utime; ! 486: wtfs(SBOFF / sectorsize, sbsize, (char *)&sblock); ! 487: for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) ! 488: wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)), ! 489: sblock.fs_cssize - i < sblock.fs_bsize ? ! 490: sblock.fs_cssize - i : sblock.fs_bsize, ! 491: ((char *)fscs) + i); ! 492: /* ! 493: * Write out the duplicate super blocks ! 494: */ ! 495: for (cylno = 0; cylno < sblock.fs_ncg; cylno++) ! 496: wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)), ! 497: sbsize, (char *)&sblock); ! 498: /* ! 499: * Update information about this partion in pack ! 500: * label, to that it may be updated on disk. ! 501: */ ! 502: pp->p_fstype = FS_BSDFFS; ! 503: pp->p_fsize = sblock.fs_fsize; ! 504: pp->p_frag = sblock.fs_frag; ! 505: pp->p_cpg = sblock.fs_cpg; ! 506: } ! 507: ! 508: /* ! 509: * Initialize a cylinder group. ! 510: */ ! 511: initcg(cylno) ! 512: int cylno; ! 513: { ! 514: daddr_t cbase, d, dlower, dupper, dmax; ! 515: long i, j, s; ! 516: register struct csum *cs; ! 517: ! 518: /* ! 519: * Determine block bounds for cylinder group. ! 520: * Allow space for super block summary information in first ! 521: * cylinder group. ! 522: */ ! 523: cbase = cgbase(&sblock, cylno); ! 524: dmax = cbase + sblock.fs_fpg; ! 525: if (dmax > sblock.fs_size) ! 526: dmax = sblock.fs_size; ! 527: dlower = cgsblock(&sblock, cylno) - cbase; ! 528: dupper = cgdmin(&sblock, cylno) - cbase; ! 529: cs = fscs + cylno; ! 530: acg.cg_time = utime; ! 531: acg.cg_magic = CG_MAGIC; ! 532: acg.cg_cgx = cylno; ! 533: if (cylno == sblock.fs_ncg - 1) ! 534: acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg; ! 535: else ! 536: acg.cg_ncyl = sblock.fs_cpg; ! 537: acg.cg_niblk = sblock.fs_ipg; ! 538: acg.cg_ndblk = dmax - cbase; ! 539: acg.cg_cs.cs_ndir = 0; ! 540: acg.cg_cs.cs_nffree = 0; ! 541: acg.cg_cs.cs_nbfree = 0; ! 542: acg.cg_cs.cs_nifree = 0; ! 543: acg.cg_rotor = 0; ! 544: acg.cg_frotor = 0; ! 545: acg.cg_irotor = 0; ! 546: for (i = 0; i < sblock.fs_frag; i++) { ! 547: acg.cg_frsum[i] = 0; ! 548: } ! 549: for (i = 0; i < sblock.fs_ipg; ) { ! 550: for (j = INOPB(&sblock); j > 0; j--) { ! 551: clrbit(acg.cg_iused, i); ! 552: i++; ! 553: } ! 554: acg.cg_cs.cs_nifree += INOPB(&sblock); ! 555: } ! 556: if (cylno == 0) ! 557: for (i = 0; i < ROOTINO; i++) { ! 558: setbit(acg.cg_iused, i); ! 559: acg.cg_cs.cs_nifree--; ! 560: } ! 561: while (i < MAXIPG) { ! 562: clrbit(acg.cg_iused, i); ! 563: i++; ! 564: } ! 565: wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno)), ! 566: sblock.fs_ipg * sizeof (struct dinode), (char *)zino); ! 567: for (i = 0; i < MAXCPG; i++) { ! 568: acg.cg_btot[i] = 0; ! 569: for (j = 0; j < NRPOS; j++) ! 570: acg.cg_b[i][j] = 0; ! 571: } ! 572: if (cylno == 0) { ! 573: /* ! 574: * reserve space for summary info and Boot block ! 575: */ ! 576: dupper += howmany(sblock.fs_cssize, sblock.fs_fsize); ! 577: for (d = 0; d < dlower; d += sblock.fs_frag) ! 578: clrblock(&sblock, acg.cg_free, d/sblock.fs_frag); ! 579: } else { ! 580: for (d = 0; d < dlower; d += sblock.fs_frag) { ! 581: setblock(&sblock, acg.cg_free, d/sblock.fs_frag); ! 582: acg.cg_cs.cs_nbfree++; ! 583: acg.cg_btot[cbtocylno(&sblock, d)]++; ! 584: acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]++; ! 585: } ! 586: sblock.fs_dsize += dlower; ! 587: } ! 588: sblock.fs_dsize += acg.cg_ndblk - dupper; ! 589: for (; d < dupper; d += sblock.fs_frag) ! 590: clrblock(&sblock, acg.cg_free, d/sblock.fs_frag); ! 591: if (d > dupper) { ! 592: acg.cg_frsum[d - dupper]++; ! 593: for (i = d - 1; i >= dupper; i--) { ! 594: setbit(acg.cg_free, i); ! 595: acg.cg_cs.cs_nffree++; ! 596: } ! 597: } ! 598: while ((d + sblock.fs_frag) <= dmax - cbase) { ! 599: setblock(&sblock, acg.cg_free, d/sblock.fs_frag); ! 600: acg.cg_cs.cs_nbfree++; ! 601: acg.cg_btot[cbtocylno(&sblock, d)]++; ! 602: acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]++; ! 603: d += sblock.fs_frag; ! 604: } ! 605: if (d < dmax - cbase) { ! 606: acg.cg_frsum[dmax - cbase - d]++; ! 607: for (; d < dmax - cbase; d++) { ! 608: setbit(acg.cg_free, d); ! 609: acg.cg_cs.cs_nffree++; ! 610: } ! 611: for (; d % sblock.fs_frag != 0; d++) ! 612: clrbit(acg.cg_free, d); ! 613: } ! 614: for (d /= sblock.fs_frag; d < MAXBPG(&sblock); d ++) ! 615: clrblock(&sblock, acg.cg_free, d); ! 616: sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir; ! 617: sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree; ! 618: sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree; ! 619: sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree; ! 620: *cs = acg.cg_cs; ! 621: wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), ! 622: sblock.fs_bsize, (char *)&acg); ! 623: } ! 624: ! 625: /* ! 626: * initialize the file system ! 627: */ ! 628: struct inode node; ! 629: ! 630: #ifdef LOSTDIR ! 631: #define PREDEFDIR 3 ! 632: #else ! 633: #define PREDEFDIR 2 ! 634: #endif ! 635: ! 636: struct direct root_dir[] = { ! 637: { ROOTINO, sizeof(struct direct), 1, "." }, ! 638: { ROOTINO, sizeof(struct direct), 2, ".." }, ! 639: #ifdef LOSTDIR ! 640: { LOSTFOUNDINO, sizeof(struct direct), 10, "lost+found" }, ! 641: #endif ! 642: }; ! 643: #ifdef LOSTDIR ! 644: struct direct lost_found_dir[] = { ! 645: { LOSTFOUNDINO, sizeof(struct direct), 1, "." }, ! 646: { ROOTINO, sizeof(struct direct), 2, ".." }, ! 647: { 0, DIRBLKSIZ, 0, 0 }, ! 648: }; ! 649: #endif ! 650: char buf[MAXBSIZE]; ! 651: ! 652: fsinit() ! 653: { ! 654: int i; ! 655: ! 656: /* ! 657: * initialize the node ! 658: */ ! 659: node.i_atime = utime; ! 660: node.i_mtime = utime; ! 661: node.i_ctime = utime; ! 662: #ifdef LOSTDIR ! 663: /* ! 664: * create the lost+found directory ! 665: */ ! 666: (void)makedir(lost_found_dir, 2); ! 667: for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ) ! 668: bcopy(&lost_found_dir[2], &buf[i], DIRSIZ(&lost_found_dir[2])); ! 669: node.i_number = LOSTFOUNDINO; ! 670: node.i_mode = IFDIR | UMASK; ! 671: node.i_nlink = 2; ! 672: node.i_size = sblock.fs_bsize; ! 673: node.i_db[0] = alloc(node.i_size, node.i_mode); ! 674: node.i_blocks = btodb(fragroundup(&sblock, node.i_size)); ! 675: wtfs(fsbtodb(&sblock, node.i_db[0]), node.i_size, buf); ! 676: iput(&node); ! 677: #endif ! 678: /* ! 679: * create the root directory ! 680: */ ! 681: node.i_number = ROOTINO; ! 682: node.i_mode = IFDIR | UMASK; ! 683: node.i_nlink = PREDEFDIR; ! 684: node.i_size = makedir(root_dir, PREDEFDIR); ! 685: node.i_db[0] = alloc(sblock.fs_fsize, node.i_mode); ! 686: node.i_blocks = btodb(fragroundup(&sblock, node.i_size)); ! 687: wtfs(fsbtodb(&sblock, node.i_db[0]), sblock.fs_fsize, buf); ! 688: iput(&node); ! 689: } ! 690: ! 691: /* ! 692: * construct a set of directory entries in "buf". ! 693: * return size of directory. ! 694: */ ! 695: makedir(protodir, entries) ! 696: register struct direct *protodir; ! 697: int entries; ! 698: { ! 699: char *cp; ! 700: int i, spcleft; ! 701: ! 702: spcleft = DIRBLKSIZ; ! 703: for (cp = buf, i = 0; i < entries - 1; i++) { ! 704: protodir[i].d_reclen = DIRSIZ(&protodir[i]); ! 705: bcopy(&protodir[i], cp, protodir[i].d_reclen); ! 706: cp += protodir[i].d_reclen; ! 707: spcleft -= protodir[i].d_reclen; ! 708: } ! 709: protodir[i].d_reclen = spcleft; ! 710: bcopy(&protodir[i], cp, DIRSIZ(&protodir[i])); ! 711: return (DIRBLKSIZ); ! 712: } ! 713: ! 714: /* ! 715: * allocate a block or frag ! 716: */ ! 717: daddr_t ! 718: alloc(size, mode) ! 719: int size; ! 720: int mode; ! 721: { ! 722: int i, frag; ! 723: daddr_t d; ! 724: ! 725: rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize, ! 726: (char *)&acg); ! 727: if (acg.cg_magic != CG_MAGIC) { ! 728: printf("cg 0: bad magic number\n"); ! 729: return (0); ! 730: } ! 731: if (acg.cg_cs.cs_nbfree == 0) { ! 732: printf("first cylinder group ran out of space\n"); ! 733: return (0); ! 734: } ! 735: for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag) ! 736: if (isblock(&sblock, acg.cg_free, d / sblock.fs_frag)) ! 737: goto goth; ! 738: printf("internal error: can't find block in cyl 0\n"); ! 739: return (0); ! 740: goth: ! 741: clrblock(&sblock, acg.cg_free, d / sblock.fs_frag); ! 742: acg.cg_cs.cs_nbfree--; ! 743: sblock.fs_cstotal.cs_nbfree--; ! 744: fscs[0].cs_nbfree--; ! 745: if (mode & IFDIR) { ! 746: acg.cg_cs.cs_ndir++; ! 747: sblock.fs_cstotal.cs_ndir++; ! 748: fscs[0].cs_ndir++; ! 749: } ! 750: acg.cg_btot[cbtocylno(&sblock, d)]--; ! 751: acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]--; ! 752: if (size != sblock.fs_bsize) { ! 753: frag = howmany(size, sblock.fs_fsize); ! 754: fscs[0].cs_nffree += sblock.fs_frag - frag; ! 755: sblock.fs_cstotal.cs_nffree += sblock.fs_frag - frag; ! 756: acg.cg_cs.cs_nffree += sblock.fs_frag - frag; ! 757: acg.cg_frsum[sblock.fs_frag - frag]++; ! 758: for (i = frag; i < sblock.fs_frag; i++) ! 759: setbit(acg.cg_free, d + i); ! 760: } ! 761: wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize, ! 762: (char *)&acg); ! 763: return (d); ! 764: } ! 765: ! 766: /* ! 767: * Allocate an inode on the disk ! 768: */ ! 769: iput(ip) ! 770: register struct inode *ip; ! 771: { ! 772: struct dinode buf[MAXINOPB]; ! 773: daddr_t d; ! 774: int c; ! 775: ! 776: c = itog(&sblock, ip->i_number); ! 777: rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize, ! 778: (char *)&acg); ! 779: if (acg.cg_magic != CG_MAGIC) { ! 780: printf("cg 0: bad magic number\n"); ! 781: exit(1); ! 782: } ! 783: acg.cg_cs.cs_nifree--; ! 784: setbit(acg.cg_iused, ip->i_number); ! 785: wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize, ! 786: (char *)&acg); ! 787: sblock.fs_cstotal.cs_nifree--; ! 788: fscs[0].cs_nifree--; ! 789: if(ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) { ! 790: printf("fsinit: inode value out of range (%d).\n", ! 791: ip->i_number); ! 792: exit(1); ! 793: } ! 794: d = fsbtodb(&sblock, itod(&sblock, ip->i_number)); ! 795: rdfs(d, sblock.fs_bsize, buf); ! 796: buf[itoo(&sblock, ip->i_number)].di_ic = ip->i_ic; ! 797: wtfs(d, sblock.fs_bsize, buf); ! 798: } ! 799: ! 800: /* ! 801: * read a block from the file system ! 802: */ ! 803: rdfs(bno, size, bf) ! 804: daddr_t bno; ! 805: int size; ! 806: char *bf; ! 807: { ! 808: int n; ! 809: ! 810: if (lseek(fsi, bno * sectorsize, 0) < 0) { ! 811: printf("seek error: %ld\n", bno); ! 812: perror("rdfs"); ! 813: exit(1); ! 814: } ! 815: n = read(fsi, bf, size); ! 816: if(n != size) { ! 817: printf("read error: %ld\n", bno); ! 818: perror("rdfs"); ! 819: exit(1); ! 820: } ! 821: } ! 822: ! 823: /* ! 824: * write a block to the file system ! 825: */ ! 826: wtfs(bno, size, bf) ! 827: daddr_t bno; ! 828: int size; ! 829: char *bf; ! 830: { ! 831: int n; ! 832: ! 833: if (Nflag) ! 834: return; ! 835: if (lseek(fso, bno * sectorsize, 0) < 0) { ! 836: printf("seek error: %ld\n", bno); ! 837: perror("wtfs"); ! 838: exit(1); ! 839: } ! 840: n = write(fso, bf, size); ! 841: if(n != size) { ! 842: printf("write error: %D\n", bno); ! 843: perror("wtfs"); ! 844: exit(1); ! 845: } ! 846: } ! 847: ! 848: /* ! 849: * check if a block is available ! 850: */ ! 851: isblock(fs, cp, h) ! 852: struct fs *fs; ! 853: unsigned char *cp; ! 854: int h; ! 855: { ! 856: unsigned char mask; ! 857: ! 858: switch (fs->fs_frag) { ! 859: case 8: ! 860: return (cp[h] == 0xff); ! 861: case 4: ! 862: mask = 0x0f << ((h & 0x1) << 2); ! 863: return ((cp[h >> 1] & mask) == mask); ! 864: case 2: ! 865: mask = 0x03 << ((h & 0x3) << 1); ! 866: return ((cp[h >> 2] & mask) == mask); ! 867: case 1: ! 868: mask = 0x01 << (h & 0x7); ! 869: return ((cp[h >> 3] & mask) == mask); ! 870: default: ! 871: #ifdef STANDALONE ! 872: printf("isblock bad fs_frag %d\n", fs->fs_frag); ! 873: #else ! 874: fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag); ! 875: #endif ! 876: return (0); ! 877: } ! 878: } ! 879: ! 880: /* ! 881: * take a block out of the map ! 882: */ ! 883: clrblock(fs, cp, h) ! 884: struct fs *fs; ! 885: unsigned char *cp; ! 886: int h; ! 887: { ! 888: switch ((fs)->fs_frag) { ! 889: case 8: ! 890: cp[h] = 0; ! 891: return; ! 892: case 4: ! 893: cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2)); ! 894: return; ! 895: case 2: ! 896: cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1)); ! 897: return; ! 898: case 1: ! 899: cp[h >> 3] &= ~(0x01 << (h & 0x7)); ! 900: return; ! 901: default: ! 902: #ifdef STANDALONE ! 903: printf("clrblock bad fs_frag %d\n", fs->fs_frag); ! 904: #else ! 905: fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag); ! 906: #endif ! 907: return; ! 908: } ! 909: } ! 910: ! 911: /* ! 912: * put a block into the map ! 913: */ ! 914: setblock(fs, cp, h) ! 915: struct fs *fs; ! 916: unsigned char *cp; ! 917: int h; ! 918: { ! 919: switch (fs->fs_frag) { ! 920: case 8: ! 921: cp[h] = 0xff; ! 922: return; ! 923: case 4: ! 924: cp[h >> 1] |= (0x0f << ((h & 0x1) << 2)); ! 925: return; ! 926: case 2: ! 927: cp[h >> 2] |= (0x03 << ((h & 0x3) << 1)); ! 928: return; ! 929: case 1: ! 930: cp[h >> 3] |= (0x01 << (h & 0x7)); ! 931: return; ! 932: default: ! 933: #ifdef STANDALONE ! 934: printf("setblock bad fs_frag %d\n", fs->fs_frag); ! 935: #else ! 936: fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag); ! 937: #endif ! 938: return; ! 939: } ! 940: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.