home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / sys / ufs / fs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-05-08  |  17.9 KB  |  441 lines
  1. /*
  2.  * Copyright (c) 1982, 1986 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  *    @(#)fs.h    7.12 (Berkeley) 5/8/91
  34.  */
  35.  
  36. /*
  37.  * Each disk drive contains some number of file systems.
  38.  * A file system consists of a number of cylinder groups.
  39.  * Each cylinder group has inodes and data.
  40.  *
  41.  * A file system is described by its super-block, which in turn
  42.  * describes the cylinder groups.  The super-block is critical
  43.  * data and is replicated in each cylinder group to protect against
  44.  * catastrophic loss.  This is done at `newfs' time and the critical
  45.  * super-block data does not change, so the copies need not be
  46.  * referenced further unless disaster strikes.
  47.  *
  48.  * For file system fs, the offsets of the various blocks of interest
  49.  * are given in the super block as:
  50.  *    [fs->fs_sblkno]        Super-block
  51.  *    [fs->fs_cblkno]        Cylinder group block
  52.  *    [fs->fs_iblkno]        Inode blocks
  53.  *    [fs->fs_dblkno]        Data blocks
  54.  * The beginning of cylinder group cg in fs, is given by
  55.  * the ``cgbase(fs, cg)'' macro.
  56.  *
  57.  * The first boot and super blocks are given in absolute disk addresses.
  58.  * The byte-offset forms are preferred, as they don't imply a sector size.
  59.  */
  60. #define BBSIZE        8192
  61. #define SBSIZE        8192
  62. #define    BBOFF        ((off_t)(0))
  63. #define    SBOFF        ((off_t)(BBOFF + BBSIZE))
  64. #define    BBLOCK        ((daddr_t)(0))
  65. #define    SBLOCK        ((daddr_t)(BBLOCK + BBSIZE / DEV_BSIZE))
  66.  
  67. /*
  68.  * Addresses stored in inodes are capable of addressing fragments
  69.  * of `blocks'. File system blocks of at most size MAXBSIZE can 
  70.  * be optionally broken into 2, 4, or 8 pieces, each of which is
  71.  * addressible; these pieces may be DEV_BSIZE, or some multiple of
  72.  * a DEV_BSIZE unit.
  73.  *
  74.  * Large files consist of exclusively large data blocks.  To avoid
  75.  * undue wasted disk space, the last data block of a small file may be
  76.  * allocated as only as many fragments of a large block as are
  77.  * necessary.  The file system format retains only a single pointer
  78.  * to such a fragment, which is a piece of a single large block that
  79.  * has been divided.  The size of such a fragment is determinable from
  80.  * information in the inode, using the ``blksize(fs, ip, lbn)'' macro.
  81.  *
  82.  * The file system records space availability at the fragment level;
  83.  * to determine block availability, aligned fragments are examined.
  84.  *
  85.  * The root inode is the root of the file system.
  86.  * Inode 0 can't be used for normal purposes and
  87.  * historically bad blocks were linked to inode 1,
  88.  * thus the root inode is 2. (inode 1 is no longer used for
  89.  * this purpose, however numerous dump tapes make this
  90.  * assumption, so we are stuck with it)
  91.  */
  92. #define    ROOTINO        ((ino_t)2)
  93.  
  94. /*
  95.  * MINBSIZE is the smallest allowable block size.
  96.  * In order to insure that it is possible to create files of size
  97.  * 2^32 with only two levels of indirection, MINBSIZE is set to 4096.
  98.  * MINBSIZE must be big enough to hold a cylinder group block,
  99.  * thus changes to (struct cg) must keep its size within MINBSIZE.
  100.  * Note that super blocks are always of size SBSIZE,
  101.  * and that both SBSIZE and MAXBSIZE must be >= MINBSIZE.
  102.  */
  103. #define MINBSIZE    4096
  104.  
  105. /*
  106.  * The path name on which the file system is mounted is maintained
  107.  * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in 
  108.  * the super block for this name.
  109.  * The limit on the amount of summary information per file system
  110.  * is defined by MAXCSBUFS. It is currently parameterized for a
  111.  * maximum of two million cylinders.
  112.  */
  113. #define MAXMNTLEN 512
  114. #define MAXCSBUFS 32
  115.  
  116. /*
  117.  * Per cylinder group information; summarized in blocks allocated
  118.  * from first cylinder group data blocks.  These blocks have to be
  119.  * read in from fs_csaddr (size fs_cssize) in addition to the
  120.  * super block.
  121.  *
  122.  * N.B. sizeof(struct csum) must be a power of two in order for
  123.  * the ``fs_cs'' macro to work (see below).
  124.  */
  125. struct csum {
  126.     long    cs_ndir;    /* number of directories */
  127.     long    cs_nbfree;    /* number of free blocks */
  128.     long    cs_nifree;    /* number of free inodes */
  129.     long    cs_nffree;    /* number of free frags */
  130. };
  131.  
  132. /*
  133.  * Super block for a file system.
  134.  */
  135. #define    FS_MAGIC    0x011954
  136. #define    FSOKAY        0x7c269d38
  137. struct    fs
  138. {
  139.     struct    fs *fs_link;        /* linked list of file systems */
  140.     struct    fs *fs_rlink;        /*     used for incore super blocks */
  141.     daddr_t    fs_sblkno;        /* addr of super-block in filesys */
  142.     daddr_t    fs_cblkno;        /* offset of cyl-block in filesys */
  143.     daddr_t    fs_iblkno;        /* offset of inode-blocks in filesys */
  144.     daddr_t    fs_dblkno;        /* offset of first data after cg */
  145.     long    fs_cgoffset;        /* cylinder group offset in cylinder */
  146.     long    fs_cgmask;        /* used to calc mod fs_ntrak */
  147.     time_t     fs_time;            /* last time written */
  148.     long    fs_size;        /* number of blocks in fs */
  149.     long    fs_dsize;        /* number of data blocks in fs */
  150.     long    fs_ncg;            /* number of cylinder groups */
  151.     long    fs_bsize;        /* size of basic blocks in fs */
  152.     long    fs_fsize;        /* size of frag blocks in fs */
  153.     long    fs_frag;        /* number of frags in a block in fs */
  154. /* these are configuration parameters */
  155.     long    fs_minfree;        /* minimum percentage of free blocks */
  156.     long    fs_rotdelay;        /* num of ms for optimal next block */
  157.     long    fs_rps;            /* disk revolutions per second */
  158. /* these fields can be computed from the others */
  159.     long    fs_bmask;        /* ``blkoff'' calc of blk offsets */
  160.     long    fs_fmask;        /* ``fragoff'' calc of frag offsets */
  161.     long    fs_bshift;        /* ``lblkno'' calc of logical blkno */
  162.     long    fs_fshift;        /* ``numfrags'' calc number of frags */
  163. /* these are configuration parameters */
  164.     long    fs_maxcontig;        /* max number of contiguous blks */
  165.     long    fs_maxbpg;        /* max number of blks per cyl group */
  166. /* these fields can be computed from the others */
  167.     long    fs_fragshift;        /* block to frag shift */
  168.     long    fs_fsbtodb;        /* fsbtodb and dbtofsb shift constant */
  169.     long    fs_sbsize;        /* actual size of super block */
  170.     long    fs_csmask;        /* csum block offset */
  171.     long    fs_csshift;        /* csum block number */
  172.     long    fs_nindir;        /* value of NINDIR */
  173.     long    fs_inopb;        /* value of INOPB */
  174.     long    fs_nspf;        /* value of NSPF */
  175. /* yet another configuration parameter */
  176.     long    fs_optim;        /* optimization preference, see below */
  177. /* these fields are derived from the hardware */
  178.     long    fs_npsect;        /* # sectors/track including spares */
  179.     long    fs_interleave;        /* hardware sector interleave */
  180.     long    fs_trackskew;        /* sector 0 skew, per track */
  181.     long    fs_headswitch;        /* head switch time, usec */
  182.     long    fs_trkseek;        /* track-to-track seek, usec */
  183. /* sizes determined by number of cylinder groups and their sizes */
  184.     daddr_t fs_csaddr;        /* blk addr of cyl grp summary area */
  185.     long    fs_cssize;        /* size of cyl grp summary area */
  186.     long    fs_cgsize;        /* cylinder group size */
  187. /* these fields are derived from the hardware */
  188.     long    fs_ntrak;        /* tracks per cylinder */
  189.     long    fs_nsect;        /* sectors per track */
  190.     long      fs_spc;           /* sectors per cylinder */
  191. /* this comes from the disk driver partitioning */
  192.     long    fs_ncyl;           /* cylinders in file system */
  193. /* these fields can be computed from the others */
  194.     long    fs_cpg;            /* cylinders per group */
  195.     long    fs_ipg;            /* inodes per group */
  196.     long    fs_fpg;            /* blocks per group * fs_frag */
  197. /* this data must be re-computed after crashes */
  198.     struct    csum fs_cstotal;    /* cylinder summary information */
  199. /* these fields are cleared at mount time */
  200.     char       fs_fmod;            /* super block modified flag */
  201.     char       fs_clean;            /* file system is clean flag */
  202.     char       fs_ronly;           /* mounted read-only flag */
  203.     char       fs_flags;           /* currently unused flag */
  204.     char    fs_fsmnt[MAXMNTLEN];    /* name mounted on */
  205. /* these fields retain the current block allocation info */
  206.     long    fs_cgrotor;        /* last cg searched */
  207.     struct    csum *fs_csp[MAXCSBUFS];/* list of fs_cs info buffers */
  208.     long    fs_cpc;            /* cyl per cycle in postbl */
  209.     short    fs_opostbl[16][8];    /* old rotation block list head */
  210.     long    fs_sparecon[55];    /* reserved for future constants */
  211.     long    fs_state;        /* validate fs_clean field */
  212.     quad    fs_qbmask;        /* ~fs_bmask - for use with quad size */
  213.     quad    fs_qfmask;        /* ~fs_fmask - for use with quad size */
  214.     long    fs_postblformat;    /* format of positional layout tables */
  215.     long    fs_nrpos;        /* number of rotaional positions */
  216.     long    fs_postbloff;        /* (short) rotation block list head */
  217.     long    fs_rotbloff;        /* (u_char) blocks for each rotation */
  218.     long    fs_magic;        /* magic number */
  219.     u_char    fs_space[1];        /* list of blocks for each rotation */
  220. /* actually longer */
  221. };
  222. /*
  223.  * Preference for optimization.
  224.  */
  225. #define FS_OPTTIME    0    /* minimize allocation time */
  226. #define FS_OPTSPACE    1    /* minimize disk fragmentation */
  227.  
  228. /*
  229.  * Rotational layout table format types
  230.  */
  231. #define FS_42POSTBLFMT        -1    /* 4.2BSD rotational table format */
  232. #define FS_DYNAMICPOSTBLFMT    1    /* dynamic rotational table format */
  233. /*
  234.  * Macros for access to superblock array structures
  235.  */
  236. #define fs_postbl(fs, cylno) \
  237.     (((fs)->fs_postblformat == FS_42POSTBLFMT) \
  238.     ? ((fs)->fs_opostbl[cylno]) \
  239.     : ((short *)((char *)(fs) + (fs)->fs_postbloff) + (cylno) * (fs)->fs_nrpos))
  240. #define fs_rotbl(fs) \
  241.     (((fs)->fs_postblformat == FS_42POSTBLFMT) \
  242.     ? ((fs)->fs_space) \
  243.     : ((u_char *)((char *)(fs) + (fs)->fs_rotbloff)))
  244.  
  245. /*
  246.  * Convert cylinder group to base address of its global summary info.
  247.  *
  248.  * N.B. This macro assumes that sizeof(struct csum) is a power of two.
  249.  */
  250. #define fs_cs(fs, indx) \
  251.     fs_csp[(indx) >> (fs)->fs_csshift][(indx) & ~(fs)->fs_csmask]
  252.  
  253. /*
  254.  * Cylinder group block for a file system.
  255.  */
  256. #define    CG_MAGIC    0x090255
  257. struct    cg {
  258.     struct    cg *cg_link;        /* linked list of cyl groups */
  259.     long    cg_magic;        /* magic number */
  260.     time_t    cg_time;        /* time last written */
  261.     long    cg_cgx;            /* we are the cgx'th cylinder group */
  262.     short    cg_ncyl;        /* number of cyl's this cg */
  263.     short    cg_niblk;        /* number of inode blocks this cg */
  264.     long    cg_ndblk;        /* number of data blocks this cg */
  265.     struct    csum cg_cs;        /* cylinder summary information */
  266.     long    cg_rotor;        /* position of last used block */
  267.     long    cg_frotor;        /* position of last used frag */
  268.     long    cg_irotor;        /* position of last used inode */
  269.     long    cg_frsum[MAXFRAG];    /* counts of available frags */
  270.     long    cg_btotoff;        /* (long) block totals per cylinder */
  271.     long    cg_boff;        /* (short) free block positions */
  272.     long    cg_iusedoff;        /* (char) used inode map */
  273.     long    cg_freeoff;        /* (u_char) free block map */
  274.     long    cg_nextfreeoff;        /* (u_char) next available space */
  275.     long    cg_sparecon[16];    /* reserved for future use */
  276.     u_char    cg_space[1];        /* space for cylinder group maps */
  277. /* actually longer */
  278. };
  279. /*
  280.  * Macros for access to cylinder group array structures
  281.  */
  282. #define cg_blktot(cgp) \
  283.     (((cgp)->cg_magic != CG_MAGIC) \
  284.     ? (((struct ocg *)(cgp))->cg_btot) \
  285.     : ((long *)((char *)(cgp) + (cgp)->cg_btotoff)))
  286. #define cg_blks(fs, cgp, cylno) \
  287.     (((cgp)->cg_magic != CG_MAGIC) \
  288.     ? (((struct ocg *)(cgp))->cg_b[cylno]) \
  289.     : ((short *)((char *)(cgp) + (cgp)->cg_boff) + (cylno) * (fs)->fs_nrpos))
  290. #define cg_inosused(cgp) \
  291.     (((cgp)->cg_magic != CG_MAGIC) \
  292.     ? (((struct ocg *)(cgp))->cg_iused) \
  293.     : ((char *)((char *)(cgp) + (cgp)->cg_iusedoff)))
  294. #define cg_blksfree(cgp) \
  295.     (((cgp)->cg_magic != CG_MAGIC) \
  296.     ? (((struct ocg *)(cgp))->cg_free) \
  297.     : ((u_char *)((char *)(cgp) + (cgp)->cg_freeoff)))
  298. #define cg_chkmagic(cgp) \
  299.     ((cgp)->cg_magic == CG_MAGIC || ((struct ocg *)(cgp))->cg_magic == CG_MAGIC)
  300.  
  301. /*
  302.  * The following structure is defined
  303.  * for compatibility with old file systems.
  304.  */
  305. struct    ocg {
  306.     struct    ocg *cg_link;        /* linked list of cyl groups */
  307.     struct    ocg *cg_rlink;        /*     used for incore cyl groups */
  308.     time_t    cg_time;        /* time last written */
  309.     long    cg_cgx;            /* we are the cgx'th cylinder group */
  310.     short    cg_ncyl;        /* number of cyl's this cg */
  311.     short    cg_niblk;        /* number of inode blocks this cg */
  312.     long    cg_ndblk;        /* number of data blocks this cg */
  313.     struct    csum cg_cs;        /* cylinder summary information */
  314.     long    cg_rotor;        /* position of last used block */
  315.     long    cg_frotor;        /* position of last used frag */
  316.     long    cg_irotor;        /* position of last used inode */
  317.     long    cg_frsum[8];        /* counts of available frags */
  318.     long    cg_btot[32];        /* block totals per cylinder */
  319.     short    cg_b[32][8];        /* positions of free blocks */
  320.     char    cg_iused[256];        /* used inode map */
  321.     long    cg_magic;        /* magic number */
  322.     u_char    cg_free[1];        /* free block map */
  323. /* actually longer */
  324. };
  325.  
  326. /*
  327.  * Turn file system block numbers into disk block addresses.
  328.  * This maps file system blocks to device size blocks.
  329.  */
  330. #define fsbtodb(fs, b)    ((b) << (fs)->fs_fsbtodb)
  331. #define    dbtofsb(fs, b)    ((b) >> (fs)->fs_fsbtodb)
  332.  
  333. /*
  334.  * Cylinder group macros to locate things in cylinder groups.
  335.  * They calc file system addresses of cylinder group data structures.
  336.  */
  337. #define    cgbase(fs, c)    ((daddr_t)((fs)->fs_fpg * (c)))
  338. #define cgstart(fs, c) \
  339.     (cgbase(fs, c) + (fs)->fs_cgoffset * ((c) & ~((fs)->fs_cgmask)))
  340. #define    cgsblock(fs, c)    (cgstart(fs, c) + (fs)->fs_sblkno)    /* super blk */
  341. #define    cgtod(fs, c)    (cgstart(fs, c) + (fs)->fs_cblkno)    /* cg block */
  342. #define    cgimin(fs, c)    (cgstart(fs, c) + (fs)->fs_iblkno)    /* inode blk */
  343. #define    cgdmin(fs, c)    (cgstart(fs, c) + (fs)->fs_dblkno)    /* 1st data */
  344.  
  345. /*
  346.  * Macros for handling inode numbers:
  347.  *     inode number to file system block offset.
  348.  *     inode number to cylinder group number.
  349.  *     inode number to file system block address.
  350.  */
  351. #define    itoo(fs, x)    ((x) % INOPB(fs))
  352. #define    itog(fs, x)    ((x) / (fs)->fs_ipg)
  353. #define    itod(fs, x) \
  354.     ((daddr_t)(cgimin(fs, itog(fs, x)) + \
  355.     (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))
  356.  
  357. /*
  358.  * Give cylinder group number for a file system block.
  359.  * Give cylinder group block number for a file system block.
  360.  */
  361. #define    dtog(fs, d)    ((d) / (fs)->fs_fpg)
  362. #define    dtogd(fs, d)    ((d) % (fs)->fs_fpg)
  363.  
  364. /*
  365.  * Extract the bits for a block from a map.
  366.  * Compute the cylinder and rotational position of a cyl block addr.
  367.  */
  368. #define blkmap(fs, map, loc) \
  369.     (((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))
  370. #define cbtocylno(fs, bno) \
  371.     ((bno) * NSPF(fs) / (fs)->fs_spc)
  372. #define cbtorpos(fs, bno) \
  373.     (((bno) * NSPF(fs) % (fs)->fs_spc / (fs)->fs_nsect * (fs)->fs_trackskew + \
  374.      (bno) * NSPF(fs) % (fs)->fs_spc % (fs)->fs_nsect * (fs)->fs_interleave) % \
  375.      (fs)->fs_nsect * (fs)->fs_nrpos / (fs)->fs_npsect)
  376.  
  377. /*
  378.  * The following macros optimize certain frequently calculated
  379.  * quantities by using shifts and masks in place of divisions
  380.  * modulos and multiplications.
  381.  */
  382. #define blkoff(fs, loc)        /* calculates (loc % fs->fs_bsize) */ \
  383.     ((loc) & ~(fs)->fs_bmask)
  384. #define fragoff(fs, loc)    /* calculates (loc % fs->fs_fsize) */ \
  385.     ((loc) & ~(fs)->fs_fmask)
  386. #define lblktosize(fs, blk)    /* calculates (blk * fs->fs_bsize) */ \
  387.     ((blk) << (fs)->fs_bshift)
  388. #define lblkno(fs, loc)        /* calculates (loc / fs->fs_bsize) */ \
  389.     ((loc) >> (fs)->fs_bshift)
  390. #define numfrags(fs, loc)    /* calculates (loc / fs->fs_fsize) */ \
  391.     ((loc) >> (fs)->fs_fshift)
  392. #define blkroundup(fs, size)    /* calculates roundup(size, fs->fs_bsize) */ \
  393.     (((size) + (fs)->fs_bsize - 1) & (fs)->fs_bmask)
  394. #define fragroundup(fs, size)    /* calculates roundup(size, fs->fs_fsize) */ \
  395.     (((size) + (fs)->fs_fsize - 1) & (fs)->fs_fmask)
  396. #define fragstoblks(fs, frags)    /* calculates (frags / fs->fs_frag) */ \
  397.     ((frags) >> (fs)->fs_fragshift)
  398. #define blkstofrags(fs, blks)    /* calculates (blks * fs->fs_frag) */ \
  399.     ((blks) << (fs)->fs_fragshift)
  400. #define fragnum(fs, fsb)    /* calculates (fsb % fs->fs_frag) */ \
  401.     ((fsb) & ((fs)->fs_frag - 1))
  402. #define blknum(fs, fsb)        /* calculates rounddown(fsb, fs->fs_frag) */ \
  403.     ((fsb) &~ ((fs)->fs_frag - 1))
  404.  
  405. /*
  406.  * Determine the number of available frags given a
  407.  * percentage to hold in reserve
  408.  */
  409. #define freespace(fs, percentreserved) \
  410.     (blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \
  411.     (fs)->fs_cstotal.cs_nffree - ((fs)->fs_dsize * (percentreserved) / 100))
  412.  
  413. /*
  414.  * Determining the size of a file block in the file system.
  415.  */
  416. #define blksize(fs, ip, lbn) \
  417.     (((lbn) >= NDADDR || (ip)->i_size >= ((lbn) + 1) << (fs)->fs_bshift) \
  418.         ? (fs)->fs_bsize \
  419.         : (fragroundup(fs, blkoff(fs, (ip)->i_size))))
  420. #define dblksize(fs, dip, lbn) \
  421.     (((lbn) >= NDADDR || (dip)->di_size >= ((lbn) + 1) << (fs)->fs_bshift) \
  422.         ? (fs)->fs_bsize \
  423.         : (fragroundup(fs, blkoff(fs, (dip)->di_size))))
  424.  
  425. /*
  426.  * Number of disk sectors per block; assumes DEV_BSIZE byte sector size.
  427.  */
  428. #define    NSPB(fs)    ((fs)->fs_nspf << (fs)->fs_fragshift)
  429. #define    NSPF(fs)    ((fs)->fs_nspf)
  430.  
  431. /*
  432.  * INOPB is the number of inodes in a secondary storage block.
  433.  */
  434. #define    INOPB(fs)    ((fs)->fs_inopb)
  435. #define    INOPF(fs)    ((fs)->fs_inopb >> (fs)->fs_fragshift)
  436.  
  437. /*
  438.  * NINDIR is the number of indirects in a file system block.
  439.  */
  440. #define    NINDIR(fs)    ((fs)->fs_nindir)
  441.