ReactOS  0.4.13-dev-52-g0efcfec
fs.h
Go to the documentation of this file.
1 /* $NetBSD: fs.h,v 1.43 2004/03/21 18:48:24 dsl Exp $ */
2 
3 /*
4  * Copyright (c) 1982, 1986, 1993
5  * The Regents of the University of California. All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  * notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  * may be used to endorse or promote products derived from this software
17  * without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  * @(#)fs.h 8.13 (Berkeley) 3/21/95
32  */
33 
34 #ifndef _UFS_FFS_FS_H_
35 #define _UFS_FFS_FS_H_
36 
37 #include "type.h"
38 
39 /*
40  * Each disk drive contains some number of file systems.
41  * A file system consists of a number of cylinder groups.
42  * Each cylinder group has inodes and data.
43  *
44  * A file system is described by its super-block, which in turn
45  * describes the cylinder groups. The super-block is critical
46  * data and is replicated in each cylinder group to protect against
47  * catastrophic loss. This is done at `newfs' time and the critical
48  * super-block data does not change, so the copies need not be
49  * referenced further unless disaster strikes.
50  *
51  * For file system fs, the offsets of the various blocks of interest
52  * are given in the super block as:
53  * [fs->fs_sblkno] Super-block
54  * [fs->fs_cblkno] Cylinder group block
55  * [fs->fs_iblkno] Inode blocks
56  * [fs->fs_dblkno] Data blocks
57  * The beginning of cylinder group cg in fs, is given by
58  * the ``cgbase(fs, cg)'' macro.
59  *
60  * Depending on the architecture and the media, the superblock may
61  * reside in any one of four places. For tiny media where every block
62  * counts, it is placed at the very front of the partition. Historically,
63  * UFS1 placed it 8K from the front to leave room for the disk label and
64  * a small bootstrap. For UFS2 it got moved to 64K from the front to leave
65  * room for the disk label and a bigger bootstrap, and for really piggy
66  * systems we check at 256K from the front if the first three fail. In
67  * all cases the size of the superblock will be SBLOCKSIZE. All values are
68  * given in byte-offset form, so they do not imply a sector size. The
69  * SBLOCKSEARCH specifies the order in which the locations should be searched.
70  *
71  * Unfortunately the UFS2/FFSv2 change was done without adequate consideration
72  * of backward compatibility. In particular 'newfs' for a FFSv2 partition
73  * must overwrite any old FFSv1 superblock at 8k, and preferrably as many
74  * of the alternates as it can find - otherwise attempting to mount on a
75  * system that only supports FFSv1 is likely to succeed!.
76  * For a small FFSv1 filesystem, an old FFSv2 superblock can be left on
77  * the disk, and a system that tries to find an FFSv2 filesystem in preference
78  * to and FFSv1 one (as NetBSD does) can mount the old FFSv2 filesystem.
79  * As a added bonus, the 'first alternate' superblock of a FFSv1 filesystem
80  * with 64k blocks is at 64k - just where the code looks first when playing
81  * 'hunt the superblock'.
82  *
83  * The ffsv2 superblock layout (which might contain an ffsv1 filesystem)
84  * can be detected by checking for sb->fs_old_flags & FS_FLAGS_UPDATED.
85  * This is the default suberblock type for NetBSD since ffsv2 support was added.
86  */
87 #define BBSIZE 8192
88 #define BBOFF ((off_t)(0))
89 #define BBLOCK ((daddr_t)(0))
90 
91 #define SBLOCK_FLOPPY 0
92 #define SBLOCK_UFS1 8192
93 #define SBLOCK_UFS2 65536
94 #define SBLOCK_PIGGY 262144
95 #define SBLOCKSIZE 8192
96 /*
97  * NB: Do not, under any circumstances, look for an ffsv1 filesystem at
98  * SBLOCK_UFS2. Doing so will find the wrong superblock for filesystems
99  * with a 64k block size.
100  */
101 #define SBLOCKSEARCH \
102  { SBLOCK_UFS2, SBLOCK_UFS1, SBLOCK_FLOPPY, SBLOCK_PIGGY, -1 }
103 
104 /*
105  * Max number of fragments per block. This value is NOT tweakable.
106  */
107 #define MAXFRAG 8
108 
109 
110 
111 /*
112  * Addresses stored in inodes are capable of addressing fragments
113  * of `blocks'. File system blocks of at most size MAXBSIZE can
114  * be optionally broken into 2, 4, or 8 pieces, each of which is
115  * addressable; these pieces may be DEV_BSIZE, or some multiple of
116  * a DEV_BSIZE unit.
117  *
118  * Large files consist of exclusively large data blocks. To avoid
119  * undue wasted disk space, the last data block of a small file may be
120  * allocated as only as many fragments of a large block as are
121  * necessary. The file system format retains only a single pointer
122  * to such a fragment, which is a piece of a single large block that
123  * has been divided. The size of such a fragment is determinable from
124  * information in the inode, using the ``blksize(fs, ip, lbn)'' macro.
125  *
126  * The file system records space availability at the fragment level;
127  * to determine block availability, aligned fragments are examined.
128  */
129 
130 /*
131  * MINBSIZE is the smallest allowable block size.
132  * In order to insure that it is possible to create files of size
133  * 2^32 with only two levels of indirection, MINBSIZE is set to 4096.
134  * MINBSIZE must be big enough to hold a cylinder group block,
135  * thus changes to (struct cg) must keep its size within MINBSIZE.
136  * Note that super blocks are always of size SBSIZE,
137  * and that both SBSIZE and MAXBSIZE must be >= MINBSIZE.
138  */
139 #define MINBSIZE 4096
140 
141 /*
142  * The path name on which the file system is mounted is maintained
143  * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in
144  * the super block for this name.
145  */
146 #define MAXMNTLEN 468
147 
148 /*
149  * The volume name for this filesystem is maintained in fs_volname.
150  * MAXVOLLEN defines the length of the buffer allocated.
151  * This space used to be part of of fs_fsmnt.
152  */
153 #define MAXVOLLEN 32
154 
155 /*
156  * There is a 128-byte region in the superblock reserved for in-core
157  * pointers to summary information. Originally this included an array
158  * of pointers to blocks of struct csum; now there are just four
159  * pointers and the remaining space is padded with fs_ocsp[].
160  * NOCSPTRS determines the size of this padding. One pointer (fs_csp)
161  * is taken away to point to a contiguous array of struct csum for
162  * all cylinder groups; a second (fs_maxcluster) points to an array
163  * of cluster sizes that is computed as cylinder groups are inspected;
164  * the third (fs_contigdirs) points to an array that tracks the
165  * creation of new directories; and the fourth (fs_active) is used
166  * by snapshots.
167  */
168 #define NOCSPTRS ((128 / sizeof(void *)) - 4)
169 
170 /*
171  * A summary of contiguous blocks of various sizes is maintained
172  * in each cylinder group. Normally this is set by the initial
173  * value of fs_maxcontig. To conserve space, a maximum summary size
174  * is set by FS_MAXCONTIG.
175  */
176 #define FS_MAXCONTIG 16
177 
178 /*
179  * Unused value currently, FreeBSD compat.
180  */
181 #define FSMAXSNAP 20
182 
183 /*
184  * MINFREE gives the minimum acceptable percentage of file system
185  * blocks which may be free. If the freelist drops below this level
186  * only the superuser may continue to allocate blocks. This may
187  * be set to 0 if no reserve of free blocks is deemed necessary,
188  * however throughput drops by fifty percent if the file system
189  * is run at between 95% and 100% full; thus the minimum default
190  * value of fs_minfree is 5%. However, to get good clustering
191  * performance, 10% is a better choice. hence we use 10% as our
192  * default value. With 10% free space, fragmentation is not a
193  * problem, so we choose to optimize for time.
194  */
195 #define MINFREE 5
196 #define DEFAULTOPT FS_OPTTIME
197 
198 /*
199  * Grigoriy Orlov <gluk@ptci.ru> has done some extensive work to fine
200  * tune the layout preferences for directories within a filesystem.
201  * His algorithm can be tuned by adjusting the following parameters
202  * which tell the system the average file size and the average number
203  * of files per directory. These defaults are well selected for typical
204  * filesystems, but may need to be tuned for odd cases like filesystems
205  * being used for squid caches or news spools.
206  */
207 #define AVFILESIZ 16384 /* expected average file size */
208 #define AFPDIR 64 /* expected number of files per directory */
209 
210 /*
211  * Per cylinder group information; summarized in blocks allocated
212  * from first cylinder group data blocks. These blocks have to be
213  * read in from fs_csaddr (size fs_cssize) in addition to the
214  * super block.
215  */
216 struct csum {
217  int32_t cs_ndir; /* number of directories */
218  int32_t cs_nbfree; /* number of free blocks */
219  int32_t cs_nifree; /* number of free inodes */
220  int32_t cs_nffree; /* number of free frags */
221 };
222 
223 struct csum_total {
224  int64_t cs_ndir; /* number of directories */
225  int64_t cs_nbfree; /* number of free blocks */
226  int64_t cs_nifree; /* number of free inodes */
227  int64_t cs_nffree; /* number of free frags */
228  int64_t cs_spare[4]; /* future expansion */
229 };
230 
231 
232 /*
233  * Super block for an FFS file system in memory.
234  */
235 struct fs {
236  int32_t fs_firstfield; /* historic file system linked list, */
237  int32_t fs_unused_1; /* used for incore super blocks */
238  int32_t fs_sblkno; /* addr of super-block in filesys */
239  int32_t fs_cblkno; /* offset of cyl-block in filesys */
240  int32_t fs_iblkno; /* offset of inode-blocks in filesys */
241  int32_t fs_dblkno; /* offset of first data after cg */
242  int32_t fs_old_cgoffset; /* cylinder group offset in cylinder */
243  int32_t fs_old_cgmask; /* used to calc mod fs_ntrak */
244  int32_t fs_old_time; /* last time written */
245  int32_t fs_old_size; /* number of blocks in fs */
246  int32_t fs_old_dsize; /* number of data blocks in fs */
247  int32_t fs_ncg; /* number of cylinder groups */
248  int32_t fs_bsize; /* size of basic blocks in fs */
249  int32_t fs_fsize; /* size of frag blocks in fs */
250  int32_t fs_frag; /* number of frags in a block in fs */
251 /* these are configuration parameters */
252  int32_t fs_minfree; /* minimum percentage of free blocks */
253  int32_t fs_old_rotdelay; /* num of ms for optimal next block */
254  int32_t fs_old_rps; /* disk revolutions per second */
255 /* these fields can be computed from the others */
256  int32_t fs_bmask; /* ``blkoff'' calc of blk offsets */
257  int32_t fs_fmask; /* ``fragoff'' calc of frag offsets */
258  int32_t fs_bshift; /* ``lblkno'' calc of logical blkno */
259  int32_t fs_fshift; /* ``numfrags'' calc number of frags */
260 /* these are configuration parameters */
261  int32_t fs_maxcontig; /* max number of contiguous blks */
262  int32_t fs_maxbpg; /* max number of blks per cyl group */
263 /* these fields can be computed from the others */
264  int32_t fs_fragshift; /* block to frag shift */
265  int32_t fs_fsbtodb; /* fsbtodb and dbtofsb shift constant */
266  int32_t fs_sbsize; /* actual size of super block */
267  int32_t fs_spare1[2]; /* old fs_csmask */
268  /* old fs_csshift */
269  int32_t fs_nindir; /* value of NINDIR */
270  int32_t fs_inopb; /* value of INOPB */
271  int32_t fs_old_nspf; /* value of NSPF */
272 /* yet another configuration parameter */
273  int32_t fs_optim; /* optimization preference, see below */
274 /* these fields are derived from the hardware */
275  int32_t fs_old_npsect; /* # sectors/track including spares */
276  int32_t fs_old_interleave; /* hardware sector interleave */
277  int32_t fs_old_trackskew; /* sector 0 skew, per track */
278 /* fs_id takes the space of the unused fs_headswitch and fs_trkseek fields */
279  int32_t fs_id[2]; /* unique file system id */
280 /* sizes determined by number of cylinder groups and their sizes */
281  int32_t fs_old_csaddr; /* blk addr of cyl grp summary area */
282  int32_t fs_cssize; /* size of cyl grp summary area */
283  int32_t fs_cgsize; /* cylinder group size */
284 /* these fields are derived from the hardware */
285  int32_t fs_spare2; /* old fs_ntrak */
286  int32_t fs_old_nsect; /* sectors per track */
287  int32_t fs_old_spc; /* sectors per cylinder */
288  int32_t fs_old_ncyl; /* cylinders in file system */
289  int32_t fs_old_cpg; /* cylinders per group */
290  int32_t fs_ipg; /* inodes per group */
291  int32_t fs_fpg; /* blocks per group * fs_frag */
292 /* this data must be re-computed after crashes */
293  struct csum fs_old_cstotal; /* cylinder summary information */
294 /* these fields are cleared at mount time */
295  int8_t fs_fmod; /* super block modified flag */
296  int8_t fs_clean; /* file system is clean flag */
297  int8_t fs_ronly; /* mounted read-only flag */
298  uint8_t fs_old_flags; /* see FS_ flags below */
299  u_char fs_fsmnt[MAXMNTLEN]; /* name mounted on */
300  u_char fs_volname[MAXVOLLEN]; /* volume name */
301  uint64_t fs_swuid; /* system-wide uid */
303 /* these fields retain the current block allocation info */
304  int32_t fs_cgrotor; /* last cg searched (UNUSED) */
305  void *fs_ocsp[NOCSPTRS]; /* padding; was list of fs_cs buffers */
306  u_int8_t *fs_contigdirs; /* # of contiguously allocated dirs */
307  struct csum *fs_csp; /* cg summary info buffer for fs_cs */
308  int32_t *fs_maxcluster; /* max cluster in each cyl group */
309  u_int *fs_active; /* used by snapshots to track fs */
310  int32_t fs_old_cpc; /* cyl per cycle in postbl */
311 /* this area is otherwise allocated unless fs_old_flags & FS_FLAGS_UPDATED */
312  int32_t fs_maxbsize; /* maximum blocking factor permitted */
313  int64_t fs_sparecon64[17]; /* old rotation block list head */
314  int64_t fs_sblockloc; /* byte offset of standard superblock */
315  struct csum_total fs_cstotal; /* cylinder summary information */
316  int64_t fs_time; /* last time written */
317  int64_t fs_size; /* number of blocks in fs */
318  int64_t fs_dsize; /* number of data blocks in fs */
319  int64_t fs_csaddr; /* blk addr of cyl grp summary area */
320  int64_t fs_pendingblocks; /* blocks in process of being freed */
321  int32_t fs_pendinginodes; /* inodes in process of being freed */
322  int32_t fs_snapinum[FSMAXSNAP];/* list of snapshot inode numbers */
323 /* back to stuff that has been around a while */
324  int32_t fs_avgfilesize; /* expected average file size */
325  int32_t fs_avgfpdir; /* expected # of files per directory */
326  int32_t fs_save_cgsize; /* save real cg size to use fs_bsize */
327  int32_t fs_sparecon32[26]; /* reserved for future constants */
328  uint32_t fs_flags; /* see FS_ flags below */
329 /* back to stuff that has been around a while (again) */
330  int32_t fs_contigsumsize; /* size of cluster summary array */
331  int32_t fs_maxsymlinklen; /* max length of an internal symlink */
332  int32_t fs_old_inodefmt; /* format of on-disk inodes */
333  u_int64_t fs_maxfilesize; /* maximum representable file size */
334  int64_t fs_qbmask; /* ~fs_bmask for use with 64-bit size */
335  int64_t fs_qfmask; /* ~fs_fmask for use with 64-bit size */
336  int32_t fs_state; /* validate fs_clean field (UNUSED) */
337  int32_t fs_old_postblformat; /* format of positional layout tables */
338  int32_t fs_old_nrpos; /* number of rotational positions */
339  int32_t fs_spare5[2]; /* old fs_postbloff */
340  /* old fs_rotbloff */
341  int32_t fs_magic; /* magic number */
342 };
343 
344 #define fs_old_postbloff fs_spare5[0]
345 #define fs_old_rotbloff fs_spare5[1]
346 #define fs_old_postbl_start fs_maxbsize
347 #define fs_old_headswitch fs_id[0]
348 #define fs_old_trkseek fs_id[1]
349 #define fs_old_csmask fs_spare1[0]
350 #define fs_old_csshift fs_spare1[1]
351 
352 #define FS_42POSTBLFMT -1 /* 4.2BSD rotational table format */
353 #define FS_DYNAMICPOSTBLFMT 1 /* dynamic rotational table format */
354 
355 #define old_fs_postbl(fs_, cylno, opostblsave) \
356  ((((fs_)->fs_old_postblformat == FS_42POSTBLFMT) || \
357  ((fs_)->fs_old_postbloff == offsetof(struct fs, fs_old_postbl_start))) \
358  ? ((int16_t *)(opostblsave) + (cylno) * (fs_)->fs_old_nrpos) \
359  : ((int16_t *)((uint8_t *)(fs_) + \
360  (fs_)->fs_old_postbloff) + (cylno) * (fs_)->fs_old_nrpos))
361 #define old_fs_rotbl(fs) \
362  (((fs)->fs_old_postblformat == FS_42POSTBLFMT) \
363  ? ((uint8_t *)(&(fs)->fs_magic+1)) \
364  : ((uint8_t *)((uint8_t *)(fs) + (fs)->fs_old_rotbloff)))
365 
366 /*
367  * File system identification
368  */
369 #define FS_UFS1_MAGIC 0x011954 /* UFS1 fast file system magic number */
370 #define FS_UFS2_MAGIC 0x19540119 /* UFS2 fast file system magic number */
371 #define FS_UFS1_MAGIC_SWAPPED 0x54190100
372 #define FS_UFS2_MAGIC_SWAPPED 0x19015419
373 #define FS_OKAY 0x7c269d38 /* superblock checksum */
374 #define FS_42INODEFMT -1 /* 4.2BSD inode format */
375 #define FS_44INODEFMT 2 /* 4.4BSD inode format */
376 
377 /*
378  * File system clean flags
379  */
380 #define FS_ISCLEAN 0x01
381 #define FS_WASCLEAN 0x02
382 
383 /*
384  * Preference for optimization.
385  */
386 #define FS_OPTTIME 0 /* minimize allocation time */
387 #define FS_OPTSPACE 1 /* minimize disk fragmentation */
388 
389 /*
390  * File system flags
391  */
392 #define FS_UNCLEAN 0x01 /* file system not clean at mount (unused) */
393 #define FS_DOSOFTDEP 0x02 /* file system using soft dependencies */
394 #define FS_NEEDSFSCK 0x04 /* needs sync fsck (FreeBSD compat, unused) */
395 #define FS_INDEXDIRS 0x08 /* kernel supports indexed directories */
396 #define FS_ACLS 0x10 /* file system has ACLs enabled */
397 #define FS_MULTILABEL 0x20 /* file system is MAC multi-label */
398 #define FS_FLAGS_UPDATED 0x80 /* flags have been moved to new location */
399 
400 /*
401  * File system internal flags, also in fs_flags.
402  * (Pick highest number to avoid conflicts with others)
403  */
404 #define FS_SWAPPED 0x80000000 /* file system is endian swapped */
405 #define FS_INTERNAL 0x80000000 /* mask for internal flags */
406 
407 /*
408  * The size of a cylinder group is calculated by CGSIZE. The maximum size
409  * is limited by the fact that cylinder groups are at most one block.
410  * Its size is derived from the size of the maps maintained in the
411  * cylinder group and the (struct cg) size.
412  */
413 #define CGSIZE_IF(fs, ipg, fpg) \
414  /* base cg */ (sizeof(struct cg) + sizeof(int32_t) + \
415  /* old btotoff */ (fs)->fs_old_cpg * sizeof(int32_t) + \
416  /* old boff */ (fs)->fs_old_cpg * sizeof(u_int16_t) + \
417  /* inode map */ howmany((ipg), NBBY) + \
418  /* block map */ howmany((fpg), NBBY) +\
419  /* if present */ ((fs)->fs_contigsumsize <= 0 ? 0 : \
420  /* cluster sum */ (fs)->fs_contigsumsize * sizeof(int32_t) + \
421  /* cluster map */ howmany(fragstoblks(fs, (fpg)), NBBY)))
422 
423 #define CGSIZE(fs) CGSIZE_IF((fs), (fs)->fs_ipg, (fs)->fs_fpg)
424 
425 /*
426  * The minimal number of cylinder groups that should be created.
427  */
428 #define MINCYLGRPS 4
429 
430 
431 /*
432  * Convert cylinder group to base address of its global summary info.
433  */
434 #define fs_cs(fs, indx) fs_csp[indx]
435 
436 /*
437  * Cylinder group block for a file system.
438  */
439 #define CG_MAGIC 0x090255
440 struct cg {
441  int32_t cg_firstfield; /* historic cyl groups linked list */
442  int32_t cg_magic; /* magic number */
443  int32_t cg_old_time; /* time last written */
444  int32_t cg_cgx; /* we are the cgx'th cylinder group */
445  int16_t cg_old_ncyl; /* number of cyl's this cg */
446  int16_t cg_old_niblk; /* number of inode blocks this cg */
447  int32_t cg_ndblk; /* number of data blocks this cg */
448  struct csum cg_cs; /* cylinder summary information */
449  int32_t cg_rotor; /* position of last used block */
450  int32_t cg_frotor; /* position of last used frag */
451  int32_t cg_irotor; /* position of last used inode */
452  int32_t cg_frsum[MAXFRAG]; /* counts of available frags */
453  int32_t cg_old_btotoff; /* (int32) block totals per cylinder */
454  int32_t cg_old_boff; /* (u_int16) free block positions */
455  int32_t cg_iusedoff; /* (u_int8) used inode map */
456  int32_t cg_freeoff; /* (u_int8) free block map */
457  int32_t cg_nextfreeoff; /* (u_int8) next available space */
458  int32_t cg_clustersumoff; /* (u_int32) counts of avail clusters */
459  int32_t cg_clusteroff; /* (u_int8) free cluster map */
460  int32_t cg_nclusterblks; /* number of clusters this cg */
461  int32_t cg_niblk; /* number of inode blocks this cg */
462  int32_t cg_initediblk; /* last initialized inode */
463  int32_t cg_sparecon32[3]; /* reserved for future use */
464  int64_t cg_time; /* time last written */
465  int64_t cg_sparecon64[3]; /* reserved for future use */
466  u_int8_t cg_space[1]; /* space for cylinder group maps */
467 /* actually longer */
468 };
469 
470 /*
471  * The following structure is defined
472  * for compatibility with old file systems.
473  */
474 struct ocg {
475  int32_t cg_firstfield; /* historic linked list of cyl groups */
476  int32_t cg_unused_1; /* used for incore cyl groups */
477  int32_t cg_time; /* time last written */
478  int32_t cg_cgx; /* we are the cgx'th cylinder group */
479  int16_t cg_ncyl; /* number of cyl's this cg */
480  int16_t cg_niblk; /* number of inode blocks this cg */
481  int32_t cg_ndblk; /* number of data blocks this cg */
482  struct csum cg_cs; /* cylinder summary information */
483  int32_t cg_rotor; /* position of last used block */
484  int32_t cg_frotor; /* position of last used frag */
485  int32_t cg_irotor; /* position of last used inode */
486  int32_t cg_frsum[8]; /* counts of available frags */
487  int32_t cg_btot[32]; /* block totals per cylinder */
488  int16_t cg_b[32][8]; /* positions of free blocks */
489  u_int8_t cg_iused[256]; /* used inode map */
490  int32_t cg_magic; /* magic number */
491  u_int8_t cg_free[1]; /* free block map */
492 /* actually longer */
493 };
494 
495 
496 /*
497  * Macros for access to cylinder group array structures.
498  */
499 #define old_cg_blktot_old(cgp, ns) \
500  (((struct ocg *)(cgp))->cg_btot)
501 #define old_cg_blks_old(fs, cgp, cylno, ns) \
502  (((struct ocg *)(cgp))->cg_b[cylno])
503 
504 #define old_cg_blktot_new(cgp, ns) \
505  ((int32_t *)((u_int8_t *)(cgp) + \
506  ufs_rw32((cgp)->cg_old_btotoff, (ns))))
507 #define old_cg_blks_new(fs, cgp, cylno, ns) \
508  ((int16_t *)((u_int8_t *)(cgp) + \
509  ufs_rw32((cgp)->cg_old_boff, (ns))) + (cylno) * (fs)->fs_old_nrpos)
510 
511 #define old_cg_blktot(cgp, ns) \
512  ((ufs_rw32((cgp)->cg_magic, (ns)) != CG_MAGIC) ? \
513  old_cg_blktot_old(cgp, ns) : old_cg_blktot_new(cgp, ns))
514 #define old_cg_blks(fs, cgp, cylno, ns) \
515  ((ufs_rw32((cgp)->cg_magic, (ns)) != CG_MAGIC) ? \
516  old_cg_blks_old(fs, cgp, cylno, ns) : old_cg_blks_new(fs, cgp, cylno, ns))
517 
518 #define cg_inosused_new(cgp, ns) \
519  ((u_int8_t *)((u_int8_t *)(cgp) + \
520  ufs_rw32((cgp)->cg_iusedoff, (ns))))
521 #define cg_blksfree_new(cgp, ns) \
522  ((u_int8_t *)((u_int8_t *)(cgp) + \
523  ufs_rw32((cgp)->cg_freeoff, (ns))))
524 #define cg_chkmagic_new(cgp, ns) \
525  (ufs_rw32((cgp)->cg_magic, (ns)) == CG_MAGIC)
526 
527 #define cg_inosused_old(cgp, ns) \
528  (((struct ocg *)(cgp))->cg_iused)
529 #define cg_blksfree_old(cgp, ns) \
530  (((struct ocg *)(cgp))->cg_free)
531 #define cg_chkmagic_old(cgp, ns) \
532  (ufs_rw32(((struct ocg *)(cgp))->cg_magic, (ns)) == CG_MAGIC)
533 
534 #define cg_inosused(cgp, ns) \
535  ((ufs_rw32((cgp)->cg_magic, (ns)) != CG_MAGIC) ? \
536  cg_inosused_old(cgp, ns) : cg_inosused_new(cgp, ns))
537 #define cg_blksfree(cgp, ns) \
538  ((ufs_rw32((cgp)->cg_magic, (ns)) != CG_MAGIC) ? \
539  cg_blksfree_old(cgp, ns) : cg_blksfree_new(cgp, ns))
540 #define cg_chkmagic(cgp, ns) \
541  (cg_chkmagic_new(cgp, ns) || cg_chkmagic_old(cgp, ns))
542 
543 #define cg_clustersfree(cgp, ns) \
544  ((u_int8_t *)((u_int8_t *)(cgp) + \
545  ufs_rw32((cgp)->cg_clusteroff, (ns))))
546 #define cg_clustersum(cgp, ns) \
547  ((int32_t *)((u_int8_t *)(cgp) + \
548  ufs_rw32((cgp)->cg_clustersumoff, (ns))))
549 
550 
551 /*
552  * Turn file system block numbers into disk block addresses.
553  * This maps file system blocks to device size blocks.
554  */
555 #define fsbtodb(fs, b) ((b) << (fs)->fs_fsbtodb)
556 #define dbtofsb(fs, b) ((b) >> (fs)->fs_fsbtodb)
557 
558 /*
559  * Cylinder group macros to locate things in cylinder groups.
560  * They calc file system addresses of cylinder group data structures.
561  */
562 #define cgbase(fs, c) (((daddr_t)(fs)->fs_fpg) * (c))
563 #define cgstart_ufs1(fs, c) \
564  (cgbase(fs, c) + (fs)->fs_old_cgoffset * ((c) & ~((fs)->fs_old_cgmask)))
565 #define cgstart_ufs2(fs, c) cgbase((fs), (c))
566 #define cgstart(fs, c) ((fs)->fs_magic == FS_UFS2_MAGIC \
567  ? cgstart_ufs2((fs), (c)) : cgstart_ufs1((fs), (c)))
568 #define cgdmin(fs, c) (cgstart(fs, c) + (fs)->fs_dblkno) /* 1st data */
569 #define cgimin(fs, c) (cgstart(fs, c) + (fs)->fs_iblkno) /* inode blk */
570 #define cgsblock(fs, c) (cgstart(fs, c) + (fs)->fs_sblkno) /* super blk */
571 #define cgtod(fs, c) (cgstart(fs, c) + (fs)->fs_cblkno) /* cg block */
572 
573 /*
574  * Macros for handling inode numbers:
575  * inode number to file system block offset.
576  * inode number to cylinder group number.
577  * inode number to file system block address.
578  */
579 #define ino_to_cg(fs, x) ((x) / (fs)->fs_ipg)
580 #define ino_to_fsba(fs, x) \
581  ((daddr_t)(cgimin(fs, ino_to_cg(fs, x)) + \
582  (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))
583 #define ino_to_fsbo(fs, x) ((x) % INOPB(fs))
584 
585 /*
586  * Give cylinder group number for a file system block.
587  * Give cylinder group block number for a file system block.
588  */
589 #define dtog(fs, d) ((d) / (fs)->fs_fpg)
590 #define dtogd(fs, d) ((d) % (fs)->fs_fpg)
591 
592 /*
593  * Extract the bits for a block from a map.
594  * Compute the cylinder and rotational position of a cyl block addr.
595  */
596 #define blkmap(fs, map, loc) \
597  (((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))
598 #define old_cbtocylno(fs, bno) \
599  (fsbtodb(fs, bno) / (fs)->fs_old_spc)
600 #define old_cbtorpos(fs, bno) \
601  ((fs)->fs_old_nrpos <= 1 ? 0 : \
602  (fsbtodb(fs, bno) % (fs)->fs_old_spc / (fs)->fs_old_nsect * (fs)->fs_old_trackskew + \
603  fsbtodb(fs, bno) % (fs)->fs_old_spc % (fs)->fs_old_nsect * (fs)->fs_old_interleave) % \
604  (fs)->fs_old_nsect * (fs)->fs_old_nrpos / (fs)->fs_old_npsect)
605 
606 /*
607  * The following macros optimize certain frequently calculated
608  * quantities by using shifts and masks in place of divisions
609  * modulos and multiplications.
610  */
611 #define blkoff(fs, loc) /* calculates (loc % fs->fs_bsize) */ \
612  ((loc) & (fs)->fs_qbmask)
613 #define fragoff(fs, loc) /* calculates (loc % fs->fs_fsize) */ \
614  ((loc) & (fs)->fs_qfmask)
615 #define lfragtosize(fs, frag) /* calculates ((off_t)frag * fs->fs_fsize) */ \
616  (((off_t)(frag)) << (fs)->fs_fshift)
617 #define lblktosize(fs, blk) /* calculates ((off_t)blk * fs->fs_bsize) */ \
618  (((off_t)(blk)) << (fs)->fs_bshift)
619 #define lblkno(fs, loc) /* calculates (loc / fs->fs_bsize) */ \
620  ((loc) >> (fs)->fs_bshift)
621 #define numfrags(fs, loc) /* calculates (loc / fs->fs_fsize) */ \
622  ((loc) >> (fs)->fs_fshift)
623 #define blkroundup(fs, size) /* calculates roundup(size, fs->fs_bsize) */ \
624  (((size) + (fs)->fs_qbmask) & (fs)->fs_bmask)
625 #define fragroundup(fs, size) /* calculates roundup(size, fs->fs_fsize) */ \
626  (((size) + (fs)->fs_qfmask) & (fs)->fs_fmask)
627 #define fragstoblks(fs, frags) /* calculates (frags / fs->fs_frag) */ \
628  ((frags) >> (fs)->fs_fragshift)
629 #define blkstofrags(fs, blks) /* calculates (blks * fs->fs_frag) */ \
630  ((blks) << (fs)->fs_fragshift)
631 #define fragnum(fs, fsb) /* calculates (fsb % fs->fs_frag) */ \
632  ((fsb) & ((fs)->fs_frag - 1))
633 #define blknum(fs, fsb) /* calculates rounddown(fsb, fs->fs_frag) */ \
634  ((fsb) &~ ((fs)->fs_frag - 1))
635 
636 /*
637  * Determine the number of available frags given a
638  * percentage to hold in reserve.
639  */
640 #define freespace(fs, percentreserved) \
641  (blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \
642  (fs)->fs_cstotal.cs_nffree - \
643  (((off_t)((fs)->fs_dsize)) * (percentreserved) / 100))
644 
645 /*
646  * Determining the size of a file block in the file system.
647  */
648 #define blksize(fs, ip, lbn) \
649  (((lbn) >= NDADDR || (ip)->i_size >= lblktosize(fs, (lbn) + 1)) \
650  ? (fs)->fs_bsize \
651  : (fragroundup(fs, blkoff(fs, (ip)->i_size))))
652 
653 #define sblksize(fs, size, lbn) \
654  (((lbn) >= NDADDR || (size) >= ((lbn) + 1) << (fs)->fs_bshift) \
655  ? (fs)->fs_bsize \
656  : (fragroundup(fs, blkoff(fs, (size)))))
657 
658 
659 /*
660  * Number of inodes in a secondary storage block/fragment.
661  */
662 #define INOPB(fs) ((fs)->fs_inopb)
663 #define INOPF(fs) ((fs)->fs_inopb >> (fs)->fs_fragshift)
664 
665 /*
666  * Number of indirects in a file system block.
667  */
668 #define NINDIR(fs) ((fs)->fs_nindir)
669 
670 /*
671  * Apple UFS Label:
672  * We check for this to decide to use APPLEUFS_DIRBLKSIZ
673  */
674 #define APPLEUFS_LABEL_MAGIC 0x4c41424c /* LABL */
675 #define APPLEUFS_LABEL_SIZE 1024
676 #define APPLEUFS_LABEL_OFFSET (BBSIZE - APPLEUFS_LABEL_SIZE) /* located at 7k */
677 #define APPLEUFS_LABEL_VERSION 1
678 #define APPLEUFS_MAX_LABEL_NAME 512
679 
680 #if 0
681 struct appleufslabel {
682  u_int32_t ul_magic;
683  u_int16_t ul_checksum;
684  u_int16_t ul_unused0;
685  u_int32_t ul_version;
686  u_int32_t ul_time;
687  u_int16_t ul_namelen;
688  u_char ul_name[APPLEUFS_MAX_LABEL_NAME]; /* Warning: may not be null terminated */
689  u_int16_t ul_unused1;
690  u_int64_t ul_uuid; /* Note this is only 4 byte aligned */
691  u_char ul_reserved[24];
692  u_char ul_unused[460];
693 } __attribute__((__packed__));
694 #endif
695 
696 
697 #endif /* !_UFS_FFS_FS_H_ */
int8_t fs_fmod
Definition: fs.h:295
int32_t fs_maxsymlinklen
Definition: fs.h:331
int32_t cg_cgx
Definition: fs.h:444
int32_t fs_old_npsect
Definition: fs.h:275
struct csum fs_old_cstotal
Definition: fs.h:293
int32_t fs_avgfilesize
Definition: fs.h:324
int32_t fs_spare1[2]
Definition: fs.h:267
#define APPLEUFS_MAX_LABEL_NAME
Definition: fs.h:678
uint32_t fs_flags
Definition: fs.h:328
int32_t fs_old_nspf
Definition: fs.h:271
int64_t fs_pendingblocks
Definition: fs.h:320
int64_t cg_sparecon64[3]
Definition: fs.h:465
int32_t fs_old_size
Definition: fs.h:245
int64_t fs_size
Definition: fs.h:317
int64_t fs_time
Definition: fs.h:316
Definition: fs.h:223
int64_t cg_time
Definition: fs.h:464
int32_t * fs_maxcluster
Definition: fs.h:308
int32_t fs_old_csaddr
Definition: fs.h:281
int64_t fs_sparecon64[17]
Definition: fs.h:313
u_int64_t fs_maxfilesize
Definition: fs.h:333
int32_t cg_clustersumoff
Definition: fs.h:458
int32_t fs_fsbtodb
Definition: fs.h:265
int32_t fs_old_spc
Definition: fs.h:287
int32_t fs_pad
Definition: fs.h:302
int32_t fs_cssize
Definition: fs.h:282
Definition: fs.h:440
int32_t fs_old_nsect
Definition: fs.h:286
uint8_t fs_old_flags
Definition: fs.h:298
int16_t cg_niblk
Definition: fs.h:480
int32_t fs_maxbsize
Definition: fs.h:312
int32_t fs_spare2
Definition: fs.h:285
int32_t fs_bsize
Definition: fs.h:248
int16_t cg_old_ncyl
Definition: fs.h:445
int32_t fs_bmask
Definition: fs.h:256
int32_t fs_nindir
Definition: fs.h:269
#define __attribute__(Spec)
Definition: hlsl.tab.c:1213
Definition: fs.h:235
int32_t fs_dblkno
Definition: fs.h:241
u_char fs_fsmnt[MAXMNTLEN]
Definition: fs.h:299
int32_t fs_pendinginodes
Definition: fs.h:321
int32_t fs_old_cgmask
Definition: fs.h:243
int32_t cg_unused_1
Definition: fs.h:476
int32_t cg_old_boff
Definition: fs.h:454
int32_t fs_save_cgsize
Definition: fs.h:326
int32_t fs_ipg
Definition: fs.h:290
struct csum * fs_csp
Definition: fs.h:307
int64_t cs_nffree
Definition: fs.h:227
int32_t fs_old_cpc
Definition: fs.h:310
int32_t fs_sblkno
Definition: fs.h:238
int32_t cg_frsum[8]
Definition: fs.h:486
int32_t fs_state
Definition: fs.h:336
int32_t fs_fshift
Definition: fs.h:259
int8_t fs_ronly
Definition: fs.h:297
int32_t cs_ndir
Definition: fs.h:217
int32_t cg_nclusterblks
Definition: fs.h:460
unsigned char u_int8_t
Definition: rosdhcp.h:33
int64_t cs_nifree
Definition: fs.h:226
int32_t cg_rotor
Definition: fs.h:449
int32_t cg_freeoff
Definition: fs.h:456
#define MAXMNTLEN
Definition: fs.h:146
int32_t cs_nffree
Definition: fs.h:220
int16_t cg_ncyl
Definition: fs.h:479
int64_t cs_ndir
Definition: fs.h:224
int8_t fs_clean
Definition: fs.h:296
int32_t fs_old_rps
Definition: fs.h:254
UINT64 u_int64_t
Definition: types.h:76
#define MAXVOLLEN
Definition: fs.h:153
int64_t fs_qbmask
Definition: fs.h:334
int32_t cg_old_time
Definition: fs.h:443
int32_t fs_sparecon32[26]
Definition: fs.h:327
int32_t fs_old_rotdelay
Definition: fs.h:253
u_int8_t cg_free[1]
Definition: fs.h:491
int32_t cg_irotor
Definition: fs.h:451
int32_t fs_cblkno
Definition: fs.h:239
int32_t fs_old_cpg
Definition: fs.h:289
int32_t fs_old_trackskew
Definition: fs.h:277
int32_t cg_frotor
Definition: fs.h:450
int32_t fs_magic
Definition: fs.h:341
signed char int8_t
Definition: acefiex.h:50
int32_t fs_fsize
Definition: fs.h:249
int32_t cs_nifree
Definition: fs.h:219
int32_t fs_old_inodefmt
Definition: fs.h:332
int32_t fs_id[2]
Definition: fs.h:279
int32_t fs_old_interleave
Definition: fs.h:276
int32_t fs_unused_1
Definition: fs.h:237
int32_t fs_old_dsize
Definition: fs.h:246
int32_t cg_irotor
Definition: fs.h:485
int64_t cs_spare[4]
Definition: fs.h:228
uint64_t fs_swuid
Definition: fs.h:301
struct csum_total fs_cstotal
Definition: fs.h:315
#define FSMAXSNAP
Definition: fs.h:181
int32_t fs_firstfield
Definition: fs.h:236
struct csum cg_cs
Definition: fs.h:448
int32_t cg_initediblk
Definition: fs.h:462
int32_t cg_rotor
Definition: fs.h:483
unsigned short u_int16_t
Definition: rosdhcp.h:34
int32_t cg_firstfield
Definition: fs.h:441
int32_t fs_old_nrpos
Definition: fs.h:338
int32_t fs_iblkno
Definition: fs.h:240
int32_t fs_contigsumsize
Definition: fs.h:330
int64_t fs_sblockloc
Definition: fs.h:314
unsigned int u_int32_t
Definition: rosdhcp.h:35
int32_t cg_ndblk
Definition: fs.h:447
int32_t fs_cgrotor
Definition: fs.h:304
int32_t cg_cgx
Definition: fs.h:478
int32_t fs_ncg
Definition: fs.h:247
int32_t fs_old_ncyl
Definition: fs.h:288
int32_t fs_old_cgoffset
Definition: fs.h:242
BYTE uint8_t
Definition: msvideo1.c:66
Definition: fs.h:474
int32_t cg_frotor
Definition: fs.h:484
int32_t fs_avgfpdir
Definition: fs.h:325
INT32 int32_t
Definition: types.h:71
int64_t fs_qfmask
Definition: fs.h:335
int32_t cg_firstfield
Definition: fs.h:475
int32_t fs_spare5[2]
Definition: fs.h:339
int32_t fs_maxcontig
Definition: fs.h:261
int32_t cg_magic
Definition: fs.h:442
int64_t cs_nbfree
Definition: fs.h:225
#define NOCSPTRS
Definition: fs.h:168
int32_t cg_sparecon32[3]
Definition: fs.h:463
int32_t cg_niblk
Definition: fs.h:461
UINT64 uint64_t
Definition: types.h:77
#define MAXFRAG
Definition: fs.h:107
u_int8_t * fs_contigdirs
Definition: fs.h:306
int32_t cg_btot[32]
Definition: fs.h:487
int32_t cg_nextfreeoff
Definition: fs.h:457
int32_t cg_frsum[MAXFRAG]
Definition: fs.h:452
UINT32 u_int
Definition: types.h:82
int32_t fs_frag
Definition: fs.h:250
int16_t cg_b[32][8]
Definition: fs.h:488
u_int8_t cg_iused[256]
Definition: fs.h:489
int32_t fs_minfree
Definition: fs.h:252
int32_t fs_fpg
Definition: fs.h:291
int32_t cg_time
Definition: fs.h:477
int32_t fs_old_postblformat
Definition: fs.h:337
int32_t cg_clusteroff
Definition: fs.h:459
int32_t fs_cgsize
Definition: fs.h:283
UINT32 uint32_t
Definition: types.h:75
u_int8_t cg_space[1]
Definition: fs.h:466
int32_t cs_nbfree
Definition: fs.h:218
Definition: fs.h:216
int32_t fs_sbsize
Definition: fs.h:266
int32_t cg_magic
Definition: fs.h:490
u_int * fs_active
Definition: fs.h:309
int32_t fs_snapinum[FSMAXSNAP]
Definition: fs.h:322
int32_t fs_inopb
Definition: fs.h:270
int32_t fs_old_time
Definition: fs.h:244
struct csum cg_cs
Definition: fs.h:482
INT16 int16_t
Definition: types.h:70
void * fs_ocsp[NOCSPTRS]
Definition: fs.h:305
int64_t fs_csaddr
Definition: fs.h:319
int32_t cg_old_btotoff
Definition: fs.h:453
UCHAR u_char
Definition: types.h:80
INT64 int64_t
Definition: types.h:72
int32_t fs_bshift
Definition: fs.h:258
int32_t cg_ndblk
Definition: fs.h:481
int32_t fs_fragshift
Definition: fs.h:264
int32_t fs_fmask
Definition: fs.h:257
int16_t cg_old_niblk
Definition: fs.h:446
int64_t fs_dsize
Definition: fs.h:318
u_char fs_volname[MAXVOLLEN]
Definition: fs.h:300
int32_t cg_iusedoff
Definition: fs.h:455
int32_t fs_optim
Definition: fs.h:273
int32_t fs_maxbpg
Definition: fs.h:262