xref: /openbmc/linux/fs/xfs/libxfs/xfs_format.h (revision 6774def6)
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__ */
417