date and time created 83/02/18 00:41:42 by mckusick

[unix-history] / usr / src / sbin / newfs / mkfs.c

diff --git a/usr/src/sbin/newfs/mkfs.c b/usr/src/sbin/newfs/mkfs.c
index 4198999..782411d 100644 (file)
--- a/usr/src/sbin/newfs/mkfs.c
+++ b/usr/src/sbin/newfs/mkfs.c
@@ -1,4 +1,4 @@
-static char *sccsid = "@(#)mkfs.c      1.12 (Berkeley) %G%";
+static char *sccsid = "@(#)mkfs.c      2.8 (Berkeley) %G%";

 
 /*
  * make file system for cylinder-group style file systems
 
 /*
  * make file system for cylinder-group style file systems


@@ -6,18 +6,94 @@ static        char *sccsid = "@(#)mkfs.c      1.12 (Berkeley) %G%";
  * usage: mkfs special size [ nsect ntrak bsize fsize cpg ]
  */
 
  * usage: mkfs special size [ nsect ntrak bsize fsize cpg ]
  */
 

+/*
+ * The following constants set the defaults used for the number
+ * of sectors (fs_nsect), and number of tracks (fs_ntrak).
+ */
+#define DFLNSECT       32
+#define DFLNTRAK       16
+
+/*
+ * The following two constants set the default block and fragment sizes.
+ * Both constants must be a power of 2 and meet the following constraints:
+ *     MINBSIZE <= DESBLKSIZE <= MAXBSIZE
+ *     DEV_BSIZE <= DESFRAGSIZE <= DESBLKSIZE
+ *     DESBLKSIZE / DESFRAGSIZE <= 8
+ */
+#define DESBLKSIZE     8192
+#define DESFRAGSIZE    1024
+
+/*
+ * Cylinder groups may have up to MAXCPG cylinders. The actual
+ * number used depends upon how much information can be stored
+ * on a single cylinder. The default is to used 16 cylinders
+ * per group.
+ */
+#define        DESCPG          16      /* desired fs_cpg */
+
+/*
+ * MINFREE gives the minimum acceptable percentage of file system
+ * blocks which may be free. If the freelist drops below this level
+ * only the superuser may continue to allocate blocks. This may
+ * be set to 0 if no reserve of free blocks is deemed necessary,
+ * however throughput drops by fifty percent if the file system
+ * is run at between 90% and 100% full; thus the default value of
+ * fs_minfree is 10%.
+ */
+#define MINFREE                10
+
+/*
+ * ROTDELAY gives the minimum number of milliseconds to initiate
+ * another disk transfer on the same cylinder. It is used in
+ * determining the rotationally optimal layout for disk blocks
+ * within a file; the default of fs_rotdelay is 2ms.
+ */
+#define ROTDELAY       2
+
+/*
+ * MAXCONTIG sets the default for the maximum number of blocks
+ * that may be allocated sequentially. Since UNIX drivers are
+ * not capable of scheduling multi-block transfers, this defaults
+ * to 1 (ie no contiguous blocks are allocated).
+ */
+#define MAXCONTIG      1
+
+/*
+ * MAXBLKPG determines the maximum number of data blocks which are
+ * placed in a single cylinder group. This is currently a function
+ * of the block and fragment size of the file system.
+ */
+#define MAXBLKPG(fs)   ((fs)->fs_fsize / sizeof(daddr_t))
+
+/*
+ * Each file system has a number of inodes statically allocated.
+ * We allocate one inode slot per NBPI bytes, expecting this
+ * to be far more than we will ever need.
+ */
+#define        NBPI            2048
+
+/*
+ * Disks are assumed to rotate at 60HZ, unless otherwise specified.
+ */
+#define        DEFHZ           60
+

 #ifndef STANDALONE
 #include <stdio.h>
 #include <a.out.h>
 #endif
 
 #ifndef STANDALONE
 #include <stdio.h>
 #include <a.out.h>
 #endif
 

+#ifndef SIMFS
+#include <sys/param.h>
+#include <sys/inode.h>
+#include <sys/fs.h>
+#else

 #include "../h/param.h"
 #include "../h/inode.h"
 #include "../h/fs.h"
 #include "../h/param.h"
 #include "../h/inode.h"
 #include "../h/fs.h"

-#include "../h/dir.h"
+#endif
+#include <dir.h>

 
 #define UMASK          0755
 
 #define UMASK          0755

-#define MAXNDIR                (MAXBSIZE / sizeof(struct direct))

 #define MAXINOPB       (MAXBSIZE / sizeof(struct dinode))
 #define POWEROF2(num)  (((num) & ((num) - 1)) == 0)
 
 #define MAXINOPB       (MAXBSIZE / sizeof(struct dinode))
 #define POWEROF2(num)  (((num) & ((num) - 1)) == 0)
 


