Root/
Source at commit 2744 created 8 years 11 months ago. By ifabio, Removing old RLE/Clut data | |
---|---|
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 |