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 /*
 149  * The maximum pathlen is 1024 bytes. Since the minimum file system
 150  * blocksize is 512 bytes, we can get a max of 3 extents back from
 151  * bmapi when crc headers are taken into account.
 152  */
 153 #define XFS_SYMLINK_MAPS 3
 154
 155 #define XFS_SYMLINK_BUF_SPACE(mp, bufsize)      \
 156         ((bufsize) - (xfs_sb_version_hascrc(&(mp)->m_sb) ? \
 157                         sizeof(struct xfs_dsymlink_hdr) : 0))
 158
 159
 160 /*
 161  * Allocation Btree format definitions
 162  *
 163  * There are two on-disk btrees, one sorted by blockno and one sorted
 164  * by blockcount and blockno.  All blocks look the same to make the code
 165  * simpler; if we have time later, we'll make the optimizations.
 166  */
 167 #define XFS_ABTB_MAGIC          0x41425442      /* 'ABTB' for bno tree */
 168 #define XFS_ABTB_CRC_MAGIC      0x41423342      /* 'AB3B' */
 169 #define XFS_ABTC_MAGIC          0x41425443      /* 'ABTC' for cnt tree */
 170 #define XFS_ABTC_CRC_MAGIC      0x41423343      /* 'AB3C' */
 171
 172 /*
 173  * Data record/key structure
 174  */
 175 typedef struct xfs_alloc_rec {
 176         __be32          ar_startblock;  /* starting block number */
 177         __be32          ar_blockcount;  /* count of free blocks */
 178 } xfs_alloc_rec_t, xfs_alloc_key_t;
 179
 180 typedef struct xfs_alloc_rec_incore {
 181         xfs_agblock_t   ar_startblock;  /* starting block number */
 182         xfs_extlen_t    ar_blockcount;  /* count of free blocks */
 183 } xfs_alloc_rec_incore_t;
 184
 185 /* btree pointer type */
 186 typedef __be32 xfs_alloc_ptr_t;
 187
 188 /*
 189  * Block numbers in the AG:
 190  * SB is sector 0, AGF is sector 1, AGI is sector 2, AGFL is sector 3.
 191  */
 192 #define XFS_BNO_BLOCK(mp)       ((xfs_agblock_t)(XFS_AGFL_BLOCK(mp) + 1))
 193 #define XFS_CNT_BLOCK(mp)       ((xfs_agblock_t)(XFS_BNO_BLOCK(mp) + 1))
 194
 195
 196 /*
 197  * Inode Allocation Btree format definitions
 198  *
 199  * There is a btree for the inode map per allocation group.
 200  */
 201 #define XFS_IBT_MAGIC           0x49414254      /* 'IABT' */
 202 #define XFS_IBT_CRC_MAGIC       0x49414233      /* 'IAB3' */
 203
 204 typedef __uint64_t      xfs_inofree_t;
 205 #define XFS_INODES_PER_CHUNK            (NBBY * sizeof(xfs_inofree_t))
 206 #define XFS_INODES_PER_CHUNK_LOG        (XFS_NBBYLOG + 3)
 207 #define XFS_INOBT_ALL_FREE              ((xfs_inofree_t)-1)
 208 #define XFS_INOBT_MASK(i)               ((xfs_inofree_t)1 << (i))
 209
 210 static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
 211 {
 212         return ((n >= XFS_INODES_PER_CHUNK ? 0 : XFS_INOBT_MASK(n)) - 1) << i;
 213 }
 214
 215 /*
 216  * Data record structure
 217  */
 218 typedef struct xfs_inobt_rec {
 219         __be32          ir_startino;    /* starting inode number */
 220         __be32          ir_freecount;   /* count of free inodes (set bits) */
 221         __be64          ir_free;        /* free inode mask */
 222 } xfs_inobt_rec_t;
 223
 224 typedef struct xfs_inobt_rec_incore {
 225         xfs_agino_t     ir_startino;    /* starting inode number */
 226         __int32_t       ir_freecount;   /* count of free inodes (set bits) */
 227         xfs_inofree_t   ir_free;        /* free inode mask */
 228 } xfs_inobt_rec_incore_t;
 229
 230
 231 /*
 232  * Key structure
 233  */
 234 typedef struct xfs_inobt_key {
 235         __be32          ir_startino;    /* starting inode number */
 236 } xfs_inobt_key_t;
 237
 238 /* btree pointer type */
 239 typedef __be32 xfs_inobt_ptr_t;
 240
 241 /*
 242  * block numbers in the AG.
 243  */
 244 #define XFS_IBT_BLOCK(mp)               ((xfs_agblock_t)(XFS_CNT_BLOCK(mp) + 1))
 245 #define XFS_PREALLOC_BLOCKS(mp)         ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
 246
 247
 248
 249 /*
 250  * BMAP Btree format definitions
 251  *
 252  * This includes both the root block definition that sits inside an inode fork
 253  * and the record/pointer formats for the leaf/node in the blocks.
 254  */
 255 #define XFS_BMAP_MAGIC          0x424d4150      /* 'BMAP' */
 256 #define XFS_BMAP_CRC_MAGIC      0x424d4133      /* 'BMA3' */
 257
 258 /*
 259  * Bmap root header, on-disk form only.
 260  */
 261 typedef struct xfs_bmdr_block {
 262         __be16          bb_level;       /* 0 is a leaf */
 263         __be16          bb_numrecs;     /* current # of data records */
 264 } xfs_bmdr_block_t;
 265
 266 /*
 267  * Bmap btree record and extent descriptor.
 268  *  l0:63 is an extent flag (value 1 indicates non-normal).
 269  *  l0:9-62 are startoff.
 270  *  l0:0-8 and l1:21-63 are startblock.
 271  *  l1:0-20 are blockcount.
 272  */
 273 #define BMBT_EXNTFLAG_BITLEN    1
 274 #define BMBT_STARTOFF_BITLEN    54
 275 #define BMBT_STARTBLOCK_BITLEN  52
 276 #define BMBT_BLOCKCOUNT_BITLEN  21
 277
 278 typedef struct xfs_bmbt_rec {
 279         __be64                  l0, l1;
 280 } xfs_bmbt_rec_t;
 281
 282 typedef __uint64_t      xfs_bmbt_rec_base_t;    /* use this for casts */
 283 typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
 284
 285 typedef struct xfs_bmbt_rec_host {
 286         __uint64_t              l0, l1;
 287 } xfs_bmbt_rec_host_t;
 288
 289 /*
 290  * Values and macros for delayed-allocation startblock fields.
 291  */
 292 #define STARTBLOCKVALBITS       17
 293 #define STARTBLOCKMASKBITS      (15 + XFS_BIG_BLKNOS * 20)
 294 #define DSTARTBLOCKMASKBITS     (15 + 20)
 295 #define STARTBLOCKMASK          \
 296         (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 297 #define DSTARTBLOCKMASK         \
 298         (((((xfs_dfsbno_t)1) << DSTARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 299
 300 static inline int isnullstartblock(xfs_fsblock_t x)
 301 {
 302         return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
 303 }
 304
 305 static inline int isnulldstartblock(xfs_dfsbno_t x)
 306 {
 307         return ((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK;
 308 }
 309
 310 static inline xfs_fsblock_t nullstartblock(int k)
 311 {
 312         ASSERT(k < (1 << STARTBLOCKVALBITS));
 313         return STARTBLOCKMASK | (k);
 314 }
 315
 316 static inline xfs_filblks_t startblockval(xfs_fsblock_t x)
 317 {
 318         return (xfs_filblks_t)((x) & ~STARTBLOCKMASK);
 319 }
 320
 321 /*
 322  * Possible extent formats.
 323  */
 324 typedef enum {
 325         XFS_EXTFMT_NOSTATE = 0,
 326         XFS_EXTFMT_HASSTATE
 327 } xfs_exntfmt_t;
 328
 329 /*
 330  * Possible extent states.
 331  */
 332 typedef enum {
 333         XFS_EXT_NORM, XFS_EXT_UNWRITTEN,
 334         XFS_EXT_DMAPI_OFFLINE, XFS_EXT_INVALID
 335 } xfs_exntst_t;
 336
 337 /*
 338  * Incore version of above.
 339  */
 340 typedef struct xfs_bmbt_irec
 341 {
 342         xfs_fileoff_t   br_startoff;    /* starting file offset */
 343         xfs_fsblock_t   br_startblock;  /* starting block number */
 344         xfs_filblks_t   br_blockcount;  /* number of blocks */
 345         xfs_exntst_t    br_state;       /* extent state */
 346 } xfs_bmbt_irec_t;
 347
 348 /*
 349  * Key structure for non-leaf levels of the tree.
 350  */
 351 typedef struct xfs_bmbt_key {
 352         __be64          br_startoff;    /* starting file offset */
 353 } xfs_bmbt_key_t, xfs_bmdr_key_t;
 354
 355 /* btree pointer type */
 356 typedef __be64 xfs_bmbt_ptr_t, xfs_bmdr_ptr_t;
 357
 358
 359 /*
 360  * Generic Btree block format definitions
 361  *
 362  * This is a combination of the actual format used on disk for short and long
 363  * format btrees.  The first three fields are shared by both format, but the
 364  * pointers are different and should be used with care.
 365  *
 366  * To get the size of the actual short or long form headers please use the size
 367  * macros below.  Never use sizeof(xfs_btree_block).
 368  *
 369  * The blkno, crc, lsn, owner and uuid fields are only available in filesystems
 370  * with the crc feature bit, and all accesses to them must be conditional on
 371  * that flag.
 372  */
 373 struct xfs_btree_block {
 374         __be32          bb_magic;       /* magic number for block type */
 375         __be16          bb_level;       /* 0 is a leaf */
 376         __be16          bb_numrecs;     /* current # of data records */
 377         union {
 378                 struct {
 379                         __be32          bb_leftsib;
 380                         __be32          bb_rightsib;
 381
 382                         __be64          bb_blkno;
 383                         __be64          bb_lsn;
 384                         uuid_t          bb_uuid;
 385                         __be32          bb_owner;
 386                         __le32          bb_crc;
 387                 } s;                    /* short form pointers */
 388                 struct  {
 389                         __be64          bb_leftsib;
 390                         __be64          bb_rightsib;
 391
 392                         __be64          bb_blkno;
 393                         __be64          bb_lsn;
 394                         uuid_t          bb_uuid;
 395                         __be64          bb_owner;
 396                         __le32          bb_crc;
 397                         __be32          bb_pad; /* padding for alignment */
 398                 } l;                    /* long form pointers */
 399         } bb_u;                         /* rest */
 400 };
 401
 402 #define XFS_BTREE_SBLOCK_LEN    16      /* size of a short form block */
 403 #define XFS_BTREE_LBLOCK_LEN    24      /* size of a long form block */
 404
 405 /* sizes of CRC enabled btree blocks */
 406 #define XFS_BTREE_SBLOCK_CRC_LEN        (XFS_BTREE_SBLOCK_LEN + 40)
 407 #define XFS_BTREE_LBLOCK_CRC_LEN        (XFS_BTREE_LBLOCK_LEN + 48)
 408
 409 #define XFS_BTREE_SBLOCK_CRC_OFF \
 410         offsetof(struct xfs_btree_block, bb_u.s.bb_crc)
 411 #define XFS_BTREE_LBLOCK_CRC_OFF \
 412         offsetof(struct xfs_btree_block, bb_u.l.bb_crc)
 413
 414 #endif /* __XFS_FORMAT_H__ */