@@ -46,13 +122,13 @@ main(argc, argv)
        int argc;
        char *argv[];
 {
        int argc;
        char *argv[];
 {

-       long c, i, inos, fssize;
+       long cylno, rpos, blk, i, j, inos, fssize, warn = 0;

 
 #ifndef STANDALONE
        argc--, argv++;
        time(&utime);
        if (argc < 2) {
 
 #ifndef STANDALONE
        argc--, argv++;
        time(&utime);
        if (argc < 2) {

-               printf("usage: mkfs special size [ nsect ntrak bsize fsize cpg ]\n");
+               printf("usage: mkfs special size [ nsect ntrak bsize fsize cpg minfree rps ]\n");

                exit(1);
        }
        fsys = argv[0];
                exit(1);
        }
        fsys = argv[0];


@@ -108,11 +184,11 @@ main(argc, argv)
        if (argc > 4)
                sblock.fs_bsize = atoi(argv[4]);
        else
        if (argc > 4)
                sblock.fs_bsize = atoi(argv[4]);
        else

-               sblock.fs_bsize = MAXBSIZE;
+               sblock.fs_bsize = DESBLKSIZE;

        if (argc > 5)
                sblock.fs_fsize = atoi(argv[5]);
        else
        if (argc > 5)
                sblock.fs_fsize = atoi(argv[5]);
        else

-               sblock.fs_fsize = MAX(sblock.fs_bsize / DESFRAG, DEV_BSIZE);
+               sblock.fs_fsize = DESFRAGSIZE;

        if (!POWEROF2(sblock.fs_bsize)) {
                printf("block size must be a power of 2, not %d\n",
                    sblock.fs_bsize);
        if (!POWEROF2(sblock.fs_bsize)) {
                printf("block size must be a power of 2, not %d\n",
                    sblock.fs_bsize);


@@ -138,13 +214,48 @@ main(argc, argv)
                    sblock.fs_bsize, sblock.fs_fsize);
                exit(1);
        }
                    sblock.fs_bsize, sblock.fs_fsize);
                exit(1);
        }

-       sblock.fs_frag = sblock.fs_bsize / sblock.fs_fsize;
+       sblock.fs_bmask = ~(sblock.fs_bsize - 1);
+       sblock.fs_fmask = ~(sblock.fs_fsize - 1);
+       for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1)
+               sblock.fs_bshift++;
+       for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1)
+               sblock.fs_fshift++;
+       sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);
+       for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1)
+               sblock.fs_fragshift++;

        if (sblock.fs_frag > MAXFRAG) {
                printf("fragment size %d is too small, minimum with block size %d is %d\n",
                    sblock.fs_fsize, sblock.fs_bsize,
                    sblock.fs_bsize / MAXFRAG);
                exit(1);
        }
        if (sblock.fs_frag > MAXFRAG) {
                printf("fragment size %d is too small, minimum with block size %d is %d\n",
                    sblock.fs_fsize, sblock.fs_bsize,
                    sblock.fs_bsize / MAXFRAG);
                exit(1);
        }

+       sblock.fs_nindir = sblock.fs_bsize / sizeof(daddr_t);
+       sblock.fs_inopb = sblock.fs_bsize / sizeof(struct dinode);
+       sblock.fs_nspf = sblock.fs_fsize / DEV_BSIZE;
+       for (sblock.fs_fsbtodb = 0, i = sblock.fs_nspf; i > 1; i >>= 1)
+               sblock.fs_fsbtodb++;
+       sblock.fs_sblkno =
+           roundup(howmany(BBSIZE + SBSIZE, sblock.fs_fsize), sblock.fs_frag);
+       sblock.fs_cblkno = (daddr_t)(sblock.fs_sblkno +
+           roundup(howmany(SBSIZE, sblock.fs_fsize), sblock.fs_frag));
+       sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;
+       sblock.fs_cgoffset = roundup(
+           howmany(sblock.fs_nsect, sblock.fs_fsize / DEV_BSIZE),
+           sblock.fs_frag);
+       for (sblock.fs_cgmask = 0xffffffff, i = sblock.fs_ntrak; i > 1; i >>= 1)
+               sblock.fs_cgmask <<= 1;
+       if (!POWEROF2(sblock.fs_ntrak))
+               sblock.fs_cgmask <<= 1;
+       for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc;
+            sblock.fs_cpc > 1 && (i & 1) == 0;
+            sblock.fs_cpc >>= 1, i >>= 1)
+               /* void */;
+       if (sblock.fs_cpc > MAXCPG) {
+               printf("maximum block size with nsect %d and ntrak %d is %d\n",
+                   sblock.fs_nsect, sblock.fs_ntrak,
+                   sblock.fs_bsize / (sblock.fs_cpc / MAXCPG));
+               exit(1);
+       }

        /* 
         * collect and verify the number of cylinders per group
         */
        /* 
         * collect and verify the number of cylinders per group
         */


@@ -152,10 +263,11 @@ main(argc, argv)
                sblock.fs_cpg = atoi(argv[6]);
                sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
        } else {
                sblock.fs_cpg = atoi(argv[6]);
                sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
        } else {

-               sblock.fs_cpg = DESCPG;
+               sblock.fs_cpg = MAX(sblock.fs_cpc, DESCPG);

                sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
                sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);

-               while (sblock.fs_fpg / sblock.fs_frag > MAXBPG(&sblock)) {
-                       --sblock.fs_cpg;
+               while (sblock.fs_fpg / sblock.fs_frag > MAXBPG(&sblock) &&
+                   sblock.fs_cpg > sblock.fs_cpc) {
+                       sblock.fs_cpg -= sblock.fs_cpc;

                        sblock.fs_fpg =
                            (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
                }
                        sblock.fs_fpg =
                            (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
                }


@@ -168,21 +280,63 @@ main(argc, argv)
                printf("cylinder groups are limited to %d cylinders\n", MAXCPG);
                exit(1);
        }
                printf("cylinder groups are limited to %d cylinders\n", MAXCPG);
                exit(1);
        }

