429 lines
12 KiB
C
429 lines
12 KiB
C
/*
|
|
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
|
|
* All Rights Reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it would be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
#ifndef __XFS_FORMAT_H__
|
|
#define __XFS_FORMAT_H__
|
|
|
|
/*
|
|
* XFS On Disk Format Definitions
|
|
*
|
|
* This header file defines all the on-disk format definitions for
|
|
* general XFS objects. Directory and attribute related objects are defined in
|
|
* xfs_da_format.h, which log and log item formats are defined in
|
|
* xfs_log_format.h. Everything else goes here.
|
|
*/
|
|
|
|
struct xfs_mount;
|
|
struct xfs_trans;
|
|
struct xfs_inode;
|
|
struct xfs_buf;
|
|
struct xfs_ifork;
|
|
|
|
/*
|
|
* RealTime Device format definitions
|
|
*/
|
|
|
|
/* Min and max rt extent sizes, specified in bytes */
|
|
#define XFS_MAX_RTEXTSIZE (1024 * 1024 * 1024) /* 1GB */
|
|
#define XFS_DFL_RTEXTSIZE (64 * 1024) /* 64kB */
|
|
#define XFS_MIN_RTEXTSIZE (4 * 1024) /* 4kB */
|
|
|
|
#define XFS_BLOCKSIZE(mp) ((mp)->m_sb.sb_blocksize)
|
|
#define XFS_BLOCKMASK(mp) ((mp)->m_blockmask)
|
|
#define XFS_BLOCKWSIZE(mp) ((mp)->m_blockwsize)
|
|
#define XFS_BLOCKWMASK(mp) ((mp)->m_blockwmask)
|
|
|
|
/*
|
|
* RT Summary and bit manipulation macros.
|
|
*/
|
|
#define XFS_SUMOFFS(mp,ls,bb) ((int)((ls) * (mp)->m_sb.sb_rbmblocks + (bb)))
|
|
#define XFS_SUMOFFSTOBLOCK(mp,s) \
|
|
(((s) * (uint)sizeof(xfs_suminfo_t)) >> (mp)->m_sb.sb_blocklog)
|
|
#define XFS_SUMPTR(mp,bp,so) \
|
|
((xfs_suminfo_t *)((bp)->b_addr + \
|
|
(((so) * (uint)sizeof(xfs_suminfo_t)) & XFS_BLOCKMASK(mp))))
|
|
|
|
#define XFS_BITTOBLOCK(mp,bi) ((bi) >> (mp)->m_blkbit_log)
|
|
#define XFS_BLOCKTOBIT(mp,bb) ((bb) << (mp)->m_blkbit_log)
|
|
#define XFS_BITTOWORD(mp,bi) \
|
|
((int)(((bi) >> XFS_NBWORDLOG) & XFS_BLOCKWMASK(mp)))
|
|
|
|
#define XFS_RTMIN(a,b) ((a) < (b) ? (a) : (b))
|
|
#define XFS_RTMAX(a,b) ((a) > (b) ? (a) : (b))
|
|
|
|
#define XFS_RTLOBIT(w) xfs_lowbit32(w)
|
|
#define XFS_RTHIBIT(w) xfs_highbit32(w)
|
|
|
|
#if XFS_BIG_BLKNOS
|
|
#define XFS_RTBLOCKLOG(b) xfs_highbit64(b)
|
|
#else
|
|
#define XFS_RTBLOCKLOG(b) xfs_highbit32(b)
|
|
#endif
|
|
|
|
/*
|
|
* Dquot and dquot block format definitions
|
|
*/
|
|
#define XFS_DQUOT_MAGIC 0x4451 /* 'DQ' */
|
|
#define XFS_DQUOT_VERSION (u_int8_t)0x01 /* latest version number */
|
|
|
|
/*
|
|
* This is the main portion of the on-disk representation of quota
|
|
* information for a user. This is the q_core of the xfs_dquot_t that
|
|
* is kept in kernel memory. We pad this with some more expansion room
|
|
* to construct the on disk structure.
|
|
*/
|
|
typedef struct xfs_disk_dquot {
|
|
__be16 d_magic; /* dquot magic = XFS_DQUOT_MAGIC */
|
|
__u8 d_version; /* dquot version */
|
|
__u8 d_flags; /* XFS_DQ_USER/PROJ/GROUP */
|
|
__be32 d_id; /* user,project,group id */
|
|
__be64 d_blk_hardlimit;/* absolute limit on disk blks */
|
|
__be64 d_blk_softlimit;/* preferred limit on disk blks */
|
|
__be64 d_ino_hardlimit;/* maximum # allocated inodes */
|
|
__be64 d_ino_softlimit;/* preferred inode limit */
|
|
__be64 d_bcount; /* disk blocks owned by the user */
|
|
__be64 d_icount; /* inodes owned by the user */
|
|
__be32 d_itimer; /* zero if within inode limits if not,
|
|
this is when we refuse service */
|
|
__be32 d_btimer; /* similar to above; for disk blocks */
|
|
__be16 d_iwarns; /* warnings issued wrt num inodes */
|
|
__be16 d_bwarns; /* warnings issued wrt disk blocks */
|
|
__be32 d_pad0; /* 64 bit align */
|
|
__be64 d_rtb_hardlimit;/* absolute limit on realtime blks */
|
|
__be64 d_rtb_softlimit;/* preferred limit on RT disk blks */
|
|
__be64 d_rtbcount; /* realtime blocks owned */
|
|
__be32 d_rtbtimer; /* similar to above; for RT disk blocks */
|
|
__be16 d_rtbwarns; /* warnings issued wrt RT disk blocks */
|
|
__be16 d_pad;
|
|
} xfs_disk_dquot_t;
|
|
|
|
/*
|
|
* This is what goes on disk. This is separated from the xfs_disk_dquot because
|
|
* carrying the unnecessary padding would be a waste of memory.
|
|
*/
|
|
typedef struct xfs_dqblk {
|
|
xfs_disk_dquot_t dd_diskdq; /* portion that lives incore as well */
|
|
char dd_fill[4]; /* filling for posterity */
|
|
|
|
/*
|
|
* These two are only present on filesystems with the CRC bits set.
|
|
*/
|
|
__be32 dd_crc; /* checksum */
|
|
__be64 dd_lsn; /* last modification in log */
|
|
uuid_t dd_uuid; /* location information */
|
|
} xfs_dqblk_t;
|
|
|
|
#define XFS_DQUOT_CRC_OFF offsetof(struct xfs_dqblk, dd_crc)
|
|
|
|
/*
|
|
* Remote symlink format and access functions.
|
|
*/
|
|
#define XFS_SYMLINK_MAGIC 0x58534c4d /* XSLM */
|
|
|
|
struct xfs_dsymlink_hdr {
|
|
__be32 sl_magic;
|
|
__be32 sl_offset;
|
|
__be32 sl_bytes;
|
|
__be32 sl_crc;
|
|
uuid_t sl_uuid;
|
|
__be64 sl_owner;
|
|
__be64 sl_blkno;
|
|
__be64 sl_lsn;
|
|
};
|
|
|
|
#define XFS_SYMLINK_CRC_OFF offsetof(struct xfs_dsymlink_hdr, sl_crc)
|
|
|
|
/*
|
|
* The maximum pathlen is 1024 bytes. Since the minimum file system
|
|
* blocksize is 512 bytes, we can get a max of 3 extents back from
|
|
* bmapi when crc headers are taken into account.
|
|
*/
|
|
#define XFS_SYMLINK_MAPS 3
|
|
|
|
#define XFS_SYMLINK_BUF_SPACE(mp, bufsize) \
|
|
((bufsize) - (xfs_sb_version_hascrc(&(mp)->m_sb) ? \
|
|
sizeof(struct xfs_dsymlink_hdr) : 0))
|
|
|
|
|
|
/*
|
|
* Allocation Btree format definitions
|
|
*
|
|
* There are two on-disk btrees, one sorted by blockno and one sorted
|
|
* by blockcount and blockno. All blocks look the same to make the code
|
|
* simpler; if we have time later, we'll make the optimizations.
|
|
*/
|
|
#define XFS_ABTB_MAGIC 0x41425442 /* 'ABTB' for bno tree */
|
|
#define XFS_ABTB_CRC_MAGIC 0x41423342 /* 'AB3B' */
|
|
#define XFS_ABTC_MAGIC 0x41425443 /* 'ABTC' for cnt tree */
|
|
#define XFS_ABTC_CRC_MAGIC 0x41423343 /* 'AB3C' */
|
|
|
|
/*
|
|
* Data record/key structure
|
|
*/
|
|
typedef struct xfs_alloc_rec {
|
|
__be32 ar_startblock; /* starting block number */
|
|
__be32 ar_blockcount; /* count of free blocks */
|
|
} xfs_alloc_rec_t, xfs_alloc_key_t;
|
|
|
|
typedef struct xfs_alloc_rec_incore {
|
|
xfs_agblock_t ar_startblock; /* starting block number */
|
|
xfs_extlen_t ar_blockcount; /* count of free blocks */
|
|
} xfs_alloc_rec_incore_t;
|
|
|
|
/* btree pointer type */
|
|
typedef __be32 xfs_alloc_ptr_t;
|
|
|
|
/*
|
|
* Block numbers in the AG:
|
|
* SB is sector 0, AGF is sector 1, AGI is sector 2, AGFL is sector 3.
|
|
*/
|
|
#define XFS_BNO_BLOCK(mp) ((xfs_agblock_t)(XFS_AGFL_BLOCK(mp) + 1))
|
|
#define XFS_CNT_BLOCK(mp) ((xfs_agblock_t)(XFS_BNO_BLOCK(mp) + 1))
|
|
|
|
|
|
/*
|
|
* Inode Allocation Btree format definitions
|
|
*
|
|
* There is a btree for the inode map per allocation group.
|
|
*/
|
|
#define XFS_IBT_MAGIC 0x49414254 /* 'IABT' */
|
|
#define XFS_IBT_CRC_MAGIC 0x49414233 /* 'IAB3' */
|
|
#define XFS_FIBT_MAGIC 0x46494254 /* 'FIBT' */
|
|
#define XFS_FIBT_CRC_MAGIC 0x46494233 /* 'FIB3' */
|
|
|
|
typedef __uint64_t xfs_inofree_t;
|
|
#define XFS_INODES_PER_CHUNK (NBBY * sizeof(xfs_inofree_t))
|
|
#define XFS_INODES_PER_CHUNK_LOG (XFS_NBBYLOG + 3)
|
|
#define XFS_INOBT_ALL_FREE ((xfs_inofree_t)-1)
|
|
#define XFS_INOBT_MASK(i) ((xfs_inofree_t)1 << (i))
|
|
|
|
static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
|
|
{
|
|
return ((n >= XFS_INODES_PER_CHUNK ? 0 : XFS_INOBT_MASK(n)) - 1) << i;
|
|
}
|
|
|
|
/*
|
|
* Data record structure
|
|
*/
|
|
typedef struct xfs_inobt_rec {
|
|
__be32 ir_startino; /* starting inode number */
|
|
__be32 ir_freecount; /* count of free inodes (set bits) */
|
|
__be64 ir_free; /* free inode mask */
|
|
} xfs_inobt_rec_t;
|
|
|
|
typedef struct xfs_inobt_rec_incore {
|
|
xfs_agino_t ir_startino; /* starting inode number */
|
|
__int32_t ir_freecount; /* count of free inodes (set bits) */
|
|
xfs_inofree_t ir_free; /* free inode mask */
|
|
} xfs_inobt_rec_incore_t;
|
|
|
|
|
|
/*
|
|
* Key structure
|
|
*/
|
|
typedef struct xfs_inobt_key {
|
|
__be32 ir_startino; /* starting inode number */
|
|
} xfs_inobt_key_t;
|
|
|
|
/* btree pointer type */
|
|
typedef __be32 xfs_inobt_ptr_t;
|
|
|
|
/*
|
|
* block numbers in the AG.
|
|
*/
|
|
#define XFS_IBT_BLOCK(mp) ((xfs_agblock_t)(XFS_CNT_BLOCK(mp) + 1))
|
|
#define XFS_FIBT_BLOCK(mp) ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
|
|
|
|
/*
|
|
* The first data block of an AG depends on whether the filesystem was formatted
|
|
* with the finobt feature. If so, account for the finobt reserved root btree
|
|
* block.
|
|
*/
|
|
#define XFS_PREALLOC_BLOCKS(mp) \
|
|
(xfs_sb_version_hasfinobt(&((mp)->m_sb)) ? \
|
|
XFS_FIBT_BLOCK(mp) + 1 : \
|
|
XFS_IBT_BLOCK(mp) + 1)
|
|
|
|
|
|
|
|
/*
|
|
* BMAP Btree format definitions
|
|
*
|
|
* This includes both the root block definition that sits inside an inode fork
|
|
* and the record/pointer formats for the leaf/node in the blocks.
|
|
*/
|
|
#define XFS_BMAP_MAGIC 0x424d4150 /* 'BMAP' */
|
|
#define XFS_BMAP_CRC_MAGIC 0x424d4133 /* 'BMA3' */
|
|
|
|
/*
|
|
* Bmap root header, on-disk form only.
|
|
*/
|
|
typedef struct xfs_bmdr_block {
|
|
__be16 bb_level; /* 0 is a leaf */
|
|
__be16 bb_numrecs; /* current # of data records */
|
|
} xfs_bmdr_block_t;
|
|
|
|
/*
|
|
* Bmap btree record and extent descriptor.
|
|
* l0:63 is an extent flag (value 1 indicates non-normal).
|
|
* l0:9-62 are startoff.
|
|
* l0:0-8 and l1:21-63 are startblock.
|
|
* l1:0-20 are blockcount.
|
|
*/
|
|
#define BMBT_EXNTFLAG_BITLEN 1
|
|
#define BMBT_STARTOFF_BITLEN 54
|
|
#define BMBT_STARTBLOCK_BITLEN 52
|
|
#define BMBT_BLOCKCOUNT_BITLEN 21
|
|
|
|
typedef struct xfs_bmbt_rec {
|
|
__be64 l0, l1;
|
|
} xfs_bmbt_rec_t;
|
|
|
|
typedef __uint64_t xfs_bmbt_rec_base_t; /* use this for casts */
|
|
typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
|
|
|
|
typedef struct xfs_bmbt_rec_host {
|
|
__uint64_t l0, l1;
|
|
} xfs_bmbt_rec_host_t;
|
|
|
|
/*
|
|
* Values and macros for delayed-allocation startblock fields.
|
|
*/
|
|
#define STARTBLOCKVALBITS 17
|
|
#define STARTBLOCKMASKBITS (15 + XFS_BIG_BLKNOS * 20)
|
|
#define DSTARTBLOCKMASKBITS (15 + 20)
|
|
#define STARTBLOCKMASK \
|
|
(((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
|
|
#define DSTARTBLOCKMASK \
|
|
(((((xfs_dfsbno_t)1) << DSTARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
|
|
|
|
static inline int isnullstartblock(xfs_fsblock_t x)
|
|
{
|
|
return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
|
|
}
|
|
|
|
static inline int isnulldstartblock(xfs_dfsbno_t x)
|
|
{
|
|
return ((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK;
|
|
}
|
|
|
|
static inline xfs_fsblock_t nullstartblock(int k)
|
|
{
|
|
ASSERT(k < (1 << STARTBLOCKVALBITS));
|
|
return STARTBLOCKMASK | (k);
|
|
}
|
|
|
|
static inline xfs_filblks_t startblockval(xfs_fsblock_t x)
|
|
{
|
|
return (xfs_filblks_t)((x) & ~STARTBLOCKMASK);
|
|
}
|
|
|
|
/*
|
|
* Possible extent formats.
|
|
*/
|
|
typedef enum {
|
|
XFS_EXTFMT_NOSTATE = 0,
|
|
XFS_EXTFMT_HASSTATE
|
|
} xfs_exntfmt_t;
|
|
|
|
/*
|
|
* Possible extent states.
|
|
*/
|
|
typedef enum {
|
|
XFS_EXT_NORM, XFS_EXT_UNWRITTEN,
|
|
XFS_EXT_DMAPI_OFFLINE, XFS_EXT_INVALID
|
|
} xfs_exntst_t;
|
|
|
|
/*
|
|
* Incore version of above.
|
|
*/
|
|
typedef struct xfs_bmbt_irec
|
|
{
|
|
xfs_fileoff_t br_startoff; /* starting file offset */
|
|
xfs_fsblock_t br_startblock; /* starting block number */
|
|
xfs_filblks_t br_blockcount; /* number of blocks */
|
|
xfs_exntst_t br_state; /* extent state */
|
|
} xfs_bmbt_irec_t;
|
|
|
|
/*
|
|
* Key structure for non-leaf levels of the tree.
|
|
*/
|
|
typedef struct xfs_bmbt_key {
|
|
__be64 br_startoff; /* starting file offset */
|
|
} xfs_bmbt_key_t, xfs_bmdr_key_t;
|
|
|
|
/* btree pointer type */
|
|
typedef __be64 xfs_bmbt_ptr_t, xfs_bmdr_ptr_t;
|
|
|
|
|
|
/*
|
|
* Generic Btree block format definitions
|
|
*
|
|
* This is a combination of the actual format used on disk for short and long
|
|
* format btrees. The first three fields are shared by both format, but the
|
|
* pointers are different and should be used with care.
|
|
*
|
|
* To get the size of the actual short or long form headers please use the size
|
|
* macros below. Never use sizeof(xfs_btree_block).
|
|
*
|
|
* The blkno, crc, lsn, owner and uuid fields are only available in filesystems
|
|
* with the crc feature bit, and all accesses to them must be conditional on
|
|
* that flag.
|
|
*/
|
|
struct xfs_btree_block {
|
|
__be32 bb_magic; /* magic number for block type */
|
|
__be16 bb_level; /* 0 is a leaf */
|
|
__be16 bb_numrecs; /* current # of data records */
|
|
union {
|
|
struct {
|
|
__be32 bb_leftsib;
|
|
__be32 bb_rightsib;
|
|
|
|
__be64 bb_blkno;
|
|
__be64 bb_lsn;
|
|
uuid_t bb_uuid;
|
|
__be32 bb_owner;
|
|
__le32 bb_crc;
|
|
} s; /* short form pointers */
|
|
struct {
|
|
__be64 bb_leftsib;
|
|
__be64 bb_rightsib;
|
|
|
|
__be64 bb_blkno;
|
|
__be64 bb_lsn;
|
|
uuid_t bb_uuid;
|
|
__be64 bb_owner;
|
|
__le32 bb_crc;
|
|
__be32 bb_pad; /* padding for alignment */
|
|
} l; /* long form pointers */
|
|
} bb_u; /* rest */
|
|
};
|
|
|
|
#define XFS_BTREE_SBLOCK_LEN 16 /* size of a short form block */
|
|
#define XFS_BTREE_LBLOCK_LEN 24 /* size of a long form block */
|
|
|
|
/* sizes of CRC enabled btree blocks */
|
|
#define XFS_BTREE_SBLOCK_CRC_LEN (XFS_BTREE_SBLOCK_LEN + 40)
|
|
#define XFS_BTREE_LBLOCK_CRC_LEN (XFS_BTREE_LBLOCK_LEN + 48)
|
|
|
|
#define XFS_BTREE_SBLOCK_CRC_OFF \
|
|
offsetof(struct xfs_btree_block, bb_u.s.bb_crc)
|
|
#define XFS_BTREE_LBLOCK_CRC_OFF \
|
|
offsetof(struct xfs_btree_block, bb_u.l.bb_crc)
|
|
|
|
#endif /* __XFS_FORMAT_H__ */
|