Root/
| Source at commit 1551 created 12 years 10 months ago. By ifabio, Added Macedonian Language Add 1280x768 Resolution choice (pkg) Update all the language Renamed postinstall.in in postinstall correct it also into buildpkg.sh | |
|---|---|
| 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 | |