+       if (sblock.fs_cpg % sblock.fs_cpc != 0) {
+               printf("cylinder groups must have a multiple of %d cylinders\n",
+                   sblock.fs_cpc);
+               exit(1);
+       }

        /*
         * Now have size for file system and nsect and ntrak.
         * Determine number of cylinders and blocks in the file system.
         */
        sblock.fs_size = fssize = dbtofsb(&sblock, fssize);
        sblock.fs_ncyl = fssize * NSPF(&sblock) / sblock.fs_spc;
        /*
         * Now have size for file system and nsect and ntrak.
         * Determine number of cylinders and blocks in the file system.
         */
        sblock.fs_size = fssize = dbtofsb(&sblock, fssize);
        sblock.fs_ncyl = fssize * NSPF(&sblock) / sblock.fs_spc;

-       if (sblock.fs_spc > MAXBPC * NSPB(&sblock)) {
-               printf("too many sectors per cylinder (%d sectors)\n",
-                   sblock.fs_spc);
-               while (sblock.fs_spc > MAXBPC * NSPB(&sblock))
-                       sblock.fs_bsize <<= 1;
-               printf("nsect %d, and ntrak %d, requires block size of %d\n",
-                   sblock.fs_nsect, sblock.fs_ntrak, sblock.fs_bsize);
+       if (fssize * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) {
+               sblock.fs_ncyl++;
+               warn = 1;
+       }
+       if (sblock.fs_ncyl < 1) {
+               printf("file systems must have at least one cylinder\n");

                exit(1);
        }
                exit(1);
        }

+       /*
+        * determine feasability/values of rotational layout tables
+        */
+       if (sblock.fs_ntrak == 1) {
+               sblock.fs_cpc = 0;
+               goto next;
+       }
+       if (sblock.fs_spc * sblock.fs_cpc > MAXBPC * NSPB(&sblock) ||
+           sblock.fs_nsect > (1 << NBBY) * NSPB(&sblock)) {
+               printf("%s %s %d %s %d.%s",
+                   "Warning: insufficient space in super block for\n",
+                   "rotational layout tables with nsect", sblock.fs_nsect,
+                   "and ntrak", sblock.fs_ntrak,
+                   "\nFile system performance may be impared.\n");
+               sblock.fs_cpc = 0;
+               goto next;
+       }
+       /*
+        * calculate the available blocks for each rotational position
+        */
+       for (cylno = 0; cylno < MAXCPG; cylno++)
+               for (rpos = 0; rpos < NRPOS; rpos++)
+                       sblock.fs_postbl[cylno][rpos] = -1;
+       blk = sblock.fs_spc * sblock.fs_cpc / NSPF(&sblock);
+       for (i = 0; i < blk; i += sblock.fs_frag)
+               /* void */;
+       for (i -= sblock.fs_frag; i >= 0; i -= sblock.fs_frag) {
+               cylno = cbtocylno(&sblock, i);
+               rpos = cbtorpos(&sblock, i);
+               blk = i / sblock.fs_frag;
+               if (sblock.fs_postbl[cylno][rpos] == -1)
+                       sblock.fs_rotbl[blk] = 0;
+               else
+                       sblock.fs_rotbl[blk] =
+                           sblock.fs_postbl[cylno][rpos] - blk;
+               sblock.fs_postbl[cylno][rpos] = blk;
+       }
+next:

        /*
         * Validate specified/determined cpg.
         */
        /*
         * Validate specified/determined cpg.
         */


@@ -204,20 +358,16 @@ main(argc, argv)
        if (sblock.fs_fpg > MAXBPG(&sblock) * sblock.fs_frag) {
                printf("cylinder group too large (%d cylinders); ",
                    sblock.fs_cpg);
        if (sblock.fs_fpg > MAXBPG(&sblock) * sblock.fs_frag) {
                printf("cylinder group too large (%d cylinders); ",
                    sblock.fs_cpg);

-               printf("max: %d cylinders\n",
+               printf("max: %d cylinders per group\n",

                    MAXBPG(&sblock) * sblock.fs_frag /
                    (sblock.fs_fpg / sblock.fs_cpg));
                exit(1);
        }
                    MAXBPG(&sblock) * sblock.fs_frag /
                    (sblock.fs_fpg / sblock.fs_cpg));
                exit(1);
        }

-       sblock.fs_cgsize = roundup(sizeof(struct cg) +
-           howmany(sblock.fs_fpg, NBBY), sblock.fs_fsize);
+       sblock.fs_cgsize = fragroundup(&sblock,
+           sizeof(struct cg) + howmany(sblock.fs_fpg, NBBY));

        /*
         * Compute/validate number of cylinder groups.
         */
        /*
         * Compute/validate number of cylinder groups.
         */

-       if (fssize * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) {
-               printf("%d sector(s) in last cylinder unused\n",
-                   fssize * NSPF(&sblock) - sblock.fs_ncyl * sblock.fs_spc);
-       }

        sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;
        if (sblock.fs_ncyl % sblock.fs_cpg)
                sblock.fs_ncg++;
        sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;
        if (sblock.fs_ncyl % sblock.fs_cpg)
                sblock.fs_ncg++;


@@ -228,48 +378,78 @@ main(argc, argv)
                printf("is not a multiple of %d; choke!\n", sblock.fs_fsize);
                exit(1);
        }
                printf("is not a multiple of %d; choke!\n", sblock.fs_fsize);
                exit(1);
        }

