mountfs declared

[unix-history] / usr / src / sys / ufs / ffs / fs.h

diff --git a/usr/src/sys/ufs/ffs/fs.h b/usr/src/sys/ufs/ffs/fs.h
index 00107aa..425c6c3 100644 (file)
--- a/usr/src/sys/ufs/ffs/fs.h
+++ b/usr/src/sys/ufs/ffs/fs.h
@@ -1,6 +1,6 @@
 /* Copyright (c) 1981 Regents of the University of California */
 
 /* Copyright (c) 1981 Regents of the University of California */
 

-/*     fs.h    1.11    %G%     */
+/*     fs.h    4.2     82/06/14        */

 
 /*
  * Each disk drive contains some number of file systems.
 
 /*
  * Each disk drive contains some number of file systems.


@@ -16,17 +16,16 @@
  *
  * For file system fs, the offsets of the various blocks of interest
  * are given in the super block as:
  *
  * For file system fs, the offsets of the various blocks of interest
  * are given in the super block as:

- *     [fs->fs_bblkno]         Boot sector

  *     [fs->fs_sblkno]         Super-block
  *     [fs->fs_cblkno]         Cylinder group block
  *     [fs->fs_iblkno]         Inode blocks
  *     [fs->fs_dblkno]         Data blocks
  * The beginning of cylinder group cg in fs, is given by
  *     [fs->fs_sblkno]         Super-block
  *     [fs->fs_cblkno]         Cylinder group block
  *     [fs->fs_iblkno]         Inode blocks
  *     [fs->fs_dblkno]         Data blocks
  * The beginning of cylinder group cg in fs, is given by

- * the ``cgbase(cg, fs)'' macro.
+ * the ``cgbase(fs, cg)'' macro.

  *
  * The first boot and super blocks are given in absolute disk addresses.
  */
  *
  * The first boot and super blocks are given in absolute disk addresses.
  */

-#define BBSIZE         1024
+#define BBSIZE         8192

 #define SBSIZE         8192
 #define        BBLOCK          ((daddr_t)(0))
 #define        SBLOCK          ((daddr_t)(BBLOCK + BBSIZE / DEV_BSIZE))
 #define SBSIZE         8192
 #define        BBLOCK          ((daddr_t)(0))
 #define        SBLOCK          ((daddr_t)(BBLOCK + BBSIZE / DEV_BSIZE))


@@ -80,11 +79,11 @@
 
 /*
  * Under current technology, most 300MB disks have 32 sectors and
 
 /*
  * Under current technology, most 300MB disks have 32 sectors and

- * 19 tracks, thus these are the defaults used for fs_nsect and 
+ * 16 tracks, thus these are the defaults used for fs_nsect and 

  * fs_ntrak respectively.
  */
 #define DFLNSECT       32
  * fs_ntrak respectively.
  */
 #define DFLNSECT       32

-#define DFLNTRAK       19
+#define DFLNTRAK       16

 
 /*
  * Cylinder group related limits.
 
 /*
  * Cylinder group related limits.


@@ -133,6 +132,17 @@
 #define        DESCPG          16      /* desired fs_cpg */
 #define        MAXCPG          32      /* maximum fs_cpg */
 
 #define        DESCPG          16      /* desired fs_cpg */
 #define        MAXCPG          32      /* maximum fs_cpg */
 

+/*
+ * The path name on which the file system is mounted is maintained
+ * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in 
+ * the super block for this name.
+ * The limit on the amount of summary information per file system
+ * is defined by MAXCSBUFS. It is currently parameterized for a
+ * maximum of two million cylinders.
+ */
+#define MAXMNTLEN 512
+#define MAXCSBUFS 32
+

 /*
  * Per cylinder group information; summarized in blocks allocated
  * from first cylinder group data blocks.  These blocks have to be
 /*
  * Per cylinder group information; summarized in blocks allocated
  * from first cylinder group data blocks.  These blocks have to be


@@ -152,56 +162,66 @@ struct csum {
 /*
  * Super block for a file system.
  */
 /*
  * Super block for a file system.
  */

