bootx.tproj/fs.subproj/ext2fs.h

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22 /*      $NetBSD: ext2fs.h,v 1.10 2000/01/28 16:00:23 bouyer Exp $       */
  23 /*
  24  * Copyright (c) 1997 Manuel Bouyer.
  25  * Copyright (c) 1982, 1986, 1993
  26  *      The Regents of the University of California.  All rights reserved.
  27  *
  28  * Redistribution and use in source and binary forms, with or without
  29  * modification, are permitted provided that the following conditions
  30  * are met:
  31  * 1. Redistributions of source code must retain the above copyright
  32  *    notice, this list of conditions and the following disclaimer.
  33  * 2. Redistributions in binary form must reproduce the above copyright
  34  *    notice, this list of conditions and the following disclaimer in the
  35  *    documentation and/or other materials provided with the distribution.
  36  * 3. All advertising materials mentioning features or use of this software
  37  *    must display the following acknowledgement:
  38  *      This product includes software developed by the University of
  39  *      California, Berkeley and its contributors.
  40  * 4. Neither the name of the University nor the names of its contributors
  41  *    may be used to endorse or promote products derived from this software
  42  *    without specific prior written permission.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  45  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  46  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  47  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  48  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  49  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  50  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  51  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  52  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  53  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  54  * SUCH DAMAGE.
  55  *
  56  *      @(#)fs.h        8.10 (Berkeley) 10/27/94
  57  *  Modified for ext2fs by Manuel Bouyer.
  58  */
  59 /*
  60  *  ext2fs.h - Headers for Ext2 disk structures.
  61  *
  62  *  Copyright (c) 2000 Apple Computer, Inc.
  63  *
  64  *  DRI: Josh de Cesare
  65  */
  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          ((ufs_daddr_t)(0))
  87 #define SBLOCK          ((ufs_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         u_int32_t  e2fs_icount;         /* Inode count */
 130         u_int32_t  e2fs_bcount;         /* blocks count */
 131         u_int32_t  e2fs_rbcount;        /* reserved blocks count */
 132         u_int32_t  e2fs_fbcount;        /* free blocks count */
 133         u_int32_t  e2fs_ficount;        /* free inodes count */
 134         u_int32_t  e2fs_first_dblock;   /* first data block */
 135         u_int32_t  e2fs_log_bsize;      /* block size = 1024*(2^e2fs_log_bsize) */
 136         u_int32_t  e2fs_fsize;          /* fragment size */
 137         u_int32_t  e2fs_bpg;            /* blocks per group */
 138         u_int32_t  e2fs_fpg;            /* frags per group */
 139         u_int32_t  e2fs_ipg;            /* inodes per group */
 140         u_int32_t  e2fs_mtime;          /* mount time */
 141         u_int32_t  e2fs_wtime;          /* write time */
 142         u_int16_t  e2fs_mnt_count;      /* mount count */
 143         u_int16_t  e2fs_max_mnt_count;  /* max mount count */
 144         u_int16_t  e2fs_magic;          /* magic number */
 145         u_int16_t  e2fs_state;          /* file system state */
 146         u_int16_t  e2fs_beh;            /* behavior on errors */
 147         u_int16_t  e2fs_minrev;         /* minor revision level */
 148         u_int32_t  e2fs_lastfsck;       /* time of last fsck */
 149         u_int32_t  e2fs_fsckintv;       /* max time between fscks */
 150         u_int32_t  e2fs_creator;        /* creator OS */
 151         u_int32_t  e2fs_rev;            /* revision level */
 152         u_int16_t  e2fs_ruid;           /* default uid for reserved blocks */
 153         u_int16_t  e2fs_rgid;           /* default gid for reserved blocks */
 154         /* EXT2_DYNAMIC_REV superblocks */
 155         u_int32_t  e2fs_first_ino;      /* first non-reserved inode */
 156         u_int16_t  e2fs_inode_size;     /* size of inode structure */
 157         u_int16_t  e2fs_block_group_nr; /* block grp number of this sblk*/
 158         u_int32_t  e2fs_features_compat; /*  compatible feature set */
 159         u_int32_t  e2fs_features_incompat; /* incompatible feature set */
 160         u_int32_t  e2fs_features_rocompat; /* RO-compatible feature set */
 161         u_int8_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         u_int32_t  e2fs_algo;           /* For compression */
 165         u_int8_t   e2fs_prealloc;       /* # of blocks to preallocate */
 166         u_int8_t   e2fs_dir_prealloc;   /* # of blocks to preallocate for dir */
 167         u_int16_t  pad1;
 168         u_int32_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       /* revision levels */
 197 #define E2FS_REV1       1       /* revision levels */
 198
 199 /* compatible/imcompatible features */
 200 #define EXT2F_COMPAT_PREALLOC           0x0001
 201
 202 #define EXT2F_ROCOMPAT_SPARSESUPER      0x0001
 203 #define EXT2F_ROCOMPAT_LARGEFILE        0x0002
 204 #define EXT2F_ROCOMPAT_BTREE_DIR        0x0004
 205
 206 #define EXT2F_INCOMPAT_COMP             0x0001
 207 #define EXT2F_INCOMPAT_FTYPE            0x0002
 208
 209 /* features supported in this implementation */
 210 #define EXT2F_COMPAT_SUPP               0x0000
 211 #define EXT2F_ROCOMPAT_SUPP             EXT2F_ROCOMPAT_SPARSESUPER
 212 #define EXT2F_INCOMPAT_SUPP             EXT2F_INCOMPAT_FTYPE
 213
 214 /*
 215  * OS identification
 216  */
 217 #define E2FS_OS_LINUX 0
 218 #define E2FS_OS_HURD  1
 219 #define E2FS_OS_MASIX 2
 220
 221 /*
 222  * Filesystem clean flags
 223  */
 224 #define E2FS_ISCLEAN    0x01
 225 #define E2FS_ERRORS     0x02
 226
 227 /* ext2 file system block group descriptor */
 228
 229 struct ext2_gd {
 230         u_int32_t ext2bgd_b_bitmap;     /* blocks bitmap block */
 231         u_int32_t ext2bgd_i_bitmap;     /* inodes bitmap block */
 232         u_int32_t ext2bgd_i_tables;     /* inodes table block  */
 233         u_int16_t ext2bgd_nbfree;       /* number of free blocks */
 234         u_int16_t ext2bgd_nifree;       /* number of free inodes */
 235         u_int16_t ext2bgd_ndirs;        /* number of directories */
 236         u_int16_t reserved;
 237         u_int32_t reserved2[3];
 238
 239 };
 240
 241
 242 /*
 243  * If the EXT2F_ROCOMPAT_SPARSESUPER flag is set, the cylinder group has a
 244  * copy of the super and cylinder group descriptors blocks only if it's
 245  * a power of 3, 5 or 7
 246  */
 247
 248 static __inline__ int cg_has_sb __P((int)) __attribute__((__unused__));
 249 static __inline int
 250 cg_has_sb(i)
 251         int i;
 252 {
 253         int a3 ,a5 , a7;
 254
 255         if (i == 0 || i == 1)
 256                 return 1;
 257         for (a3 = 3, a5 = 5, a7 = 7;
 258             a3 <= i || a5 <= i || a7 <= i;
 259             a3 *= 3, a5 *= 5, a7 *= 7)
 260                 if (i == a3 || i == a5 || i == a7)
 261                         return 1;
 262         return 0;
 263 }
 264
 265 /* EXT2FS metadatas are stored in little-endian byte order. These macros
 266  * helps reading theses metadatas
 267  */
 268
 269 #if BYTE_ORDER == LITTLE_ENDIAN
 270 #       define h2fs16(x) (x)
 271 #       define h2fs32(x) (x)
 272 #       define fs2h16(x) (x)
 273 #       define fs2h32(x) (x)
 274 #       define e2fs_sbload(old, new) memcpy((new), (old), SBSIZE);
 275 #       define e2fs_cgload(old, new, size) memcpy((new), (old), (size));
 276 #       define e2fs_sbsave(old, new) memcpy((new), (old), SBSIZE);
 277 #       define e2fs_cgsave(old, new, size) memcpy((new), (old), (size));
 278 #else
 279 void e2fs_sb_bswap __P((struct ext2fs *, struct ext2fs *));
 280 void e2fs_cg_bswap __P((struct ext2_gd *, struct ext2_gd *, int));
 281 #       define h2fs16(x) bswap16(x)
 282 #       define h2fs32(x) bswap32(x)
 283 #       define fs2h16(x) bswap16(x)
 284 #       define fs2h32(x) bswap32(x)
 285 #       define e2fs_sbload(old, new) e2fs_sb_bswap((old), (new))
 286 #       define e2fs_cgload(old, new, size) e2fs_cg_bswap((old), (new), (size));
 287 #       define e2fs_sbsave(old, new) e2fs_sb_bswap((old), (new))
 288 #       define e2fs_cgsave(old, new, size) e2fs_cg_bswap((old), (new), (size));
 289 #endif
 290
 291 /*
 292  * Turn file system block numbers into disk block addresses.
 293  * This maps file system blocks to device size blocks.
 294  */
 295 #define fsbtodb(fs, b)  ((b) << (fs)->e2fs_fsbtodb)
 296 #define dbtofsb(fs, b)  ((b) >> (fs)->e2fs_fsbtodb)
 297
 298 /*
 299  * Macros for handling inode numbers:
 300  *       inode number to file system block offset.
 301  *       inode number to cylinder group number.
 302  *       inode number to file system block address.
 303  */
 304 #define ino_to_cg(fs, x)        (((x) - 1) / (fs)->e2fs.e2fs_ipg)
 305 #define ino_to_fsba(fs, x)                                              \
 306         ((fs)->e2fs_gd[ino_to_cg(fs, x)].ext2bgd_i_tables + \
 307         (((x)-1) % (fs)->e2fs.e2fs_ipg)/(fs)->e2fs_ipb)
 308 #define ino_to_fsbo(fs, x)      (((x)-1) % (fs)->e2fs_ipb)
 309
 310 /*
 311  * Give cylinder group number for a file system block.
 312  * Give cylinder group block number for a file system block.
 313  */
 314 #define dtog(fs, d) (((d) - (fs)->e2fs.e2fs_first_dblock) / (fs)->e2fs.e2fs_fpg)
 315 #define dtogd(fs, d) \
 316         (((d) - (fs)->e2fs.e2fs_first_dblock) % (fs)->e2fs.e2fs_fpg)
 317
 318 /*
 319  * The following macros optimize certain frequently calculated
 320  * quantities by using shifts and masks in place of divisions
 321  * modulos and multiplications.
 322  */
 323 #define blkoff(fs, loc)         /* calculates (loc % fs->e2fs_bsize) */ \
 324         ((loc) & (fs)->e2fs_qbmask)
 325 #define lblktosize(fs, blk)     /* calculates (blk * fs->e2fs_bsize) */ \
 326         ((blk) << (fs)->e2fs_bshift)
 327 #define lblkno(fs, loc)         /* calculates (loc / fs->e2fs_bsize) */ \
 328         ((loc) >> (fs)->e2fs_bshift)
 329 #define blkroundup(fs, size)    /* calculates roundup(size, fs->e2fs_bsize) */ \
 330         (((size) + (fs)->e2fs_qbmask) & (fs)->e2fs_bmask)
 331 #define fragroundup(fs, size)   /* calculates roundup(size, fs->e2fs_bsize) */ \
 332         (((size) + (fs)->e2fs_qbmask) & (fs)->e2fs_bmask)
 333 /*
 334  * Determine the number of available frags given a
 335  * percentage to hold in reserve.
 336  */
 337 #define freespace(fs) \
 338    ((fs)->e2fs.e2fs_fbcount - (fs)->e2fs.e2fs_rbcount)
 339
 340 /*
 341  * Number of indirects in a file system block.
 342  */
 343 #define NINDIR(fs)      ((fs)->e2fs_bsize / sizeof(u_int32_t))