| 1 | /* $NetBSD: ext2fs.h,v 1.48 2016/08/20 19:47:44 jdolecek 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.10 (Berkeley) 10/27/94 |
| 32 | * Modified for ext2fs by Manuel Bouyer. |
| 33 | */ |
| 34 | |
| 35 | /* |
| 36 | * Copyright (c) 1997 Manuel Bouyer. |
| 37 | * |
| 38 | * Redistribution and use in source and binary forms, with or without |
| 39 | * modification, are permitted provided that the following conditions |
| 40 | * are met: |
| 41 | * 1. Redistributions of source code must retain the above copyright |
| 42 | * notice, this list of conditions and the following disclaimer. |
| 43 | * 2. Redistributions in binary form must reproduce the above copyright |
| 44 | * notice, this list of conditions and the following disclaimer in the |
| 45 | * documentation and/or other materials provided with the distribution. |
| 46 | * |
| 47 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| 48 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| 49 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| 50 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| 51 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| 52 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 53 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 54 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 55 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| 56 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 57 | * |
| 58 | * @(#)fs.h 8.10 (Berkeley) 10/27/94 |
| 59 | * Modified for ext2fs by Manuel Bouyer. |
| 60 | */ |
| 61 | |
| 62 | #ifndef _UFS_EXT2FS_EXT2FS_H_ |
| 63 | #define _UFS_EXT2FS_EXT2FS_H_ |
| 64 | |
| 65 | #include <sys/bswap.h> |
| 66 | |
| 67 | /* |
| 68 | * Each disk drive contains some number of file systems. |
| 69 | * A file system consists of a number of cylinder groups. |
| 70 | * Each cylinder group has inodes and data. |
| 71 | * |
| 72 | * A file system is described by its super-block, which in turn |
| 73 | * describes the cylinder groups. The super-block is critical |
| 74 | * data and is replicated in each cylinder group to protect against |
| 75 | * catastrophic loss. This is done at `newfs' time and the critical |
| 76 | * super-block data does not change, so the copies need not be |
| 77 | * referenced further unless disaster strikes. |
| 78 | * |
| 79 | * The first boot and super blocks are given in absolute disk addresses. |
| 80 | * The byte-offset forms are preferred, as they don't imply a sector size. |
| 81 | */ |
| 82 | #define BBSIZE 1024 |
| 83 | #define SBSIZE 1024 |
| 84 | #define BBOFF ((off_t)(0)) |
| 85 | #define SBOFF ((off_t)(BBOFF + BBSIZE)) |
| 86 | #define BBLOCK ((daddr_t)(0)) |
| 87 | #define SBLOCK ((daddr_t)(BBLOCK + BBSIZE / DEV_BSIZE)) |
| 88 | |
| 89 | #define fsbtodb(fs, b) ((daddr_t)(b) << (fs)->e2fs_fsbtodb) |
| 90 | /* calculates (loc / fs->fs_bsize) */ |
| 91 | #define lblkno(fs, loc) ((loc) >> (fs->e2fs_bshift)) |
| 92 | #define blksize(fs, ip, lbn) ((fs)->e2fs_bsize) |
| 93 | |
| 94 | /* |
| 95 | * Addresses stored in inodes are capable of addressing blocks |
| 96 | * XXX |
| 97 | */ |
| 98 | |
| 99 | /* |
| 100 | * MINBSIZE is the smallest allowable block size. |
| 101 | * MINBSIZE must be big enough to hold a cylinder group block, |
| 102 | * thus changes to (struct cg) must keep its size within MINBSIZE. |
| 103 | * Note that super blocks are always of size SBSIZE, |
| 104 | * and that both SBSIZE and MAXBSIZE must be >= MINBSIZE. |
| 105 | */ |
| 106 | #define LOG_MINBSIZE 10 |
| 107 | #define MINBSIZE (1 << LOG_MINBSIZE) |
| 108 | |
| 109 | /* |
| 110 | * The path name on which the file system is mounted is maintained |
| 111 | * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in |
| 112 | * the super block for this name. |
| 113 | */ |
| 114 | #define MAXMNTLEN 512 |
| 115 | |
| 116 | /* |
| 117 | * MINFREE gives the minimum acceptable percentage of file system |
| 118 | * blocks which may be free. If the freelist drops below this level |
| 119 | * only the superuser may continue to allocate blocks. This may |
| 120 | * be set to 0 if no reserve of free blocks is deemed necessary, |
| 121 | * however throughput drops by fifty percent if the file system |
| 122 | * is run at between 95% and 100% full; thus the minimum default |
| 123 | * value of fs_minfree is 5%. However, to get good clustering |
| 124 | * performance, 10% is a better choice. hence we use 10% as our |
| 125 | * default value. With 10% free space, fragmentation is not a |
| 126 | * problem, so we choose to optimize for time. |
| 127 | */ |
| 128 | #define MINFREE 5 |
| 129 | |
| 130 | /* |
| 131 | * This is maximum amount of links allowed for files. For directories, |
| 132 | * going over this means setting DIR_NLINK feature. |
| 133 | */ |
| 134 | #define EXT2FS_LINK_MAX 65000 |
| 135 | #define EXT2FS_LINK_INF 1 /* link count unknown */ |
| 136 | |
| 137 | /* |
| 138 | * Super block for an ext2fs file system. |
| 139 | */ |
| 140 | struct ext2fs { |
| 141 | uint32_t e2fs_icount; /* Inode count */ |
| 142 | uint32_t e2fs_bcount; /* blocks count */ |
| 143 | uint32_t e2fs_rbcount; /* reserved blocks count */ |
| 144 | uint32_t e2fs_fbcount; /* free blocks count */ |
| 145 | uint32_t e2fs_ficount; /* free inodes count */ |
| 146 | uint32_t e2fs_first_dblock; /* first data block */ |
| 147 | uint32_t e2fs_log_bsize; /* bsize = 1024*(2^e2fs_log_bsize) */ |
| 148 | uint32_t e2fs_fsize; /* fragment size */ |
| 149 | uint32_t e2fs_bpg; /* blocks per group */ |
| 150 | uint32_t e2fs_fpg; /* frags per group */ |
| 151 | uint32_t e2fs_ipg; /* inodes per group */ |
| 152 | uint32_t e2fs_mtime; /* mount time */ |
| 153 | uint32_t e2fs_wtime; /* write time */ |
| 154 | uint16_t e2fs_mnt_count; /* mount count */ |
| 155 | uint16_t e2fs_max_mnt_count; /* max mount count */ |
| 156 | uint16_t e2fs_magic; /* magic number */ |
| 157 | uint16_t e2fs_state; /* file system state */ |
| 158 | uint16_t e2fs_beh; /* behavior on errors */ |
| 159 | uint16_t e2fs_minrev; /* minor revision level */ |
| 160 | uint32_t e2fs_lastfsck; /* time of last fsck */ |
| 161 | uint32_t e2fs_fsckintv; /* max time between fscks */ |
| 162 | uint32_t e2fs_creator; /* creator OS */ |
| 163 | uint32_t e2fs_rev; /* revision level */ |
| 164 | uint16_t e2fs_ruid; /* default uid for reserved blocks */ |
| 165 | uint16_t e2fs_rgid; /* default gid for reserved blocks */ |
| 166 | /* EXT2_DYNAMIC_REV superblocks */ |
| 167 | uint32_t e2fs_first_ino; /* first non-reserved inode */ |
| 168 | uint16_t e2fs_inode_size; /* size of inode structure */ |
| 169 | uint16_t e2fs_block_group_nr; /* block grp number of this sblk*/ |
| 170 | uint32_t e2fs_features_compat; /* compatible feature set */ |
| 171 | uint32_t e2fs_features_incompat; /* incompatible feature set */ |
| 172 | uint32_t e2fs_features_rocompat; /* RO-compatible feature set */ |
| 173 | uint8_t e2fs_uuid[16]; /* 128-bit uuid for volume */ |
| 174 | char e2fs_vname[16]; /* volume name */ |
| 175 | char e2fs_fsmnt[64]; /* name mounted on */ |
| 176 | uint32_t e2fs_algo; /* For compression */ |
| 177 | uint8_t e2fs_prealloc; /* # of blocks to preallocate */ |
| 178 | uint8_t e2fs_dir_prealloc; /* # of blocks to preallocate for dir */ |
| 179 | uint16_t e2fs_reserved_ngdb; /* # of reserved gd blocks for resize */ |
| 180 | |
| 181 | /* Additional fields */ |
| 182 | char e3fs_journal_uuid[16];/* uuid of journal superblock */ |
| 183 | uint32_t e3fs_journal_inum; /* inode number of journal file */ |
| 184 | uint32_t e3fs_journal_dev; /* device number of journal file */ |
| 185 | uint32_t e3fs_last_orphan; /* start of list of inodes to delete */ |
| 186 | uint32_t e3fs_hash_seed[4]; /* HTREE hash seed */ |
| 187 | char e3fs_def_hash_version;/* Default hash version to use */ |
| 188 | char e3fs_jnl_backup_type; |
| 189 | uint16_t e3fs_desc_size; /* size of group descriptor */ |
| 190 | uint32_t e3fs_default_mount_opts; |
| 191 | uint32_t e3fs_first_meta_bg; /* First metablock block group */ |
| 192 | uint32_t e3fs_mkfs_time; /* when the fs was created */ |
| 193 | uint32_t e3fs_jnl_blks[17]; /* backup of the journal inode */ |
| 194 | uint32_t e4fs_bcount_hi; /* high bits of blocks count */ |
| 195 | uint32_t e4fs_rbcount_hi; /* high bits of reserved blocks count */ |
| 196 | uint32_t e4fs_fbcount_hi; /* high bits of free blocks count */ |
| 197 | uint16_t ; /* all inodes have some bytes */ |
| 198 | uint16_t ;/* inodes must reserve some bytes */ |
| 199 | uint32_t e4fs_flags; /* miscellaneous flags */ |
| 200 | uint16_t e4fs_raid_stride; /* RAID stride */ |
| 201 | uint16_t e4fs_mmpintv; /* seconds to wait in MMP checking */ |
| 202 | uint64_t e4fs_mmpblk; /* block for multi-mount protection */ |
| 203 | uint32_t e4fs_raid_stripe_wid; /* blocks on data disks (N * stride) */ |
| 204 | uint8_t e4fs_log_gpf; /* FLEX_BG group size */ |
| 205 | uint8_t e4fs_chksum_type; /* metadata checksum algorithm used */ |
| 206 | uint8_t e4fs_encrypt; /* versioning level for encryption */ |
| 207 | uint8_t e4fs_reserved_pad; |
| 208 | uint64_t e4fs_kbytes_written; /* number of lifetime kilobytes */ |
| 209 | uint32_t e4fs_snapinum; /* inode number of active snapshot */ |
| 210 | uint32_t e4fs_snapid; /* sequential ID of active snapshot */ |
| 211 | uint64_t e4fs_snaprbcount; /* rsvd blocks for active snapshot */ |
| 212 | uint32_t e4fs_snaplist; /* inode number for on-disk snapshot */ |
| 213 | uint32_t e4fs_errcount; /* number of file system errors */ |
| 214 | uint32_t e4fs_first_errtime; /* first time an error happened */ |
| 215 | uint32_t e4fs_first_errino; /* inode involved in first error */ |
| 216 | uint64_t e4fs_first_errblk; /* block involved of first error */ |
| 217 | uint8_t e4fs_first_errfunc[32];/* function where error happened */ |
| 218 | uint32_t e4fs_first_errline; /* line number where error happened */ |
| 219 | uint32_t e4fs_last_errtime; /* most recent time of an error */ |
| 220 | uint32_t e4fs_last_errino; /* inode involved in last error */ |
| 221 | uint32_t e4fs_last_errline; /* line number where error happened */ |
| 222 | uint64_t e4fs_last_errblk; /* block involved of last error */ |
| 223 | uint8_t e4fs_last_errfunc[32];/* function where error happened */ |
| 224 | uint8_t e4fs_mount_opts[64]; |
| 225 | uint32_t e4fs_usrquota_inum; /* inode for tracking user quota */ |
| 226 | uint32_t e4fs_grpquota_inum; /* inode for tracking group quota */ |
| 227 | uint32_t e4fs_overhead_clusters;/* overhead blocks/clusters */ |
| 228 | uint32_t e4fs_backup_bgs[2]; /* groups with sparse_super2 SBs */ |
| 229 | uint8_t e4fs_encrypt_algos[4];/* encryption algorithms in use */ |
| 230 | uint8_t e4fs_encrypt_pw_salt[16];/* salt used for string2key */ |
| 231 | uint32_t e4fs_lpf_ino; /* location of the lost+found inode */ |
| 232 | uint32_t e4fs_proj_quota_inum; /* inode for tracking project quota */ |
| 233 | uint32_t e4fs_chksum_seed; /* checksum seed */ |
| 234 | uint32_t e4fs_reserved[98]; /* padding to the end of the block */ |
| 235 | uint32_t e4fs_sbchksum; /* superblock checksum */ |
| 236 | }; |
| 237 | |
| 238 | |
| 239 | /* in-memory data for ext2fs */ |
| 240 | struct m_ext2fs { |
| 241 | struct ext2fs e2fs; |
| 242 | u_char e2fs_fsmnt[MAXMNTLEN]; /* name mounted on */ |
| 243 | int8_t e2fs_ronly; /* mounted read-only flag */ |
| 244 | int8_t e2fs_fmod; /* super block modified flag */ |
| 245 | int8_t e2fs_uhash; /* 3 if hash should be signed, 0 if not */ |
| 246 | int32_t e2fs_bsize; /* block size */ |
| 247 | int32_t e2fs_bshift; /* ``lblkno'' calc of logical blkno */ |
| 248 | int32_t e2fs_bmask; /* ``blkoff'' calc of blk offsets */ |
| 249 | int64_t e2fs_qbmask; /* ~fs_bmask - for use with quad size */ |
| 250 | int32_t e2fs_fsbtodb; /* fsbtodb and dbtofsb shift constant */ |
| 251 | int32_t e2fs_ncg; /* number of cylinder groups */ |
| 252 | int32_t e2fs_ngdb; /* number of group descriptor blocks */ |
| 253 | int32_t e2fs_ipb; /* number of inodes per block */ |
| 254 | int32_t e2fs_itpg; /* number of inode table blocks per group */ |
| 255 | struct ext2_gd *e2fs_gd; /* group descriptors (data not byteswapped) */ |
| 256 | }; |
| 257 | |
| 258 | |
| 259 | |
| 260 | /* |
| 261 | * Filesystem identification |
| 262 | */ |
| 263 | #define E2FS_MAGIC 0xef53 /* the ext2fs magic number */ |
| 264 | #define E2FS_REV0 0 /* GOOD_OLD revision */ |
| 265 | #define E2FS_REV1 1 /* Support compat/incompat features */ |
| 266 | |
| 267 | /* compatible/incompatible features */ |
| 268 | #define EXT2F_COMPAT_PREALLOC 0x0001 |
| 269 | #define EXT2F_COMPAT_AFS 0x0002 |
| 270 | #define EXT2F_COMPAT_HASJOURNAL 0x0004 |
| 271 | #define EXT2F_COMPAT_EXTATTR 0x0008 |
| 272 | #define EXT2F_COMPAT_RESIZE 0x0010 |
| 273 | #define EXT2F_COMPAT_DIRHASHINDEX 0x0020 |
| 274 | #define EXT2F_COMPAT_SPARSESUPER2 0x0200 |
| 275 | #define EXT2F_COMPAT_BITS \ |
| 276 | "\20" \ |
| 277 | "\12COMPAT_SPARSESUPER2" \ |
| 278 | "\11" \ |
| 279 | "\10" \ |
| 280 | "\07" \ |
| 281 | "\06COMPAT_DIRHASHINDEX" \ |
| 282 | "\05COMPAT_RESIZE" \ |
| 283 | "\04COMPAT_EXTATTR" \ |
| 284 | "\03COMPAT_HASJOURNAL" \ |
| 285 | "\02COMPAT_AFS" \ |
| 286 | "\01COMPAT_PREALLOC" |
| 287 | |
| 288 | #define EXT2F_ROCOMPAT_SPARSESUPER 0x0001 |
| 289 | #define EXT2F_ROCOMPAT_LARGEFILE 0x0002 |
| 290 | #define EXT2F_ROCOMPAT_BTREE_DIR 0x0004 |
| 291 | #define EXT2F_ROCOMPAT_HUGE_FILE 0x0008 |
| 292 | #define EXT2F_ROCOMPAT_GDT_CSUM 0x0010 |
| 293 | #define EXT2F_ROCOMPAT_DIR_NLINK 0x0020 |
| 294 | #define 0x0040 |
| 295 | #define EXT2F_ROCOMPAT_QUOTA 0x0100 |
| 296 | #define EXT2F_ROCOMPAT_BIGALLOC 0x0200 |
| 297 | #define EXT2F_ROCOMPAT_METADATA_CKSUM 0x0400 |
| 298 | #define EXT2F_ROCOMPAT_READONLY 0x1000 |
| 299 | #define EXT2F_ROCOMPAT_PROJECT 0x2000 |
| 300 | #define EXT2F_ROCOMPAT_BITS \ |
| 301 | "\20" \ |
| 302 | "\16ROCOMPAT_PROJECT" \ |
| 303 | "\15ROCOMPAT_READONLY" \ |
| 304 | "\14" \ |
| 305 | "\13ROCOMPAT_METADATA_CKSUM" \ |
| 306 | "\12ROCOMPAT_BIGALLOC" \ |
| 307 | "\11ROCOMPAT_QUOTA" \ |
| 308 | "\10" \ |
| 309 | "\07ROCOMPAT_EXTRA_ISIZE" \ |
| 310 | "\06ROCOMPAT_DIR_NLINK" \ |
| 311 | "\05ROCOMPAT_GDT_CSUM" \ |
| 312 | "\04ROCOMPAT_HUGE_FILE" \ |
| 313 | "\03ROCOMPAT_BTREE_DIR" \ |
| 314 | "\02ROCOMPAT_LARGEFILE" \ |
| 315 | "\01ROCOMPAT_SPARSESUPER" |
| 316 | |
| 317 | #define EXT2F_INCOMPAT_COMP 0x0001 |
| 318 | #define EXT2F_INCOMPAT_FTYPE 0x0002 |
| 319 | #define EXT2F_INCOMPAT_REPLAY_JOURNAL 0x0004 |
| 320 | #define EXT2F_INCOMPAT_USES_JOURNAL 0x0008 |
| 321 | #define EXT2F_INCOMPAT_META_BG 0x0010 |
| 322 | #define EXT2F_INCOMPAT_EXTENTS 0x0040 |
| 323 | #define EXT2F_INCOMPAT_64BIT 0x0080 |
| 324 | #define EXT2F_INCOMPAT_MMP 0x0100 |
| 325 | #define EXT2F_INCOMPAT_FLEX_BG 0x0200 |
| 326 | #define EXT2F_INCOMPAT_EA_INODE 0x0400 |
| 327 | #define EXT2F_INCOMPAT_DIRDATA 0x1000 |
| 328 | #define EXT2F_INCOMPAT_CSUM_SEED 0x2000 |
| 329 | #define EXT2F_INCOMPAT_LARGEDIR 0x4000 |
| 330 | #define EXT2F_INCOMPAT_INLINE_DATA 0x8000 |
| 331 | #define EXT2F_INCOMPAT_ENCRYPT 0x10000 |
| 332 | #define EXT2F_INCOMPAT_BITS \ |
| 333 | "\20" \ |
| 334 | "\021INCOMPAT_ENCRYPT" \ |
| 335 | "\020INCOMPAT_INLINE_DATA" \ |
| 336 | "\017INCOMPAT_LARGEDIR" \ |
| 337 | "\016INCOMPAT_CSUM_SEED" \ |
| 338 | "\015INCOMPAT_DIRDATA" \ |
| 339 | "\014" \ |
| 340 | "\013INCOMPAT_EA_INODE" \ |
| 341 | "\012INCOMPAT_FLEX_BG" \ |
| 342 | "\011INCOMPAT_MMP" \ |
| 343 | "\010INCOMPAT_64BIT" \ |
| 344 | "\07INCOMPAT_EXTENTS" \ |
| 345 | "\05INCOMPAT_META_BG" \ |
| 346 | "\04INCOMPAT_USES_JOURNAL" \ |
| 347 | "\03INCOMPAT_REPLAY_JOURNAL" \ |
| 348 | "\02INCOMPAT_FTYPE" \ |
| 349 | "\01INCOMPAT_COMP" |
| 350 | |
| 351 | /* |
| 352 | * Features supported in this implementation |
| 353 | * |
| 354 | * We support the following REV1 features: |
| 355 | * - EXT2F_ROCOMPAT_SPARSESUPER |
| 356 | * superblock backups stored only in cg_has_sb(bno) groups |
| 357 | * - EXT2F_ROCOMPAT_LARGEFILE |
| 358 | * use e2di_size_high in struct ext2fs_dinode to store |
| 359 | * upper 32bit of size for >2GB files |
| 360 | * - EXT2F_INCOMPAT_FTYPE |
| 361 | * store file type to e2d_type in struct ext2fs_direct |
| 362 | * (on REV0 e2d_namlen is uint16_t and no e2d_type, like ffs) |
| 363 | */ |
| 364 | #define EXT2F_COMPAT_SUPP 0x0000 |
| 365 | #define EXT2F_ROCOMPAT_SUPP (EXT2F_ROCOMPAT_SPARSESUPER \ |
| 366 | | EXT2F_ROCOMPAT_LARGEFILE \ |
| 367 | | EXT2F_ROCOMPAT_HUGE_FILE \ |
| 368 | | EXT2F_ROCOMPAT_EXTRA_ISIZE \ |
| 369 | | EXT2F_ROCOMPAT_DIR_NLINK \ |
| 370 | | EXT2F_ROCOMPAT_GDT_CSUM) |
| 371 | #define EXT2F_INCOMPAT_SUPP (EXT2F_INCOMPAT_FTYPE \ |
| 372 | | EXT2F_INCOMPAT_EXTENTS \ |
| 373 | | EXT2F_INCOMPAT_FLEX_BG) |
| 374 | |
| 375 | /* |
| 376 | * Feature set definitions |
| 377 | */ |
| 378 | #define EXT2F_HAS_COMPAT_FEATURE(fs, feature) \ |
| 379 | ((fs)->e2fs.e2fs_rev >= E2FS_REV1 && \ |
| 380 | ((fs)->e2fs.e2fs_features_compat & (feature)) != 0) |
| 381 | |
| 382 | #define EXT2F_HAS_ROCOMPAT_FEATURE(fs, feature) \ |
| 383 | ((fs)->e2fs.e2fs_rev >= E2FS_REV1 && \ |
| 384 | ((fs)->e2fs.e2fs_features_rocompat & (feature)) != 0) |
| 385 | |
| 386 | #define EXT2F_HAS_INCOMPAT_FEATURE(fs, feature) \ |
| 387 | ((fs)->e2fs.e2fs_rev >= E2FS_REV1 && \ |
| 388 | ((fs)->e2fs.e2fs_features_incompat & (feature)) != 0) |
| 389 | |
| 390 | |
| 391 | /* |
| 392 | * Definitions of behavior on errors |
| 393 | */ |
| 394 | #define E2FS_BEH_CONTINUE 1 /* continue operation */ |
| 395 | #define E2FS_BEH_READONLY 2 /* remount fs read only */ |
| 396 | #define E2FS_BEH_PANIC 3 /* cause panic */ |
| 397 | #define E2FS_BEH_DEFAULT E2FS_BEH_CONTINUE |
| 398 | |
| 399 | /* |
| 400 | * OS identification |
| 401 | */ |
| 402 | #define E2FS_OS_LINUX 0 |
| 403 | #define E2FS_OS_HURD 1 |
| 404 | #define E2FS_OS_MASIX 2 |
| 405 | #define E2FS_OS_FREEBSD 3 |
| 406 | #define E2FS_OS_LITES 4 |
| 407 | |
| 408 | /* |
| 409 | * Filesystem clean flags |
| 410 | */ |
| 411 | #define E2FS_ISCLEAN 0x01 |
| 412 | #define E2FS_ERRORS 0x02 |
| 413 | |
| 414 | /* ext2 file system block group descriptor */ |
| 415 | |
| 416 | struct ext2_gd { |
| 417 | uint32_t ext2bgd_b_bitmap; /* blocks bitmap block */ |
| 418 | uint32_t ext2bgd_i_bitmap; /* inodes bitmap block */ |
| 419 | uint32_t ext2bgd_i_tables; /* first inodes table block */ |
| 420 | uint16_t ext2bgd_nbfree; /* number of free blocks */ |
| 421 | uint16_t ext2bgd_nifree; /* number of free inodes */ |
| 422 | uint16_t ext2bgd_ndirs; /* number of directories */ |
| 423 | |
| 424 | /* |
| 425 | * Following only valid when either GDT_CSUM (AKA uninit_bg) |
| 426 | * or METADATA_CKSUM feature is on |
| 427 | */ |
| 428 | uint16_t ext2bgd_flags; /* ext4 bg flags (INODE_UNINIT, ...)*/ |
| 429 | uint32_t ext2bgd_exclude_bitmap_lo; /* snapshot exclude bitmap */ |
| 430 | uint16_t ext2bgd_block_bitmap_csum_lo; /* Low block bitmap checksum */ |
| 431 | uint16_t ext2bgd_inode_bitmap_csum_lo; /* Low inode bitmap checksum */ |
| 432 | uint16_t ext2bgd_itable_unused_lo; /* Low unused inode offset */ |
| 433 | uint16_t ext2bgd_checksum; /* Group desc checksum */ |
| 434 | |
| 435 | /* |
| 436 | * XXX disk32 Further fields only exist if 64BIT feature is on |
| 437 | * and superblock desc_size > 32, not supported for now. |
| 438 | */ |
| 439 | }; |
| 440 | |
| 441 | #define E2FS_BG_INODE_UNINIT 0x0001 /* Inode bitmap not used/initialized */ |
| 442 | #define E2FS_BG_BLOCK_UNINIT 0x0002 /* Block bitmap not used/initialized */ |
| 443 | #define E2FS_BG_INODE_ZEROED 0x0004 /* On-disk inode table initialized */ |
| 444 | |
| 445 | #define E2FS_HAS_GD_CSUM(fs) \ |
| 446 | EXT2F_HAS_ROCOMPAT_FEATURE(fs, EXT2F_ROCOMPAT_GDT_CSUM|EXT2F_ROCOMPAT_METADATA_CKSUM) != 0 |
| 447 | |
| 448 | /* |
| 449 | * If the EXT2F_ROCOMPAT_SPARSESUPER flag is set, the cylinder group has a |
| 450 | * copy of the super and cylinder group descriptors blocks only if it's |
| 451 | * 1, a power of 3, 5 or 7 |
| 452 | */ |
| 453 | |
| 454 | static __inline int cg_has_sb(int) __unused; |
| 455 | static __inline int |
| 456 | cg_has_sb(int i) |
| 457 | { |
| 458 | int a3, a5, a7; |
| 459 | |
| 460 | if (i == 0 || i == 1) |
| 461 | return 1; |
| 462 | for (a3 = 3, a5 = 5, a7 = 7; |
| 463 | a3 <= i || a5 <= i || a7 <= i; |
| 464 | a3 *= 3, a5 *= 5, a7 *= 7) |
| 465 | if (i == a3 || i == a5 || i == a7) |
| 466 | return 1; |
| 467 | return 0; |
| 468 | } |
| 469 | |
| 470 | /* EXT2FS metadatas are stored in little-endian byte order. These macros |
| 471 | * helps reading theses metadatas |
| 472 | */ |
| 473 | |
| 474 | #if BYTE_ORDER == LITTLE_ENDIAN |
| 475 | # define h2fs16(x) (x) |
| 476 | # define h2fs32(x) (x) |
| 477 | # define h2fs64(x) (x) |
| 478 | # define fs2h16(x) (x) |
| 479 | # define fs2h32(x) (x) |
| 480 | # define fs2h64(x) (x) |
| 481 | # define e2fs_sbload(old, new) memcpy((new), (old), SBSIZE) |
| 482 | # define e2fs_sbsave(old, new) memcpy((new), (old), SBSIZE) |
| 483 | #else |
| 484 | void e2fs_sb_bswap(struct ext2fs *, struct ext2fs *); |
| 485 | # define h2fs16(x) bswap16(x) |
| 486 | # define h2fs32(x) bswap32(x) |
| 487 | # define h2fs64(x) bswap64(x) |
| 488 | # define fs2h16(x) bswap16(x) |
| 489 | # define fs2h32(x) bswap32(x) |
| 490 | # define fs2h64(x) bswap64(x) |
| 491 | # define e2fs_sbload(old, new) e2fs_sb_bswap((old), (new)) |
| 492 | # define e2fs_sbsave(old, new) e2fs_sb_bswap((old), (new)) |
| 493 | #endif |
| 494 | |
| 495 | /* Group descriptors are not byte swapped */ |
| 496 | #define e2fs_cgload(old, new, size) memcpy((new), (old), (size)) |
| 497 | #define e2fs_cgsave(old, new, size) memcpy((new), (old), (size)) |
| 498 | |
| 499 | /* |
| 500 | * Turn file system block numbers into disk block addresses. |
| 501 | * This maps file system blocks to device size blocks. |
| 502 | */ |
| 503 | #define EXT2_FSBTODB(fs, b) ((b) << (fs)->e2fs_fsbtodb) |
| 504 | #define EXT2_DBTOFSB(fs, b) ((b) >> (fs)->e2fs_fsbtodb) |
| 505 | |
| 506 | /* |
| 507 | * Macros for handling inode numbers: |
| 508 | * inode number to file system block offset. |
| 509 | * inode number to cylinder group number. |
| 510 | * inode number to file system block address. |
| 511 | */ |
| 512 | #define ino_to_cg(fs, x) (((x) - 1) / (fs)->e2fs.e2fs_ipg) |
| 513 | #define ino_to_fsba(fs, x) \ |
| 514 | (fs2h32((fs)->e2fs_gd[ino_to_cg((fs), (x))].ext2bgd_i_tables) + \ |
| 515 | (((x) - 1) % (fs)->e2fs.e2fs_ipg) / (fs)->e2fs_ipb) |
| 516 | #define ino_to_fsbo(fs, x) (((x) - 1) % (fs)->e2fs_ipb) |
| 517 | |
| 518 | /* |
| 519 | * Give cylinder group number for a file system block. |
| 520 | * Give cylinder group block number for a file system block. |
| 521 | */ |
| 522 | #define dtog(fs, d) (((d) - (fs)->e2fs.e2fs_first_dblock) / (fs)->e2fs.e2fs_fpg) |
| 523 | #define dtogd(fs, d) \ |
| 524 | (((d) - (fs)->e2fs.e2fs_first_dblock) % (fs)->e2fs.e2fs_fpg) |
| 525 | |
| 526 | /* |
| 527 | * The following macros optimize certain frequently calculated |
| 528 | * quantities by using shifts and masks in place of divisions |
| 529 | * modulos and multiplications. |
| 530 | */ |
| 531 | #define ext2_blkoff(fs, loc) /* calculates (loc % fs->e2fs_bsize) */ \ |
| 532 | ((loc) & (fs)->e2fs_qbmask) |
| 533 | #define ext2_lblktosize(fs, blk) /* calculates (blk * fs->e2fs_bsize) */ \ |
| 534 | ((blk) << (fs)->e2fs_bshift) |
| 535 | #define ext2_lblkno(fs, loc) /* calculates (loc / fs->e2fs_bsize) */ \ |
| 536 | ((loc) >> (fs)->e2fs_bshift) |
| 537 | #define ext2_blkroundup(fs, size) /* calculates roundup(size, fs->e2fs_bsize) */ \ |
| 538 | (((size) + (fs)->e2fs_qbmask) & (fs)->e2fs_bmask) |
| 539 | #define ext2_fragroundup(fs, size) /* calculates roundup(size, fs->e2fs_bsize) */ \ |
| 540 | (((size) + (fs)->e2fs_qbmask) & (fs)->e2fs_bmask) |
| 541 | /* |
| 542 | * Determine the number of available frags given a |
| 543 | * percentage to hold in reserve. |
| 544 | */ |
| 545 | #define freespace(fs) \ |
| 546 | ((fs)->e2fs.e2fs_fbcount - (fs)->e2fs.e2fs_rbcount) |
| 547 | |
| 548 | /* |
| 549 | * Number of indirects in a file system block. |
| 550 | */ |
| 551 | #define EXT2_NINDIR(fs) ((fs)->e2fs_bsize / sizeof(uint32_t)) |
| 552 | |
| 553 | #endif /* !_UFS_EXT2FS_EXT2FS_H_ */ |
| 554 | |