]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - sys/ufs/ffs/fs.h
MFV r325013,r325034: 640 number_to_scaled_string is duplicated in several commands
[FreeBSD/FreeBSD.git] / sys / ufs / ffs / fs.h
1 /*-
2  * Copyright (c) 1982, 1986, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  *      @(#)fs.h        8.13 (Berkeley) 3/21/95
30  * $FreeBSD$
31  */
32
33 #ifndef _UFS_FFS_FS_H_
34 #define _UFS_FFS_FS_H_
35
36 #include <sys/mount.h>
37 #include <ufs/ufs/dinode.h>
38
39 /*
40  * Each disk drive contains some number of filesystems.
41  * A filesystem consists of a number of cylinder groups.
42  * Each cylinder group has inodes and data.
43  *
44  * A filesystem 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 filesystem 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 #define SBLOCK_FLOPPY        0
72 #define SBLOCK_UFS1       8192
73 #define SBLOCK_UFS2      65536
74 #define SBLOCK_PIGGY    262144
75 #define SBLOCKSIZE        8192
76 #define SBLOCKSEARCH \
77         { SBLOCK_UFS2, SBLOCK_UFS1, SBLOCK_FLOPPY, SBLOCK_PIGGY, -1 }
78
79 /*
80  * Max number of fragments per block. This value is NOT tweakable.
81  */
82 #define MAXFRAG         8
83
84 /*
85  * Addresses stored in inodes are capable of addressing fragments
86  * of `blocks'. File system blocks of at most size MAXBSIZE can
87  * be optionally broken into 2, 4, or 8 pieces, each of which is
88  * addressable; these pieces may be DEV_BSIZE, or some multiple of
89  * a DEV_BSIZE unit.
90  *
91  * Large files consist of exclusively large data blocks.  To avoid
92  * undue wasted disk space, the last data block of a small file may be
93  * allocated as only as many fragments of a large block as are
94  * necessary.  The filesystem format retains only a single pointer
95  * to such a fragment, which is a piece of a single large block that
96  * has been divided.  The size of such a fragment is determinable from
97  * information in the inode, using the ``blksize(fs, ip, lbn)'' macro.
98  *
99  * The filesystem records space availability at the fragment level;
100  * to determine block availability, aligned fragments are examined.
101  */
102
103 /*
104  * MINBSIZE is the smallest allowable block size.
105  * In order to insure that it is possible to create files of size
106  * 2^32 with only two levels of indirection, MINBSIZE is set to 4096.
107  * MINBSIZE must be big enough to hold a cylinder group block,
108  * thus changes to (struct cg) must keep its size within MINBSIZE.
109  * Note that super blocks are always of size SBLOCKSIZE,
110  * and that both SBLOCKSIZE and MAXBSIZE must be >= MINBSIZE.
111  */
112 #define MINBSIZE        4096
113
114 /*
115  * The path name on which the filesystem is mounted is maintained
116  * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in
117  * the super block for this name.
118  */
119 #define MAXMNTLEN       468
120
121 /*
122  * The volume name for this filesystem is maintained in fs_volname.
123  * MAXVOLLEN defines the length of the buffer allocated.
124  */
125 #define MAXVOLLEN       32
126
127 /*
128  * There is a 128-byte region in the superblock reserved for in-core
129  * pointers to summary information. Originally this included an array
130  * of pointers to blocks of struct csum; now there are just a few
131  * pointers and the remaining space is padded with fs_ocsp[].
132  *
133  * NOCSPTRS determines the size of this padding. One pointer (fs_csp)
134  * is taken away to point to a contiguous array of struct csum for
135  * all cylinder groups; a second (fs_maxcluster) points to an array
136  * of cluster sizes that is computed as cylinder groups are inspected,
137  * and the third points to an array that tracks the creation of new
138  * directories. A fourth pointer, fs_active, is used when creating
139  * snapshots; it points to a bitmap of cylinder groups for which the
140  * free-block bitmap has changed since the snapshot operation began.
141  */
142 #define NOCSPTRS        ((128 / sizeof(void *)) - 4)
143
144 /*
145  * A summary of contiguous blocks of various sizes is maintained
146  * in each cylinder group. Normally this is set by the initial
147  * value of fs_maxcontig. To conserve space, a maximum summary size
148  * is set by FS_MAXCONTIG.
149  */
150 #define FS_MAXCONTIG    16
151
152 /*
153  * MINFREE gives the minimum acceptable percentage of filesystem
154  * blocks which may be free. If the freelist drops below this level
155  * only the superuser may continue to allocate blocks. This may
156  * be set to 0 if no reserve of free blocks is deemed necessary,
157  * however throughput drops by fifty percent if the filesystem
158  * is run at between 95% and 100% full; thus the minimum default
159  * value of fs_minfree is 5%. However, to get good clustering
160  * performance, 10% is a better choice. hence we use 10% as our
161  * default value. With 10% free space, fragmentation is not a
162  * problem, so we choose to optimize for time.
163  */
164 #define MINFREE         8
165 #define DEFAULTOPT      FS_OPTTIME
166
167 /*
168  * Grigoriy Orlov <gluk@ptci.ru> has done some extensive work to fine
169  * tune the layout preferences for directories within a filesystem.
170  * His algorithm can be tuned by adjusting the following parameters
171  * which tell the system the average file size and the average number
172  * of files per directory. These defaults are well selected for typical
173  * filesystems, but may need to be tuned for odd cases like filesystems
174  * being used for squid caches or news spools.
175  */
176 #define AVFILESIZ       16384   /* expected average file size */
177 #define AFPDIR          64      /* expected number of files per directory */
178
179 /*
180  * The maximum number of snapshot nodes that can be associated
181  * with each filesystem. This limit affects only the number of
182  * snapshot files that can be recorded within the superblock so
183  * that they can be found when the filesystem is mounted. However,
184  * maintaining too many will slow the filesystem performance, so
185  * having this limit is a good idea.
186  */
187 #define FSMAXSNAP 20
188
189 /*
190  * Used to identify special blocks in snapshots:
191  *
192  * BLK_NOCOPY - A block that was unallocated at the time the snapshot
193  *      was taken, hence does not need to be copied when written.
194  * BLK_SNAP - A block held by another snapshot that is not needed by this
195  *      snapshot. When the other snapshot is freed, the BLK_SNAP entries
196  *      are converted to BLK_NOCOPY. These are needed to allow fsck to
197  *      identify blocks that are in use by other snapshots (which are
198  *      expunged from this snapshot).
199  */
200 #define BLK_NOCOPY ((ufs2_daddr_t)(1))
201 #define BLK_SNAP ((ufs2_daddr_t)(2))
202
203 /*
204  * Sysctl values for the fast filesystem.
205  */
206 #define FFS_ADJ_REFCNT           1      /* adjust inode reference count */
207 #define FFS_ADJ_BLKCNT           2      /* adjust inode used block count */
208 #define FFS_BLK_FREE             3      /* free range of blocks in map */
209 #define FFS_DIR_FREE             4      /* free specified dir inodes in map */
210 #define FFS_FILE_FREE            5      /* free specified file inodes in map */
211 #define FFS_SET_FLAGS            6      /* set filesystem flags */
212 #define FFS_ADJ_NDIR             7      /* adjust number of directories */
213 #define FFS_ADJ_NBFREE           8      /* adjust number of free blocks */
214 #define FFS_ADJ_NIFREE           9      /* adjust number of free inodes */
215 #define FFS_ADJ_NFFREE          10      /* adjust number of free frags */
216 #define FFS_ADJ_NUMCLUSTERS     11      /* adjust number of free clusters */
217 #define FFS_SET_CWD             12      /* set current directory */
218 #define FFS_SET_DOTDOT          13      /* set inode number for ".." */
219 #define FFS_UNLINK              14      /* remove a name in the filesystem */
220 #define FFS_SET_INODE           15      /* update an on-disk inode */
221 #define FFS_SET_BUFOUTPUT       16      /* set buffered writing on descriptor */
222 #define FFS_MAXID               16      /* number of valid ffs ids */
223
224 /*
225  * Command structure passed in to the filesystem to adjust filesystem values.
226  */
227 #define FFS_CMD_VERSION         0x19790518      /* version ID */
228 struct fsck_cmd {
229         int32_t version;        /* version of command structure */
230         int32_t handle;         /* reference to filesystem to be changed */
231         int64_t value;          /* inode or block number to be affected */
232         int64_t size;           /* amount or range to be adjusted */
233         int64_t spare;          /* reserved for future use */
234 };
235
236 /*
237  * A recovery structure placed at the end of the boot block area by newfs
238  * that can be used by fsck to search for alternate superblocks.
239  */
240 struct fsrecovery {
241         int32_t fsr_magic;      /* magic number */
242         int32_t fsr_fsbtodb;    /* fsbtodb and dbtofsb shift constant */
243         int32_t fsr_sblkno;     /* offset of super-block in filesys */
244         int32_t fsr_fpg;        /* blocks per group * fs_frag */
245         u_int32_t fsr_ncg;      /* number of cylinder groups */
246 };
247
248 /*
249  * Per cylinder group information; summarized in blocks allocated
250  * from first cylinder group data blocks.  These blocks have to be
251  * read in from fs_csaddr (size fs_cssize) in addition to the
252  * super block.
253  */
254 struct csum {
255         int32_t cs_ndir;                /* number of directories */
256         int32_t cs_nbfree;              /* number of free blocks */
257         int32_t cs_nifree;              /* number of free inodes */
258         int32_t cs_nffree;              /* number of free frags */
259 };
260 struct csum_total {
261         int64_t cs_ndir;                /* number of directories */
262         int64_t cs_nbfree;              /* number of free blocks */
263         int64_t cs_nifree;              /* number of free inodes */
264         int64_t cs_nffree;              /* number of free frags */
265         int64_t cs_numclusters;         /* number of free clusters */
266         int64_t cs_spare[3];            /* future expansion */
267 };
268
269 /*
270  * Super block for an FFS filesystem.
271  */
272 struct fs {
273         int32_t  fs_firstfield;         /* historic filesystem linked list, */
274         int32_t  fs_unused_1;           /*     used for incore super blocks */
275         int32_t  fs_sblkno;             /* offset of super-block in filesys */
276         int32_t  fs_cblkno;             /* offset of cyl-block in filesys */
277         int32_t  fs_iblkno;             /* offset of inode-blocks in filesys */
278         int32_t  fs_dblkno;             /* offset of first data after cg */
279         int32_t  fs_old_cgoffset;       /* cylinder group offset in cylinder */
280         int32_t  fs_old_cgmask;         /* used to calc mod fs_ntrak */
281         int32_t  fs_old_time;           /* last time written */
282         int32_t  fs_old_size;           /* number of blocks in fs */
283         int32_t  fs_old_dsize;          /* number of data blocks in fs */
284         u_int32_t fs_ncg;               /* number of cylinder groups */
285         int32_t  fs_bsize;              /* size of basic blocks in fs */
286         int32_t  fs_fsize;              /* size of frag blocks in fs */
287         int32_t  fs_frag;               /* number of frags in a block in fs */
288 /* these are configuration parameters */
289         int32_t  fs_minfree;            /* minimum percentage of free blocks */
290         int32_t  fs_old_rotdelay;       /* num of ms for optimal next block */
291         int32_t  fs_old_rps;            /* disk revolutions per second */
292 /* these fields can be computed from the others */
293         int32_t  fs_bmask;              /* ``blkoff'' calc of blk offsets */
294         int32_t  fs_fmask;              /* ``fragoff'' calc of frag offsets */
295         int32_t  fs_bshift;             /* ``lblkno'' calc of logical blkno */
296         int32_t  fs_fshift;             /* ``numfrags'' calc number of frags */
297 /* these are configuration parameters */
298         int32_t  fs_maxcontig;          /* max number of contiguous blks */
299         int32_t  fs_maxbpg;             /* max number of blks per cyl group */
300 /* these fields can be computed from the others */
301         int32_t  fs_fragshift;          /* block to frag shift */
302         int32_t  fs_fsbtodb;            /* fsbtodb and dbtofsb shift constant */
303         int32_t  fs_sbsize;             /* actual size of super block */
304         int32_t  fs_spare1[2];          /* old fs_csmask */
305                                         /* old fs_csshift */
306         int32_t  fs_nindir;             /* value of NINDIR */
307         u_int32_t fs_inopb;             /* value of INOPB */
308         int32_t  fs_old_nspf;           /* value of NSPF */
309 /* yet another configuration parameter */
310         int32_t  fs_optim;              /* optimization preference, see below */
311         int32_t  fs_old_npsect;         /* # sectors/track including spares */
312         int32_t  fs_old_interleave;     /* hardware sector interleave */
313         int32_t  fs_old_trackskew;      /* sector 0 skew, per track */
314         int32_t  fs_id[2];              /* unique filesystem id */
315 /* sizes determined by number of cylinder groups and their sizes */
316         int32_t  fs_old_csaddr;         /* blk addr of cyl grp summary area */
317         int32_t  fs_cssize;             /* size of cyl grp summary area */
318         int32_t  fs_cgsize;             /* cylinder group size */
319         int32_t  fs_spare2;             /* old fs_ntrak */
320         int32_t  fs_old_nsect;          /* sectors per track */
321         int32_t  fs_old_spc;            /* sectors per cylinder */
322         int32_t  fs_old_ncyl;           /* cylinders in filesystem */
323         int32_t  fs_old_cpg;            /* cylinders per group */
324         u_int32_t fs_ipg;               /* inodes per group */
325         int32_t  fs_fpg;                /* blocks per group * fs_frag */
326 /* this data must be re-computed after crashes */
327         struct  csum fs_old_cstotal;    /* cylinder summary information */
328 /* these fields are cleared at mount time */
329         int8_t   fs_fmod;               /* super block modified flag */
330         int8_t   fs_clean;              /* filesystem is clean flag */
331         int8_t   fs_ronly;              /* mounted read-only flag */
332         int8_t   fs_old_flags;          /* old FS_ flags */
333         u_char   fs_fsmnt[MAXMNTLEN];   /* name mounted on */
334         u_char   fs_volname[MAXVOLLEN]; /* volume name */
335         u_int64_t fs_swuid;             /* system-wide uid */
336         int32_t  fs_pad;                /* due to alignment of fs_swuid */
337 /* these fields retain the current block allocation info */
338         int32_t  fs_cgrotor;            /* last cg searched */
339         void    *fs_ocsp[NOCSPTRS];     /* padding; was list of fs_cs buffers */
340         u_int8_t *fs_contigdirs;        /* (u) # of contig. allocated dirs */
341         struct  csum *fs_csp;           /* (u) cg summary info buffer */
342         int32_t *fs_maxcluster;         /* (u) max cluster in each cyl group */
343         u_int   *fs_active;             /* (u) used by snapshots to track fs */
344         int32_t  fs_old_cpc;            /* cyl per cycle in postbl */
345         int32_t  fs_maxbsize;           /* maximum blocking factor permitted */
346         int64_t  fs_unrefs;             /* number of unreferenced inodes */
347         int64_t  fs_providersize;       /* size of underlying GEOM provider */
348         int64_t  fs_metaspace;          /* size of area reserved for metadata */
349         int64_t  fs_sparecon64[14];     /* old rotation block list head */
350         int64_t  fs_sblockloc;          /* byte offset of standard superblock */
351         struct  csum_total fs_cstotal;  /* (u) cylinder summary information */
352         ufs_time_t fs_time;             /* last time written */
353         int64_t  fs_size;               /* number of blocks in fs */
354         int64_t  fs_dsize;              /* number of data blocks in fs */
355         ufs2_daddr_t fs_csaddr;         /* blk addr of cyl grp summary area */
356         int64_t  fs_pendingblocks;      /* (u) blocks being freed */
357         u_int32_t fs_pendinginodes;     /* (u) inodes being freed */
358         uint32_t fs_snapinum[FSMAXSNAP];/* list of snapshot inode numbers */
359         u_int32_t fs_avgfilesize;       /* expected average file size */
360         u_int32_t fs_avgfpdir;          /* expected # of files per directory */
361         int32_t  fs_save_cgsize;        /* save real cg size to use fs_bsize */
362         ufs_time_t fs_mtime;            /* Last mount or fsck time. */
363         int32_t  fs_sujfree;            /* SUJ free list */
364         int32_t  fs_sparecon32[22];     /* reserved for future constants */
365         u_int32_t fs_metackhash;        /* metadata check-hash, see CK_ below */
366         int32_t  fs_flags;              /* see FS_ flags below */
367         int32_t  fs_contigsumsize;      /* size of cluster summary array */ 
368         int32_t  fs_maxsymlinklen;      /* max length of an internal symlink */
369         int32_t  fs_old_inodefmt;       /* format of on-disk inodes */
370         u_int64_t fs_maxfilesize;       /* maximum representable file size */
371         int64_t  fs_qbmask;             /* ~fs_bmask for use with 64-bit size */
372         int64_t  fs_qfmask;             /* ~fs_fmask for use with 64-bit size */
373         int32_t  fs_state;              /* validate fs_clean field */
374         int32_t  fs_old_postblformat;   /* format of positional layout tables */
375         int32_t  fs_old_nrpos;          /* number of rotational positions */
376         int32_t  fs_spare5[2];          /* old fs_postbloff */
377                                         /* old fs_rotbloff */
378         int32_t  fs_magic;              /* magic number */
379 };
380
381 /* Sanity checking. */
382 #ifdef CTASSERT
383 CTASSERT(sizeof(struct fs) == 1376);
384 #endif
385
386 /*
387  * Filesystem identification
388  */
389 #define FS_UFS1_MAGIC   0x011954        /* UFS1 fast filesystem magic number */
390 #define FS_UFS2_MAGIC   0x19540119      /* UFS2 fast filesystem magic number */
391 #define FS_BAD_MAGIC    0x19960408      /* UFS incomplete newfs magic number */
392 #define FS_42INODEFMT   -1              /* 4.2BSD inode format */
393 #define FS_44INODEFMT   2               /* 4.4BSD inode format */
394
395 /*
396  * Preference for optimization.
397  */
398 #define FS_OPTTIME      0       /* minimize allocation time */
399 #define FS_OPTSPACE     1       /* minimize disk fragmentation */
400
401 /*
402  * Filesystem flags.
403  *
404  * The FS_UNCLEAN flag is set by the kernel when the filesystem was
405  * mounted with fs_clean set to zero. The FS_DOSOFTDEP flag indicates
406  * that the filesystem should be managed by the soft updates code.
407  * Note that the FS_NEEDSFSCK flag is set and cleared only by the
408  * fsck utility. It is set when background fsck finds an unexpected
409  * inconsistency which requires a traditional foreground fsck to be
410  * run. Such inconsistencies should only be found after an uncorrectable
411  * disk error. A foreground fsck will clear the FS_NEEDSFSCK flag when
412  * it has successfully cleaned up the filesystem. The kernel uses this
413  * flag to enforce that inconsistent filesystems be mounted read-only.
414  * The FS_INDEXDIRS flag when set indicates that the kernel maintains
415  * on-disk auxiliary indexes (such as B-trees) for speeding directory
416  * accesses. Kernels that do not support auxiliary indices clear the
417  * flag to indicate that the indices need to be rebuilt (by fsck) before
418  * they can be used. When a filesystem is mounted, any flags not
419  * included in FS_SUPPORTED are cleared. This lets newer features
420  * know that the filesystem has been run on an older version of the
421  * filesystem and thus that data structures associated with those
422  * features are out-of-date and need to be rebuilt.
423  *
424  * FS_ACLS indicates that POSIX.1e ACLs are administratively enabled
425  * for the file system, so they should be loaded from extended attributes,
426  * observed for access control purposes, and be administered by object
427  * owners.  FS_NFS4ACLS indicates that NFSv4 ACLs are administratively
428  * enabled.  This flag is mutually exclusive with FS_ACLS.  FS_MULTILABEL
429  * indicates that the TrustedBSD MAC Framework should attempt to back MAC
430  * labels into extended attributes on the file system rather than maintain
431  * a single mount label for all objects.
432  */
433 #define FS_UNCLEAN      0x0001  /* filesystem not clean at mount */
434 #define FS_DOSOFTDEP    0x0002  /* filesystem using soft dependencies */
435 #define FS_NEEDSFSCK    0x0004  /* filesystem needs sync fsck before mount */
436 #define FS_SUJ          0x0008  /* Filesystem using softupdate journal */
437 #define FS_ACLS         0x0010  /* file system has POSIX.1e ACLs enabled */
438 #define FS_MULTILABEL   0x0020  /* file system is MAC multi-label */
439 #define FS_GJOURNAL     0x0040  /* gjournaled file system */
440 #define FS_FLAGS_UPDATED 0x0080 /* flags have been moved to new location */
441 #define FS_NFS4ACLS     0x0100  /* file system has NFSv4 ACLs enabled */
442 #define FS_INDEXDIRS    0x0200  /* kernel supports indexed directories */
443 #define FS_TRIM         0x0400  /* issue BIO_DELETE for deleted blocks */
444 #define FS_SUPPORTED    0xFFFF  /* supported flags, others cleared at mount */
445
446 /*
447  * The fs_metackhash field indicates the types of metadata check-hash
448  * that are maintained for a filesystem. Not all filesystems check-hash
449  * all metadata.
450  */
451 #define CK_SUPERBLOCK   0x0001  /* the superblock */
452 #define CK_CYLGRP       0x0002  /* the cylinder groups */
453 #define CK_INODE        0x0004  /* inodes */
454 #define CK_INDIR        0x0008  /* indirect blocks */
455 #define CK_DIR          0x0010  /* directory contents */
456 /*
457  * The BX_FSPRIV buffer b_xflags are used to track types of data in buffers.
458  */
459 #define BX_SUPERBLOCK   0x00010000      /* superblock */
460 #define BX_CYLGRP       0x00020000      /* cylinder groups */
461 #define BX_INODE        0x00040000      /* inodes */
462 #define BX_INDIR        0x00080000      /* indirect blocks */
463 #define BX_DIR          0x00100000      /* directory contents */
464
465 #define PRINT_UFS_BUF_XFLAGS "\20\25dir\24indir\23inode\22cylgrp\21superblock"
466
467 /*
468  * Macros to access bits in the fs_active array.
469  */
470 #define ACTIVECGNUM(fs, cg)     ((fs)->fs_active[(cg) / (NBBY * sizeof(int))])
471 #define ACTIVECGOFF(cg)         (1 << ((cg) % (NBBY * sizeof(int))))
472 #define ACTIVESET(fs, cg)       do {                                    \
473         if ((fs)->fs_active)                                            \
474                 ACTIVECGNUM((fs), (cg)) |= ACTIVECGOFF((cg));           \
475 } while (0)
476 #define ACTIVECLEAR(fs, cg)     do {                                    \
477         if ((fs)->fs_active)                                            \
478                 ACTIVECGNUM((fs), (cg)) &= ~ACTIVECGOFF((cg));          \
479 } while (0)
480
481 /*
482  * The size of a cylinder group is calculated by CGSIZE. The maximum size
483  * is limited by the fact that cylinder groups are at most one block.
484  * Its size is derived from the size of the maps maintained in the
485  * cylinder group and the (struct cg) size.
486  */
487 #define CGSIZE(fs) \
488     /* base cg */       (sizeof(struct cg) + sizeof(int32_t) + \
489     /* old btotoff */   (fs)->fs_old_cpg * sizeof(int32_t) + \
490     /* old boff */      (fs)->fs_old_cpg * sizeof(u_int16_t) + \
491     /* inode map */     howmany((fs)->fs_ipg, NBBY) + \
492     /* block map */     howmany((fs)->fs_fpg, NBBY) +\
493     /* if present */    ((fs)->fs_contigsumsize <= 0 ? 0 : \
494     /* cluster sum */   (fs)->fs_contigsumsize * sizeof(int32_t) + \
495     /* cluster map */   howmany(fragstoblks(fs, (fs)->fs_fpg), NBBY)))
496
497 /*
498  * The minimal number of cylinder groups that should be created.
499  */
500 #define MINCYLGRPS      4
501
502 /*
503  * Convert cylinder group to base address of its global summary info.
504  */
505 #define fs_cs(fs, indx) fs_csp[indx]
506
507 /*
508  * Cylinder group block for a filesystem.
509  */
510 #define CG_MAGIC        0x090255
511 struct cg {
512         int32_t  cg_firstfield;         /* historic cyl groups linked list */
513         int32_t  cg_magic;              /* magic number */
514         int32_t  cg_old_time;           /* time last written */
515         u_int32_t cg_cgx;               /* we are the cgx'th cylinder group */
516         int16_t  cg_old_ncyl;           /* number of cyl's this cg */
517         int16_t  cg_old_niblk;          /* number of inode blocks this cg */
518         u_int32_t cg_ndblk;             /* number of data blocks this cg */
519         struct   csum cg_cs;            /* cylinder summary information */
520         u_int32_t cg_rotor;             /* position of last used block */
521         u_int32_t cg_frotor;            /* position of last used frag */
522         u_int32_t cg_irotor;            /* position of last used inode */
523         u_int32_t cg_frsum[MAXFRAG];    /* counts of available frags */
524         int32_t  cg_old_btotoff;        /* (int32) block totals per cylinder */
525         int32_t  cg_old_boff;           /* (u_int16) free block positions */
526         u_int32_t cg_iusedoff;          /* (u_int8) used inode map */
527         u_int32_t cg_freeoff;           /* (u_int8) free block map */
528         u_int32_t cg_nextfreeoff;       /* (u_int8) next available space */
529         u_int32_t cg_clustersumoff;     /* (u_int32) counts of avail clusters */
530         u_int32_t cg_clusteroff;                /* (u_int8) free cluster map */
531         u_int32_t cg_nclusterblks;      /* number of clusters this cg */
532         u_int32_t cg_niblk;             /* number of inode blocks this cg */
533         u_int32_t cg_initediblk;                /* last initialized inode */
534         u_int32_t cg_unrefs;            /* number of unreferenced inodes */
535         int32_t  cg_sparecon32[1];      /* reserved for future use */
536         u_int32_t cg_ckhash;            /* check-hash of this cg */
537         ufs_time_t cg_time;             /* time last written */
538         int64_t  cg_sparecon64[3];      /* reserved for future use */
539         u_int8_t cg_space[1];           /* space for cylinder group maps */
540 /* actually longer */
541 };
542
543 /*
544  * Macros for access to cylinder group array structures
545  */
546 #define cg_chkmagic(cgp) ((cgp)->cg_magic == CG_MAGIC)
547 #define cg_inosused(cgp) \
548     ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_iusedoff))
549 #define cg_blksfree(cgp) \
550     ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_freeoff))
551 #define cg_clustersfree(cgp) \
552     ((u_int8_t *)((u_int8_t *)(cgp) + (cgp)->cg_clusteroff))
553 #define cg_clustersum(cgp) \
554     ((int32_t *)((uintptr_t)(cgp) + (cgp)->cg_clustersumoff))
555
556 /*
557  * Turn filesystem block numbers into disk block addresses.
558  * This maps filesystem blocks to device size blocks.
559  */
560 #define fsbtodb(fs, b)  ((daddr_t)(b) << (fs)->fs_fsbtodb)
561 #define dbtofsb(fs, b)  ((b) >> (fs)->fs_fsbtodb)
562
563 /*
564  * Cylinder group macros to locate things in cylinder groups.
565  * They calc filesystem addresses of cylinder group data structures.
566  */
567 #define cgbase(fs, c)   (((ufs2_daddr_t)(fs)->fs_fpg) * (c))
568 #define cgdata(fs, c)   (cgdmin(fs, c) + (fs)->fs_metaspace)    /* data zone */
569 #define cgmeta(fs, c)   (cgdmin(fs, c))                         /* meta data */
570 #define cgdmin(fs, c)   (cgstart(fs, c) + (fs)->fs_dblkno)      /* 1st data */
571 #define cgimin(fs, c)   (cgstart(fs, c) + (fs)->fs_iblkno)      /* inode blk */
572 #define cgsblock(fs, c) (cgstart(fs, c) + (fs)->fs_sblkno)      /* super blk */
573 #define cgtod(fs, c)    (cgstart(fs, c) + (fs)->fs_cblkno)      /* cg block */
574 #define cgstart(fs, c)                                                  \
575        ((fs)->fs_magic == FS_UFS2_MAGIC ? cgbase(fs, c) :               \
576        (cgbase(fs, c) + (fs)->fs_old_cgoffset * ((c) & ~((fs)->fs_old_cgmask))))
577
578 /*
579  * Macros for handling inode numbers:
580  *     inode number to filesystem block offset.
581  *     inode number to cylinder group number.
582  *     inode number to filesystem block address.
583  */
584 #define ino_to_cg(fs, x)        (((ino_t)(x)) / (fs)->fs_ipg)
585 #define ino_to_fsba(fs, x)                                              \
586         ((ufs2_daddr_t)(cgimin(fs, ino_to_cg(fs, (ino_t)(x))) +         \
587             (blkstofrags((fs), ((((ino_t)(x)) % (fs)->fs_ipg) / INOPB(fs))))))
588 #define ino_to_fsbo(fs, x)      (((ino_t)(x)) % INOPB(fs))
589
590 /*
591  * Give cylinder group number for a filesystem block.
592  * Give cylinder group block number for a filesystem block.
593  */
594 #define dtog(fs, d)     ((d) / (fs)->fs_fpg)
595 #define dtogd(fs, d)    ((d) % (fs)->fs_fpg)
596
597 /*
598  * Extract the bits for a block from a map.
599  * Compute the cylinder and rotational position of a cyl block addr.
600  */
601 #define blkmap(fs, map, loc) \
602     (((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))
603
604 /*
605  * The following macros optimize certain frequently calculated
606  * quantities by using shifts and masks in place of divisions
607  * modulos and multiplications.
608  */
609 #define blkoff(fs, loc)         /* calculates (loc % fs->fs_bsize) */ \
610         ((loc) & (fs)->fs_qbmask)
611 #define fragoff(fs, loc)        /* calculates (loc % fs->fs_fsize) */ \
612         ((loc) & (fs)->fs_qfmask)
613 #define lfragtosize(fs, frag)   /* calculates ((off_t)frag * fs->fs_fsize) */ \
614         (((off_t)(frag)) << (fs)->fs_fshift)
615 #define lblktosize(fs, blk)     /* calculates ((off_t)blk * fs->fs_bsize) */ \
616         (((off_t)(blk)) << (fs)->fs_bshift)
617 /* Use this only when `blk' is known to be small, e.g., < UFS_NDADDR. */
618 #define smalllblktosize(fs, blk)    /* calculates (blk * fs->fs_bsize) */ \
619         ((blk) << (fs)->fs_bshift)
620 #define lblkno(fs, loc)         /* calculates (loc / fs->fs_bsize) */ \
621         ((loc) >> (fs)->fs_bshift)
622 #define numfrags(fs, loc)       /* calculates (loc / fs->fs_fsize) */ \
623         ((loc) >> (fs)->fs_fshift)
624 #define blkroundup(fs, size)    /* calculates roundup(size, fs->fs_bsize) */ \
625         (((size) + (fs)->fs_qbmask) & (fs)->fs_bmask)
626 #define fragroundup(fs, size)   /* calculates roundup(size, fs->fs_fsize) */ \
627         (((size) + (fs)->fs_qfmask) & (fs)->fs_fmask)
628 #define fragstoblks(fs, frags)  /* calculates (frags / fs->fs_frag) */ \
629         ((frags) >> (fs)->fs_fragshift)
630 #define blkstofrags(fs, blks)   /* calculates (blks * fs->fs_frag) */ \
631         ((blks) << (fs)->fs_fragshift)
632 #define fragnum(fs, fsb)        /* calculates (fsb % fs->fs_frag) */ \
633         ((fsb) & ((fs)->fs_frag - 1))
634 #define blknum(fs, fsb)         /* calculates rounddown(fsb, fs->fs_frag) */ \
635         ((fsb) &~ ((fs)->fs_frag - 1))
636
637 /*
638  * Determine the number of available frags given a
639  * percentage to hold in reserve.
640  */
641 #define freespace(fs, percentreserved) \
642         (blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \
643         (fs)->fs_cstotal.cs_nffree - \
644         (((off_t)((fs)->fs_dsize)) * (percentreserved) / 100))
645
646 /*
647  * Determining the size of a file block in the filesystem.
648  */
649 #define blksize(fs, ip, lbn) \
650         (((lbn) >= UFS_NDADDR || (ip)->i_size >= \
651             (uint64_t)smalllblktosize(fs, (lbn) + 1)) \
652             ? (fs)->fs_bsize \
653             : (fragroundup(fs, blkoff(fs, (ip)->i_size))))
654 #define sblksize(fs, size, lbn) \
655         (((lbn) >= UFS_NDADDR || (size) >= ((lbn) + 1) << (fs)->fs_bshift) \
656           ? (fs)->fs_bsize \
657           : (fragroundup(fs, blkoff(fs, (size)))))
658
659 /*
660  * Number of indirects in a filesystem block.
661  */
662 #define NINDIR(fs)      ((fs)->fs_nindir)
663
664 /*
665  * Indirect lbns are aligned on UFS_NDADDR addresses where single indirects
666  * are the negated address of the lowest lbn reachable, double indirects
667  * are this lbn - 1 and triple indirects are this lbn - 2.  This yields
668  * an unusual bit order to determine level.
669  */
670 static inline int
671 lbn_level(ufs_lbn_t lbn)
672 {
673         if (lbn >= 0)
674                 return 0;
675         switch (lbn & 0x3) {
676         case 0:
677                 return (0);
678         case 1:
679                 break;
680         case 2:
681                 return (2);
682         case 3:
683                 return (1);
684         default:
685                 break;
686         }
687         return (-1);
688 }
689
690 static inline ufs_lbn_t
691 lbn_offset(struct fs *fs, int level)
692 {
693         ufs_lbn_t res;
694
695         for (res = 1; level > 0; level--)
696                 res *= NINDIR(fs);
697         return (res);
698 }
699
700 /*
701  * Number of inodes in a secondary storage block/fragment.
702  */
703 #define INOPB(fs)       ((fs)->fs_inopb)
704 #define INOPF(fs)       ((fs)->fs_inopb >> (fs)->fs_fragshift)
705
706 /*
707  * Softdep journal record format.
708  */
709
710 #define JOP_ADDREF      1       /* Add a reference to an inode. */
711 #define JOP_REMREF      2       /* Remove a reference from an inode. */
712 #define JOP_NEWBLK      3       /* Allocate a block. */
713 #define JOP_FREEBLK     4       /* Free a block or a tree of blocks. */
714 #define JOP_MVREF       5       /* Move a reference from one off to another. */
715 #define JOP_TRUNC       6       /* Partial truncation record. */
716 #define JOP_SYNC        7       /* fsync() complete record. */
717
718 #define JREC_SIZE       32      /* Record and segment header size. */
719
720 #define SUJ_MIN         (4 * 1024 * 1024)       /* Minimum journal size */
721 #define SUJ_MAX         (32 * 1024 * 1024)      /* Maximum journal size */
722 #define SUJ_FILE        ".sujournal"            /* Journal file name */
723
724 /*
725  * Size of the segment record header.  There is at most one for each disk
726  * block in the journal.  The segment header is followed by an array of
727  * records.  fsck depends on the first element in each record being 'op'
728  * and the second being 'ino'.  Segments may span multiple disk blocks but
729  * the header is present on each.
730  */
731 struct jsegrec {
732         uint64_t        jsr_seq;        /* Our sequence number */
733         uint64_t        jsr_oldest;     /* Oldest valid sequence number */
734         uint16_t        jsr_cnt;        /* Count of valid records */
735         uint16_t        jsr_blocks;     /* Count of device bsize blocks. */
736         uint32_t        jsr_crc;        /* 32bit crc of the valid space */
737         ufs_time_t      jsr_time;       /* timestamp for mount instance */
738 };
739
740 /*
741  * Reference record.  Records a single link count modification.
742  */
743 struct jrefrec {
744         uint32_t        jr_op;
745         uint32_t        jr_ino;
746         uint32_t        jr_parent;
747         uint16_t        jr_nlink;
748         uint16_t        jr_mode;
749         int64_t         jr_diroff;
750         uint64_t        jr_unused;
751 };
752
753 /*
754  * Move record.  Records a reference moving within a directory block.  The
755  * nlink is unchanged but we must search both locations.
756  */
757 struct jmvrec {
758         uint32_t        jm_op;
759         uint32_t        jm_ino;
760         uint32_t        jm_parent;
761         uint16_t        jm_unused;
762         int64_t         jm_oldoff;
763         int64_t         jm_newoff;
764 };
765
766 /*
767  * Block record.  A set of frags or tree of blocks starting at an indirect are
768  * freed or a set of frags are allocated.
769  */
770 struct jblkrec {
771         uint32_t        jb_op;
772         uint32_t        jb_ino;
773         ufs2_daddr_t    jb_blkno;
774         ufs_lbn_t       jb_lbn;
775         uint16_t        jb_frags;
776         uint16_t        jb_oldfrags;
777         uint32_t        jb_unused;
778 };
779
780 /*
781  * Truncation record.  Records a partial truncation so that it may be
782  * completed at check time.  Also used for sync records.
783  */
784 struct jtrncrec {
785         uint32_t        jt_op;
786         uint32_t        jt_ino;
787         int64_t         jt_size;
788         uint32_t        jt_extsize;
789         uint32_t        jt_pad[3];
790 };
791
792 union jrec {
793         struct jsegrec  rec_jsegrec;
794         struct jrefrec  rec_jrefrec;
795         struct jmvrec   rec_jmvrec;
796         struct jblkrec  rec_jblkrec;
797         struct jtrncrec rec_jtrncrec;
798 };
799
800 #ifdef CTASSERT
801 CTASSERT(sizeof(struct jsegrec) == JREC_SIZE);
802 CTASSERT(sizeof(struct jrefrec) == JREC_SIZE);
803 CTASSERT(sizeof(struct jmvrec) == JREC_SIZE);
804 CTASSERT(sizeof(struct jblkrec) == JREC_SIZE);
805 CTASSERT(sizeof(struct jtrncrec) == JREC_SIZE);
806 CTASSERT(sizeof(union jrec) == JREC_SIZE);
807 #endif
808
809 extern int inside[], around[];
810 extern u_char *fragtbl[];
811
812 /*
813  * IOCTLs used for filesystem write suspension.
814  */
815 #define UFSSUSPEND      _IOW('U', 1, fsid_t)
816 #define UFSRESUME       _IO('U', 2)
817
818 #endif