-#define        FS_MAGIC        0x110854
+#define        FS_MAGIC        0x011954

 struct fs
 {
 struct fs
 {

-       long    fs_magic;               /* magic number */
-       daddr_t fs_bblkno;              /* abs addr of boot-block in filesys */
-       daddr_t fs_sblkno;              /* abs addr of super-block in filesys */
+       struct  fs *fs_link;            /* linked list of file systems */
+       struct  fs *fs_rlink;           /*     used for incore super blocks */
+       daddr_t fs_sblkno;              /* addr of super-block in filesys */

        daddr_t fs_cblkno;              /* offset of cyl-block in filesys */
        daddr_t fs_iblkno;              /* offset of inode-blocks in filesys */
        daddr_t fs_cblkno;              /* offset of cyl-block in filesys */
        daddr_t fs_iblkno;              /* offset of inode-blocks in filesys */

-       daddr_t fs_dblkno;              /* offset of data-blocks in filesys */
+       daddr_t fs_dblkno;              /* offset of first data after cg */
+       long    fs_cgoffset;            /* cylinder group offset in cylinder */
+       long    fs_cgmask;              /* used to calc mod fs_ntrak */

        time_t  fs_time;                /* last time written */
        long    fs_size;                /* number of blocks in fs */
        long    fs_dsize;               /* number of data blocks in fs */
        long    fs_ncg;                 /* number of cylinder groups */
        long    fs_bsize;               /* size of basic blocks in fs */
        long    fs_fsize;               /* size of frag blocks in fs */
        time_t  fs_time;                /* last time written */
        long    fs_size;                /* number of blocks in fs */
        long    fs_dsize;               /* number of data blocks in fs */
        long    fs_ncg;                 /* number of cylinder groups */
        long    fs_bsize;               /* size of basic blocks in fs */
        long    fs_fsize;               /* size of frag blocks in fs */

-       short   fs_frag;                /* number of frags in a block in fs */
-       short   fs_minfree;             /* minimum percentage of free blocks */
-       short   fs_rotdelay;            /* num of ms for optimal next block */
-       short   fs_rps;                 /* disk revolutions per second */
+       long    fs_frag;                /* number of frags in a block in fs */
+       long    fs_minfree;             /* minimum percentage of free blocks */
+       long    fs_rotdelay;            /* num of ms for optimal next block */
+       long    fs_rps;                 /* disk revolutions per second */
+       long    fs_bmask;               /* ``blkoff'' calc of blk offsets */
+       long    fs_fmask;               /* ``fragoff'' calc of frag offsets */
+       long    fs_bshift;              /* ``lblkno'' calc of logical blkno */
+       long    fs_fshift;              /* ``numfrags'' calc number of frags */
+       long    fs_sparecon[16];        /* reserved for future constants */

 /* sizes determined by number of cylinder groups and their sizes */
        daddr_t fs_csaddr;              /* blk addr of cyl grp summary area */
        long    fs_cssize;              /* size of cyl grp summary area */
        long    fs_cgsize;              /* cylinder group size */
 /* these fields should be derived from the hardware */
 /* sizes determined by number of cylinder groups and their sizes */
        daddr_t fs_csaddr;              /* blk addr of cyl grp summary area */
        long    fs_cssize;              /* size of cyl grp summary area */
        long    fs_cgsize;              /* cylinder group size */
 /* these fields should be derived from the hardware */

-       short   fs_ntrak;               /* tracks per cylinder */
-       short   fs_nsect;               /* sectors per track */
+       long    fs_ntrak;               /* tracks per cylinder */
+       long    fs_nsect;               /* sectors per track */

        long    fs_spc;                 /* sectors per cylinder */
 /* this comes from the disk driver partitioning */
        long    fs_ncyl;                /* cylinders in file system */
 /* these fields can be computed from the others */
        long    fs_spc;                 /* sectors per cylinder */
 /* this comes from the disk driver partitioning */
        long    fs_ncyl;                /* cylinders in file system */
 /* these fields can be computed from the others */

-       short   fs_cpg;                 /* cylinders per group */
-       short   fs_ipg;                 /* inodes per group */
+       long    fs_cpg;                 /* cylinders per group */
+       long    fs_ipg;                 /* inodes per group */

        long    fs_fpg;                 /* blocks per group * fs_frag */
 /* this data must be re-computed after crashes */
        struct  csum fs_cstotal;        /* cylinder summary information */
 /* these fields are cleared at mount time */
        char    fs_fmod;                /* super block modified flag */
        long    fs_fpg;                 /* blocks per group * fs_frag */
 /* this data must be re-computed after crashes */
        struct  csum fs_cstotal;        /* cylinder summary information */
 /* these fields are cleared at mount time */
        char    fs_fmod;                /* super block modified flag */

+       char    fs_clean;               /* file system is clean flag */

        char    fs_ronly;               /* mounted read-only flag */
        char    fs_ronly;               /* mounted read-only flag */

-       char    fs_fsmnt[34];           /* name mounted on */
+       char    fs_flags;               /* currently unused flag */
+       char    fs_fsmnt[MAXMNTLEN];    /* name mounted on */

 /* these fields retain the current block allocation info */
        long    fs_cgrotor;             /* last cg searched */
 /* these fields retain the current block allocation info */
        long    fs_cgrotor;             /* last cg searched */

-       struct  csum *fs_csp[NBUF];     /* list of fs_cs info buffers */
-       short   fs_cpc;                 /* cyl per cycle in postbl */
+       struct  csum *fs_csp[MAXCSBUFS];/* list of fs_cs info buffers */
+       long    fs_cpc;                 /* cyl per cycle in postbl */

        short   fs_postbl[MAXCPG][NRPOS];/* head of blocks for each rotation */
        short   fs_postbl[MAXCPG][NRPOS];/* head of blocks for each rotation */

+       long    fs_magic;               /* magic number */

        u_char  fs_rotbl[1];            /* list of blocks for each rotation */
 /* actually longer */
 };
 
 /*
        u_char  fs_rotbl[1];            /* list of blocks for each rotation */
 /* actually longer */
 };
 
 /*

- * convert cylinder group to base address of its global summary info.
+ * Convert cylinder group to base address of its global summary info.

  *
  * N.B. This macro assumes that sizeof(struct csum) is a power of two.
  */
  *
  * N.B. This macro assumes that sizeof(struct csum) is a power of two.
  */


