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