-       fscs = (struct csum *)
-           calloc(1, roundup(sblock.fs_ncg * sizeof (struct csum),
-               sblock.fs_bsize));

        /*
         * Compute number of inode blocks per cylinder group.
         * Start with one inode per NBPI bytes; adjust as necessary.
         */
        /*
         * Compute number of inode blocks per cylinder group.
         * Start with one inode per NBPI bytes; adjust as necessary.
         */

-       inos = ((fssize * sblock.fs_fsize) / MAX(NBPI, sblock.fs_fsize)) /
-           INOPB(&sblock);
+       i = sblock.fs_iblkno + MAXIPG / INOPF(&sblock);
+       inos = (fssize - sblock.fs_ncg * i) * sblock.fs_fsize /
+           MAX(NBPI, sblock.fs_fsize) / INOPB(&sblock);

        if (inos <= 0)
                inos = 1;
        sblock.fs_ipg = ((inos / sblock.fs_ncg) + 1) * INOPB(&sblock);
        if (sblock.fs_ipg > MAXIPG)
                sblock.fs_ipg = MAXIPG;
        if (inos <= 0)
                inos = 1;
        sblock.fs_ipg = ((inos / sblock.fs_ncg) + 1) * INOPB(&sblock);
        if (sblock.fs_ipg > MAXIPG)
                sblock.fs_ipg = MAXIPG;

-       if (cgdmin(0,&sblock) >= sblock.fs_fpg) {
+       sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);
+       i = MIN(~sblock.fs_cgmask, sblock.fs_ncg - 1);
+       if (cgdmin(&sblock, i) - cgbase(&sblock, i) >= sblock.fs_fpg) {

                printf("inode blocks/cyl group (%d) >= data blocks (%d)\n",
                printf("inode blocks/cyl group (%d) >= data blocks (%d)\n",

-                   cgdmin(0,&sblock) / sblock.fs_frag,
+                   cgdmin(&sblock, i) - cgbase(&sblock, i) / sblock.fs_frag,

                    sblock.fs_fpg / sblock.fs_frag);
                    sblock.fs_fpg / sblock.fs_frag);

-               printf("number of cylinder per cylinder group must be increased\n");
+               printf("number of cylinders per cylinder group must be increased\n");

                exit(1);
        }
                exit(1);
        }

-       /*
-        * calculate the available blocks for each rotational position
-        */
-       for (i = 0; i < NRPOS; i++)
-               sblock.fs_postbl[i] = -1;
-       for (i = 0; i < sblock.fs_spc; i += NSPB(&sblock))
-               /* void */;
-       for (i -= NSPB(&sblock); i >= 0; i -= NSPB(&sblock)) {
-               c = i % sblock.fs_nsect * NRPOS / sblock.fs_nsect;
-               sblock.fs_rotbl[i / NSPB(&sblock)] = sblock.fs_postbl[c];
-               sblock.fs_postbl[c] = i / NSPB(&sblock);
+       j = sblock.fs_ncg - 1;
+       if ((i = fssize - j * sblock.fs_fpg) < sblock.fs_fpg &&
+           cgdmin(&sblock, j) - cgbase(&sblock, j) > i) {
+               printf("Warning: inode blocks/cyl group (%d) >= data blocks (%d) in last\n",
+                   (cgdmin(&sblock, j) - cgbase(&sblock, j)) / sblock.fs_frag,
+                   i / sblock.fs_frag);
+               printf("    cylinder group. This implies %d sector(s) cannot be allocated.\n",
+                   i * NSPF(&sblock));
+               sblock.fs_ncg--;
+               sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;
+               sblock.fs_size = fssize = sblock.fs_ncyl * sblock.fs_spc /
+                   NSPF(&sblock);
+               warn = 0;
+       }
+       if (warn) {
+               printf("Warning: %d sector(s) in last cylinder unallocated\n",
+                   sblock.fs_spc -
+                   (fssize * NSPF(&sblock) - (sblock.fs_ncyl - 1)
+                   * sblock.fs_spc));

        }
        /*
         * fill in remaining fields of the super block
         */
        }
        /*
         * fill in remaining fields of the super block
         */

-       sblock.fs_csaddr = cgdmin(0, &sblock);
-       sblock.fs_cssize = sblock.fs_ncg * sizeof(struct csum);
-       sblock.fs_rotdelay = ROTDELAY;
-       sblock.fs_minfree = MINFREE;
+       sblock.fs_csaddr = cgdmin(&sblock, 0);
+       sblock.fs_cssize =
+           fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));
+       i = sblock.fs_bsize / sizeof(struct csum);
+       sblock.fs_csmask = ~(i - 1);
+       for (sblock.fs_csshift = 0; i > 1; i >>= 1)
+               sblock.fs_csshift++;
+       i = sizeof(struct fs) +
+               howmany(sblock.fs_spc * sblock.fs_cpc, NSPB(&sblock));
+       sblock.fs_sbsize = fragroundup(&sblock, i);
+       fscs = (struct csum *)calloc(1, sblock.fs_cssize);

        sblock.fs_magic = FS_MAGIC;
        sblock.fs_magic = FS_MAGIC;

