![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ufs_fs.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs|
Return to ufs_fs.h CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs |
1.1 ! root 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: * 4. 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: src/sys/ufs/ffs/fs.h,v 1.43.2.3 2005/02/28 16:04:53 delphij Exp $ ! 31: */ ! 32: ! 33: #ifndef _UFS_FFS_FS_H_ ! 34: #define _UFS_FFS_FS_H_ ! 35: ! 36: /* ! 37: * Each disk drive contains some number of filesystems. ! 38: * A filesystem consists of a number of cylinder groups. ! 39: * Each cylinder group has inodes and data. ! 40: * ! 41: * A filesystem is described by its super-block, which in turn ! 42: * describes the cylinder groups. The super-block is critical ! 43: * data and is replicated in each cylinder group to protect against ! 44: * catastrophic loss. This is done at `newfs' time and the critical ! 45: * super-block data does not change, so the copies need not be ! 46: * referenced further unless disaster strikes. ! 47: * ! 48: * For filesystem fs, the offsets of the various blocks of interest ! 49: * are given in the super block as: ! 50: * [fs->fs_sblkno] Super-block ! 51: * [fs->fs_cblkno] Cylinder group block ! 52: * [fs->fs_iblkno] Inode blocks ! 53: * [fs->fs_dblkno] Data blocks ! 54: * The beginning of cylinder group cg in fs, is given by ! 55: * the ``cgbase(fs, cg)'' macro. ! 56: * ! 57: * Depending on the architecture and the media, the superblock may ! 58: * reside in any one of four places. For tiny media where every block ! 59: * counts, it is placed at the very front of the partition. Historically, ! 60: * UFS1 placed it 8K from the front to leave room for the disk label and ! 61: * a small bootstrap. For UFS2 it got moved to 64K from the front to leave ! 62: * room for the disk label and a bigger bootstrap, and for really piggy ! 63: * systems we check at 256K from the front if the first three fail. In ! 64: * all cases the size of the superblock will be SBLOCKSIZE. All values are ! 65: * given in byte-offset form, so they do not imply a sector size. The ! 66: * SBLOCKSEARCH specifies the order in which the locations should be searched. ! 67: */ ! 68: #define SBLOCK_FLOPPY 0 ! 69: #define SBLOCK_UFS1 8192 ! 70: #define SBLOCK_UFS2 65536 ! 71: #define SBLOCK_PIGGY 262144 ! 72: #define SBLOCKSIZE 8192 ! 73: #define SBLOCKSEARCH \ ! 74: { SBLOCK_UFS2, SBLOCK_UFS1, SBLOCK_FLOPPY, SBLOCK_PIGGY, -1 } ! 75: ! 76: /* ! 77: * Max number of fragments per block. This value is NOT tweakable. ! 78: */ ! 79: #define MAXFRAG 8 ! 80: ! 81: /* ! 82: * Addresses stored in inodes are capable of addressing fragments ! 83: * of `blocks'. File system blocks of at most size MAXBSIZE can ! 84: * be optionally broken into 2, 4, or 8 pieces, each of which is ! 85: * addressable; these pieces may be DEV_BSIZE, or some multiple of ! 86: * a DEV_BSIZE unit. ! 87: * ! 88: * Large files consist of exclusively large data blocks. To avoid ! 89: * undue wasted disk space, the last data block of a small file may be ! 90: * allocated as only as many fragments of a large block as are ! 91: * necessary. The filesystem format retains only a single pointer ! 92: * to such a fragment, which is a piece of a single large block that ! 93: * has been divided. The size of such a fragment is determinable from ! 94: * information in the inode, using the ``blksize(fs, ip, lbn)'' macro. ! 95: * ! 96: * The filesystem records space availability at the fragment level; ! 97: * to determine block availability, aligned fragments are examined. ! 98: */ ! 99: ! 100: /* ! 101: * MINBSIZE is the smallest allowable block size. ! 102: * In order to insure that it is possible to create files of size ! 103: * 2^32 with only two levels of indirection, MINBSIZE is set to 4096. ! 104: * MINBSIZE must be big enough to hold a cylinder group block, ! 105: * thus changes to (struct cg) must keep its size within MINBSIZE. ! 106: * Note that super blocks are always of size SBSIZE, ! 107: * and that both SBSIZE and MAXBSIZE must be >= MINBSIZE. ! 108: */ ! 109: #define MINBSIZE 4096 ! 110: ! 111: /* ! 112: * The path name on which the filesystem is mounted is maintained ! 113: * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in ! 114: * the super block for this name. ! 115: */ ! 116: #define MAXMNTLEN 468 ! 117: ! 118: /* ! 119: * The volume name for this filesystem is maintained in fs_volname. ! 120: * MAXVOLLEN defines the length of the buffer allocated. ! 121: */ ! 122: #define MAXVOLLEN 32 ! 123: ! 124: /* ! 125: * There is a 128-byte region in the superblock reserved for in-core ! 126: * pointers to summary information. Originally this included an array ! 127: * of pointers to blocks of struct csum; now there are just a few ! 128: * pointers and the remaining space is padded with fs_ocsp[]. ! 129: * ! 130: * NOCSPTRS determines the size of this padding. One pointer (fs_csp) ! 131: * is taken away to point to a contiguous array of struct csum for ! 132: * all cylinder groups; a second (fs_maxcluster) points to an array ! 133: * of cluster sizes that is computed as cylinder groups are inspected, ! 134: * and the third points to an array that tracks the creation of new ! 135: * directories. A fourth pointer, fs_active, is used when creating ! 136: * snapshots; it points to a bitmap of cylinder groups for which the ! 137: * free-block bitmap has changed since the snapshot operation began. ! 138: */ ! 139: #define NOCSPTRS ((128 / sizeof(void *)) - 4) ! 140: ! 141: /* ! 142: * A summary of contiguous blocks of various sizes is maintained ! 143: * in each cylinder group. Normally this is set by the initial ! 144: * value of fs_maxcontig. To conserve space, a maximum summary size ! 145: * is set by FS_MAXCONTIG. ! 146: */ ! 147: #define FS_MAXCONTIG 16 ! 148: ! 149: /* ! 150: * MINFREE gives the minimum acceptable percentage of filesystem ! 151: * blocks which may be free. If the freelist drops below this level ! 152: * only the superuser may continue to allocate blocks. This may ! 153: * be set to 0 if no reserve of free blocks is deemed necessary, ! 154: * however throughput drops by fifty percent if the filesystem ! 155: * is run at between 95% and 100% full; thus the minimum default ! 156: * value of fs_minfree is 5%. However, to get good clustering ! 157: * performance, 10% is a better choice. hence we use 10% as our ! 158: * default value. With 10% free space, fragmentation is not a ! 159: * problem, so we choose to optimize for time. ! 160: */ ! 161: #define MINFREE 8 ! 162: #define DEFAULTOPT FS_OPTTIME ! 163: ! 164: /* ! 165: * Grigoriy Orlov <[email protected]> has done some extensive work to fine ! 166: * tune the layout preferences for directories within a filesystem. ! 167: * His algorithm can be tuned by adjusting the following parameters ! 168: * which tell the system the average file size and the average number ! 169: * of files per directory. These defaults are well selected for typical ! 170: * filesystems, but may need to be tuned for odd cases like filesystems ! 171: * being used for squid caches or news spools. ! 172: */ ! 173: #define AVFILESIZ 16384 /* expected average file size */ ! 174: #define AFPDIR 64 /* expected number of files per directory */ ! 175: ! 176: /* ! 177: * The maximum number of snapshot nodes that can be associated ! 178: * with each filesystem. This limit affects only the number of ! 179: * snapshot files that can be recorded within the superblock so ! 180: * that they can be found when the filesystem is mounted. However, ! 181: * maintaining too many will slow the filesystem performance, so ! 182: * having this limit is a good idea. ! 183: */ ! 184: #define FSMAXSNAP 20 ! 185: ! 186: /* ! 187: * Used to identify special blocks in snapshots: ! 188: * ! 189: * BLK_NOCOPY - A block that was unallocated at the time the snapshot ! 190: * was taken, hence does not need to be copied when written. ! 191: * BLK_SNAP - A block held by another snapshot that is not needed by this ! 192: * snapshot. When the other snapshot is freed, the BLK_SNAP entries ! 193: * are converted to BLK_NOCOPY. These are needed to allow fsck to ! 194: * identify blocks that are in use by other snapshots (which are ! 195: * expunged from this snapshot). ! 196: */ ! 197: #define BLK_NOCOPY ((ufs2_daddr_t)(1)) ! 198: #define BLK_SNAP ((ufs2_daddr_t)(2)) ! 199: ! 200: /* ! 201: * Sysctl values for the fast filesystem. ! 202: */ ! 203: #define FFS_ADJ_REFCNT 1 /* adjust inode reference count */ ! 204: #define FFS_ADJ_BLKCNT 2 /* adjust inode used block count */ ! 205: #define FFS_BLK_FREE 3 /* free range of blocks in map */ ! 206: #define FFS_DIR_FREE 4 /* free specified dir inodes in map */ ! 207: #define FFS_FILE_FREE 5 /* free specified file inodes in map */ ! 208: #define FFS_SET_FLAGS 6 /* set filesystem flags */ ! 209: #define FFS_ADJ_NDIR 7 /* adjust number of directories */ ! 210: #define FFS_ADJ_NBFREE 8 /* adjust number of free blocks */ ! 211: #define FFS_ADJ_NIFREE 9 /* adjust number of free inodes */ ! 212: #define FFS_ADJ_NFFREE 10 /* adjust number of free frags */ ! 213: #define FFS_ADJ_NUMCLUSTERS 11 /* adjust number of free clusters */ ! 214: #define FFS_MAXID 12 /* number of valid ffs ids */ ! 215: ! 216: /* ! 217: * Command structure passed in to the filesystem to adjust filesystem values. ! 218: */ ! 219: #define FFS_CMD_VERSION 0x19790518 /* version ID */ ! 220: struct fsck_cmd { ! 221: int32_t version; /* version of command structure */ ! 222: int32_t handle; /* reference to filesystem to be changed */ ! 223: int64_t value; /* inode or block number to be affected */ ! 224: int64_t size; /* amount or range to be adjusted */ ! 225: int64_t spare; /* reserved for future use */ ! 226: }; ! 227: ! 228: /* ! 229: * Per cylinder group information; summarized in blocks allocated ! 230: * from first cylinder group data blocks. These blocks have to be ! 231: * read in from fs_csaddr (size fs_cssize) in addition to the ! 232: * super block. ! 233: */ ! 234: struct csum { ! 235: int32_t cs_ndir; /* number of directories */ ! 236: int32_t cs_nbfree; /* number of free blocks */ ! 237: int32_t cs_nifree; /* number of free inodes */ ! 238: int32_t cs_nffree; /* number of free frags */ ! 239: }; ! 240: struct csum_total { ! 241: int64_t cs_ndir; /* number of directories */ ! 242: int64_t cs_nbfree; /* number of free blocks */ ! 243: int64_t cs_nifree; /* number of free inodes */ ! 244: int64_t cs_nffree; /* number of free frags */ ! 245: int64_t cs_numclusters; /* number of free clusters */ ! 246: int64_t cs_spare[3]; /* future expansion */ ! 247: }; ! 248: ! 249: /* ! 250: * Super block for an FFS filesystem. ! 251: */ ! 252: struct fs { ! 253: int32_t fs_firstfield; /* historic filesystem linked list, */ ! 254: int32_t fs_unused_1; /* used for incore super blocks */ ! 255: int32_t fs_sblkno; /* offset of super-block in filesys */ ! 256: int32_t fs_cblkno; /* offset of cyl-block in filesys */ ! 257: int32_t fs_iblkno; /* offset of inode-blocks in filesys */ ! 258: int32_t fs_dblkno; /* offset of first data after cg */ ! 259: int32_t fs_old_cgoffset; /* cylinder group offset in cylinder */ ! 260: int32_t fs_old_cgmask; /* used to calc mod fs_ntrak */ ! 261: int32_t fs_old_time; /* last time written */ ! 262: int32_t fs_old_size; /* number of blocks in fs */ ! 263: int32_t fs_old_dsize; /* number of data blocks in fs */ ! 264: int32_t fs_ncg; /* number of cylinder groups */ ! 265: int32_t fs_bsize; /* size of basic blocks in fs */ ! 266: int32_t fs_fsize; /* size of frag blocks in fs */ ! 267: int32_t fs_frag; /* number of frags in a block in fs */ ! 268: /* these are configuration parameters */ ! 269: int32_t fs_minfree; /* minimum percentage of free blocks */ ! 270: int32_t fs_old_rotdelay; /* num of ms for optimal next block */ ! 271: int32_t fs_old_rps; /* disk revolutions per second */ ! 272: /* these fields can be computed from the others */ ! 273: int32_t fs_bmask; /* ``blkoff'' calc of blk offsets */ ! 274: int32_t fs_fmask; /* ``fragoff'' calc of frag offsets */ ! 275: int32_t fs_bshift; /* ``lblkno'' calc of logical blkno */ ! 276: int32_t fs_fshift; /* ``numfrags'' calc number of frags */ ! 277: /* these are configuration parameters */ ! 278: int32_t fs_maxcontig; /* max number of contiguous blks */ ! 279: int32_t fs_maxbpg; /* max number of blks per cyl group */ ! 280: /* these fields can be computed from the others */ ! 281: int32_t fs_fragshift; /* block to frag shift */ ! 282: int32_t fs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ ! 283: int32_t fs_sbsize; /* actual size of super block */ ! 284: int32_t fs_spare1[2]; /* old fs_csmask */ ! 285: /* old fs_csshift */ ! 286: int32_t fs_nindir; /* value of NINDIR */ ! 287: int32_t fs_inopb; /* value of INOPB */ ! 288: int32_t fs_old_nspf; /* value of NSPF */ ! 289: /* yet another configuration parameter */ ! 290: int32_t fs_optim; /* optimization preference, see below */ ! 291: int32_t fs_old_npsect; /* # sectors/track including spares */ ! 292: int32_t fs_old_interleave; /* hardware sector interleave */ ! 293: int32_t fs_old_trackskew; /* sector 0 skew, per track */ ! 294: int32_t fs_id[2]; /* unique filesystem id */ ! 295: /* sizes determined by number of cylinder groups and their sizes */ ! 296: int32_t fs_old_csaddr; /* blk addr of cyl grp summary area */ ! 297: int32_t fs_cssize; /* size of cyl grp summary area */ ! 298: int32_t fs_cgsize; /* cylinder group size */ ! 299: int32_t fs_spare2; /* old fs_ntrak */ ! 300: int32_t fs_old_nsect; /* sectors per track */ ! 301: int32_t fs_old_spc; /* sectors per cylinder */ ! 302: int32_t fs_old_ncyl; /* cylinders in filesystem */ ! 303: int32_t fs_old_cpg; /* cylinders per group */ ! 304: int32_t fs_ipg; /* inodes per group */ ! 305: int32_t fs_fpg; /* blocks per group * fs_frag */ ! 306: /* this data must be re-computed after crashes */ ! 307: struct csum fs_old_cstotal; /* cylinder summary information */ ! 308: /* these fields are cleared at mount time */ ! 309: int8_t fs_fmod; /* super block modified flag */ ! 310: int8_t fs_clean; /* filesystem is clean flag */ ! 311: int8_t fs_ronly; /* mounted read-only flag */ ! 312: int8_t fs_old_flags; /* old FS_ flags */ ! 313: char fs_fsmnt[MAXMNTLEN]; /* name mounted on */ ! 314: char fs_volname[MAXVOLLEN]; /* volume name */ ! 315: uint64_t fs_swuid; /* system-wide uid */ ! 316: int32_t fs_pad; /* due to alignment of fs_swuid */ ! 317: /* these fields retain the current block allocation info */ ! 318: int32_t fs_cgrotor; /* last cg searched */ ! 319: void *fs_ocsp[NOCSPTRS]; /* padding; was list of fs_cs buffers */ ! 320: uint8_t *fs_contigdirs; /* # of contiguously allocated dirs */ ! 321: struct csum *fs_csp; /* cg summary info buffer for fs_cs */ ! 322: int32_t *fs_maxcluster; /* max cluster in each cyl group */ ! 323: unsigned int *fs_active; /* used by snapshots to track fs */ ! 324: int32_t fs_old_cpc; /* cyl per cycle in postbl */ ! 325: int32_t fs_maxbsize; /* maximum blocking factor permitted */ ! 326: int64_t fs_sparecon64[17]; /* old rotation block list head */ ! 327: int64_t fs_sblockloc; /* byte offset of standard superblock */ ! 328: struct csum_total fs_cstotal; /* cylinder summary information */ ! 329: ufs_time_t fs_time; /* last time written */ ! 330: int64_t fs_size; /* number of blocks in fs */ ! 331: int64_t fs_dsize; /* number of data blocks in fs */ ! 332: ufs2_daddr_t fs_csaddr; /* blk addr of cyl grp summary area */ ! 333: int64_t fs_pendingblocks; /* blocks in process of being freed */ ! 334: int32_t fs_pendinginodes; /* inodes in process of being freed */ ! 335: int32_t fs_snapinum[FSMAXSNAP];/* list of snapshot inode numbers */ ! 336: int32_t fs_avgfilesize; /* expected average file size */ ! 337: int32_t fs_avgfpdir; /* expected # of files per directory */ ! 338: int32_t fs_save_cgsize; /* save real cg size to use fs_bsize */ ! 339: int32_t fs_sparecon32[26]; /* reserved for future constants */ ! 340: int32_t fs_flags; /* see FS_ flags below */ ! 341: int32_t fs_contigsumsize; /* size of cluster summary array */ ! 342: int32_t fs_maxsymlinklen; /* max length of an internal symlink */ ! 343: int32_t fs_old_inodefmt; /* format of on-disk inodes */ ! 344: uint64_t fs_maxfilesize; /* maximum representable file size */ ! 345: int64_t fs_qbmask; /* ~fs_bmask for use with 64-bit size */ ! 346: int64_t fs_qfmask; /* ~fs_fmask for use with 64-bit size */ ! 347: int32_t fs_state; /* validate fs_clean field */ ! 348: int32_t fs_old_postblformat; /* format of positional layout tables */ ! 349: int32_t fs_old_nrpos; /* number of rotational positions */ ! 350: int32_t fs_spare5[2]; /* old fs_postbloff */ ! 351: /* old fs_rotbloff */ ! 352: int32_t fs_magic; /* magic number */ ! 353: }; ! 354: ! 355: /* Sanity checking. */ ! 356: #ifdef CTASSERT ! 357: CTASSERT(sizeof(struct fs) == 1376); ! 358: #endif ! 359: ! 360: /* ! 361: * Filesystem identification ! 362: */ ! 363: #define FS_UFS1_MAGIC 0x011954 /* UFS1 fast filesystem magic number */ ! 364: #define FS_UFS2_MAGIC 0x19540119 /* UFS2 fast filesystem magic number */ ! 365: #define FS_BAD_MAGIC 0x19960408 /* UFS incomplete newfs magic number */ ! 366: #define FS_OKAY 0x7c269d38 /* superblock checksum */ ! 367: #define FS_42INODEFMT -1 /* 4.2BSD inode format */ ! 368: #define FS_44INODEFMT 2 /* 4.4BSD inode format */ ! 369: ! 370: /* ! 371: * Preference for optimization. ! 372: */ ! 373: #define FS_OPTTIME 0 /* minimize allocation time */ ! 374: #define FS_OPTSPACE 1 /* minimize disk fragmentation */ ! 375: ! 376: /* ! 377: * Filesystem flags. ! 378: * ! 379: * The FS_UNCLEAN flag is set by the kernel when the filesystem was ! 380: * mounted with fs_clean set to zero. The FS_DOSOFTDEP flag indicates ! 381: * that the filesystem should be managed by the soft updates code. ! 382: * Note that the FS_NEEDSFSCK flag is set and cleared only by the ! 383: * fsck utility. It is set when background fsck finds an unexpected ! 384: * inconsistency which requires a traditional foreground fsck to be ! 385: * run. Such inconsistencies should only be found after an uncorrectable ! 386: * disk error. A foreground fsck will clear the FS_NEEDSFSCK flag when ! 387: * it has successfully cleaned up the filesystem. The kernel uses this ! 388: * flag to enforce that inconsistent filesystems be mounted read-only. ! 389: * The FS_INDEXDIRS flag when set indicates that the kernel maintains ! 390: * on-disk auxiliary indexes (such as B-trees) for speeding directory ! 391: * accesses. Kernels that do not support auxiliary indicies clear the ! 392: * flag to indicate that the indicies need to be rebuilt (by fsck) before ! 393: * they can be used. ! 394: * ! 395: * FS_ACLS indicates that ACLs are administratively enabled for the ! 396: * file system, so they should be loaded from extended attributes, ! 397: * observed for access control purposes, and be administered by object ! 398: * owners. FS_MULTILABEL indicates that the TrustedBSD MAC Framework ! 399: * should attempt to back MAC labels into extended attributes on the ! 400: * file system rather than maintain a single mount label for all ! 401: * objects. ! 402: */ ! 403: #define FS_UNCLEAN 0x01 /* filesystem not clean at mount */ ! 404: #define FS_DOSOFTDEP 0x02 /* filesystem using soft dependencies */ ! 405: #define FS_NEEDSFSCK 0x04 /* filesystem needs sync fsck before mount */ ! 406: #define FS_INDEXDIRS 0x08 /* kernel supports indexed directories */ ! 407: #define FS_ACLS 0x10 /* file system has ACLs enabled */ ! 408: #define FS_MULTILABEL 0x20 /* file system is MAC multi-label */ ! 409: #define FS_FLAGS_UPDATED 0x80 /* flags have been moved to new location */ ! 410: ! 411: /* ! 412: * Macros to access bits in the fs_active array. ! 413: */ ! 414: #define ACTIVECGNUM(fs, cg) ((fs)->fs_active[(cg) / (NBBY * sizeof(int))]) ! 415: #define ACTIVECGOFF(cg) (1 << ((cg) % (NBBY * sizeof(int)))) ! 416: ! 417: /* ! 418: * The size of a cylinder group is calculated by CGSIZE. The maximum size ! 419: * is limited by the fact that cylinder groups are at most one block. ! 420: * Its size is derived from the size of the maps maintained in the ! 421: * cylinder group and the (struct cg) size. ! 422: */ ! 423: #define CGSIZE(fs) \ ! 424: /* base cg */ (sizeof(struct cg) + sizeof(int32_t) + \ ! 425: /* old btotoff */ (fs)->fs_old_cpg * sizeof(int32_t) + \ ! 426: /* old boff */ (fs)->fs_old_cpg * sizeof(uint16_t) + \ ! 427: /* inode map */ howmany((fs)->fs_ipg, NBBY) + \ ! 428: /* block map */ howmany((fs)->fs_fpg, NBBY) +\ ! 429: /* if present */ ((fs)->fs_contigsumsize <= 0 ? 0 : \ ! 430: /* cluster sum */ (fs)->fs_contigsumsize * sizeof(int32_t) + \ ! 431: /* cluster map */ howmany(fragstoblks(fs, (fs)->fs_fpg), NBBY))) ! 432: ! 433: /* ! 434: * The minimal number of cylinder groups that should be created. ! 435: */ ! 436: #define MINCYLGRPS 4 ! 437: ! 438: /* ! 439: * Convert cylinder group to base address of its global summary info. ! 440: */ ! 441: #define fs_cs(fs, indx) fs_csp[indx] ! 442: ! 443: /* ! 444: * Cylinder group block for a filesystem. ! 445: */ ! 446: #define CG_MAGIC 0x090255 ! 447: struct cg { ! 448: int32_t cg_firstfield; /* historic cyl groups linked list */ ! 449: int32_t cg_magic; /* magic number */ ! 450: int32_t cg_old_time; /* time last written */ ! 451: int32_t cg_cgx; /* we are the cgx'th cylinder group */ ! 452: int16_t cg_old_ncyl; /* number of cyl's this cg */ ! 453: int16_t cg_old_niblk; /* number of inode blocks this cg */ ! 454: int32_t cg_ndblk; /* number of data blocks this cg */ ! 455: struct csum cg_cs; /* cylinder summary information */ ! 456: int32_t cg_rotor; /* position of last used block */ ! 457: int32_t cg_frotor; /* position of last used frag */ ! 458: int32_t cg_irotor; /* position of last used inode */ ! 459: int32_t cg_frsum[MAXFRAG]; /* counts of available frags */ ! 460: int32_t cg_old_btotoff; /* (int32) block totals per cylinder */ ! 461: int32_t cg_old_boff; /* (uint16) free block positions */ ! 462: int32_t cg_iusedoff; /* (uint8) used inode map */ ! 463: int32_t cg_freeoff; /* (uint8) free block map */ ! 464: int32_t cg_nextfreeoff; /* (uint8) next available space */ ! 465: int32_t cg_clustersumoff; /* (uint32) counts of avail clusters */ ! 466: int32_t cg_clusteroff; /* (uint8) free cluster map */ ! 467: int32_t cg_nclusterblks; /* number of clusters this cg */ ! 468: int32_t cg_niblk; /* number of inode blocks this cg */ ! 469: int32_t cg_initediblk; /* last initialized inode */ ! 470: int32_t cg_sparecon32[3]; /* reserved for future use */ ! 471: ufs_time_t cg_time; /* time last written */ ! 472: int64_t cg_sparecon64[3]; /* reserved for future use */ ! 473: uint8_t cg_space[1]; /* space for cylinder group maps */ ! 474: /* actually longer */ ! 475: }; ! 476: ! 477: /* ! 478: * Macros for access to cylinder group array structures ! 479: */ ! 480: #define cg_chkmagic(cgp) ((cgp)->cg_magic == CG_MAGIC) ! 481: #define cg_inosused(cgp) \ ! 482: ((uint8_t *)((uint8_t *)(cgp) + (cgp)->cg_iusedoff)) ! 483: #define cg_blksfree(cgp) \ ! 484: ((uint8_t *)((uint8_t *)(cgp) + (cgp)->cg_freeoff)) ! 485: #define cg_clustersfree(cgp) \ ! 486: ((uint8_t *)((uint8_t *)(cgp) + (cgp)->cg_clusteroff)) ! 487: #define cg_clustersum(cgp) \ ! 488: ((int32_t *)((uintptr_t)(cgp) + (cgp)->cg_clustersumoff)) ! 489: ! 490: /* ! 491: * Turn filesystem block numbers into disk block addresses. ! 492: * This maps filesystem blocks to device size blocks. ! 493: */ ! 494: #define fsbtodb(fs, b) ((b) << (fs)->fs_fsbtodb) ! 495: #define dbtofsb(fs, b) ((b) >> (fs)->fs_fsbtodb) ! 496: ! 497: /* ! 498: * Cylinder group macros to locate things in cylinder groups. ! 499: * They calc filesystem addresses of cylinder group data structures. ! 500: */ ! 501: #define cgbase(fs, c) (((ufs2_daddr_t)(fs)->fs_fpg) * (c)) ! 502: #define cgdmin(fs, c) (cgstart(fs, c) + (fs)->fs_dblkno) /* 1st data */ ! 503: #define cgimin(fs, c) (cgstart(fs, c) + (fs)->fs_iblkno) /* inode blk */ ! 504: #define cgsblock(fs, c) (cgstart(fs, c) + (fs)->fs_sblkno) /* super blk */ ! 505: #define cgtod(fs, c) (cgstart(fs, c) + (fs)->fs_cblkno) /* cg block */ ! 506: #define cgstart(fs, c) \ ! 507: ((fs)->fs_magic == FS_UFS2_MAGIC ? cgbase(fs, c) : \ ! 508: (cgbase(fs, c) + (fs)->fs_old_cgoffset * ((c) & ~((fs)->fs_old_cgmask)))) ! 509: ! 510: /* ! 511: * Macros for handling inode numbers: ! 512: * inode number to filesystem block offset. ! 513: * inode number to cylinder group number. ! 514: * inode number to filesystem block address. ! 515: */ ! 516: #define ino_to_cg(fs, x) ((x) / (fs)->fs_ipg) ! 517: #define ino_to_fsba(fs, x) \ ! 518: ((ufs2_daddr_t)(cgimin(fs, ino_to_cg(fs, x)) + \ ! 519: (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs)))))) ! 520: #define ino_to_fsbo(fs, x) ((x) % INOPB(fs)) ! 521: ! 522: /* ! 523: * Give cylinder group number for a filesystem block. ! 524: * Give cylinder group block number for a filesystem block. ! 525: */ ! 526: #define dtog(fs, d) ((d) / (fs)->fs_fpg) ! 527: #define dtogd(fs, d) ((d) % (fs)->fs_fpg) ! 528: ! 529: /* ! 530: * Extract the bits for a block from a map. ! 531: * Compute the cylinder and rotational position of a cyl block addr. ! 532: */ ! 533: #define blkmap(fs, map, loc) \ ! 534: (((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag))) ! 535: ! 536: /* ! 537: * The following macros optimize certain frequently calculated ! 538: * quantities by using shifts and masks in place of divisions ! 539: * modulos and multiplications. ! 540: */ ! 541: #define blkoff(fs, loc) /* calculates (loc % fs->fs_bsize) */ \ ! 542: ((loc) & (fs)->fs_qbmask) ! 543: #define fragoff(fs, loc) /* calculates (loc % fs->fs_fsize) */ \ ! 544: ((loc) & (fs)->fs_qfmask) ! 545: #define lfragtosize(fs, frag) /* calculates ((off_t)frag * fs->fs_fsize) */ \ ! 546: (((off_t)(frag)) << (fs)->fs_fshift) ! 547: #define lblktosize(fs, blk) /* calculates ((off_t)blk * fs->fs_bsize) */ \ ! 548: (((off_t)(blk)) << (fs)->fs_bshift) ! 549: /* Use this only when `blk' is known to be small, e.g., < NDADDR. */ ! 550: #define smalllblktosize(fs, blk) /* calculates (blk * fs->fs_bsize) */ \ ! 551: ((blk) << (fs)->fs_bshift) ! 552: #define lblkno(fs, loc) /* calculates (loc / fs->fs_bsize) */ \ ! 553: ((loc) >> (fs)->fs_bshift) ! 554: #define numfrags(fs, loc) /* calculates (loc / fs->fs_fsize) */ \ ! 555: ((loc) >> (fs)->fs_fshift) ! 556: #define blkroundup(fs, size) /* calculates roundup(size, fs->fs_bsize) */ \ ! 557: (((size) + (fs)->fs_qbmask) & (fs)->fs_bmask) ! 558: #define fragroundup(fs, size) /* calculates roundup(size, fs->fs_fsize) */ \ ! 559: (((size) + (fs)->fs_qfmask) & (fs)->fs_fmask) ! 560: #define fragstoblks(fs, frags) /* calculates (frags / fs->fs_frag) */ \ ! 561: ((frags) >> (fs)->fs_fragshift) ! 562: #define blkstofrags(fs, blks) /* calculates (blks * fs->fs_frag) */ \ ! 563: ((blks) << (fs)->fs_fragshift) ! 564: #define fragnum(fs, fsb) /* calculates (fsb % fs->fs_frag) */ \ ! 565: ((fsb) & ((fs)->fs_frag - 1)) ! 566: #define blknum(fs, fsb) /* calculates rounddown(fsb, fs->fs_frag) */ \ ! 567: ((fsb) &~ ((fs)->fs_frag - 1)) ! 568: ! 569: /* ! 570: * Determine the number of available frags given a ! 571: * percentage to hold in reserve. ! 572: */ ! 573: #define freespace(fs, percentreserved) \ ! 574: (blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \ ! 575: (fs)->fs_cstotal.cs_nffree - \ ! 576: (((off_t)((fs)->fs_dsize)) * (percentreserved) / 100)) ! 577: ! 578: /* ! 579: * Determining the size of a file block in the filesystem. ! 580: */ ! 581: #define blksize(fs, ip, lbn) \ ! 582: (((lbn) >= NDADDR || (ip)->i_size >= smalllblktosize(fs, (lbn) + 1)) \ ! 583: ? (fs)->fs_bsize \ ! 584: : (fragroundup(fs, blkoff(fs, (ip)->i_size)))) ! 585: #define sblksize(fs, size, lbn) \ ! 586: (((lbn) >= NDADDR || (size) >= ((lbn) + 1) << (fs)->fs_bshift) \ ! 587: ? (fs)->fs_bsize \ ! 588: : (fragroundup(fs, blkoff(fs, (size))))) ! 589: ! 590: ! 591: /* ! 592: * Number of inodes in a secondary storage block/fragment. ! 593: */ ! 594: #define INOPB(fs) ((fs)->fs_inopb) ! 595: #define INOPF(fs) ((fs)->fs_inopb >> (fs)->fs_fragshift) ! 596: ! 597: /* ! 598: * Number of indirects in a filesystem block. ! 599: */ ! 600: #define NINDIR(fs) ((fs)->fs_nindir) ! 601: ! 602: extern int inside[], around[]; ! 603: extern char *fragtbl[]; ! 604: ! 605: struct ufs_dirent { ! 606: uint32_t d_fileno; /* file number of entry */ ! 607: uint16_t d_reclen; /* length of this record */ ! 608: uint8_t d_type; /* file type, see below */ ! 609: uint8_t d_namlen; /* length of string in d_name */ ! 610: #define MAXNAMLEN 255 ! 611: char d_name[MAXNAMLEN + 1]; /* name must be no longer than this */ ! 612: }; ! 613: ! 614: /* ! 615: * File types ! 616: */ ! 617: #define DT_UNKNOWN 0 ! 618: #define DT_FIFO 1 ! 619: #define DT_CHR 2 ! 620: #define DT_DIR 4 ! 621: #define DT_BLK 6 ! 622: #define DT_REG 8 ! 623: #define DT_LNK 10 ! 624: #define DT_SOCK 12 ! 625: #define DT_WHT 14 ! 626: ! 627: /* XXX: We hardcode BSIZE and BSIZE_SHIFT here. fsys_ffs seems to do the same, ! 628: * so we should get away with it :-) */ ! 629: #define DEV_BSIZE 512 ! 630: #define DEV_BSHIFT 9 /* 2**9 = 512 */ ! 631: #define MAXBSIZE 8192 ! 632: ! 633: typedef unsigned int ino_t; ! 634: ! 635: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.