@@ -223,9 +243,10 @@ struct     fs
 /*
  * Cylinder group block for a file system.
  */
 /*
  * Cylinder group block for a file system.
  */

-#define        CG_MAGIC        0x092752
+#define        CG_MAGIC        0x090255

 struct cg {
 struct cg {

-       long    cg_magic;               /* magic number */
+       struct  cg *cg_link;            /* linked list of cyl groups */
+       struct  cg *cg_rlink;           /*     used for incore cyl groups */

        time_t  cg_time;                /* time last written */
        long    cg_cgx;                 /* we are the cgx'th cylinder group */
        short   cg_ncyl;                /* number of cyl's this cg */
        time_t  cg_time;                /* time last written */
        long    cg_cgx;                 /* we are the cgx'th cylinder group */
        short   cg_ncyl;                /* number of cyl's this cg */


@@ -236,8 +257,10 @@ struct     cg {
        long    cg_frotor;              /* position of last used frag */
        long    cg_irotor;              /* position of last used inode */
        long    cg_frsum[MAXFRAG];      /* counts of available frags */
        long    cg_frotor;              /* position of last used frag */
        long    cg_irotor;              /* position of last used inode */
        long    cg_frsum[MAXFRAG];      /* counts of available frags */

+       long    cg_btot[MAXCPG];        /* block totals per cylinder */

        short   cg_b[MAXCPG][NRPOS];    /* positions of free blocks */
        char    cg_iused[MAXIPG/NBBY];  /* used inode map */
        short   cg_b[MAXCPG][NRPOS];    /* positions of free blocks */
        char    cg_iused[MAXIPG/NBBY];  /* used inode map */

+       long    cg_magic;               /* magic number */

        char    cg_free[1];             /* free block map */
 /* actually longer */
 };
        char    cg_free[1];             /* free block map */
 /* actually longer */
 };


@@ -260,99 +283,94 @@ struct    cg {
 
 /*
  * Cylinder group macros to locate things in cylinder groups.
 
 /*
  * Cylinder group macros to locate things in cylinder groups.

- *
- * cylinder group to disk block address of spare boot block
- * and super block
- * Note that these are in absolute addresses, and can NOT
- * in general be expressable in terms of file system addresses.
- */
-#define        cgbblock(c,fs)  (fsbtodb(fs, cgbase(c,fs)) + (fs)->fs_bblkno)
-#define        cgsblock(c,fs)  (fsbtodb(fs, cgbase(c,fs)) + (fs)->fs_sblkno)
-
-/*
- * cylinder group to disk block at very beginning
- */
-#define        cgbase(c,fs)    ((daddr_t)((fs)->fs_fpg * (c)))
-
-/*
- * convert cylinder group to index of its cg block
- */
-#define        cgtod(c,fs)     (cgbase(c,fs) + (fs)->fs_cblkno)
-
-/*
- * give address of first inode block in cylinder group
- */
-#define        cgimin(c,fs)    (cgbase(c,fs) + (fs)->fs_iblkno)
-
-/*
- * give address of first data block in cylinder group
+ * They calc file system addresses of cylinder group data structures.

  */
  */

-#define        cgdmin(c,fs)    (cgbase(c,fs) + (fs)->fs_dblkno)
+#define        cgbase(fs, c)   ((daddr_t)((fs)->fs_fpg * (c)))
+#define cgstart(fs, c) \
+       (cgbase(fs, c) + (fs)->fs_cgoffset * ((c) & ~((fs)->fs_cgmask)))
+#define        cgsblock(fs, c) (cgstart(fs, c) + (fs)->fs_sblkno)      /* super blk */
+#define        cgtod(fs, c)    (cgstart(fs, c) + (fs)->fs_cblkno)      /* cg block */
+#define        cgimin(fs, c)   (cgstart(fs, c) + (fs)->fs_iblkno)      /* inode blk */
+#define        cgdmin(fs, c)   (cgstart(fs, c) + (fs)->fs_dblkno)      /* 1st data */

 
 /*
 
 /*

- * turn inode number into cylinder group number
+ * Macros for handling inode numbers:
+ *     inode number to file system block offset.
+ *     inode number to cylinder group number.
+ *     inode number to file system block address.

  */
  */

-#define        itog(x,fs)      ((x) / (fs)->fs_ipg)
-
-/*
- * turn inode number into file system block address
- */
-#define        itod(x,fs) \
-       ((daddr_t)(cgimin(itog(x,fs),fs) + \
+#define        itoo(fs, x)     ((x) % INOPB(fs))
+#define        itog(fs, x)     ((x) / (fs)->fs_ipg)
+#define        itod(fs, x) \
+       ((daddr_t)(cgimin(fs, itog(fs, x)) + \

        (x) % (fs)->fs_ipg / INOPB(fs) * (fs)->fs_frag))
 
 /*
        (x) % (fs)->fs_ipg / INOPB(fs) * (fs)->fs_frag))
 
 /*

- * turn inode number into file system block offset
- */
-#define        itoo(x,fs)      ((x) % INOPB(fs))
-
-/*
- * give cylinder group number for a file system block
- */
-#define        dtog(d,fs)      ((d) / (fs)->fs_fpg)
-
-/*
- * give cylinder group block number for a file system block
+ * Give cylinder group number for a file system block.
+ * Give cylinder group block number for a file system block.

  */
  */

-#define        dtogd(d,fs)     ((d) % (fs)->fs_fpg)
+#define        dtog(fs, d)     ((d) / (fs)->fs_fpg)
+#define        dtogd(fs, d)    ((d) % (fs)->fs_fpg)

 
 /*
 
 /*

- * compute the cylinder and rotational position of a cyl block addr
+ * Extract the bits for a block from a map.
+ * Compute the cylinder and rotational position of a cyl block addr.

  */
  */

+#define blkmap(fs, map, loc) \
+    (((map)[loc / NBBY] >> (loc % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))

 #define cbtocylno(fs, bno) \
        ((bno) * NSPF(fs) / (fs)->fs_spc)
 #define cbtorpos(fs, bno) \
        ((bno) * NSPF(fs) % (fs)->fs_nsect * NRPOS / (fs)->fs_nsect)
 
 /*
 #define cbtocylno(fs, bno) \
        ((bno) * NSPF(fs) / (fs)->fs_spc)
 #define cbtorpos(fs, bno) \
        ((bno) * NSPF(fs) % (fs)->fs_nsect * NRPOS / (fs)->fs_nsect)
 
 /*

- * determining the size of a file block in the file system
+ * The following macros optimize certain frequently calculated
+ * quantities by using shifts and masks in place of divisions
+ * modulos and multiplications.
+ */
+#define blkoff(fs, loc)                /* calculates (loc % fs->fs_bsize) */ \
+       ((loc) & ~(fs)->fs_bmask)
+#define fragoff(fs, loc)       /* calculates (loc % fs->fs_fsize) */ \
+       ((loc) & ~(fs)->fs_fmask)
+#define lblkno(fs, loc)                /* calculates (loc / fs->fs_bsize) */ \
+       ((loc) >> (fs)->fs_bshift)
+#define numfrags(fs, loc)      /* calculates (loc / fs->fs_fsize) */ \
+       ((loc) >> (fs)->fs_fshift)
+#define blkroundup(fs, size)   /* calculates roundup(size, fs->fs_bsize) */ \
+       (((size) + (fs)->fs_bsize - 1) & (fs)->fs_bmask)
+#define fragroundup(fs, size)  /* calculates roundup(size, fs->fs_fsize) */ \
+       (((size) + (fs)->fs_fsize - 1) & (fs)->fs_fmask)
+
+/*
+ * Determining the size of a file block in the file system.

  */
 #define blksize(fs, ip, lbn) \
        (((lbn) >= NDADDR || (ip)->i_size >= ((lbn) + 1) * (fs)->fs_bsize) \
  */
 #define blksize(fs, ip, lbn) \
        (((lbn) >= NDADDR || (ip)->i_size >= ((lbn) + 1) * (fs)->fs_bsize) \

-               ? (fs)->fs_bsize \
-               : (roundup((ip)->i_size % (fs)->fs_bsize, (fs)->fs_fsize)))
+           ? (fs)->fs_bsize \
+           : (fragroundup(fs, blkoff(fs, (ip)->i_size))))

 #define dblksize(fs, dip, lbn) \
        (((lbn) >= NDADDR || (dip)->di_size >= ((lbn) + 1) * (fs)->fs_bsize) \
 #define dblksize(fs, dip, lbn) \
        (((lbn) >= NDADDR || (dip)->di_size >= ((lbn) + 1) * (fs)->fs_bsize) \

-               ? (fs)->fs_bsize \
-               : (roundup((dip)->di_size % (fs)->fs_bsize, (fs)->fs_fsize)))
+           ? (fs)->fs_bsize \
+           : (fragroundup(fs, blkoff(fs, (dip)->di_size))))

 
 /*
 
 /*

- * number of disk sectors per block; assumes DEV_BSIZE byte sector size
+ * Number of disk sectors per block; assumes DEV_BSIZE byte sector size.

  */
 #define        NSPB(fs)        ((fs)->fs_bsize / DEV_BSIZE)
 #define        NSPF(fs)        ((fs)->fs_fsize / DEV_BSIZE)
 
 /*
  */
 #define        NSPB(fs)        ((fs)->fs_bsize / DEV_BSIZE)
 #define        NSPF(fs)        ((fs)->fs_fsize / DEV_BSIZE)
 
 /*

- * INOPB is the number of inodes in a secondary storage block
+ * INOPB is the number of inodes in a secondary storage block.

  */
 #define        INOPB(fs)       ((fs)->fs_bsize / sizeof (struct dinode))
 #define        INOPF(fs)       ((fs)->fs_fsize / sizeof (struct dinode))
 
 /*
  */
 #define        INOPB(fs)       ((fs)->fs_bsize / sizeof (struct dinode))
 #define        INOPF(fs)       ((fs)->fs_fsize / sizeof (struct dinode))
 
 /*

- * NINDIR is the number of indirects in a file system block
+ * NINDIR is the number of indirects in a file system block.

  */
 #define        NINDIR(fs)      ((fs)->fs_bsize / sizeof (daddr_t))
 
 #ifdef KERNEL
 struct fs *getfs();
  */
 #define        NINDIR(fs)      ((fs)->fs_bsize / sizeof (daddr_t))
 
 #ifdef KERNEL
 struct fs *getfs();

+struct fs *mountfs();

 #endif
 #endif