-       sblock.fs_sblkno = SBLOCK;
+       sblock.fs_rotdelay = ROTDELAY;
+       if (argc > 7) {
+               sblock.fs_minfree = atoi(argv[7]);
+               if (sblock.fs_minfree < 0 || sblock.fs_minfree > 99) {
+                       printf("%s: bogus minfree reset to %d%%\n", argv[7],
+                               MINFREE);
+                       sblock.fs_minfree = MINFREE;
+               }
+       } else
+               sblock.fs_minfree = MINFREE;
+       sblock.fs_maxcontig = MAXCONTIG;
+       sblock.fs_maxbpg = MAXBLKPG(&sblock);
+       if (argc > 8)
+               sblock.fs_rps = atoi(argv[8]);
+       else
+               sblock.fs_rps = DEFHZ;

        sblock.fs_cgrotor = 0;
        sblock.fs_cstotal.cs_ndir = 0;
        sblock.fs_cstotal.cs_nbfree = 0;
        sblock.fs_cgrotor = 0;
        sblock.fs_cstotal.cs_ndir = 0;
        sblock.fs_cstotal.cs_nbfree = 0;


@@ -291,15 +471,16 @@ main(argc, argv)
         * Now build the cylinders group blocks and
         * then print out indices of cylinder groups.
         */
         * Now build the cylinders group blocks and
         * then print out indices of cylinder groups.
         */

-       for (c = 0; c < sblock.fs_ncg; c++)
-               initcg(c);
-       if (sblock.fs_ncg == 1)
-               printf("Warning, no super-block backups with only one cylinder group\n");
-       else
-               printf("\tsuper-block backups (for fsck -b#) at %d+k*%d (%d .. %d)\n",
-                   SBLOCK, fsbtodb(&sblock, cgsblock(1, &sblock)) - SBLOCK,
-                   fsbtodb(&sblock, cgsblock(1, &sblock)),
-                   fsbtodb(&sblock, cgsblock(sblock.fs_ncg - 1, &sblock)));
+       printf("super-block backups (for fsck -b#) at:");
+       for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
+               initcg(cylno);
+               if (cylno % 10 == 0)
+                       printf("\n");
+               printf(" %d,", fsbtodb(&sblock, cgsblock(&sblock, cylno)));
+       }
+       printf("\n%s\n%s\n",
+           "WRITE THESE NUMBERS DOWN!!!",
+           "fsck depends on them to recover this file system.");

        /*
         * Now construct the initial file system,
         * then write out the super-block.
        /*
         * Now construct the initial file system,
         * then write out the super-block.


@@ -308,14 +489,16 @@ main(argc, argv)
        sblock.fs_time = utime;
        wtfs(SBLOCK, SBSIZE, (char *)&sblock);
        for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize)
        sblock.fs_time = utime;
        wtfs(SBLOCK, SBSIZE, (char *)&sblock);
        for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize)

-               wtfs(fsbtodb(&sblock, sblock.fs_csaddr + i / sblock.fs_fsize),
-                       sblock.fs_bsize, ((char *)fscs) + i);
+               wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
+                       sblock.fs_cssize - i < sblock.fs_bsize ?
+                           sblock.fs_cssize - i : sblock.fs_bsize,
+                       ((char *)fscs) + i);

        /* 
         * Write out the duplicate super blocks
         */
        /* 
         * Write out the duplicate super blocks
         */

-       for (c = 1; c < sblock.fs_ncg; c++)
-               wtfs(fsbtodb(&sblock, cgsblock(c, &sblock)),
-                       SBSIZE, (char *)&sblock);
+       for (cylno = 0; cylno < sblock.fs_ncg; cylno++)
+               wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
+                   SBSIZE, (char *)&sblock);

 #ifndef STANDALONE
        exit(0);
 #endif
 #ifndef STANDALONE
        exit(0);
 #endif


@@ -324,10 +507,10 @@ main(argc, argv)
 /*
  * Initialize a cylinder group.
  */
 /*
  * Initialize a cylinder group.
  */

-initcg(c)
-       int c;
+initcg(cylno)
+       int cylno;

 {
 {

-       daddr_t cbase, d, dmin, dmax;
+       daddr_t cbase, d, dlower, dupper, dmax;

        long i, j, s;
        register struct csum *cs;
 
        long i, j, s;
        register struct csum *cs;
 


@@ -336,25 +519,28 @@ initcg(c)
         * Allow space for super block summary information in first
         * cylinder group.
         */
         * Allow space for super block summary information in first
         * cylinder group.
         */

-       cbase = cgbase(c,&sblock);
+       cbase = cgbase(&sblock, cylno);

        dmax = cbase + sblock.fs_fpg;
        if (dmax > sblock.fs_size)
                dmax = sblock.fs_size;
        dmax = cbase + sblock.fs_fpg;
        if (dmax > sblock.fs_size)
                dmax = sblock.fs_size;

-       dmin = cgdmin(c,&sblock) - cbase;
-       d = cbase;
-       cs = fscs+c;
+       dlower = cgsblock(&sblock, cylno) - cbase;
+       dupper = cgdmin(&sblock, cylno) - cbase;
+       cs = fscs + cylno;

        acg.cg_time = utime;
        acg.cg_magic = CG_MAGIC;
        acg.cg_time = utime;
        acg.cg_magic = CG_MAGIC;

-       acg.cg_cgx = c;
-       acg.cg_ncyl = sblock.fs_cpg;
+       acg.cg_cgx = cylno;
+       if (cylno == sblock.fs_ncg - 1)
+               acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
+       else
+               acg.cg_ncyl = sblock.fs_cpg;

        acg.cg_niblk = sblock.fs_ipg;
        acg.cg_ndblk = dmax - cbase;
        acg.cg_cs.cs_ndir = 0;
        acg.cg_cs.cs_nffree = 0;
        acg.cg_cs.cs_nbfree = 0;
        acg.cg_cs.cs_nifree = 0;
        acg.cg_niblk = sblock.fs_ipg;
        acg.cg_ndblk = dmax - cbase;
        acg.cg_cs.cs_ndir = 0;
        acg.cg_cs.cs_nffree = 0;
        acg.cg_cs.cs_nbfree = 0;
        acg.cg_cs.cs_nifree = 0;

-       acg.cg_rotor = dmin;
-       acg.cg_frotor = dmin;
+       acg.cg_rotor = 0;
+       acg.cg_frotor = 0;

        acg.cg_irotor = 0;
        for (i = 0; i < sblock.fs_frag; i++) {
                acg.cg_frsum[i] = 0;
        acg.cg_irotor = 0;
        for (i = 0; i < sblock.fs_frag; i++) {
                acg.cg_frsum[i] = 0;


@@ -366,7 +552,7 @@ initcg(c)
                }
                acg.cg_cs.cs_nifree += INOPB(&sblock);
        }
                }
                acg.cg_cs.cs_nifree += INOPB(&sblock);
        }

