fs/xfs/libxfs/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 #define XFS_RTBLOCKLOG(b)       xfs_highbit64(b)
  72
  73 /*
  74  * Dquot and dquot block format definitions
  75  */
  76 #define XFS_DQUOT_MAGIC         0x4451          /* 'DQ' */
  77 #define XFS_DQUOT_VERSION       (u_int8_t)0x01  /* latest version number */
  78
  79 /*
  80  * This is the main portion of the on-disk representation of quota
  81  * information for a user. This is the q_core of the xfs_dquot_t that
  82  * is kept in kernel memory. We pad this with some more expansion room
  83  * to construct the on disk structure.
  84  */
  85 typedef struct  xfs_disk_dquot {
  86         __be16          d_magic;        /* dquot magic = XFS_DQUOT_MAGIC */
  87         __u8            d_version;      /* dquot version */
  88         __u8            d_flags;        /* XFS_DQ_USER/PROJ/GROUP */
  89         __be32          d_id;           /* user,project,group id */
  90         __be64          d_blk_hardlimit;/* absolute limit on disk blks */
  91         __be64          d_blk_softlimit;/* preferred limit on disk blks */
  92         __be64          d_ino_hardlimit;/* maximum # allocated inodes */
  93         __be64          d_ino_softlimit;/* preferred inode limit */
  94         __be64          d_bcount;       /* disk blocks owned by the user */
  95         __be64          d_icount;       /* inodes owned by the user */
  96         __be32          d_itimer;       /* zero if within inode limits if not,
  97                                            this is when we refuse service */
  98         __be32          d_btimer;       /* similar to above; for disk blocks */
  99         __be16          d_iwarns;       /* warnings issued wrt num inodes */
 100         __be16          d_bwarns;       /* warnings issued wrt disk blocks */
 101         __be32          d_pad0;         /* 64 bit align */
 102         __be64          d_rtb_hardlimit;/* absolute limit on realtime blks */
 103         __be64          d_rtb_softlimit;/* preferred limit on RT disk blks */
 104         __be64          d_rtbcount;     /* realtime blocks owned */
 105         __be32          d_rtbtimer;     /* similar to above; for RT disk blocks */
 106         __be16          d_rtbwarns;     /* warnings issued wrt RT disk blocks */
 107         __be16          d_pad;
 108 } xfs_disk_dquot_t;
 109
 110 /*
 111  * This is what goes on disk. This is separated from the xfs_disk_dquot because
 112  * carrying the unnecessary padding would be a waste of memory.
 113  */
 114 typedef struct xfs_dqblk {
 115         xfs_disk_dquot_t  dd_diskdq;    /* portion that lives incore as well */
 116         char              dd_fill[4];   /* filling for posterity */
 117
 118         /*
 119          * These two are only present on filesystems with the CRC bits set.
 120          */
 121         __be32            dd_crc;       /* checksum */
 122         __be64            dd_lsn;       /* last modification in log */
 123         uuid_t            dd_uuid;      /* location information */
 124 } xfs_dqblk_t;
 125
 126 #define XFS_DQUOT_CRC_OFF       offsetof(struct xfs_dqblk, dd_crc)
 127
 128 /*
 129  * Remote symlink format and access functions.
 130  */
 131 #define XFS_SYMLINK_MAGIC       0x58534c4d      /* XSLM */
 132
 133 struct xfs_dsymlink_hdr {
 134         __be32  sl_magic;
 135         __be32  sl_offset;
 136         __be32  sl_bytes;
 137         __be32  sl_crc;
 138         uuid_t  sl_uuid;
 139         __be64  sl_owner;
 140         __be64  sl_blkno;
 141         __be64  sl_lsn;
 142 };
 143
 144 #define XFS_SYMLINK_CRC_OFF     offsetof(struct xfs_dsymlink_hdr, sl_crc)
 145
 146 /*
 147  * The maximum pathlen is 1024 bytes. Since the minimum file system
 148  * blocksize is 512 bytes, we can get a max of 3 extents back from
 149  * bmapi when crc headers are taken into account.
 150  */
 151 #define XFS_SYMLINK_MAPS 3
 152
 153 #define XFS_SYMLINK_BUF_SPACE(mp, bufsize)      \
 154         ((bufsize) - (xfs_sb_version_hascrc(&(mp)->m_sb) ? \
 155                         sizeof(struct xfs_dsymlink_hdr) : 0))
 156
 157
 158 /*
 159  * Allocation Btree format definitions
 160  *
 161  * There are two on-disk btrees, one sorted by blockno and one sorted
 162  * by blockcount and blockno.  All blocks look the same to make the code
 163  * simpler; if we have time later, we'll make the optimizations.
 164  */
 165 #define XFS_ABTB_MAGIC          0x41425442      /* 'ABTB' for bno tree */
 166 #define XFS_ABTB_CRC_MAGIC      0x41423342      /* 'AB3B' */
 167 #define XFS_ABTC_MAGIC          0x41425443      /* 'ABTC' for cnt tree */
 168 #define XFS_ABTC_CRC_MAGIC      0x41423343      /* 'AB3C' */
 169
 170 /*
 171  * Data record/key structure
 172  */
 173 typedef struct xfs_alloc_rec {
 174         __be32          ar_startblock;  /* starting block number */
 175         __be32          ar_blockcount;  /* count of free blocks */
 176 } xfs_alloc_rec_t, xfs_alloc_key_t;
 177
 178 typedef struct xfs_alloc_rec_incore {
 179         xfs_agblock_t   ar_startblock;  /* starting block number */
 180         xfs_extlen_t    ar_blockcount;  /* count of free blocks */
 181 } xfs_alloc_rec_incore_t;
 182
 183 /* btree pointer type */
 184 typedef __be32 xfs_alloc_ptr_t;
 185
 186 /*
 187  * Block numbers in the AG:
 188  * SB is sector 0, AGF is sector 1, AGI is sector 2, AGFL is sector 3.
 189  */
 190 #define XFS_BNO_BLOCK(mp)       ((xfs_agblock_t)(XFS_AGFL_BLOCK(mp) + 1))
 191 #define XFS_CNT_BLOCK(mp)       ((xfs_agblock_t)(XFS_BNO_BLOCK(mp) + 1))
 192
 193
 194 /*
 195  * Inode Allocation Btree format definitions
 196  *
 197  * There is a btree for the inode map per allocation group.
 198  */
 199 #define XFS_IBT_MAGIC           0x49414254      /* 'IABT' */
 200 #define XFS_IBT_CRC_MAGIC       0x49414233      /* 'IAB3' */
 201 #define XFS_FIBT_MAGIC          0x46494254      /* 'FIBT' */
 202 #define XFS_FIBT_CRC_MAGIC      0x46494233      /* 'FIB3' */
 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_FIBT_BLOCK(mp)              ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
 246
 247 /*
 248  * The first data block of an AG depends on whether the filesystem was formatted
 249  * with the finobt feature. If so, account for the finobt reserved root btree
 250  * block.
 251  */
 252 #define XFS_PREALLOC_BLOCKS(mp) \
 253         (xfs_sb_version_hasfinobt(&((mp)->m_sb)) ? \
 254          XFS_FIBT_BLOCK(mp) + 1 : \
 255          XFS_IBT_BLOCK(mp) + 1)
 256
 257
 258
 259 /*
 260  * BMAP Btree format definitions
 261  *
 262  * This includes both the root block definition that sits inside an inode fork
 263  * and the record/pointer formats for the leaf/node in the blocks.
 264  */
 265 #define XFS_BMAP_MAGIC          0x424d4150      /* 'BMAP' */
 266 #define XFS_BMAP_CRC_MAGIC      0x424d4133      /* 'BMA3' */
 267
 268 /*
 269  * Bmap root header, on-disk form only.
 270  */
 271 typedef struct xfs_bmdr_block {
 272         __be16          bb_level;       /* 0 is a leaf */
 273         __be16          bb_numrecs;     /* current # of data records */
 274 } xfs_bmdr_block_t;
 275
 276 /*
 277  * Bmap btree record and extent descriptor.
 278  *  l0:63 is an extent flag (value 1 indicates non-normal).
 279  *  l0:9-62 are startoff.
 280  *  l0:0-8 and l1:21-63 are startblock.
 281  *  l1:0-20 are blockcount.
 282  */
 283 #define BMBT_EXNTFLAG_BITLEN    1
 284 #define BMBT_STARTOFF_BITLEN    54
 285 #define BMBT_STARTBLOCK_BITLEN  52
 286 #define BMBT_BLOCKCOUNT_BITLEN  21
 287
 288 typedef struct xfs_bmbt_rec {
 289         __be64                  l0, l1;
 290 } xfs_bmbt_rec_t;
 291
 292 typedef __uint64_t      xfs_bmbt_rec_base_t;    /* use this for casts */
 293 typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
 294
 295 typedef struct xfs_bmbt_rec_host {
 296         __uint64_t              l0, l1;
 297 } xfs_bmbt_rec_host_t;
 298
 299 /*
 300  * Values and macros for delayed-allocation startblock fields.
 301  */
 302 #define STARTBLOCKVALBITS       17
 303 #define STARTBLOCKMASKBITS      (15 + 20)
 304 #define STARTBLOCKMASK          \
 305         (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 306
 307 static inline int isnullstartblock(xfs_fsblock_t x)
 308 {
 309         return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
 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__ */