sys/ufs/ext2fs/ext2fs.h

   1 /*      $NetBSD: ext2fs.h,v 1.27 2009/09/12 11:27:39 tsutsui 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 /*
  90  * Addresses stored in inodes are capable of addressing blocks
  91  * XXX
  92  */
  93
  94 /*
  95  * MINBSIZE is the smallest allowable block size.
  96  * MINBSIZE must be big enough to hold a cylinder group block,
  97  * thus changes to (struct cg) must keep its size within MINBSIZE.
  98  * Note that super blocks are always of size SBSIZE,
  99  * and that both SBSIZE and MAXBSIZE must be >= MINBSIZE.
 100  */
 101 #define LOG_MINBSIZE    10
 102 #define MINBSIZE        (1 << LOG_MINBSIZE)
 103
 104 /*
 105  * The path name on which the file system is mounted is maintained
 106  * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in
 107  * the super block for this name.
 108  */
 109 #define MAXMNTLEN       512
 110
 111 /*
 112  * MINFREE gives the minimum acceptable percentage of file system
 113  * blocks which may be free. If the freelist drops below this level
 114  * only the superuser may continue to allocate blocks. This may
 115  * be set to 0 if no reserve of free blocks is deemed necessary,
 116  * however throughput drops by fifty percent if the file system
 117  * is run at between 95% and 100% full; thus the minimum default
 118  * value of fs_minfree is 5%. However, to get good clustering
 119  * performance, 10% is a better choice. hence we use 10% as our
 120  * default value. With 10% free space, fragmentation is not a
 121  * problem, so we choose to optimize for time.
 122  */
 123 #define MINFREE         5
 124
 125 /*
 126  * Super block for an ext2fs file system.
 127  */
 128 struct ext2fs {
 129         uint32_t  e2fs_icount;          /* Inode count */
 130         uint32_t  e2fs_bcount;          /* blocks count */
 131         uint32_t  e2fs_rbcount;         /* reserved blocks count */
 132         uint32_t  e2fs_fbcount;         /* free blocks count */
 133         uint32_t  e2fs_ficount;         /* free inodes count */
 134         uint32_t  e2fs_first_dblock;    /* first data block */
 135         uint32_t  e2fs_log_bsize;       /* block size = 1024*(2^e2fs_log_bsize) */
 136         uint32_t  e2fs_fsize;           /* fragment size */
 137         uint32_t  e2fs_bpg;             /* blocks per group */
 138         uint32_t  e2fs_fpg;             /* frags per group */
 139         uint32_t  e2fs_ipg;             /* inodes per group */
 140         uint32_t  e2fs_mtime;           /* mount time */
 141         uint32_t  e2fs_wtime;           /* write time */
 142         uint16_t  e2fs_mnt_count;       /* mount count */
 143         uint16_t  e2fs_max_mnt_count;   /* max mount count */
 144         uint16_t  e2fs_magic;           /* magic number */
 145         uint16_t  e2fs_state;           /* file system state */
 146         uint16_t  e2fs_beh;             /* behavior on errors */
 147         uint16_t  e2fs_minrev;          /* minor revision level */
 148         uint32_t  e2fs_lastfsck;        /* time of last fsck */
 149         uint32_t  e2fs_fsckintv;        /* max time between fscks */
 150         uint32_t  e2fs_creator;         /* creator OS */
 151         uint32_t  e2fs_rev;             /* revision level */
 152         uint16_t  e2fs_ruid;            /* default uid for reserved blocks */
 153         uint16_t  e2fs_rgid;            /* default gid for reserved blocks */
 154         /* EXT2_DYNAMIC_REV superblocks */
 155         uint32_t  e2fs_first_ino;       /* first non-reserved inode */
 156         uint16_t  e2fs_inode_size;      /* size of inode structure */
 157         uint16_t  e2fs_block_group_nr;  /* block grp number of this sblk*/
 158         uint32_t  e2fs_features_compat; /*  compatible feature set */
 159         uint32_t  e2fs_features_incompat; /* incompatible feature set */
 160         uint32_t  e2fs_features_rocompat; /* RO-compatible feature set */
 161         uint8_t   e2fs_uuid[16];        /* 128-bit uuid for volume */
 162         char      e2fs_vname[16];       /* volume name */
 163         char      e2fs_fsmnt[64];       /* name mounted on */
 164         uint32_t  e2fs_algo;            /* For compression */
 165         uint8_t   e2fs_prealloc;        /* # of blocks to preallocate */
 166         uint8_t   e2fs_dir_prealloc;    /* # of blocks to preallocate for dir */
 167         uint16_t  e2fs_reserved_ngdb;   /* # of reserved gd blocks for resize */
 168         uint32_t  reserved2[204];
 169 };
 170
 171
 172 /* in-memory data for ext2fs */
 173 struct m_ext2fs {
 174         struct ext2fs e2fs;
 175         u_char  e2fs_fsmnt[MAXMNTLEN];  /* name mounted on */
 176         int8_t  e2fs_ronly;     /* mounted read-only flag */
 177         int8_t  e2fs_fmod;      /* super block modified flag */
 178         int32_t e2fs_bsize;     /* block size */
 179         int32_t e2fs_bshift;    /* ``lblkno'' calc of logical blkno */
 180         int32_t e2fs_bmask;     /* ``blkoff'' calc of blk offsets */
 181         int64_t e2fs_qbmask;    /* ~fs_bmask - for use with quad size */
 182         int32_t e2fs_fsbtodb;   /* fsbtodb and dbtofsb shift constant */
 183         int32_t e2fs_ncg;       /* number of cylinder groups */
 184         int32_t e2fs_ngdb;      /* number of group descriptor block */
 185         int32_t e2fs_ipb;       /* number of inodes per block */
 186         int32_t e2fs_itpg;      /* number of inode table per group */
 187         struct  ext2_gd *e2fs_gd; /* group descripors */
 188 };
 189
 190
 191
 192 /*
 193  * Filesystem identification
 194  */
 195 #define E2FS_MAGIC      0xef53  /* the ext2fs magic number */
 196 #define E2FS_REV0       0       /* GOOD_OLD revision */
 197 #define E2FS_REV1       1       /* Support compat/incompat features */
 198
 199 /* compatible/incompatible features */
 200 #define EXT2F_COMPAT_PREALLOC           0x0001
 201 #define EXT2F_COMPAT_RESIZE             0x0010
 202
 203 #define EXT2F_ROCOMPAT_SPARSESUPER      0x0001
 204 #define EXT2F_ROCOMPAT_LARGEFILE        0x0002
 205 #define EXT2F_ROCOMPAT_BTREE_DIR        0x0004
 206
 207 #define EXT2F_INCOMPAT_COMP             0x0001
 208 #define EXT2F_INCOMPAT_FTYPE            0x0002
 209
 210 /*
 211  * Features supported in this implementation
 212  *
 213  * We support the following REV1 features:
 214  * - EXT2F_ROCOMPAT_SPARSESUPER
 215  *    superblock backups stored only in cg_has_sb(bno) groups
 216  * - EXT2F_ROCOMPAT_LARGEFILE
 217  *    use e2di_dacl in struct ext2fs_dinode to store
 218  *    upper 32bit of size for >2GB files
 219  * - EXT2F_INCOMPAT_FTYPE
 220  *    store file type to e2d_type in struct ext2fs_direct
 221  *    (on REV0 e2d_namlen is uint16_t and no e2d_type, like ffs)
 222  */
 223 #define EXT2F_COMPAT_SUPP               0x0000
 224 #define EXT2F_ROCOMPAT_SUPP             (EXT2F_ROCOMPAT_SPARSESUPER \
 225                                          | EXT2F_ROCOMPAT_LARGEFILE)
 226 #define EXT2F_INCOMPAT_SUPP             EXT2F_INCOMPAT_FTYPE
 227
 228 /*
 229  * Definitions of behavior on errors
 230  */
 231 #define E2FS_BEH_CONTINUE       1       /* continue operation */
 232 #define E2FS_BEH_READONLY       2       /* remount fs read only */
 233 #define E2FS_BEH_PANIC          3       /* cause panic */
 234 #define E2FS_BEH_DEFAULT        E2FS_BEH_CONTINUE
 235
 236 /*
 237  * OS identification
 238  */
 239 #define E2FS_OS_LINUX   0
 240 #define E2FS_OS_HURD    1
 241 #define E2FS_OS_MASIX   2
 242 #define E2FS_OS_FREEBSD 3
 243 #define E2FS_OS_LITES   4
 244
 245 /*
 246  * Filesystem clean flags
 247  */
 248 #define E2FS_ISCLEAN    0x01
 249 #define E2FS_ERRORS     0x02
 250
 251 /* ext2 file system block group descriptor */
 252
 253 struct ext2_gd {
 254         uint32_t ext2bgd_b_bitmap;      /* blocks bitmap block */
 255         uint32_t ext2bgd_i_bitmap;      /* inodes bitmap block */
 256         uint32_t ext2bgd_i_tables;      /* inodes table block  */
 257         uint16_t ext2bgd_nbfree;        /* number of free blocks */
 258         uint16_t ext2bgd_nifree;        /* number of free inodes */
 259         uint16_t ext2bgd_ndirs;         /* number of directories */
 260         uint16_t reserved;
 261         uint32_t reserved2[3];
 262 };
 263
 264
 265 /*
 266  * If the EXT2F_ROCOMPAT_SPARSESUPER flag is set, the cylinder group has a
 267  * copy of the super and cylinder group descriptors blocks only if it's
 268  * 1, a power of 3, 5 or 7
 269  */
 270
 271 static __inline int cg_has_sb(int) __unused;
 272 static __inline int
 273 cg_has_sb(int i)
 274 {
 275         int a3, a5, a7;
 276
 277         if (i == 0 || i == 1)
 278                 return 1;
 279         for (a3 = 3, a5 = 5, a7 = 7;
 280             a3 <= i || a5 <= i || a7 <= i;
 281             a3 *= 3, a5 *= 5, a7 *= 7)
 282                 if (i == a3 || i == a5 || i == a7)
 283                         return 1;
 284         return 0;
 285 }
 286
 287 /* EXT2FS metadatas are stored in little-endian byte order. These macros
 288  * helps reading theses metadatas
 289  */
 290
 291 #if BYTE_ORDER == LITTLE_ENDIAN
 292 #       define h2fs16(x) (x)
 293 #       define h2fs32(x) (x)
 294 #       define h2fs64(x) (x)
 295 #       define fs2h16(x) (x)
 296 #       define fs2h32(x) (x)
 297 #       define fs2h64(x) (x)
 298 #       define e2fs_sbload(old, new) memcpy((new), (old), SBSIZE);
 299 #       define e2fs_cgload(old, new, size) memcpy((new), (old), (size));
 300 #       define e2fs_sbsave(old, new) memcpy((new), (old), SBSIZE);
 301 #       define e2fs_cgsave(old, new, size) memcpy((new), (old), (size));
 302 #else
 303 void e2fs_sb_bswap(struct ext2fs *, struct ext2fs *);
 304 void e2fs_cg_bswap(struct ext2_gd *, struct ext2_gd *, int);
 305 #       define h2fs16(x) bswap16(x)
 306 #       define h2fs32(x) bswap32(x)
 307 #       define h2fs64(x) bswap64(x)
 308 #       define fs2h16(x) bswap16(x)
 309 #       define fs2h32(x) bswap32(x)
 310 #       define fs2h64(x) bswap64(x)
 311 #       define e2fs_sbload(old, new) e2fs_sb_bswap((old), (new))
 312 #       define e2fs_cgload(old, new, size) e2fs_cg_bswap((old), (new), (size));
 313 #       define e2fs_sbsave(old, new) e2fs_sb_bswap((old), (new))
 314 #       define e2fs_cgsave(old, new, size) e2fs_cg_bswap((old), (new), (size));
 315 #endif
 316
 317 /*
 318  * Turn file system block numbers into disk block addresses.
 319  * This maps file system blocks to device size blocks.
 320  */
 321 #define fsbtodb(fs, b)  ((b) << (fs)->e2fs_fsbtodb)
 322 #define dbtofsb(fs, b)  ((b) >> (fs)->e2fs_fsbtodb)
 323
 324 /*
 325  * Macros for handling inode numbers:
 326  *       inode number to file system block offset.
 327  *       inode number to cylinder group number.
 328  *       inode number to file system block address.
 329  */
 330 #define ino_to_cg(fs, x)        (((x) - 1) / (fs)->e2fs.e2fs_ipg)
 331 #define ino_to_fsba(fs, x)                                              \
 332         ((fs)->e2fs_gd[ino_to_cg((fs), (x))].ext2bgd_i_tables +         \
 333         (((x) - 1) % (fs)->e2fs.e2fs_ipg) / (fs)->e2fs_ipb)
 334 #define ino_to_fsbo(fs, x)      (((x) - 1) % (fs)->e2fs_ipb)
 335
 336 /*
 337  * Give cylinder group number for a file system block.
 338  * Give cylinder group block number for a file system block.
 339  */
 340 #define dtog(fs, d) (((d) - (fs)->e2fs.e2fs_first_dblock) / (fs)->e2fs.e2fs_fpg)
 341 #define dtogd(fs, d) \
 342         (((d) - (fs)->e2fs.e2fs_first_dblock) % (fs)->e2fs.e2fs_fpg)
 343
 344 /*
 345  * The following macros optimize certain frequently calculated
 346  * quantities by using shifts and masks in place of divisions
 347  * modulos and multiplications.
 348  */
 349 #define blkoff(fs, loc)         /* calculates (loc % fs->e2fs_bsize) */ \
 350         ((loc) & (fs)->e2fs_qbmask)
 351 #define lblktosize(fs, blk)     /* calculates (blk * fs->e2fs_bsize) */ \
 352         ((blk) << (fs)->e2fs_bshift)
 353 #define lblkno(fs, loc)         /* calculates (loc / fs->e2fs_bsize) */ \
 354         ((loc) >> (fs)->e2fs_bshift)
 355 #define blkroundup(fs, size)    /* calculates roundup(size, fs->e2fs_bsize) */ \
 356         (((size) + (fs)->e2fs_qbmask) & (fs)->e2fs_bmask)
 357 #define fragroundup(fs, size)   /* calculates roundup(size, fs->e2fs_bsize) */ \
 358         (((size) + (fs)->e2fs_qbmask) & (fs)->e2fs_bmask)
 359 /*
 360  * Determine the number of available frags given a
 361  * percentage to hold in reserve.
 362  */
 363 #define freespace(fs) \
 364    ((fs)->e2fs.e2fs_fbcount - (fs)->e2fs.e2fs_rbcount)
 365
 366 /*
 367  * Number of indirects in a file system block.
 368  */
 369 #define NINDIR(fs)      ((fs)->e2fs_bsize / sizeof(uint32_t))
 370
 371 #endif /* !_UFS_EXT2FS_EXT2FS_H_ */