-       if (c == 0)
+       if (cylno == 0)

                for (i = 0; i < ROOTINO; i++) {
                        setbit(acg.cg_iused, i);
                        acg.cg_cs.cs_nifree--;
                for (i = 0; i < ROOTINO; i++) {
                        setbit(acg.cg_iused, i);
                        acg.cg_cs.cs_nifree--;


@@ -375,41 +561,65 @@ initcg(c)
                clrbit(acg.cg_iused, i);
                i++;
        }
                clrbit(acg.cg_iused, i);
                i++;
        }

-       lseek(fso, fsbtodb(&sblock, cgimin(c,&sblock)) * DEV_BSIZE, 0);
+       lseek(fso, fsbtodb(&sblock, cgimin(&sblock, cylno)) * DEV_BSIZE, 0);

        if (write(fso, (char *)zino, sblock.fs_ipg * sizeof (struct dinode)) !=
            sblock.fs_ipg * sizeof (struct dinode))
        if (write(fso, (char *)zino, sblock.fs_ipg * sizeof (struct dinode)) !=
            sblock.fs_ipg * sizeof (struct dinode))

-               printf("write error %D\n", tell(fso) / sblock.fs_bsize);
-       for (i = 0; i < MAXCPG; i++)
+               printf("write error %D\n", numfrags(&sblock, tell(fso)));
+       for (i = 0; i < MAXCPG; i++) {
+               acg.cg_btot[i] = 0;

                for (j = 0; j < NRPOS; j++)
                        acg.cg_b[i][j] = 0;
                for (j = 0; j < NRPOS; j++)
                        acg.cg_b[i][j] = 0;

-       if (c == 0) {
-               dmin += howmany(sblock.fs_cssize, sblock.fs_bsize) *
-                       sblock.fs_frag;

        }
        }

-       for (d = 0; d < dmin; d += sblock.fs_frag)
+       if (cylno == 0) {
+               /*
+                * reserve space for summary info and Boot block
+                */
+               dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
+               for (d = 0; d < dlower; d += sblock.fs_frag)
+                       clrblock(&sblock, acg.cg_free, d/sblock.fs_frag);
+       } else {
+               for (d = 0; d < dlower; d += sblock.fs_frag) {
+                       setblock(&sblock, acg.cg_free, d/sblock.fs_frag);
+                       acg.cg_cs.cs_nbfree++;
+                       acg.cg_btot[cbtocylno(&sblock, d)]++;
+                       acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]++;
+               }
+               sblock.fs_dsize += dlower;
+       }
+       sblock.fs_dsize += acg.cg_ndblk - dupper;
+       for (; d < dupper; d += sblock.fs_frag)

                clrblock(&sblock, acg.cg_free, d/sblock.fs_frag);
                clrblock(&sblock, acg.cg_free, d/sblock.fs_frag);

-       while ((d+sblock.fs_frag) <= dmax - cbase) {
+       if (d > dupper) {
+               acg.cg_frsum[d - dupper]++;
+               for (i = d - 1; i >= dupper; i--) {
+                       setbit(acg.cg_free, i);
+                       acg.cg_cs.cs_nffree++;
+               }
+       }
+       while ((d + sblock.fs_frag) <= dmax - cbase) {

                setblock(&sblock, acg.cg_free, d/sblock.fs_frag);
                acg.cg_cs.cs_nbfree++;
                setblock(&sblock, acg.cg_free, d/sblock.fs_frag);
                acg.cg_cs.cs_nbfree++;

-               s = d * NSPF(&sblock);
-               acg.cg_b[s / sblock.fs_spc]
-                   [s % sblock.fs_nsect * NRPOS / sblock.fs_nsect]++;
+               acg.cg_btot[cbtocylno(&sblock, d)]++;
+               acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]++;

                d += sblock.fs_frag;
        }
                d += sblock.fs_frag;
        }

