fs/xfs/xfs_format.h

   1 /*
   2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18 #ifndef __XFS_FORMAT_H__
  19 #define __XFS_FORMAT_H__
  20
  21 /*
  22  * XFS On Disk Format Definitions
  23  *
  24  * This header file defines all the on-disk format definitions for
  25  * general XFS objects. Directory and attribute related objects are defined in
  26  * xfs_da_format.h, which log and log item formats are defined in
  27  * xfs_log_format.h. Everything else goes here.
  28  */
  29
  30 struct xfs_mount;
  31 struct xfs_trans;
  32 struct xfs_inode;
  33 struct xfs_buf;
  34 struct xfs_ifork;
  35
  36 /*
  37  * RealTime Device format definitions
  38  */
  39
  40 /* Min and max rt extent sizes, specified in bytes */
  41 #define XFS_MAX_RTEXTSIZE       (1024 * 1024 * 1024)    /* 1GB */
  42 #define XFS_DFL_RTEXTSIZE       (64 * 1024)             /* 64kB */
  43 #define XFS_MIN_RTEXTSIZE       (4 * 1024)              /* 4kB */
  44
  45 #define XFS_BLOCKSIZE(mp)       ((mp)->m_sb.sb_blocksize)
  46 #define XFS_BLOCKMASK(mp)       ((mp)->m_blockmask)
  47 #define XFS_BLOCKWSIZE(mp)      ((mp)->m_blockwsize)
  48 #define XFS_BLOCKWMASK(mp)      ((mp)->m_blockwmask)
  49
  50 /*
  51  * RT Summary and bit manipulation macros.
  52  */
  53 #define XFS_SUMOFFS(mp,ls,bb)   ((int)((ls) * (mp)->m_sb.sb_rbmblocks + (bb)))
  54 #define XFS_SUMOFFSTOBLOCK(mp,s)        \
  55         (((s) * (uint)sizeof(xfs_suminfo_t)) >> (mp)->m_sb.sb_blocklog)
  56 #define XFS_SUMPTR(mp,bp,so)    \
  57         ((xfs_suminfo_t *)((bp)->b_addr + \
  58                 (((so) * (uint)sizeof(xfs_suminfo_t)) & XFS_BLOCKMASK(mp))))
  59
  60 #define XFS_BITTOBLOCK(mp,bi)   ((bi) >> (mp)->m_blkbit_log)
  61 #define XFS_BLOCKTOBIT(mp,bb)   ((bb) << (mp)->m_blkbit_log)
  62 #define XFS_BITTOWORD(mp,bi)    \
  63         ((int)(((bi) >> XFS_NBWORDLOG) & XFS_BLOCKWMASK(mp)))
  64
  65 #define XFS_RTMIN(a,b)  ((a) < (b) ? (a) : (b))
  66 #define XFS_RTMAX(a,b)  ((a) > (b) ? (a) : (b))
  67
  68 #define XFS_RTLOBIT(w)  xfs_lowbit32(w)
  69 #define XFS_RTHIBIT(w)  xfs_highbit32(w)
  70
  71 #if XFS_BIG_BLKNOS
  72 #define XFS_RTBLOCKLOG(b)       xfs_highbit64(b)
  73 #else
  74 #define XFS_RTBLOCKLOG(b)       xfs_highbit32(b)
  75 #endif
  76
  77 /*
  78  * Dquot and dquot block format definitions
  79  */
  80 #define XFS_DQUOT_MAGIC         0x4451          /* 'DQ' */
  81 #define XFS_DQUOT_VERSION       (u_int8_t)0x01  /* latest version number */
  82
  83 /*
  84  * This is the main portion of the on-disk representation of quota
  85  * information for a user. This is the q_core of the xfs_dquot_t that
  86  * is kept in kernel memory. We pad this with some more expansion room
  87  * to construct the on disk structure.
  88  */
  89 typedef struct  xfs_disk_dquot {
  90         __be16          d_magic;        /* dquot magic = XFS_DQUOT_MAGIC */
  91         __u8            d_version;      /* dquot version */
  92         __u8            d_flags;        /* XFS_DQ_USER/PROJ/GROUP */
  93         __be32          d_id;           /* user,project,group id */
  94         __be64          d_blk_hardlimit;/* absolute limit on disk blks */
  95         __be64          d_blk_softlimit;/* preferred limit on disk blks */
  96         __be64          d_ino_hardlimit;/* maximum # allocated inodes */
  97         __be64          d_ino_softlimit;/* preferred inode limit */
  98         __be64          d_bcount;       /* disk blocks owned by the user */
  99         __be64          d_icount;       /* inodes owned by the user */
 100         __be32          d_itimer;       /* zero if within inode limits if not,
 101                                            this is when we refuse service */
 102         __be32          d_btimer;       /* similar to above; for disk blocks */
 103         __be16          d_iwarns;       /* warnings issued wrt num inodes */
 104         __be16          d_bwarns;       /* warnings issued wrt disk blocks */
 105         __be32          d_pad0;         /* 64 bit align */
 106         __be64          d_rtb_hardlimit;/* absolute limit on realtime blks */
 107         __be64          d_rtb_softlimit;/* preferred limit on RT disk blks */
 108         __be64          d_rtbcount;     /* realtime blocks owned */
 109         __be32          d_rtbtimer;     /* similar to above; for RT disk blocks */
 110         __be16          d_rtbwarns;     /* warnings issued wrt RT disk blocks */
 111         __be16          d_pad;
 112 } xfs_disk_dquot_t;
 113
 114 /*
 115  * This is what goes on disk. This is separated from the xfs_disk_dquot because
 116  * carrying the unnecessary padding would be a waste of memory.
 117  */
 118 typedef struct xfs_dqblk {
 119         xfs_disk_dquot_t  dd_diskdq;    /* portion that lives incore as well */
 120         char              dd_fill[4];   /* filling for posterity */
 121
 122         /*
 123          * These two are only present on filesystems with the CRC bits set.
 124          */
 125         __be32            dd_crc;       /* checksum */
 126         __be64            dd_lsn;       /* last modification in log */
 127         uuid_t            dd_uuid;      /* location information */
 128 } xfs_dqblk_t;
 129
 130 #define XFS_DQUOT_CRC_OFF       offsetof(struct xfs_dqblk, dd_crc)
 131
 132 /*
 133  * Remote symlink format and access functions.
 134  */
 135 #define XFS_SYMLINK_MAGIC       0x58534c4d      /* XSLM */
 136
 137 struct xfs_dsymlink_hdr {
 138         __be32  sl_magic;
 139         __be32  sl_offset;
 140         __be32  sl_bytes;
 141         __be32  sl_crc;
 142         uuid_t  sl_uuid;
 143         __be64  sl_owner;
 144         __be64  sl_blkno;
 145         __be64  sl_lsn;
 146 };
 147
 148 #define XFS_SYMLINK_CRC_OFF     offsetof(struct xfs_dsymlink_hdr, sl_crc)
 149
 150 /*
 151  * The maximum pathlen is 1024 bytes. Since the minimum file system
 152  * blocksize is 512 bytes, we can get a max of 3 extents back from
 153  * bmapi when crc headers are taken into account.
 154  */
 155 #define XFS_SYMLINK_MAPS 3
 156
 157 #define XFS_SYMLINK_BUF_SPACE(mp, bufsize)      \
 158         ((bufsize) - (xfs_sb_version_hascrc(&(mp)->m_sb) ? \
 159                         sizeof(struct xfs_dsymlink_hdr) : 0))
 160
 161
 162 /*
 163  * Allocation Btree format definitions
 164  *
 165  * There are two on-disk btrees, one sorted by blockno and one sorted
 166  * by blockcount and blockno.  All blocks look the same to make the code
 167  * simpler; if we have time later, we'll make the optimizations.
 168  */
 169 #define XFS_ABTB_MAGIC          0x41425442      /* 'ABTB' for bno tree */
 170 #define XFS_ABTB_CRC_MAGIC      0x41423342      /* 'AB3B' */
 171 #define XFS_ABTC_MAGIC          0x41425443      /* 'ABTC' for cnt tree */
 172 #define XFS_ABTC_CRC_MAGIC      0x41423343      /* 'AB3C' */
 173
 174 /*
 175  * Data record/key structure
 176  */
 177 typedef struct xfs_alloc_rec {
 178         __be32          ar_startblock;  /* starting block number */
 179         __be32          ar_blockcount;  /* count of free blocks */
 180 } xfs_alloc_rec_t, xfs_alloc_key_t;
 181
 182 typedef struct xfs_alloc_rec_incore {
 183         xfs_agblock_t   ar_startblock;  /* starting block number */
 184         xfs_extlen_t    ar_blockcount;  /* count of free blocks */
 185 } xfs_alloc_rec_incore_t;
 186
 187 /* btree pointer type */
 188 typedef __be32 xfs_alloc_ptr_t;
 189
 190 /*
 191  * Block numbers in the AG:
 192  * SB is sector 0, AGF is sector 1, AGI is sector 2, AGFL is sector 3.
 193  */
 194 #define XFS_BNO_BLOCK(mp)       ((xfs_agblock_t)(XFS_AGFL_BLOCK(mp) + 1))
 195 #define XFS_CNT_BLOCK(mp)       ((xfs_agblock_t)(XFS_BNO_BLOCK(mp) + 1))
 196
 197
 198 /*
 199  * Inode Allocation Btree format definitions
 200  *
 201  * There is a btree for the inode map per allocation group.
 202  */
 203 #define XFS_IBT_MAGIC           0x49414254      /* 'IABT' */
 204 #define XFS_IBT_CRC_MAGIC       0x49414233      /* 'IAB3' */
 205
 206 typedef __uint64_t      xfs_inofree_t;
 207 #define XFS_INODES_PER_CHUNK            (NBBY * sizeof(xfs_inofree_t))
 208 #define XFS_INODES_PER_CHUNK_LOG        (XFS_NBBYLOG + 3)
 209 #define XFS_INOBT_ALL_FREE              ((xfs_inofree_t)-1)
 210 #define XFS_INOBT_MASK(i)               ((xfs_inofree_t)1 << (i))
 211
 212 static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
 213 {
 214         return ((n >= XFS_INODES_PER_CHUNK ? 0 : XFS_INOBT_MASK(n)) - 1) << i;
 215 }
 216
 217 /*
 218  * Data record structure
 219  */
 220 typedef struct xfs_inobt_rec {
 221         __be32          ir_startino;    /* starting inode number */
 222         __be32          ir_freecount;   /* count of free inodes (set bits) */
 223         __be64          ir_free;        /* free inode mask */
 224 } xfs_inobt_rec_t;
 225
 226 typedef struct xfs_inobt_rec_incore {
 227         xfs_agino_t     ir_startino;    /* starting inode number */
 228         __int32_t       ir_freecount;   /* count of free inodes (set bits) */
 229         xfs_inofree_t   ir_free;        /* free inode mask */
 230 } xfs_inobt_rec_incore_t;
 231
 232
 233 /*
 234  * Key structure
 235  */
 236 typedef struct xfs_inobt_key {
 237         __be32          ir_startino;    /* starting inode number */
 238 } xfs_inobt_key_t;
 239
 240 /* btree pointer type */
 241 typedef __be32 xfs_inobt_ptr_t;
 242
 243 /*
 244  * block numbers in the AG.
 245  */
 246 #define XFS_IBT_BLOCK(mp)               ((xfs_agblock_t)(XFS_CNT_BLOCK(mp) + 1))
 247 #define XFS_PREALLOC_BLOCKS(mp)         ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
 248
 249
 250
 251 /*
 252  * BMAP Btree format definitions
 253  *
 254  * This includes both the root block definition that sits inside an inode fork
 255  * and the record/pointer formats for the leaf/node in the blocks.
 256  */
 257 #define XFS_BMAP_MAGIC          0x424d4150      /* 'BMAP' */
 258 #define XFS_BMAP_CRC_MAGIC      0x424d4133      /* 'BMA3' */
 259
 260 /*
 261  * Bmap root header, on-disk form only.
 262  */
 263 typedef struct xfs_bmdr_block {
 264         __be16          bb_level;       /* 0 is a leaf */
 265         __be16          bb_numrecs;     /* current # of data records */
 266 } xfs_bmdr_block_t;
 267
 268 /*
 269  * Bmap btree record and extent descriptor.
 270  *  l0:63 is an extent flag (value 1 indicates non-normal).
 271  *  l0:9-62 are startoff.
 272  *  l0:0-8 and l1:21-63 are startblock.
 273  *  l1:0-20 are blockcount.
 274  */
 275 #define BMBT_EXNTFLAG_BITLEN    1
 276 #define BMBT_STARTOFF_BITLEN    54
 277 #define BMBT_STARTBLOCK_BITLEN  52
 278 #define BMBT_BLOCKCOUNT_BITLEN  21
 279
 280 typedef struct xfs_bmbt_rec {
 281         __be64                  l0, l1;
 282 } xfs_bmbt_rec_t;
 283
 284 typedef __uint64_t      xfs_bmbt_rec_base_t;    /* use this for casts */
 285 typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
 286
 287 typedef struct xfs_bmbt_rec_host {
 288         __uint64_t              l0, l1;
 289 } xfs_bmbt_rec_host_t;
 290
 291 /*
 292  * Values and macros for delayed-allocation startblock fields.
 293  */
 294 #define STARTBLOCKVALBITS       17
 295 #define STARTBLOCKMASKBITS      (15 + XFS_BIG_BLKNOS * 20)
 296 #define DSTARTBLOCKMASKBITS     (15 + 20)
 297 #define STARTBLOCKMASK          \
 298         (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 299 #define DSTARTBLOCKMASK         \
 300         (((((xfs_dfsbno_t)1) << DSTARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 301
 302 static inline int isnullstartblock(xfs_fsblock_t x)
 303 {
 304         return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
 305 }
 306
 307 static inline int isnulldstartblock(xfs_dfsbno_t x)
 308 {
 309         return ((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK;
 310 }
 311
 312 static inline xfs_fsblock_t nullstartblock(int k)
 313 {
 314         ASSERT(k < (1 << STARTBLOCKVALBITS));
 315         return STARTBLOCKMASK | (k);
 316 }
 317
 318 static inline xfs_filblks_t startblockval(xfs_fsblock_t x)
 319 {
 320         return (xfs_filblks_t)((x) & ~STARTBLOCKMASK);
 321 }
 322
 323 /*
 324  * Possible extent formats.
 325  */
 326 typedef enum {
 327         XFS_EXTFMT_NOSTATE = 0,
 328         XFS_EXTFMT_HASSTATE
 329 } xfs_exntfmt_t;
 330
 331 /*
 332  * Possible extent states.
 333  */
 334 typedef enum {
 335         XFS_EXT_NORM, XFS_EXT_UNWRITTEN,
 336         XFS_EXT_DMAPI_OFFLINE, XFS_EXT_INVALID
 337 } xfs_exntst_t;
 338
 339 /*
 340  * Incore version of above.
 341  */
 342 typedef struct xfs_bmbt_irec
 343 {
 344         xfs_fileoff_t   br_startoff;    /* starting file offset */
 345         xfs_fsblock_t   br_startblock;  /* starting block number */
 346         xfs_filblks_t   br_blockcount;  /* number of blocks */
 347         xfs_exntst_t    br_state;       /* extent state */
 348 } xfs_bmbt_irec_t;
 349
 350 /*
 351  * Key structure for non-leaf levels of the tree.
 352  */
 353 typedef struct xfs_bmbt_key {
 354         __be64          br_startoff;    /* starting file offset */
 355 } xfs_bmbt_key_t, xfs_bmdr_key_t;
 356
 357 /* btree pointer type */
 358 typedef __be64 xfs_bmbt_ptr_t, xfs_bmdr_ptr_t;
 359
 360
 361 /*
 362  * Generic Btree block format definitions
 363  *
 364  * This is a combination of the actual format used on disk for short and long
 365  * format btrees.  The first three fields are shared by both format, but the
 366  * pointers are different and should be used with care.
 367  *
 368  * To get the size of the actual short or long form headers please use the size
 369  * macros below.  Never use sizeof(xfs_btree_block).
 370  *
 371  * The blkno, crc, lsn, owner and uuid fields are only available in filesystems
 372  * with the crc feature bit, and all accesses to them must be conditional on
 373  * that flag.
 374  */
 375 struct xfs_btree_block {
 376         __be32          bb_magic;       /* magic number for block type */
 377         __be16          bb_level;       /* 0 is a leaf */
 378         __be16          bb_numrecs;     /* current # of data records */
 379         union {
 380                 struct {
 381                         __be32          bb_leftsib;
 382                         __be32          bb_rightsib;
 383
 384                         __be64          bb_blkno;
 385                         __be64          bb_lsn;
 386                         uuid_t          bb_uuid;
 387                         __be32          bb_owner;
 388                         __le32          bb_crc;
 389                 } s;                    /* short form pointers */
 390                 struct  {
 391                         __be64          bb_leftsib;
 392                         __be64          bb_rightsib;
 393
 394                         __be64          bb_blkno;
 395                         __be64          bb_lsn;
 396                         uuid_t          bb_uuid;
 397                         __be64          bb_owner;
 398                         __le32          bb_crc;
 399                         __be32          bb_pad; /* padding for alignment */
 400                 } l;                    /* long form pointers */
 401         } bb_u;                         /* rest */
 402 };
 403
 404 #define XFS_BTREE_SBLOCK_LEN    16      /* size of a short form block */
 405 #define XFS_BTREE_LBLOCK_LEN    24      /* size of a long form block */
 406
 407 /* sizes of CRC enabled btree blocks */
 408 #define XFS_BTREE_SBLOCK_CRC_LEN        (XFS_BTREE_SBLOCK_LEN + 40)
 409 #define XFS_BTREE_LBLOCK_CRC_LEN        (XFS_BTREE_LBLOCK_LEN + 48)
 410
 411 #define XFS_BTREE_SBLOCK_CRC_OFF \
 412         offsetof(struct xfs_btree_block, bb_u.s.bb_crc)
 413 #define XFS_BTREE_LBLOCK_CRC_OFF \
 414         offsetof(struct xfs_btree_block, bb_u.l.bb_crc)
 415
 416 #endif /* __XFS_FORMAT_H__ */