home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 4 / hacker04 / 04_HACK04.ISO / darwin / darwinx86.iso / usr / include / ufs / ffs / fs.h < prev   
Encoding:
C/C++ Source or Header  |  2001-09-30  |  23.0 KB  |  559 lines
  1. /*
  2.  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
  3.  *
  4.  * @APPLE_LICENSE_HEADER_START@
  5.  * 
  6.  * The contents of this file constitute Original Code as defined in and
  7.  * are subject to the Apple Public Source License Version 1.1 (the
  8.  * "License").  You may not use this file except in compliance with the
  9.  * License.  Please obtain a copy of the License at
  10.  * http://www.apple.com/publicsource and read it before using this file.
  11.  * 
  12.  * This Original Code and all software distributed under the License are
  13.  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14.  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16.  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17.  * License for the specific language governing rights and limitations
  18.  * under the License.
  19.  * 
  20.  * @APPLE_LICENSE_HEADER_END@
  21.  */
  22. /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
  23. /*
  24.  * Copyright (c) 1982, 1986, 1993
  25.  *    The Regents of the University of California.  All rights reserved.
  26.  *
  27.  * Redistribution and use in source and binary forms, with or without
  28.  * modification, are permitted provided that the following conditions
  29.  * are met:
  30.  * 1. Redistributions of source code must retain the above copyright
  31.  *    notice, this list of conditions and the following disclaimer.
  32.  * 2. Redistributions in binary form must reproduce the above copyright
  33.  *    notice, this list of conditions and the following disclaimer in the
  34.  *    documentation and/or other materials provided with the distribution.
  35.  * 3. All advertising materials mentioning features or use of this software
  36.  *    must display the following acknowledgement:
  37.  *    This product includes software developed by the University of
  38.  *    California, Berkeley and its contributors.
  39.  * 4. Neither the name of the University nor the names of its contributors
  40.  *    may be used to endorse or promote products derived from this software
  41.  *    without specific prior written permission.
  42.  *
  43.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  44.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  45.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  46.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  47.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  48.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  49.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  50.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  51.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  52.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  53.  * SUCH DAMAGE.
  54.  *
  55.  *    @(#)fs.h    8.13 (Berkeley) 3/21/95
  56.  */
  57. #ifndef _FFS_FS_H_
  58. #define _FFS_FS_H_
  59.  
  60. /*
  61.  * Each disk drive contains some number of file systems.
  62.  * A file system consists of a number of cylinder groups.
  63.  * Each cylinder group has inodes and data.
  64.  *
  65.  * A file system is described by its super-block, which in turn
  66.  * describes the cylinder groups.  The super-block is critical
  67.  * data and is replicated in each cylinder group to protect against
  68.  * catastrophic loss.  This is done at `newfs' time and the critical
  69.  * super-block data does not change, so the copies need not be
  70.  * referenced further unless disaster strikes.
  71.  *
  72.  * For file system fs, the offsets of the various blocks of interest
  73.  * are given in the super block as:
  74.  *    [fs->fs_sblkno]        Super-block
  75.  *    [fs->fs_cblkno]        Cylinder group block
  76.  *    [fs->fs_iblkno]        Inode blocks
  77.  *    [fs->fs_dblkno]        Data blocks
  78.  * The beginning of cylinder group cg in fs, is given by
  79.  * the ``cgbase(fs, cg)'' macro.
  80.  *
  81.  * The first boot and super blocks are given in absolute disk addresses.
  82.  * The byte-offset forms are preferred, as they don't imply a sector size.
  83.  */
  84. #define BBSIZE        8192
  85. #define SBSIZE        8192
  86. #define    BBOFF        ((off_t)(0))
  87. #define    SBOFF        ((off_t)(BBOFF + BBSIZE))
  88. #define    BBLOCK        ((ufs_daddr_t)(0))
  89. #define    SBLOCK        ((ufs_daddr_t)(BBLOCK + BBSIZE / DEV_BSIZE))
  90.  
  91. /*
  92.  * Addresses stored in inodes are capable of addressing fragments
  93.  * of `blocks'. File system blocks of at most size MAXBSIZE can 
  94.  * be optionally broken into 2, 4, or 8 pieces, each of which is
  95.  * addressible; these pieces may be DEV_BSIZE, or some multiple of
  96.  * a DEV_BSIZE unit.
  97.  *
  98.  * Large files consist of exclusively large data blocks.  To avoid
  99.  * undue wasted disk space, the last data block of a small file may be
  100.  * allocated as only as many fragments of a large block as are
  101.  * necessary.  The file system format retains only a single pointer
  102.  * to such a fragment, which is a piece of a single large block that
  103.  * has been divided.  The size of such a fragment is determinable from
  104.  * information in the inode, using the ``blksize(fs, ip, lbn)'' macro.
  105.  *
  106.  * The file system records space availability at the fragment level;
  107.  * to determine block availability, aligned fragments are examined.
  108.  */
  109.  
  110. /*
  111.  * MINBSIZE is the smallest allowable block size.
  112.  * In order to insure that it is possible to create files of size
  113.  * 2^32 with only two levels of indirection, MINBSIZE is set to 4096.
  114.  * MINBSIZE must be big enough to hold a cylinder group block,
  115.  * thus changes to (struct cg) must keep its size within MINBSIZE.
  116.  * Note that super blocks are always of size SBSIZE,
  117.  * and that both SBSIZE and MAXBSIZE must be >= MINBSIZE.
  118.  */
  119. #define MINBSIZE    4096
  120.  
  121. /*
  122.  * The path name on which the file system is mounted is maintained
  123.  * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in 
  124.  * the super block for this name.
  125.  */
  126. #define MAXMNTLEN    512
  127.  
  128. /*
  129.  * The limit on the amount of summary information per file system
  130.  * is defined by MAXCSBUFS. It is currently parameterized for a
  131.  * size of 128 bytes (2 million cylinder groups on machines with
  132.  * 32-bit pointers, and 1 million on 64-bit machines). One pointer
  133.  * is taken away to point to an array of cluster sizes that is
  134.  * computed as cylinder groups are inspected.
  135.  */
  136. #define    MAXCSBUFS    ((128 / sizeof(void *)) - 1)
  137.  
  138. /*
  139.  * A summary of contiguous blocks of various sizes is maintained
  140.  * in each cylinder group. Normally this is set by the initial
  141.  * value of fs_maxcontig. To conserve space, a maximum summary size
  142.  * is set by FS_MAXCONTIG.
  143.  */
  144. #define FS_MAXCONTIG    16
  145.  
  146. /*
  147.  * MINFREE gives the minimum acceptable percentage of file system
  148.  * blocks which may be free. If the freelist drops below this level
  149.  * only the superuser may continue to allocate blocks. This may
  150.  * be set to 0 if no reserve of free blocks is deemed necessary,
  151.  * however throughput drops by fifty percent if the file system
  152.  * is run at between 95% and 100% full; thus the minimum default
  153.  * value of fs_minfree is 5%. However, to get good clustering
  154.  * performance, 10% is a better choice. hence we use 10% as our
  155.  * default value. With 10% free space, fragmentation is not a
  156.  * problem, so we choose to optimize for time.
  157.  */
  158. #define MINFREE        5
  159. #define DEFAULTOPT    FS_OPTTIME
  160.  
  161. /*
  162.  * Per cylinder group information; summarized in blocks allocated
  163.  * from first cylinder group data blocks.  These blocks have to be
  164.  * read in from fs_csaddr (size fs_cssize) in addition to the
  165.  * super block.
  166.  *
  167.  * N.B. sizeof(struct csum) must be a power of two in order for
  168.  * the ``fs_cs'' macro to work (see below).
  169.  */
  170. struct csum {
  171.     int32_t    cs_ndir;        /* number of directories */
  172.     int32_t    cs_nbfree;        /* number of free blocks */
  173.     int32_t    cs_nifree;        /* number of free inodes */
  174.     int32_t    cs_nffree;        /* number of free frags */
  175. };
  176.  
  177. /*
  178.  * Super block for an FFS file system.
  179.  */
  180. struct fs {
  181.     int32_t     fs_firstfield;        /* historic file system linked list, */
  182.     int32_t     fs_unused_1;        /*     used for incore super blocks */
  183.     ufs_daddr_t fs_sblkno;        /* addr of super-block in filesys */
  184.     ufs_daddr_t fs_cblkno;        /* offset of cyl-block in filesys */
  185.     ufs_daddr_t fs_iblkno;        /* offset of inode-blocks in filesys */
  186.     ufs_daddr_t fs_dblkno;        /* offset of first data after cg */
  187.     int32_t     fs_cgoffset;        /* cylinder group offset in cylinder */
  188.     int32_t     fs_cgmask;        /* used to calc mod fs_ntrak */
  189.     time_t      fs_time;        /* last time written */
  190.     int32_t     fs_size;        /* number of blocks in fs */
  191.     int32_t     fs_dsize;        /* number of data blocks in fs */
  192.     int32_t     fs_ncg;        /* number of cylinder groups */
  193.     int32_t     fs_bsize;        /* size of basic blocks in fs */
  194.     int32_t     fs_fsize;        /* size of frag blocks in fs */
  195.     int32_t     fs_frag;        /* number of frags in a block in fs */
  196. /* these are configuration parameters */
  197.     int32_t     fs_minfree;        /* minimum percentage of free blocks */
  198.     int32_t     fs_rotdelay;        /* num of ms for optimal next block */
  199.     int32_t     fs_rps;        /* disk revolutions per second */
  200. /* these fields can be computed from the others */
  201.     int32_t     fs_bmask;        /* ``blkoff'' calc of blk offsets */
  202.     int32_t     fs_fmask;        /* ``fragoff'' calc of frag offsets */
  203.     int32_t     fs_bshift;        /* ``lblkno'' calc of logical blkno */
  204.     int32_t     fs_fshift;        /* ``numfrags'' calc number of frags */
  205. /* these are configuration parameters */
  206.     int32_t     fs_maxcontig;        /* max number of contiguous blks */
  207.     int32_t     fs_maxbpg;        /* max number of blks per cyl group */
  208. /* these fields can be computed from the others */
  209.     int32_t     fs_fragshift;        /* block to frag shift */
  210.     int32_t     fs_fsbtodb;        /* fsbtodb and dbtofsb shift constant */
  211.     int32_t     fs_sbsize;        /* actual size of super block */
  212.     int32_t     fs_csmask;        /* csum block offset */
  213.     int32_t     fs_csshift;        /* csum block number */
  214.     int32_t     fs_nindir;        /* value of NINDIR */
  215.     int32_t     fs_inopb;        /* value of INOPB */
  216.     int32_t     fs_nspf;        /* value of NSPF */
  217. /* yet another configuration parameter */
  218.     int32_t     fs_optim;        /* optimization preference, see below */
  219. /* these fields are derived from the hardware */
  220.     int32_t     fs_npsect;        /* # sectors/track including spares */
  221.     int32_t     fs_interleave;        /* hardware sector interleave */
  222.     int32_t     fs_trackskew;        /* sector 0 skew, per track */
  223.     int32_t     fs_headswitch;        /* head switch time, usec */
  224.     int32_t     fs_trkseek;        /* track-to-track seek, usec */
  225. /* sizes determined by number of cylinder groups and their sizes */
  226.     ufs_daddr_t fs_csaddr;        /* blk addr of cyl grp summary area */
  227.     int32_t     fs_cssize;        /* size of cyl grp summary area */
  228.     int32_t     fs_cgsize;        /* cylinder group size */
  229. /* these fields are derived from the hardware */
  230.     int32_t     fs_ntrak;        /* tracks per cylinder */
  231.     int32_t     fs_nsect;        /* sectors per track */
  232.     int32_t  fs_spc;            /* sectors per cylinder */
  233. /* this comes from the disk driver partitioning */
  234.     int32_t     fs_ncyl;        /* cylinders in file system */
  235. /* these fields can be computed from the others */
  236.     int32_t     fs_cpg;            /* cylinders per group */
  237.     int32_t     fs_ipg;            /* inodes per group */
  238.     int32_t     fs_fpg;            /* blocks per group * fs_frag */
  239. /* this data must be re-computed after crashes */
  240.     struct    csum fs_cstotal;    /* cylinder summary information */
  241. /* these fields are cleared at mount time */
  242.     int8_t   fs_fmod;        /* super block modified flag */
  243.     int8_t   fs_clean;        /* file system is clean flag */
  244.     int8_t      fs_ronly;        /* mounted read-only flag */
  245.     int8_t   fs_flags;        /* currently unused flag */
  246.     u_char     fs_fsmnt[MAXMNTLEN];    /* name mounted on */
  247. /* these fields retain the current block allocation info */
  248.     int32_t     fs_cgrotor;        /* last cg searched */
  249.     struct    csum *fs_csp[MAXCSBUFS];/* list of fs_cs info buffers */
  250.     int32_t     *fs_maxcluster;    /* max cluster in each cyl group */
  251.     int32_t     fs_cpc;        /* cyl per cycle in postbl */
  252.     int16_t     fs_opostbl[16][8];    /* old rotation block list head */
  253.     int32_t     fs_sparecon[50];    /* reserved for future constants */
  254.     int32_t     fs_contigsumsize;    /* size of cluster summary array */ 
  255.     int32_t     fs_maxsymlinklen;    /* max length of an internal symlink */
  256.     int32_t     fs_inodefmt;        /* format of on-disk inodes */
  257.     u_int64_t fs_maxfilesize;    /* maximum representable file size */
  258.     int64_t     fs_qbmask;        /* ~fs_bmask for use with 64-bit size */
  259.     int64_t     fs_qfmask;        /* ~fs_fmask for use with 64-bit size */
  260.     int32_t     fs_state;        /* validate fs_clean field */
  261.     int32_t     fs_postblformat;    /* format of positional layout tables */
  262.     int32_t     fs_nrpos;        /* number of rotational positions */
  263.     int32_t     fs_postbloff;        /* (u_int16) rotation block list head */
  264.     int32_t     fs_rotbloff;        /* (u_int8) blocks for each rotation */
  265.     int32_t     fs_magic;        /* magic number */
  266.     u_int8_t fs_space[1];        /* list of blocks for each rotation */
  267. /* actually longer */
  268. };
  269.  
  270. /*
  271.  * Filesystem identification
  272.  */
  273. #define    FS_MAGIC    0x011954    /* the fast filesystem magic number */
  274. #define    FS_OKAY        0x7c269d38    /* superblock checksum */
  275. #define FS_42INODEFMT    -1        /* 4.2BSD inode format */
  276. #define FS_44INODEFMT    2        /* 4.4BSD inode format */
  277. /*
  278.  * Preference for optimization.
  279.  */
  280. #define FS_OPTTIME    0    /* minimize allocation time */
  281. #define FS_OPTSPACE    1    /* minimize disk fragmentation */
  282.  
  283. /*
  284.  * Rotational layout table format types
  285.  */
  286. #define FS_42POSTBLFMT        -1    /* 4.2BSD rotational table format */
  287. #define FS_DYNAMICPOSTBLFMT    1    /* dynamic rotational table format */
  288. /*
  289.  * Macros for access to superblock array structures
  290.  */
  291. #define fs_postbl(fs, cylno) \
  292.     (((fs)->fs_postblformat == FS_42POSTBLFMT) \
  293.     ? ((fs)->fs_opostbl[cylno]) \
  294.     : ((int16_t *)((u_int8_t *)(fs) + \
  295.     (fs)->fs_postbloff) + (cylno) * (fs)->fs_nrpos))
  296. #define fs_rotbl(fs) \
  297.     (((fs)->fs_postblformat == FS_42POSTBLFMT) \
  298.     ? ((fs)->fs_space) \
  299.     : ((u_int8_t *)((u_int8_t *)(fs) + (fs)->fs_rotbloff)))
  300.  
  301. /*
  302.  * The size of a cylinder group is calculated by CGSIZE. The maximum size
  303.  * is limited by the fact that cylinder groups are at most one block.
  304.  * Its size is derived from the size of the maps maintained in the 
  305.  * cylinder group and the (struct cg) size.
  306.  */
  307. #define CGSIZE(fs) \
  308.     /* base cg */    (sizeof(struct cg) + sizeof(int32_t) + \
  309.     /* blktot size */    (fs)->fs_cpg * sizeof(int32_t) + \
  310.     /* blks size */    (fs)->fs_cpg * (fs)->fs_nrpos * sizeof(int16_t) + \
  311.     /* inode map */    howmany((fs)->fs_ipg, NBBY) + \
  312.     /* block map */    howmany((fs)->fs_cpg * (fs)->fs_spc / NSPF(fs), NBBY) +\
  313.     /* if present */    ((fs)->fs_contigsumsize <= 0 ? 0 : \
  314.     /* cluster sum */    (fs)->fs_contigsumsize * sizeof(int32_t) + \
  315.     /* cluster map */    howmany((fs)->fs_cpg * (fs)->fs_spc / NSPB(fs), NBBY)))
  316.  
  317. /*
  318.  * Convert cylinder group to base address of its global summary info.
  319.  *
  320.  * N.B. This macro assumes that sizeof(struct csum) is a power of two.
  321.  */
  322. #define fs_cs(fs, indx) \
  323.     fs_csp[(indx) >> (fs)->fs_csshift][(indx) & ~(fs)->fs_csmask]
  324.  
  325. /*
  326.  * Cylinder group block for a file system.
  327.  */
  328. #define    CG_MAGIC    0x090255
  329. struct cg {
  330.     int32_t     cg_firstfield;        /* historic cyl groups linked list */
  331.     int32_t     cg_magic;        /* magic number */
  332.     time_t     cg_time;        /* time last written */
  333.     int32_t     cg_cgx;        /* we are the cgx'th cylinder group */
  334.     int16_t     cg_ncyl;        /* number of cyl's this cg */
  335.     int16_t     cg_niblk;        /* number of inode blocks this cg */
  336.     int32_t     cg_ndblk;        /* number of data blocks this cg */
  337.     struct    csum cg_cs;        /* cylinder summary information */
  338.     int32_t     cg_rotor;        /* position of last used block */
  339.     int32_t     cg_frotor;        /* position of last used frag */
  340.     int32_t     cg_irotor;        /* position of last used inode */
  341.     int32_t     cg_frsum[MAXFRAG];    /* counts of available frags */
  342.     int32_t     cg_btotoff;        /* (int32) block totals per cylinder */
  343.     int32_t     cg_boff;        /* (u_int16) free block positions */
  344.     int32_t     cg_iusedoff;        /* (u_int8) used inode map */
  345.     int32_t     cg_freeoff;        /* (u_int8) free block map */
  346.     int32_t     cg_nextfreeoff;    /* (u_int8) next available space */
  347.     int32_t     cg_clustersumoff;    /* (u_int32) counts of avail clusters */
  348.     int32_t     cg_clusteroff;        /* (u_int8) free cluster map */
  349.     int32_t     cg_nclusterblks;    /* number of clusters this cg */
  350.     int32_t     cg_sparecon[13];    /* reserved for future use */
  351.     u_int8_t cg_space[1];        /* space for cylinder group maps */
  352. /* actually longer */
  353. };
  354.  
  355. /*
  356.  * Macros for access to cylinder group array structures
  357.  */
  358. #define cg_blktot(cgp) \
  359.     (((cgp)->cg_magic != CG_MAGIC) \
  360.     ? (((struct ocg *)(cgp))->cg_btot) \
  361.     : ((int32_t *)((u_int8_t *)(cgp) + (cgp)->cg_btotoff)))
  362. #define cg_blks(fs, cgp, cylno) \
  363.     (((cgp)->cg_magic != CG_MAGIC) \
  364.     ? (((struct ocg *)(cgp))->cg_b[cylno]) \
  365.     : ((int16_t *)((u_int8_t *)(cgp) + \
  366.     (cgp)->cg_boff) + (cylno) * (fs)->fs_nrpos))
  367. #define cg_inosused(cgp) \
  368.     (((cgp)->cg_magic != CG_MAGIC) \
  369.     ? (((struct ocg *)(cgp))->cg_iused) \
  370.     : ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_iusedoff)))
  371. #define cg_blksfree(cgp) \
  372.     (((cgp)->cg_magic != CG_MAGIC) \
  373.     ? (((struct ocg *)(cgp))->cg_free) \
  374.     : ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_freeoff)))
  375. #define cg_chkmagic(cgp) \
  376.     ((cgp)->cg_magic == CG_MAGIC || ((struct ocg *)(cgp))->cg_magic == CG_MAGIC)
  377. #define cg_clustersfree(cgp) \
  378.     ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_clusteroff))
  379. #define cg_clustersum(cgp) \
  380.     ((int32_t *)((u_int8_t *)(cgp) + (cgp)->cg_clustersumoff))
  381.  
  382. /*
  383.  * The following structure is defined
  384.  * for compatibility with old file systems.
  385.  */
  386. struct ocg {
  387.     int32_t     cg_firstfield;        /* historic linked list of cyl groups */
  388.     int32_t     cg_unused_1;        /*     used for incore cyl groups */
  389.     time_t     cg_time;        /* time last written */
  390.     int32_t     cg_cgx;        /* we are the cgx'th cylinder group */
  391.     int16_t     cg_ncyl;        /* number of cyl's this cg */
  392.     int16_t     cg_niblk;        /* number of inode blocks this cg */
  393.     int32_t     cg_ndblk;        /* number of data blocks this cg */
  394.     struct    csum cg_cs;        /* cylinder summary information */
  395.     int32_t     cg_rotor;        /* position of last used block */
  396.     int32_t     cg_frotor;        /* position of last used frag */
  397.     int32_t     cg_irotor;        /* position of last used inode */
  398.     int32_t     cg_frsum[8];        /* counts of available frags */
  399.     int32_t     cg_btot[32];        /* block totals per cylinder */
  400.     int16_t     cg_b[32][8];        /* positions of free blocks */
  401.     u_int8_t cg_iused[256];        /* used inode map */
  402.     int32_t     cg_magic;        /* magic number */
  403.     u_int8_t cg_free[1];        /* free block map */
  404. /* actually longer */
  405. };
  406.  
  407. /*
  408.  * Turn file system block numbers into disk block addresses.
  409.  * This maps file system blocks to device size blocks.
  410.  */
  411. #define fsbtodb(fs, b)    ((b) << (fs)->fs_fsbtodb)
  412. #define    dbtofsb(fs, b)    ((b) >> (fs)->fs_fsbtodb)
  413.  
  414. /*
  415.  * Cylinder group macros to locate things in cylinder groups.
  416.  * They calc file system addresses of cylinder group data structures.
  417.  */
  418. #define    cgbase(fs, c)    ((ufs_daddr_t)((fs)->fs_fpg * (c)))
  419. #define    cgdmin(fs, c)    (cgstart(fs, c) + (fs)->fs_dblkno)    /* 1st data */
  420. #define    cgimin(fs, c)    (cgstart(fs, c) + (fs)->fs_iblkno)    /* inode blk */
  421. #define    cgsblock(fs, c)    (cgstart(fs, c) + (fs)->fs_sblkno)    /* super blk */
  422. #define    cgtod(fs, c)    (cgstart(fs, c) + (fs)->fs_cblkno)    /* cg block */
  423. #define cgstart(fs, c)                            \
  424.     (cgbase(fs, c) + (fs)->fs_cgoffset * ((c) & ~((fs)->fs_cgmask)))
  425.  
  426. /*
  427.  * Macros for handling inode numbers:
  428.  *     inode number to file system block offset.
  429.  *     inode number to cylinder group number.
  430.  *     inode number to file system block address.
  431.  */
  432. #define    ino_to_cg(fs, x)    ((x) / (fs)->fs_ipg)
  433. #define    ino_to_fsba(fs, x)                        \
  434.     ((ufs_daddr_t)(cgimin(fs, ino_to_cg(fs, x)) +            \
  435.         (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))
  436. #define    ino_to_fsbo(fs, x)    ((x) % INOPB(fs))
  437.  
  438. /*
  439.  * Give cylinder group number for a file system block.
  440.  * Give cylinder group block number for a file system block.
  441.  */
  442. #define    dtog(fs, d)    ((d) / (fs)->fs_fpg)
  443. #define    dtogd(fs, d)    ((d) % (fs)->fs_fpg)
  444.  
  445. /*
  446.  * Extract the bits for a block from a map.
  447.  * Compute the cylinder and rotational position of a cyl block addr.
  448.  */
  449. #define blkmap(fs, map, loc) \
  450.     (((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))
  451. #define cbtocylno(fs, bno) \
  452.     ((bno) * NSPF(fs) / (fs)->fs_spc)
  453. #define cbtorpos(fs, bno) \
  454.     (((bno) * NSPF(fs) % (fs)->fs_spc / (fs)->fs_nsect * (fs)->fs_trackskew + \
  455.      (bno) * NSPF(fs) % (fs)->fs_spc % (fs)->fs_nsect * (fs)->fs_interleave) % \
  456.      (fs)->fs_nsect * (fs)->fs_nrpos / (fs)->fs_npsect)
  457.  
  458. /*
  459.  * The following macros optimize certain frequently calculated
  460.  * quantities by using shifts and masks in place of divisions
  461.  * modulos and multiplications.
  462.  */
  463. #define blkoff(fs, loc)        /* calculates (loc % fs->fs_bsize) */ \
  464.     ((loc) & (fs)->fs_qbmask)
  465. #define fragoff(fs, loc)    /* calculates (loc % fs->fs_fsize) */ \
  466.     ((loc) & (fs)->fs_qfmask)
  467. #define lblktosize(fs, blk)    /* calculates (blk * fs->fs_bsize) */ \
  468.     ((blk) << (fs)->fs_bshift)
  469. #define lblkno(fs, loc)        /* calculates (loc / fs->fs_bsize) */ \
  470.     ((loc) >> (fs)->fs_bshift)
  471. #define numfrags(fs, loc)    /* calculates (loc / fs->fs_fsize) */ \
  472.     ((loc) >> (fs)->fs_fshift)
  473. #define blkroundup(fs, size)    /* calculates roundup(size, fs->fs_bsize) */ \
  474.     (((size) + (fs)->fs_qbmask) & (fs)->fs_bmask)
  475. #define fragroundup(fs, size)    /* calculates roundup(size, fs->fs_fsize) */ \
  476.     (((size) + (fs)->fs_qfmask) & (fs)->fs_fmask)
  477. #define fragstoblks(fs, frags)    /* calculates (frags / fs->fs_frag) */ \
  478.     ((frags) >> (fs)->fs_fragshift)
  479. #define blkstofrags(fs, blks)    /* calculates (blks * fs->fs_frag) */ \
  480.     ((blks) << (fs)->fs_fragshift)
  481. #define fragnum(fs, fsb)    /* calculates (fsb % fs->fs_frag) */ \
  482.     ((fsb) & ((fs)->fs_frag - 1))
  483. #define blknum(fs, fsb)        /* calculates rounddown(fsb, fs->fs_frag) */ \
  484.     ((fsb) &~ ((fs)->fs_frag - 1))
  485.  
  486. /*
  487.  * Determine the number of available frags given a
  488.  * percentage to hold in reserve.
  489.  */
  490. #define freespace(fs, percentreserved) \
  491.     (blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \
  492.     (fs)->fs_cstotal.cs_nffree - ((fs)->fs_dsize * (percentreserved) / 100))
  493.  
  494. /*
  495.  * Determining the size of a file block in the file system.
  496.  */
  497. #define blksize(fs, ip, lbn) \
  498.     (((lbn) >= NDADDR || (ip)->i_size >= ((lbn) + 1) << (fs)->fs_bshift) \
  499.         ? (fs)->fs_bsize \
  500.         : (fragroundup(fs, blkoff(fs, (ip)->i_size))))
  501. #define dblksize(fs, dip, lbn) \
  502.     (((lbn) >= NDADDR || (dip)->di_size >= ((lbn) + 1) << (fs)->fs_bshift) \
  503.         ? (fs)->fs_bsize \
  504.         : (fragroundup(fs, blkoff(fs, (dip)->di_size))))
  505.  
  506. /*
  507.  * Number of disk sectors per block/fragment; assumes DEV_BSIZE byte
  508.  * sector size.
  509.  */
  510. #define    NSPB(fs)    ((fs)->fs_nspf << (fs)->fs_fragshift)
  511. #define    NSPF(fs)    ((fs)->fs_nspf)
  512.  
  513. /*
  514.  * Number of inodes in a secondary storage block/fragment.
  515.  */
  516. #define    INOPB(fs)    ((fs)->fs_inopb)
  517. #define    INOPF(fs)    ((fs)->fs_inopb >> (fs)->fs_fragshift)
  518.  
  519. /*
  520.  * Number of indirects in a file system block.
  521.  */
  522. #define    NINDIR(fs)    ((fs)->fs_nindir)
  523.  
  524. /*
  525.  * This macro controls whether the file system format is byte swapped or not.
  526.  * At NeXT, all little endian machines read and write big endian file systems.
  527.  */
  528. #define    BIG_ENDIAN_FS    (__LITTLE_ENDIAN__)
  529.  
  530. extern int inside[], around[];
  531. extern u_char *fragtbl[];
  532.  
  533.  
  534. /*
  535.  * UFS Label:
  536.  *   The purpose of this label is to name a UFS/FFS filesystem.  The label
  537.  *   is located at offset 7K (BBSIZE=8K - UFS_LABEL_SIZE=1K = 7K) of the 
  538.  *   partition.  The first 7K is still available for boot blocks.
  539.  */
  540.  
  541. #define UFS_LABEL_MAGIC        { 'L', 'A', 'B', 'L' }
  542. #define UFS_LABEL_SIZE        1024
  543. #define UFS_LABEL_OFFSET    (BBSIZE - UFS_LABEL_SIZE) /* top 1K */
  544. #define UFS_LABEL_VERSION    1
  545. #define UFS_MAX_LABEL_NAME    512
  546.  
  547. struct ufslabel {
  548.     u_int32_t        ul_magic;
  549.     u_int16_t        ul_checksum;    /* checksum over entire label*/
  550.     u_int32_t        ul_version;    /* label version */
  551.     u_int32_t        ul_time;    /* creation time */
  552.     u_int16_t        ul_namelen;    /* filesystem name length */
  553.     u_char        ul_name[UFS_MAX_LABEL_NAME]; /* filesystem name */
  554.     u_char        ul_reserved[32];/* reserved for future use */
  555.     u_char        ul_unused[460];    /* pad out to 1K */
  556. };
  557.  
  558. #endif /* ! _FFS_FS_H_ */
  559.