-       if (d < dmax - cbase)
+       if (d < dmax - cbase) {
+               acg.cg_frsum[dmax - cbase - d]++;

                for (; d < dmax - cbase; d++) {
                        setbit(acg.cg_free, d);
                        acg.cg_cs.cs_nffree++;
                }
                for (; d < dmax - cbase; d++) {
                        setbit(acg.cg_free, d);
                        acg.cg_cs.cs_nffree++;
                }

-       for (; d < MAXBPG(&sblock); d++)
-               clrbit(acg.cg_free, d);
-       sblock.fs_dsize += acg.cg_ndblk - dmin;
+               for (; d % sblock.fs_frag != 0; d++)
+                       clrbit(acg.cg_free, d);
+       }
+       for (d /= sblock.fs_frag; d < MAXBPG(&sblock); d ++)
+               clrblock(&sblock, acg.cg_free, d);

        sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;
        sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
        sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
        sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
        *cs = acg.cg_cs;
        sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;
        sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
        sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
        sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
        *cs = acg.cg_cs;

-       wtfs(fsbtodb(&sblock, cgtod(c, &sblock)),
+       wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),

                sblock.fs_bsize, (char *)&acg);
 }
 
                sblock.fs_bsize, (char *)&acg);
 }
 


@@ -418,18 +628,22 @@ initcg(c)
  */
 struct inode node;
 #define PREDEFDIR 3
  */
 struct inode node;
 #define PREDEFDIR 3

-struct direct root_dir[MAXNDIR] = {
-       { ROOTINO, ".", 0, IFDIR },
-       { ROOTINO, "..", 0, IFDIR },
-       { LOSTFOUNDINO, "lost+found", 0, IFDIR },
+struct direct root_dir[] = {
+       { ROOTINO, sizeof(struct direct), 1, "." },
+       { ROOTINO, sizeof(struct direct), 2, ".." },
+       { LOSTFOUNDINO, sizeof(struct direct), 10, "lost+found" },

 };
 };

-struct direct lost_found_dir[MAXNDIR] = {
-       { LOSTFOUNDINO, ".", 0, IFDIR },
-       { ROOTINO, "..", 0, IFDIR },
+struct direct lost_found_dir[] = {
+       { LOSTFOUNDINO, sizeof(struct direct), 1, "." },
+       { ROOTINO, sizeof(struct direct), 2, ".." },
+       { 0, DIRBLKSIZ, 0, 0 },

 };
 };

+char buf[MAXBSIZE];

 
 fsinit()
 {
 
 fsinit()
 {

+       int i;
+

        /*
         * initialize the node
         */
        /*
         * initialize the node
         */


@@ -439,12 +653,15 @@ fsinit()
        /*
         * create the lost+found directory
         */
        /*
         * create the lost+found directory
         */

+       (void)makedir(lost_found_dir, 2);
+       for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ)
+               bcopy(&lost_found_dir[2], &buf[i], DIRSIZ(&lost_found_dir[2]));

        node.i_number = LOSTFOUNDINO;
        node.i_mode = IFDIR | UMASK;
        node.i_nlink = 2;
        node.i_size = sblock.fs_bsize;
        node.i_db[0] = alloc(node.i_size, node.i_mode);
        node.i_number = LOSTFOUNDINO;
        node.i_mode = IFDIR | UMASK;
        node.i_nlink = 2;
        node.i_size = sblock.fs_bsize;
        node.i_db[0] = alloc(node.i_size, node.i_mode);

-       wtfs(fsbtodb(&sblock, node.i_db[0]), node.i_size, lost_found_dir);
+       wtfs(fsbtodb(&sblock, node.i_db[0]), node.i_size, buf);

        iput(&node);
        /*
         * create the root directory
        iput(&node);
        /*
         * create the root directory


@@ -452,12 +669,36 @@ fsinit()
        node.i_number = ROOTINO;
        node.i_mode = IFDIR | UMASK;
        node.i_nlink = PREDEFDIR;
        node.i_number = ROOTINO;
        node.i_mode = IFDIR | UMASK;
        node.i_nlink = PREDEFDIR;

-       node.i_size = PREDEFDIR * sizeof(struct direct);
+       node.i_size = makedir(root_dir, PREDEFDIR);

        node.i_db[0] = alloc(sblock.fs_fsize, node.i_mode);
        node.i_db[0] = alloc(sblock.fs_fsize, node.i_mode);

-       wtfs(fsbtodb(&sblock, node.i_db[0]), sblock.fs_fsize, root_dir);
+       wtfs(fsbtodb(&sblock, node.i_db[0]), sblock.fs_fsize, buf);

        iput(&node);
 }
 
        iput(&node);
 }
 

+/*
+ * construct a set of directory entries in "buf".
+ * return size of directory.
+ */
+makedir(protodir, entries)
+       register struct direct *protodir;
+       int entries;
+{
+       char *cp;
+       int i, spcleft;
+
+       spcleft = DIRBLKSIZ;
+       for (cp = buf, i = 0; i < entries - 1; i++) {
+               protodir[i].d_reclen = DIRSIZ(&protodir[i]);
+               bcopy(&protodir[i], cp, protodir[i].d_reclen);
+               cp += protodir[i].d_reclen;
+               spcleft -= protodir[i].d_reclen;
+       }
+       protodir[i].d_reclen = spcleft;
+       bcopy(&protodir[i], cp, DIRSIZ(&protodir[i]));
+       cp += DIRSIZ(&protodir[i]);
+       return (cp - buf);
+}
+

 /*
  * allocate a block or frag
  */
 /*
  * allocate a block or frag
  */


@@ -466,12 +707,15 @@ alloc(size, mode)
        int size;
        int mode;
 {
        int size;
        int mode;
 {

-       int c, i, s, frag;
+       int i, frag;

        daddr_t d;
 
        daddr_t d;
 

-       c = 0;
-       rdfs(fsbtodb(&sblock, cgtod(0,&sblock)),
-               roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
+       rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+           (char *)&acg);
+       if (acg.cg_magic != CG_MAGIC) {
+               printf("cg 0: bad magic number\n");
+               return (0);
+       }

        if (acg.cg_cs.cs_nbfree == 0) {
                printf("first cylinder group ran out of space\n");
                return (0);
        if (acg.cg_cs.cs_nbfree == 0) {
                printf("first cylinder group ran out of space\n");
                return (0);


@@ -491,9 +735,8 @@ goth:
                sblock.fs_cstotal.cs_ndir++;
                fscs[0].cs_ndir++;
        }
                sblock.fs_cstotal.cs_ndir++;
                fscs[0].cs_ndir++;
        }

-       s = d * NSPF(&sblock);
-       acg.cg_b[s / sblock.fs_spc]
-               [s % sblock.fs_nsect * NRPOS / sblock.fs_nsect]--;
+       acg.cg_btot[cbtocylno(&sblock, d)]--;
+       acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]--;

        if (size != sblock.fs_bsize) {
                frag = howmany(size, sblock.fs_fsize);
                fscs[0].cs_nffree += sblock.fs_frag - frag;
        if (size != sblock.fs_bsize) {
                frag = howmany(size, sblock.fs_fsize);
                fscs[0].cs_nffree += sblock.fs_frag - frag;


@@ -501,10 +744,10 @@ goth:
                acg.cg_cs.cs_nffree += sblock.fs_frag - frag;
                acg.cg_frsum[sblock.fs_frag - frag]++;
                for (i = frag; i < sblock.fs_frag; i++)
                acg.cg_cs.cs_nffree += sblock.fs_frag - frag;
                acg.cg_frsum[sblock.fs_frag - frag]++;
                for (i = frag; i < sblock.fs_frag; i++)

-                       setbit(acg.cg_free, d+i);
+                       setbit(acg.cg_free, d + i);

        }
        }

-       wtfs(fsbtodb(&sblock, cgtod(0,&sblock)),
-               roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
+       wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+           (char *)&acg);

        return (d);
 }
 
        return (d);
 }
 


