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 #define XFS_FIBT_MAGIC          0x46494254      /* 'FIBT' */
 206 #define XFS_FIBT_CRC_MAGIC      0x46494233      /* 'FIB3' */
 207
 208 typedef __uint64_t      xfs_inofree_t;
 209 #define XFS_INODES_PER_CHUNK            (NBBY * sizeof(xfs_inofree_t))
 210 #define XFS_INODES_PER_CHUNK_LOG        (XFS_NBBYLOG + 3)
 211 #define XFS_INOBT_ALL_FREE              ((xfs_inofree_t)-1)
 212 #define XFS_INOBT_MASK(i)               ((xfs_inofree_t)1 << (i))
 213
 214 static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
 215 {
 216         return ((n >= XFS_INODES_PER_CHUNK ? 0 : XFS_INOBT_MASK(n)) - 1) << i;
 217 }
 218
 219 /*
 220  * Data record structure
 221  */
 222 typedef struct xfs_inobt_rec {
 223         __be32          ir_startino;    /* starting inode number */
 224         __be32          ir_freecount;   /* count of free inodes (set bits) */
 225         __be64          ir_free;        /* free inode mask */
 226 } xfs_inobt_rec_t;
 227
 228 typedef struct xfs_inobt_rec_incore {
 229         xfs_agino_t     ir_startino;    /* starting inode number */
 230         __int32_t       ir_freecount;   /* count of free inodes (set bits) */
 231         xfs_inofree_t   ir_free;        /* free inode mask */
 232 } xfs_inobt_rec_incore_t;
 233
 234
 235 /*
 236  * Key structure
 237  */
 238 typedef struct xfs_inobt_key {
 239         __be32          ir_startino;    /* starting inode number */
 240 } xfs_inobt_key_t;
 241
 242 /* btree pointer type */
 243 typedef __be32 xfs_inobt_ptr_t;
 244
 245 /*
 246  * block numbers in the AG.
 247  */
 248 #define XFS_IBT_BLOCK(mp)               ((xfs_agblock_t)(XFS_CNT_BLOCK(mp) + 1))
 249 #define XFS_FIBT_BLOCK(mp)              ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
 250
 251 /*
 252  * The first data block of an AG depends on whether the filesystem was formatted
 253  * with the finobt feature. If so, account for the finobt reserved root btree
 254  * block.
 255  */
 256 #define XFS_PREALLOC_BLOCKS(mp) \
 257         (xfs_sb_version_hasfinobt(&((mp)->m_sb)) ? \
 258          XFS_FIBT_BLOCK(mp) + 1 : \
 259          XFS_IBT_BLOCK(mp) + 1)
 260
 261
 262
 263 /*
 264  * BMAP Btree format definitions
 265  *
 266  * This includes both the root block definition that sits inside an inode fork
 267  * and the record/pointer formats for the leaf/node in the blocks.
 268  */
 269 #define XFS_BMAP_MAGIC          0x424d4150      /* 'BMAP' */
 270 #define XFS_BMAP_CRC_MAGIC      0x424d4133      /* 'BMA3' */
 271
 272 /*
 273  * Bmap root header, on-disk form only.
 274  */
 275 typedef struct xfs_bmdr_block {
 276         __be16          bb_level;       /* 0 is a leaf */
 277         __be16          bb_numrecs;     /* current # of data records */
 278 } xfs_bmdr_block_t;
 279
 280 /*
 281  * Bmap btree record and extent descriptor.
 282  *  l0:63 is an extent flag (value 1 indicates non-normal).
 283  *  l0:9-62 are startoff.
 284  *  l0:0-8 and l1:21-63 are startblock.
 285  *  l1:0-20 are blockcount.
 286  */
 287 #define BMBT_EXNTFLAG_BITLEN    1
 288 #define BMBT_STARTOFF_BITLEN    54
 289 #define BMBT_STARTBLOCK_BITLEN  52
 290 #define BMBT_BLOCKCOUNT_BITLEN  21
 291
 292 typedef struct xfs_bmbt_rec {
 293         __be64                  l0, l1;
 294 } xfs_bmbt_rec_t;
 295
 296 typedef __uint64_t      xfs_bmbt_rec_base_t;    /* use this for casts */
 297 typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
 298
 299 typedef struct xfs_bmbt_rec_host {
 300         __uint64_t              l0, l1;
 301 } xfs_bmbt_rec_host_t;
 302
 303 /*
 304  * Values and macros for delayed-allocation startblock fields.
 305  */
 306 #define STARTBLOCKVALBITS       17
 307 #define STARTBLOCKMASKBITS      (15 + XFS_BIG_BLKNOS * 20)
 308 #define DSTARTBLOCKMASKBITS     (15 + 20)
 309 #define STARTBLOCKMASK          \
 310         (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 311 #define DSTARTBLOCKMASK         \
 312         (((((xfs_dfsbno_t)1) << DSTARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 313
 314 static inline int isnullstartblock(xfs_fsblock_t x)
 315 {
 316         return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
 317 }
 318
 319 static inline int isnulldstartblock(xfs_dfsbno_t x)
 320 {
 321         return ((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK;
 322 }
 323
 324 static inline xfs_fsblock_t nullstartblock(int k)
 325 {
 326         ASSERT(k < (1 << STARTBLOCKVALBITS));
 327         return STARTBLOCKMASK | (k);
 328 }
 329
 330 static inline xfs_filblks_t startblockval(xfs_fsblock_t x)
 331 {
 332         return (xfs_filblks_t)((x) & ~STARTBLOCKMASK);
 333 }
 334
 335 /*
 336  * Possible extent formats.
 337  */
 338 typedef enum {
 339         XFS_EXTFMT_NOSTATE = 0,
 340         XFS_EXTFMT_HASSTATE
 341 } xfs_exntfmt_t;
 342
 343 /*
 344  * Possible extent states.
 345  */
 346 typedef enum {
 347         XFS_EXT_NORM, XFS_EXT_UNWRITTEN,
 348         XFS_EXT_DMAPI_OFFLINE, XFS_EXT_INVALID
 349 } xfs_exntst_t;
 350
 351 /*
 352  * Incore version of above.
 353  */
 354 typedef struct xfs_bmbt_irec
 355 {
 356         xfs_fileoff_t   br_startoff;    /* starting file offset */
 357         xfs_fsblock_t   br_startblock;  /* starting block number */
 358         xfs_filblks_t   br_blockcount;  /* number of blocks */
 359         xfs_exntst_t    br_state;       /* extent state */
 360 } xfs_bmbt_irec_t;
 361
 362 /*
 363  * Key structure for non-leaf levels of the tree.
 364  */
 365 typedef struct xfs_bmbt_key {
 366         __be64          br_startoff;    /* starting file offset */
 367 } xfs_bmbt_key_t, xfs_bmdr_key_t;
 368
 369 /* btree pointer type */
 370 typedef __be64 xfs_bmbt_ptr_t, xfs_bmdr_ptr_t;
 371
 372
 373 /*
 374  * Generic Btree block format definitions
 375  *
 376  * This is a combination of the actual format used on disk for short and long
 377  * format btrees.  The first three fields are shared by both format, but the
 378  * pointers are different and should be used with care.
 379  *
 380  * To get the size of the actual short or long form headers please use the size
 381  * macros below.  Never use sizeof(xfs_btree_block).
 382  *
 383  * The blkno, crc, lsn, owner and uuid fields are only available in filesystems
 384  * with the crc feature bit, and all accesses to them must be conditional on
 385  * that flag.
 386  */
 387 struct xfs_btree_block {
 388         __be32          bb_magic;       /* magic number for block type */
 389         __be16          bb_level;       /* 0 is a leaf */
 390         __be16          bb_numrecs;     /* current # of data records */
 391         union {
 392                 struct {
 393                         __be32          bb_leftsib;
 394                         __be32          bb_rightsib;
 395
 396                         __be64          bb_blkno;
 397                         __be64          bb_lsn;
 398                         uuid_t          bb_uuid;
 399                         __be32          bb_owner;
 400                         __le32          bb_crc;
 401                 } s;                    /* short form pointers */
 402                 struct  {
 403                         __be64          bb_leftsib;
 404                         __be64          bb_rightsib;
 405
 406                         __be64          bb_blkno;
 407                         __be64          bb_lsn;
 408                         uuid_t          bb_uuid;
 409                         __be64          bb_owner;
 410                         __le32          bb_crc;
 411                         __be32          bb_pad; /* padding for alignment */
 412                 } l;                    /* long form pointers */
 413         } bb_u;                         /* rest */
 414 };
 415
 416 #define XFS_BTREE_SBLOCK_LEN    16      /* size of a short form block */
 417 #define XFS_BTREE_LBLOCK_LEN    24      /* size of a long form block */
 418
 419 /* sizes of CRC enabled btree blocks */
 420 #define XFS_BTREE_SBLOCK_CRC_LEN        (XFS_BTREE_SBLOCK_LEN + 40)
 421 #define XFS_BTREE_LBLOCK_CRC_LEN        (XFS_BTREE_LBLOCK_LEN + 48)
 422
 423 #define XFS_BTREE_SBLOCK_CRC_OFF \
 424         offsetof(struct xfs_btree_block, bb_u.s.bb_crc)
 425 #define XFS_BTREE_LBLOCK_CRC_OFF \
 426         offsetof(struct xfs_btree_block, bb_u.l.bb_crc)
 427
 428 #endif /* __XFS_FORMAT_H__ */