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