@@ -518,13 +761,17 @@ iput(ip)
        daddr_t d;
        int c;
 
        daddr_t d;
        int c;
 

-       c = itog(ip->i_number, &sblock);
-       rdfs(fsbtodb(&sblock, cgtod(c,&sblock)),
-               roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
+       c = itog(&sblock, ip->i_number);
+       rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+           (char *)&acg);
+       if (acg.cg_magic != CG_MAGIC) {
+               printf("cg 0: bad magic number\n");
+               exit(1);
+       }

        acg.cg_cs.cs_nifree--;
        setbit(acg.cg_iused, ip->i_number);
        acg.cg_cs.cs_nifree--;
        setbit(acg.cg_iused, ip->i_number);

-       wtfs(fsbtodb(&sblock, cgtod(c,&sblock)),
-               roundup(sblock.fs_cgsize, DEV_BSIZE), (char *)&acg);
+       wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
+           (char *)&acg);

        sblock.fs_cstotal.cs_nifree--;
        fscs[0].cs_nifree--;
        if(ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {
        sblock.fs_cstotal.cs_nifree--;
        fscs[0].cs_nifree--;
        if(ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {


@@ -532,9 +779,9 @@ iput(ip)
                    ip->i_number);
                exit(1);
        }
                    ip->i_number);
                exit(1);
        }

-       d = fsbtodb(&sblock, itod(ip->i_number, &sblock));
+       d = fsbtodb(&sblock, itod(&sblock, ip->i_number));

        rdfs(d, sblock.fs_bsize, buf);
        rdfs(d, sblock.fs_bsize, buf);

-       buf[itoo(ip->i_number, &sblock)].di_ic = ip->i_ic;
+       buf[itoo(&sblock, ip->i_number)].di_ic = ip->i_ic;

        wtfs(d, sblock.fs_bsize, buf);
 }
 
        wtfs(d, sblock.fs_bsize, buf);
 }
 


@@ -608,7 +855,11 @@ isblock(fs, cp, h)
                mask = 0x01 << (h & 0x7);
                return ((cp[h >> 3] & mask) == mask);
        default:
                mask = 0x01 << (h & 0x7);
                return ((cp[h >> 3] & mask) == mask);
        default:

+#ifdef STANDALONE
+               printf("isblock bad fs_frag %d\n", fs->fs_frag);
+#else

                fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
                fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);

+#endif

                return;
        }
 }
                return;
        }
 }


@@ -635,7 +886,11 @@ clrblock(fs, cp, h)
                cp[h >> 3] &= ~(0x01 << (h & 0x7));
                return;
        default:
                cp[h >> 3] &= ~(0x01 << (h & 0x7));
                return;
        default:

+#ifdef STANDALONE
+               printf("clrblock bad fs_frag %d\n", fs->fs_frag);
+#else

                fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag);
                fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag);

+#endif

                return;
        }
 }
                return;
        }
 }


@@ -662,7 +917,11 @@ setblock(fs, cp, h)
                cp[h >> 3] |= (0x01 << (h & 0x7));
                return;
        default:
                cp[h >> 3] |= (0x01 << (h & 0x7));
                return;
        default:

+#ifdef STANDALONE
+               printf("setblock bad fs_frag %d\n", fs->fs_frag);
+#else

                fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);
                fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);

+#endif

                return;
        }
 }
                return;
        }
 }