Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0 */
2 : /*
3 : * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4 : * All Rights Reserved.
5 : */
6 : #ifndef __XFS_FORMAT_H__
7 : #define __XFS_FORMAT_H__
8 :
9 : /*
10 : * XFS On Disk Format Definitions
11 : *
12 : * This header file defines all the on-disk format definitions for
13 : * general XFS objects. Directory and attribute related objects are defined in
14 : * xfs_da_format.h, which log and log item formats are defined in
15 : * xfs_log_format.h. Everything else goes here.
16 : */
17 :
18 : struct xfs_mount;
19 : struct xfs_trans;
20 : struct xfs_inode;
21 : struct xfs_buf;
22 : struct xfs_ifork;
23 :
24 : /*
25 : * Super block
26 : * Fits into a sector-sized buffer at address 0 of each allocation group.
27 : * Only the first of these is ever updated except during growfs.
28 : */
29 : #define XFS_SB_MAGIC 0x58465342 /* 'XFSB' */
30 : #define XFS_SB_VERSION_1 1 /* 5.3, 6.0.1, 6.1 */
31 : #define XFS_SB_VERSION_2 2 /* 6.2 - attributes */
32 : #define XFS_SB_VERSION_3 3 /* 6.2 - new inode version */
33 : #define XFS_SB_VERSION_4 4 /* 6.2+ - bitmask version */
34 : #define XFS_SB_VERSION_5 5 /* CRC enabled filesystem */
35 : #define XFS_SB_VERSION_NUMBITS 0x000f
36 : #define XFS_SB_VERSION_ALLFBITS 0xfff0
37 : #define XFS_SB_VERSION_ATTRBIT 0x0010
38 : #define XFS_SB_VERSION_NLINKBIT 0x0020
39 : #define XFS_SB_VERSION_QUOTABIT 0x0040
40 : #define XFS_SB_VERSION_ALIGNBIT 0x0080
41 : #define XFS_SB_VERSION_DALIGNBIT 0x0100
42 : #define XFS_SB_VERSION_SHAREDBIT 0x0200
43 : #define XFS_SB_VERSION_LOGV2BIT 0x0400
44 : #define XFS_SB_VERSION_SECTORBIT 0x0800
45 : #define XFS_SB_VERSION_EXTFLGBIT 0x1000
46 : #define XFS_SB_VERSION_DIRV2BIT 0x2000
47 : #define XFS_SB_VERSION_BORGBIT 0x4000 /* ASCII only case-insens. */
48 : #define XFS_SB_VERSION_MOREBITSBIT 0x8000
49 :
50 : /*
51 : * The size of a single extended attribute on disk is limited by
52 : * the size of index values within the attribute entries themselves.
53 : * These are be16 fields, so we can only support attribute data
54 : * sizes up to 2^16 bytes in length.
55 : */
56 : #define XFS_XATTR_SIZE_MAX (1 << 16)
57 :
58 : /*
59 : * Supported feature bit list is just all bits in the versionnum field because
60 : * we've used them all up and understand them all. Except, of course, for the
61 : * shared superblock bit, which nobody knows what it does and so is unsupported.
62 : */
63 : #define XFS_SB_VERSION_OKBITS \
64 : ((XFS_SB_VERSION_NUMBITS | XFS_SB_VERSION_ALLFBITS) & \
65 : ~XFS_SB_VERSION_SHAREDBIT)
66 :
67 : /*
68 : * There are two words to hold XFS "feature" bits: the original
69 : * word, sb_versionnum, and sb_features2. Whenever a bit is set in
70 : * sb_features2, the feature bit XFS_SB_VERSION_MOREBITSBIT must be set.
71 : *
72 : * These defines represent bits in sb_features2.
73 : */
74 : #define XFS_SB_VERSION2_RESERVED1BIT 0x00000001
75 : #define XFS_SB_VERSION2_LAZYSBCOUNTBIT 0x00000002 /* Superblk counters */
76 : #define XFS_SB_VERSION2_RESERVED4BIT 0x00000004
77 : #define XFS_SB_VERSION2_ATTR2BIT 0x00000008 /* Inline attr rework */
78 : #define XFS_SB_VERSION2_PARENTBIT 0x00000010 /* parent pointers */
79 : #define XFS_SB_VERSION2_PROJID32BIT 0x00000080 /* 32 bit project id */
80 : #define XFS_SB_VERSION2_CRCBIT 0x00000100 /* metadata CRCs */
81 : #define XFS_SB_VERSION2_FTYPE 0x00000200 /* inode type in dir */
82 :
83 : #define XFS_SB_VERSION2_OKBITS \
84 : (XFS_SB_VERSION2_LAZYSBCOUNTBIT | \
85 : XFS_SB_VERSION2_ATTR2BIT | \
86 : XFS_SB_VERSION2_PROJID32BIT | \
87 : XFS_SB_VERSION2_FTYPE)
88 :
89 : /* Maximum size of the xfs filesystem label, no terminating NULL */
90 : #define XFSLABEL_MAX 12
91 :
92 : /*
93 : * Superblock - in core version. Must match the ondisk version below.
94 : * Must be padded to 64 bit alignment.
95 : */
96 : typedef struct xfs_sb {
97 : uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */
98 : uint32_t sb_blocksize; /* logical block size, bytes */
99 : xfs_rfsblock_t sb_dblocks; /* number of data blocks */
100 : xfs_rfsblock_t sb_rblocks; /* number of realtime blocks */
101 : xfs_rtblock_t sb_rextents; /* number of realtime extents */
102 : uuid_t sb_uuid; /* user-visible file system unique id */
103 : xfs_fsblock_t sb_logstart; /* starting block of log if internal */
104 : xfs_ino_t sb_rootino; /* root inode number */
105 : xfs_ino_t sb_rbmino; /* bitmap inode for realtime extents */
106 : xfs_ino_t sb_rsumino; /* summary inode for rt bitmap */
107 : xfs_agblock_t sb_rextsize; /* realtime extent size, blocks */
108 : xfs_agblock_t sb_agblocks; /* size of an allocation group */
109 : xfs_agnumber_t sb_agcount; /* number of allocation groups */
110 : xfs_extlen_t sb_rbmblocks; /* number of rt bitmap blocks */
111 : xfs_extlen_t sb_logblocks; /* number of log blocks */
112 : uint16_t sb_versionnum; /* header version == XFS_SB_VERSION */
113 : uint16_t sb_sectsize; /* volume sector size, bytes */
114 : uint16_t sb_inodesize; /* inode size, bytes */
115 : uint16_t sb_inopblock; /* inodes per block */
116 : char sb_fname[XFSLABEL_MAX]; /* file system name */
117 : uint8_t sb_blocklog; /* log2 of sb_blocksize */
118 : uint8_t sb_sectlog; /* log2 of sb_sectsize */
119 : uint8_t sb_inodelog; /* log2 of sb_inodesize */
120 : uint8_t sb_inopblog; /* log2 of sb_inopblock */
121 : uint8_t sb_agblklog; /* log2 of sb_agblocks (rounded up) */
122 : uint8_t sb_rextslog; /* log2 of sb_rextents */
123 : uint8_t sb_inprogress; /* mkfs is in progress, don't mount */
124 : uint8_t sb_imax_pct; /* max % of fs for inode space */
125 : /* statistics */
126 : /*
127 : * These fields must remain contiguous. If you really
128 : * want to change their layout, make sure you fix the
129 : * code in xfs_trans_apply_sb_deltas().
130 : */
131 : uint64_t sb_icount; /* allocated inodes */
132 : uint64_t sb_ifree; /* free inodes */
133 : uint64_t sb_fdblocks; /* free data blocks */
134 : uint64_t sb_frextents; /* free realtime extents */
135 : /*
136 : * End contiguous fields.
137 : */
138 : xfs_ino_t sb_uquotino; /* user quota inode */
139 : xfs_ino_t sb_gquotino; /* group quota inode */
140 : uint16_t sb_qflags; /* quota flags */
141 : uint8_t sb_flags; /* misc. flags */
142 : uint8_t sb_shared_vn; /* shared version number */
143 : xfs_extlen_t sb_inoalignmt; /* inode chunk alignment, fsblocks */
144 : uint32_t sb_unit; /* stripe or raid unit */
145 : uint32_t sb_width; /* stripe or raid width */
146 : uint8_t sb_dirblklog; /* log2 of dir block size (fsbs) */
147 : uint8_t sb_logsectlog; /* log2 of the log sector size */
148 : uint16_t sb_logsectsize; /* sector size for the log, bytes */
149 : uint32_t sb_logsunit; /* stripe unit size for the log */
150 : uint32_t sb_features2; /* additional feature bits */
151 :
152 : /*
153 : * bad features2 field as a result of failing to pad the sb structure to
154 : * 64 bits. Some machines will be using this field for features2 bits.
155 : * Easiest just to mark it bad and not use it for anything else.
156 : *
157 : * This is not kept up to date in memory; it is always overwritten by
158 : * the value in sb_features2 when formatting the incore superblock to
159 : * the disk buffer.
160 : */
161 : uint32_t sb_bad_features2;
162 :
163 : /* version 5 superblock fields start here */
164 :
165 : /* feature masks */
166 : uint32_t sb_features_compat;
167 : uint32_t sb_features_ro_compat;
168 : uint32_t sb_features_incompat;
169 : uint32_t sb_features_log_incompat;
170 :
171 : uint32_t sb_crc; /* superblock crc */
172 : xfs_extlen_t sb_spino_align; /* sparse inode chunk alignment */
173 :
174 : xfs_ino_t sb_pquotino; /* project quota inode */
175 : xfs_lsn_t sb_lsn; /* last write sequence */
176 : uuid_t sb_meta_uuid; /* metadata file system unique id */
177 :
178 : /* must be padded to 64 bit alignment */
179 : } xfs_sb_t;
180 :
181 : #define XFS_SB_CRC_OFF offsetof(struct xfs_sb, sb_crc)
182 :
183 : /*
184 : * Superblock - on disk version. Must match the in core version above.
185 : * Must be padded to 64 bit alignment.
186 : */
187 : struct xfs_dsb {
188 : __be32 sb_magicnum; /* magic number == XFS_SB_MAGIC */
189 : __be32 sb_blocksize; /* logical block size, bytes */
190 : __be64 sb_dblocks; /* number of data blocks */
191 : __be64 sb_rblocks; /* number of realtime blocks */
192 : __be64 sb_rextents; /* number of realtime extents */
193 : uuid_t sb_uuid; /* user-visible file system unique id */
194 : __be64 sb_logstart; /* starting block of log if internal */
195 : __be64 sb_rootino; /* root inode number */
196 : __be64 sb_rbmino; /* bitmap inode for realtime extents */
197 : __be64 sb_rsumino; /* summary inode for rt bitmap */
198 : __be32 sb_rextsize; /* realtime extent size, blocks */
199 : __be32 sb_agblocks; /* size of an allocation group */
200 : __be32 sb_agcount; /* number of allocation groups */
201 : __be32 sb_rbmblocks; /* number of rt bitmap blocks */
202 : __be32 sb_logblocks; /* number of log blocks */
203 : __be16 sb_versionnum; /* header version == XFS_SB_VERSION */
204 : __be16 sb_sectsize; /* volume sector size, bytes */
205 : __be16 sb_inodesize; /* inode size, bytes */
206 : __be16 sb_inopblock; /* inodes per block */
207 : char sb_fname[XFSLABEL_MAX]; /* file system name */
208 : __u8 sb_blocklog; /* log2 of sb_blocksize */
209 : __u8 sb_sectlog; /* log2 of sb_sectsize */
210 : __u8 sb_inodelog; /* log2 of sb_inodesize */
211 : __u8 sb_inopblog; /* log2 of sb_inopblock */
212 : __u8 sb_agblklog; /* log2 of sb_agblocks (rounded up) */
213 : __u8 sb_rextslog; /* log2 of sb_rextents */
214 : __u8 sb_inprogress; /* mkfs is in progress, don't mount */
215 : __u8 sb_imax_pct; /* max % of fs for inode space */
216 : /* statistics */
217 : /*
218 : * These fields must remain contiguous. If you really
219 : * want to change their layout, make sure you fix the
220 : * code in xfs_trans_apply_sb_deltas().
221 : */
222 : __be64 sb_icount; /* allocated inodes */
223 : __be64 sb_ifree; /* free inodes */
224 : __be64 sb_fdblocks; /* free data blocks */
225 : __be64 sb_frextents; /* free realtime extents */
226 : /*
227 : * End contiguous fields.
228 : */
229 : __be64 sb_uquotino; /* user quota inode */
230 : __be64 sb_gquotino; /* group quota inode */
231 : __be16 sb_qflags; /* quota flags */
232 : __u8 sb_flags; /* misc. flags */
233 : __u8 sb_shared_vn; /* shared version number */
234 : __be32 sb_inoalignmt; /* inode chunk alignment, fsblocks */
235 : __be32 sb_unit; /* stripe or raid unit */
236 : __be32 sb_width; /* stripe or raid width */
237 : __u8 sb_dirblklog; /* log2 of dir block size (fsbs) */
238 : __u8 sb_logsectlog; /* log2 of the log sector size */
239 : __be16 sb_logsectsize; /* sector size for the log, bytes */
240 : __be32 sb_logsunit; /* stripe unit size for the log */
241 : __be32 sb_features2; /* additional feature bits */
242 : /*
243 : * bad features2 field as a result of failing to pad the sb
244 : * structure to 64 bits. Some machines will be using this field
245 : * for features2 bits. Easiest just to mark it bad and not use
246 : * it for anything else.
247 : */
248 : __be32 sb_bad_features2;
249 :
250 : /* version 5 superblock fields start here */
251 :
252 : /* feature masks */
253 : __be32 sb_features_compat;
254 : __be32 sb_features_ro_compat;
255 : __be32 sb_features_incompat;
256 : __be32 sb_features_log_incompat;
257 :
258 : __le32 sb_crc; /* superblock crc */
259 : __be32 sb_spino_align; /* sparse inode chunk alignment */
260 :
261 : __be64 sb_pquotino; /* project quota inode */
262 : __be64 sb_lsn; /* last write sequence */
263 : uuid_t sb_meta_uuid; /* metadata file system unique id */
264 :
265 : /* must be padded to 64 bit alignment */
266 : };
267 :
268 : /*
269 : * Misc. Flags - warning - these will be cleared by xfs_repair unless
270 : * a feature bit is set when the flag is used.
271 : */
272 : #define XFS_SBF_NOFLAGS 0x00 /* no flags set */
273 : #define XFS_SBF_READONLY 0x01 /* only read-only mounts allowed */
274 :
275 : /*
276 : * define max. shared version we can interoperate with
277 : */
278 : #define XFS_SB_MAX_SHARED_VN 0
279 :
280 : #define XFS_SB_VERSION_NUM(sbp) ((sbp)->sb_versionnum & XFS_SB_VERSION_NUMBITS)
281 :
282 : static inline bool xfs_sb_is_v5(struct xfs_sb *sbp)
283 : {
284 10087470 : return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5;
285 : }
286 :
287 : /*
288 : * Detect a mismatched features2 field. Older kernels read/wrote
289 : * this into the wrong slot, so to be safe we keep them in sync.
290 : */
291 : static inline bool xfs_sb_has_mismatched_features2(struct xfs_sb *sbp)
292 : {
293 59415 : return sbp->sb_bad_features2 != sbp->sb_features2;
294 : }
295 :
296 : static inline bool xfs_sb_version_hasmorebits(struct xfs_sb *sbp)
297 : {
298 1321300 : return xfs_sb_is_v5(sbp) ||
299 : (sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT);
300 : }
301 :
302 : static inline void xfs_sb_version_addattr(struct xfs_sb *sbp)
303 : {
304 1496 : sbp->sb_versionnum |= XFS_SB_VERSION_ATTRBIT;
305 : }
306 :
307 : static inline void xfs_sb_version_addquota(struct xfs_sb *sbp)
308 : {
309 6701 : sbp->sb_versionnum |= XFS_SB_VERSION_QUOTABIT;
310 : }
311 :
312 : static inline void xfs_sb_version_addattr2(struct xfs_sb *sbp)
313 : {
314 0 : sbp->sb_versionnum |= XFS_SB_VERSION_MOREBITSBIT;
315 0 : sbp->sb_features2 |= XFS_SB_VERSION2_ATTR2BIT;
316 : }
317 :
318 : static inline void xfs_sb_version_addprojid32(struct xfs_sb *sbp)
319 : {
320 : sbp->sb_versionnum |= XFS_SB_VERSION_MOREBITSBIT;
321 : sbp->sb_features2 |= XFS_SB_VERSION2_PROJID32BIT;
322 : }
323 :
324 : /*
325 : * Extended v5 superblock feature masks. These are to be used for new v5
326 : * superblock features only.
327 : *
328 : * Compat features are new features that old kernels will not notice or affect
329 : * and so can mount read-write without issues.
330 : *
331 : * RO-Compat (read only) are features that old kernels can read but will break
332 : * if they write. Hence only read-only mounts of such filesystems are allowed on
333 : * kernels that don't support the feature bit.
334 : *
335 : * InCompat features are features which old kernels will not understand and so
336 : * must not mount.
337 : *
338 : * Log-InCompat features are for changes to log formats or new transactions that
339 : * can't be replayed on older kernels. The fields are set when the filesystem is
340 : * mounted, and a clean unmount clears the fields.
341 : */
342 : #define XFS_SB_FEAT_COMPAT_ALL 0
343 : #define XFS_SB_FEAT_COMPAT_UNKNOWN ~XFS_SB_FEAT_COMPAT_ALL
344 : static inline bool
345 : xfs_sb_has_compat_feature(
346 : struct xfs_sb *sbp,
347 : uint32_t feature)
348 : {
349 983501 : return (sbp->sb_features_compat & feature) != 0;
350 : }
351 :
352 : #define XFS_SB_FEAT_RO_COMPAT_FINOBT (1 << 0) /* free inode btree */
353 : #define XFS_SB_FEAT_RO_COMPAT_RMAPBT (1 << 1) /* reverse map btree */
354 : #define XFS_SB_FEAT_RO_COMPAT_REFLINK (1 << 2) /* reflinked files */
355 : #define XFS_SB_FEAT_RO_COMPAT_INOBTCNT (1 << 3) /* inobt block counts */
356 : #define XFS_SB_FEAT_RO_COMPAT_ALL \
357 : (XFS_SB_FEAT_RO_COMPAT_FINOBT | \
358 : XFS_SB_FEAT_RO_COMPAT_RMAPBT | \
359 : XFS_SB_FEAT_RO_COMPAT_REFLINK| \
360 : XFS_SB_FEAT_RO_COMPAT_INOBTCNT)
361 : #define XFS_SB_FEAT_RO_COMPAT_UNKNOWN ~XFS_SB_FEAT_RO_COMPAT_ALL
362 : static inline bool
363 : xfs_sb_has_ro_compat_feature(
364 : struct xfs_sb *sbp,
365 : uint32_t feature)
366 : {
367 984024 : return (sbp->sb_features_ro_compat & feature) != 0;
368 : }
369 :
370 : #define XFS_SB_FEAT_INCOMPAT_FTYPE (1 << 0) /* filetype in dirent */
371 : #define XFS_SB_FEAT_INCOMPAT_SPINODES (1 << 1) /* sparse inode chunks */
372 : #define XFS_SB_FEAT_INCOMPAT_META_UUID (1 << 2) /* metadata UUID */
373 : #define XFS_SB_FEAT_INCOMPAT_BIGTIME (1 << 3) /* large timestamps */
374 : #define XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR (1 << 4) /* needs xfs_repair */
375 : #define XFS_SB_FEAT_INCOMPAT_NREXT64 (1 << 5) /* large extent counters */
376 : #define XFS_SB_FEAT_INCOMPAT_ALL \
377 : (XFS_SB_FEAT_INCOMPAT_FTYPE| \
378 : XFS_SB_FEAT_INCOMPAT_SPINODES| \
379 : XFS_SB_FEAT_INCOMPAT_META_UUID| \
380 : XFS_SB_FEAT_INCOMPAT_BIGTIME| \
381 : XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR| \
382 : XFS_SB_FEAT_INCOMPAT_NREXT64)
383 :
384 : #define XFS_SB_FEAT_INCOMPAT_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_ALL
385 : static inline bool
386 : xfs_sb_has_incompat_feature(
387 : struct xfs_sb *sbp,
388 : uint32_t feature)
389 : {
390 983479 : return (sbp->sb_features_incompat & feature) != 0;
391 : }
392 :
393 : #define XFS_SB_FEAT_INCOMPAT_LOG_XATTRS (1 << 0) /* Delayed Attributes */
394 : #define XFS_SB_FEAT_INCOMPAT_LOG_ALL \
395 : (XFS_SB_FEAT_INCOMPAT_LOG_XATTRS)
396 : #define XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_LOG_ALL
397 : static inline bool
398 : xfs_sb_has_incompat_log_feature(
399 : struct xfs_sb *sbp,
400 : uint32_t feature)
401 : {
402 506861 : return (sbp->sb_features_log_incompat & feature) != 0;
403 : }
404 :
405 : static inline void
406 : xfs_sb_remove_incompat_log_features(
407 : struct xfs_sb *sbp)
408 : {
409 1327 : sbp->sb_features_log_incompat &= ~XFS_SB_FEAT_INCOMPAT_LOG_ALL;
410 : }
411 :
412 : static inline void
413 : xfs_sb_add_incompat_log_features(
414 : struct xfs_sb *sbp,
415 : unsigned int features)
416 : {
417 1323 : sbp->sb_features_log_incompat |= features;
418 : }
419 :
420 : static inline bool xfs_sb_version_haslogxattrs(struct xfs_sb *sbp)
421 : {
422 2732838 : return xfs_sb_is_v5(sbp) && (sbp->sb_features_log_incompat &
423 : XFS_SB_FEAT_INCOMPAT_LOG_XATTRS);
424 : }
425 :
426 : static inline bool
427 : xfs_is_quota_inode(struct xfs_sb *sbp, xfs_ino_t ino)
428 : {
429 >14963*10^7 : return (ino == sbp->sb_uquotino ||
430 >14963*10^7 : ino == sbp->sb_gquotino ||
431 74812348964 : ino == sbp->sb_pquotino);
432 : }
433 :
434 : #define XFS_SB_DADDR ((xfs_daddr_t)0) /* daddr in filesystem/ag */
435 : #define XFS_SB_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_SB_DADDR)
436 :
437 : #define XFS_HDR_BLOCK(mp,d) ((xfs_agblock_t)XFS_BB_TO_FSBT(mp,d))
438 : #define XFS_DADDR_TO_FSB(mp,d) XFS_AGB_TO_FSB(mp, \
439 : xfs_daddr_to_agno(mp,d), xfs_daddr_to_agbno(mp,d))
440 : #define XFS_FSB_TO_DADDR(mp,fsbno) XFS_AGB_TO_DADDR(mp, \
441 : XFS_FSB_TO_AGNO(mp,fsbno), XFS_FSB_TO_AGBNO(mp,fsbno))
442 :
443 : /*
444 : * File system sector to basic block conversions.
445 : */
446 : #define XFS_FSS_TO_BB(mp,sec) ((sec) << (mp)->m_sectbb_log)
447 :
448 : /*
449 : * File system block to basic block conversions.
450 : */
451 : #define XFS_FSB_TO_BB(mp,fsbno) ((fsbno) << (mp)->m_blkbb_log)
452 : #define XFS_BB_TO_FSB(mp,bb) \
453 : (((bb) + (XFS_FSB_TO_BB(mp,1) - 1)) >> (mp)->m_blkbb_log)
454 : #define XFS_BB_TO_FSBT(mp,bb) ((bb) >> (mp)->m_blkbb_log)
455 :
456 : /*
457 : * File system block to byte conversions.
458 : */
459 : #define XFS_FSB_TO_B(mp,fsbno) ((xfs_fsize_t)(fsbno) << (mp)->m_sb.sb_blocklog)
460 : #define XFS_B_TO_FSB(mp,b) \
461 : ((((uint64_t)(b)) + (mp)->m_blockmask) >> (mp)->m_sb.sb_blocklog)
462 : #define XFS_B_TO_FSBT(mp,b) (((uint64_t)(b)) >> (mp)->m_sb.sb_blocklog)
463 :
464 : /*
465 : * Allocation group header
466 : *
467 : * This is divided into three structures, placed in sequential 512-byte
468 : * buffers after a copy of the superblock (also in a 512-byte buffer).
469 : */
470 : #define XFS_AGF_MAGIC 0x58414746 /* 'XAGF' */
471 : #define XFS_AGI_MAGIC 0x58414749 /* 'XAGI' */
472 : #define XFS_AGFL_MAGIC 0x5841464c /* 'XAFL' */
473 : #define XFS_AGF_VERSION 1
474 : #define XFS_AGI_VERSION 1
475 :
476 : #define XFS_AGF_GOOD_VERSION(v) ((v) == XFS_AGF_VERSION)
477 : #define XFS_AGI_GOOD_VERSION(v) ((v) == XFS_AGI_VERSION)
478 :
479 : /*
480 : * Btree number 0 is bno, 1 is cnt, 2 is rmap. This value gives the size of the
481 : * arrays below.
482 : */
483 : #define XFS_BTNUM_AGF ((int)XFS_BTNUM_RMAPi + 1)
484 :
485 : /*
486 : * The second word of agf_levels in the first a.g. overlaps the EFS
487 : * superblock's magic number. Since the magic numbers valid for EFS
488 : * are > 64k, our value cannot be confused for an EFS superblock's.
489 : */
490 :
491 : typedef struct xfs_agf {
492 : /*
493 : * Common allocation group header information
494 : */
495 : __be32 agf_magicnum; /* magic number == XFS_AGF_MAGIC */
496 : __be32 agf_versionnum; /* header version == XFS_AGF_VERSION */
497 : __be32 agf_seqno; /* sequence # starting from 0 */
498 : __be32 agf_length; /* size in blocks of a.g. */
499 : /*
500 : * Freespace and rmap information
501 : */
502 : __be32 agf_roots[XFS_BTNUM_AGF]; /* root blocks */
503 : __be32 agf_levels[XFS_BTNUM_AGF]; /* btree levels */
504 :
505 : __be32 agf_flfirst; /* first freelist block's index */
506 : __be32 agf_fllast; /* last freelist block's index */
507 : __be32 agf_flcount; /* count of blocks in freelist */
508 : __be32 agf_freeblks; /* total free blocks */
509 :
510 : __be32 agf_longest; /* longest free space */
511 : __be32 agf_btreeblks; /* # of blocks held in AGF btrees */
512 : uuid_t agf_uuid; /* uuid of filesystem */
513 :
514 : __be32 agf_rmap_blocks; /* rmapbt blocks used */
515 : __be32 agf_refcount_blocks; /* refcountbt blocks used */
516 :
517 : __be32 agf_refcount_root; /* refcount tree root block */
518 : __be32 agf_refcount_level; /* refcount btree levels */
519 :
520 : /*
521 : * reserve some contiguous space for future logged fields before we add
522 : * the unlogged fields. This makes the range logging via flags and
523 : * structure offsets much simpler.
524 : */
525 : __be64 agf_spare64[14];
526 :
527 : /* unlogged fields, written during buffer writeback. */
528 : __be64 agf_lsn; /* last write sequence */
529 : __be32 agf_crc; /* crc of agf sector */
530 : __be32 agf_spare2;
531 :
532 : /* structure must be padded to 64 bit alignment */
533 : } xfs_agf_t;
534 :
535 : #define XFS_AGF_CRC_OFF offsetof(struct xfs_agf, agf_crc)
536 :
537 : #define XFS_AGF_MAGICNUM (1u << 0)
538 : #define XFS_AGF_VERSIONNUM (1u << 1)
539 : #define XFS_AGF_SEQNO (1u << 2)
540 : #define XFS_AGF_LENGTH (1u << 3)
541 : #define XFS_AGF_ROOTS (1u << 4)
542 : #define XFS_AGF_LEVELS (1u << 5)
543 : #define XFS_AGF_FLFIRST (1u << 6)
544 : #define XFS_AGF_FLLAST (1u << 7)
545 : #define XFS_AGF_FLCOUNT (1u << 8)
546 : #define XFS_AGF_FREEBLKS (1u << 9)
547 : #define XFS_AGF_LONGEST (1u << 10)
548 : #define XFS_AGF_BTREEBLKS (1u << 11)
549 : #define XFS_AGF_UUID (1u << 12)
550 : #define XFS_AGF_RMAP_BLOCKS (1u << 13)
551 : #define XFS_AGF_REFCOUNT_BLOCKS (1u << 14)
552 : #define XFS_AGF_REFCOUNT_ROOT (1u << 15)
553 : #define XFS_AGF_REFCOUNT_LEVEL (1u << 16)
554 : #define XFS_AGF_SPARE64 (1u << 17)
555 : #define XFS_AGF_NUM_BITS 18
556 : #define XFS_AGF_ALL_BITS ((1u << XFS_AGF_NUM_BITS) - 1)
557 :
558 : #define XFS_AGF_FLAGS \
559 : { XFS_AGF_MAGICNUM, "MAGICNUM" }, \
560 : { XFS_AGF_VERSIONNUM, "VERSIONNUM" }, \
561 : { XFS_AGF_SEQNO, "SEQNO" }, \
562 : { XFS_AGF_LENGTH, "LENGTH" }, \
563 : { XFS_AGF_ROOTS, "ROOTS" }, \
564 : { XFS_AGF_LEVELS, "LEVELS" }, \
565 : { XFS_AGF_FLFIRST, "FLFIRST" }, \
566 : { XFS_AGF_FLLAST, "FLLAST" }, \
567 : { XFS_AGF_FLCOUNT, "FLCOUNT" }, \
568 : { XFS_AGF_FREEBLKS, "FREEBLKS" }, \
569 : { XFS_AGF_LONGEST, "LONGEST" }, \
570 : { XFS_AGF_BTREEBLKS, "BTREEBLKS" }, \
571 : { XFS_AGF_UUID, "UUID" }, \
572 : { XFS_AGF_RMAP_BLOCKS, "RMAP_BLOCKS" }, \
573 : { XFS_AGF_REFCOUNT_BLOCKS, "REFCOUNT_BLOCKS" }, \
574 : { XFS_AGF_REFCOUNT_ROOT, "REFCOUNT_ROOT" }, \
575 : { XFS_AGF_REFCOUNT_LEVEL, "REFCOUNT_LEVEL" }, \
576 : { XFS_AGF_SPARE64, "SPARE64" }
577 :
578 : /* disk block (xfs_daddr_t) in the AG */
579 : #define XFS_AGF_DADDR(mp) ((xfs_daddr_t)(1 << (mp)->m_sectbb_log))
580 : #define XFS_AGF_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGF_DADDR(mp))
581 :
582 : /*
583 : * Size of the unlinked inode hash table in the agi.
584 : */
585 : #define XFS_AGI_UNLINKED_BUCKETS 64
586 :
587 : typedef struct xfs_agi {
588 : /*
589 : * Common allocation group header information
590 : */
591 : __be32 agi_magicnum; /* magic number == XFS_AGI_MAGIC */
592 : __be32 agi_versionnum; /* header version == XFS_AGI_VERSION */
593 : __be32 agi_seqno; /* sequence # starting from 0 */
594 : __be32 agi_length; /* size in blocks of a.g. */
595 : /*
596 : * Inode information
597 : * Inodes are mapped by interpreting the inode number, so no
598 : * mapping data is needed here.
599 : */
600 : __be32 agi_count; /* count of allocated inodes */
601 : __be32 agi_root; /* root of inode btree */
602 : __be32 agi_level; /* levels in inode btree */
603 : __be32 agi_freecount; /* number of free inodes */
604 :
605 : __be32 agi_newino; /* new inode just allocated */
606 : __be32 agi_dirino; /* last directory inode chunk */
607 : /*
608 : * Hash table of inodes which have been unlinked but are
609 : * still being referenced.
610 : */
611 : __be32 agi_unlinked[XFS_AGI_UNLINKED_BUCKETS];
612 : /*
613 : * This marks the end of logging region 1 and start of logging region 2.
614 : */
615 : uuid_t agi_uuid; /* uuid of filesystem */
616 : __be32 agi_crc; /* crc of agi sector */
617 : __be32 agi_pad32;
618 : __be64 agi_lsn; /* last write sequence */
619 :
620 : __be32 agi_free_root; /* root of the free inode btree */
621 : __be32 agi_free_level;/* levels in free inode btree */
622 :
623 : __be32 agi_iblocks; /* inobt blocks used */
624 : __be32 agi_fblocks; /* finobt blocks used */
625 :
626 : /* structure must be padded to 64 bit alignment */
627 : } xfs_agi_t;
628 :
629 : #define XFS_AGI_CRC_OFF offsetof(struct xfs_agi, agi_crc)
630 :
631 : #define XFS_AGI_MAGICNUM (1u << 0)
632 : #define XFS_AGI_VERSIONNUM (1u << 1)
633 : #define XFS_AGI_SEQNO (1u << 2)
634 : #define XFS_AGI_LENGTH (1u << 3)
635 : #define XFS_AGI_COUNT (1u << 4)
636 : #define XFS_AGI_ROOT (1u << 5)
637 : #define XFS_AGI_LEVEL (1u << 6)
638 : #define XFS_AGI_FREECOUNT (1u << 7)
639 : #define XFS_AGI_NEWINO (1u << 8)
640 : #define XFS_AGI_DIRINO (1u << 9)
641 : #define XFS_AGI_UNLINKED (1u << 10)
642 : #define XFS_AGI_NUM_BITS_R1 11 /* end of the 1st agi logging region */
643 : #define XFS_AGI_ALL_BITS_R1 ((1u << XFS_AGI_NUM_BITS_R1) - 1)
644 : #define XFS_AGI_FREE_ROOT (1u << 11)
645 : #define XFS_AGI_FREE_LEVEL (1u << 12)
646 : #define XFS_AGI_IBLOCKS (1u << 13) /* both inobt/finobt block counters */
647 : #define XFS_AGI_NUM_BITS_R2 14
648 :
649 : /* disk block (xfs_daddr_t) in the AG */
650 : #define XFS_AGI_DADDR(mp) ((xfs_daddr_t)(2 << (mp)->m_sectbb_log))
651 : #define XFS_AGI_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGI_DADDR(mp))
652 :
653 : /*
654 : * The third a.g. block contains the a.g. freelist, an array
655 : * of block pointers to blocks owned by the allocation btree code.
656 : */
657 : #define XFS_AGFL_DADDR(mp) ((xfs_daddr_t)(3 << (mp)->m_sectbb_log))
658 : #define XFS_AGFL_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGFL_DADDR(mp))
659 : #define XFS_BUF_TO_AGFL(bp) ((struct xfs_agfl *)((bp)->b_addr))
660 :
661 : struct xfs_agfl {
662 : __be32 agfl_magicnum;
663 : __be32 agfl_seqno;
664 : uuid_t agfl_uuid;
665 : __be64 agfl_lsn;
666 : __be32 agfl_crc;
667 : } __attribute__((packed));
668 :
669 : #define XFS_AGFL_CRC_OFF offsetof(struct xfs_agfl, agfl_crc)
670 :
671 : #define XFS_AGB_TO_FSB(mp,agno,agbno) \
672 : (((xfs_fsblock_t)(agno) << (mp)->m_sb.sb_agblklog) | (agbno))
673 : #define XFS_FSB_TO_AGNO(mp,fsbno) \
674 : ((xfs_agnumber_t)((fsbno) >> (mp)->m_sb.sb_agblklog))
675 : #define XFS_FSB_TO_AGBNO(mp,fsbno) \
676 : ((xfs_agblock_t)((fsbno) & xfs_mask32lo((mp)->m_sb.sb_agblklog)))
677 : #define XFS_AGB_TO_DADDR(mp,agno,agbno) \
678 : ((xfs_daddr_t)XFS_FSB_TO_BB(mp, \
679 : (xfs_fsblock_t)(agno) * (mp)->m_sb.sb_agblocks + (agbno)))
680 : #define XFS_AG_DADDR(mp,agno,d) (XFS_AGB_TO_DADDR(mp, agno, 0) + (d))
681 :
682 : /*
683 : * For checking for bad ranges of xfs_daddr_t's, covering multiple
684 : * allocation groups or a single xfs_daddr_t that's a superblock copy.
685 : */
686 : #define XFS_AG_CHECK_DADDR(mp,d,len) \
687 : ((len) == 1 ? \
688 : ASSERT((d) == XFS_SB_DADDR || \
689 : xfs_daddr_to_agbno(mp, d) != XFS_SB_DADDR) : \
690 : ASSERT(xfs_daddr_to_agno(mp, d) == \
691 : xfs_daddr_to_agno(mp, (d) + (len) - 1)))
692 :
693 : /*
694 : * XFS Timestamps
695 : * ==============
696 : *
697 : * Traditional ondisk inode timestamps consist of signed 32-bit counters for
698 : * seconds and nanoseconds; time zero is the Unix epoch, Jan 1 00:00:00 UTC
699 : * 1970, which means that the timestamp epoch is the same as the Unix epoch.
700 : * Therefore, the ondisk min and max defined here can be used directly to
701 : * constrain the incore timestamps on a Unix system. Note that we actually
702 : * encode a __be64 value on disk.
703 : *
704 : * When the bigtime feature is enabled, ondisk inode timestamps become an
705 : * unsigned 64-bit nanoseconds counter. This means that the bigtime inode
706 : * timestamp epoch is the start of the classic timestamp range, which is
707 : * Dec 13 20:45:52 UTC 1901. Because the epochs are not the same, callers
708 : * /must/ use the bigtime conversion functions when encoding and decoding raw
709 : * timestamps.
710 : */
711 : typedef __be64 xfs_timestamp_t;
712 :
713 : /* Legacy timestamp encoding format. */
714 : struct xfs_legacy_timestamp {
715 : __be32 t_sec; /* timestamp seconds */
716 : __be32 t_nsec; /* timestamp nanoseconds */
717 : };
718 :
719 : /*
720 : * Smallest possible ondisk seconds value with traditional timestamps. This
721 : * corresponds exactly with the incore timestamp Dec 13 20:45:52 UTC 1901.
722 : */
723 : #define XFS_LEGACY_TIME_MIN ((int64_t)S32_MIN)
724 :
725 : /*
726 : * Largest possible ondisk seconds value with traditional timestamps. This
727 : * corresponds exactly with the incore timestamp Jan 19 03:14:07 UTC 2038.
728 : */
729 : #define XFS_LEGACY_TIME_MAX ((int64_t)S32_MAX)
730 :
731 : /*
732 : * Smallest possible ondisk seconds value with bigtime timestamps. This
733 : * corresponds (after conversion to a Unix timestamp) with the traditional
734 : * minimum timestamp of Dec 13 20:45:52 UTC 1901.
735 : */
736 : #define XFS_BIGTIME_TIME_MIN ((int64_t)0)
737 :
738 : /*
739 : * Largest supported ondisk seconds value with bigtime timestamps. This
740 : * corresponds (after conversion to a Unix timestamp) with an incore timestamp
741 : * of Jul 2 20:20:24 UTC 2486.
742 : *
743 : * We round down the ondisk limit so that the bigtime quota and inode max
744 : * timestamps will be the same.
745 : */
746 : #define XFS_BIGTIME_TIME_MAX ((int64_t)((-1ULL / NSEC_PER_SEC) & ~0x3ULL))
747 :
748 : /*
749 : * Bigtime epoch is set exactly to the minimum time value that a traditional
750 : * 32-bit timestamp can represent when using the Unix epoch as a reference.
751 : * Hence the Unix epoch is at a fixed offset into the supported bigtime
752 : * timestamp range.
753 : *
754 : * The bigtime epoch also matches the minimum value an on-disk 32-bit XFS
755 : * timestamp can represent so we will not lose any fidelity in converting
756 : * to/from unix and bigtime timestamps.
757 : *
758 : * The following conversion factor converts a seconds counter from the Unix
759 : * epoch to the bigtime epoch.
760 : */
761 : #define XFS_BIGTIME_EPOCH_OFFSET (-(int64_t)S32_MIN)
762 :
763 : /* Convert a timestamp from the Unix epoch to the bigtime epoch. */
764 : static inline uint64_t xfs_unix_to_bigtime(time64_t unix_seconds)
765 : {
766 9169306114 : return (uint64_t)unix_seconds + XFS_BIGTIME_EPOCH_OFFSET;
767 : }
768 :
769 : /* Convert a timestamp from the bigtime epoch to the Unix epoch. */
770 : static inline time64_t xfs_bigtime_to_unix(uint64_t ondisk_seconds)
771 : {
772 3085436388 : return (time64_t)ondisk_seconds - XFS_BIGTIME_EPOCH_OFFSET;
773 : }
774 :
775 : /*
776 : * On-disk inode structure.
777 : *
778 : * This is just the header or "dinode core", the inode is expanded to fill a
779 : * variable size the leftover area split into a data and an attribute fork.
780 : * The format of the data and attribute fork depends on the format of the
781 : * inode as indicated by di_format and di_aformat. To access the data and
782 : * attribute use the XFS_DFORK_DPTR, XFS_DFORK_APTR, and XFS_DFORK_PTR macros
783 : * below.
784 : *
785 : * There is a very similar struct xfs_log_dinode which matches the layout of
786 : * this structure, but is kept in native format instead of big endian.
787 : *
788 : * Note: di_flushiter is only used by v1/2 inodes - it's effectively a zeroed
789 : * padding field for v3 inodes.
790 : */
791 : #define XFS_DINODE_MAGIC 0x494e /* 'IN' */
792 : struct xfs_dinode {
793 : __be16 di_magic; /* inode magic # = XFS_DINODE_MAGIC */
794 : __be16 di_mode; /* mode and type of file */
795 : __u8 di_version; /* inode version */
796 : __u8 di_format; /* format of di_c data */
797 : __be16 di_onlink; /* old number of links to file */
798 : __be32 di_uid; /* owner's user id */
799 : __be32 di_gid; /* owner's group id */
800 : __be32 di_nlink; /* number of links to file */
801 : __be16 di_projid_lo; /* lower part of owner's project id */
802 : __be16 di_projid_hi; /* higher part owner's project id */
803 : union {
804 : /* Number of data fork extents if NREXT64 is set */
805 : __be64 di_big_nextents;
806 :
807 : /* Padding for V3 inodes without NREXT64 set. */
808 : __be64 di_v3_pad;
809 :
810 : /* Padding and inode flush counter for V2 inodes. */
811 : struct {
812 : __u8 di_v2_pad[6];
813 : __be16 di_flushiter;
814 : };
815 : };
816 : xfs_timestamp_t di_atime; /* time last accessed */
817 : xfs_timestamp_t di_mtime; /* time last modified */
818 : xfs_timestamp_t di_ctime; /* time created/inode modified */
819 : __be64 di_size; /* number of bytes in file */
820 : __be64 di_nblocks; /* # of direct & btree blocks used */
821 : __be32 di_extsize; /* basic/minimum extent size for file */
822 : union {
823 : /*
824 : * For V2 inodes and V3 inodes without NREXT64 set, this
825 : * is the number of data and attr fork extents.
826 : */
827 : struct {
828 : __be32 di_nextents;
829 : __be16 di_anextents;
830 : } __packed;
831 :
832 : /* Number of attr fork extents if NREXT64 is set. */
833 : struct {
834 : __be32 di_big_anextents;
835 : __be16 di_nrext64_pad;
836 : } __packed;
837 : } __packed;
838 : __u8 di_forkoff; /* attr fork offs, <<3 for 64b align */
839 : __s8 di_aformat; /* format of attr fork's data */
840 : __be32 di_dmevmask; /* DMIG event mask */
841 : __be16 di_dmstate; /* DMIG state info */
842 : __be16 di_flags; /* random flags, XFS_DIFLAG_... */
843 : __be32 di_gen; /* generation number */
844 :
845 : /* di_next_unlinked is the only non-core field in the old dinode */
846 : __be32 di_next_unlinked;/* agi unlinked list ptr */
847 :
848 : /* start of the extended dinode, writable fields */
849 : __le32 di_crc; /* CRC of the inode */
850 : __be64 di_changecount; /* number of attribute changes */
851 : __be64 di_lsn; /* flush sequence */
852 : __be64 di_flags2; /* more random flags */
853 : __be32 di_cowextsize; /* basic cow extent size for file */
854 : __u8 di_pad2[12]; /* more padding for future expansion */
855 :
856 : /* fields only written to during inode creation */
857 : xfs_timestamp_t di_crtime; /* time created */
858 : __be64 di_ino; /* inode number */
859 : uuid_t di_uuid; /* UUID of the filesystem */
860 :
861 : /* structure must be padded to 64 bit alignment */
862 : };
863 :
864 : #define XFS_DINODE_CRC_OFF offsetof(struct xfs_dinode, di_crc)
865 :
866 : #define DI_MAX_FLUSH 0xffff
867 :
868 : /*
869 : * Size of the core inode on disk. Version 1 and 2 inodes have
870 : * the same size, but version 3 has grown a few additional fields.
871 : */
872 : static inline uint xfs_dinode_size(int version)
873 : {
874 889308165 : if (version == 3)
875 1027587678 : return sizeof(struct xfs_dinode);
876 : return offsetof(struct xfs_dinode, di_crc);
877 : }
878 :
879 : /*
880 : * The 32 bit link count in the inode theoretically maxes out at UINT_MAX.
881 : * Since the pathconf interface is signed, we use 2^31 - 1 instead.
882 : */
883 : #define XFS_MAXLINK ((1U << 31) - 1U)
884 :
885 : /*
886 : * Values for di_format
887 : *
888 : * This enum is used in string mapping in xfs_trace.h; please keep the
889 : * TRACE_DEFINE_ENUMs for it up to date.
890 : */
891 : enum xfs_dinode_fmt {
892 : XFS_DINODE_FMT_DEV, /* xfs_dev_t */
893 : XFS_DINODE_FMT_LOCAL, /* bulk data */
894 : XFS_DINODE_FMT_EXTENTS, /* struct xfs_bmbt_rec */
895 : XFS_DINODE_FMT_BTREE, /* struct xfs_bmdr_block */
896 : XFS_DINODE_FMT_UUID /* added long ago, but never used */
897 : };
898 :
899 : #define XFS_INODE_FORMAT_STR \
900 : { XFS_DINODE_FMT_DEV, "dev" }, \
901 : { XFS_DINODE_FMT_LOCAL, "local" }, \
902 : { XFS_DINODE_FMT_EXTENTS, "extent" }, \
903 : { XFS_DINODE_FMT_BTREE, "btree" }, \
904 : { XFS_DINODE_FMT_UUID, "uuid" }
905 :
906 : /*
907 : * Max values for extnum and aextnum.
908 : *
909 : * The original on-disk extent counts were held in signed fields, resulting in
910 : * maximum extent counts of 2^31 and 2^15 for the data and attr forks
911 : * respectively. Similarly the maximum extent length is limited to 2^21 blocks
912 : * by the 21-bit wide blockcount field of a BMBT extent record.
913 : *
914 : * The newly introduced data fork extent counter can hold a 64-bit value,
915 : * however the maximum number of extents in a file is also limited to 2^54
916 : * extents by the 54-bit wide startoff field of a BMBT extent record.
917 : *
918 : * It is further limited by the maximum supported file size of 2^63
919 : * *bytes*. This leads to a maximum extent count for maximally sized filesystem
920 : * blocks (64kB) of:
921 : *
922 : * 2^63 bytes / 2^16 bytes per block = 2^47 blocks
923 : *
924 : * Rounding up 47 to the nearest multiple of bits-per-byte results in 48. Hence
925 : * 2^48 was chosen as the maximum data fork extent count.
926 : *
927 : * The maximum file size that can be represented by the data fork extent counter
928 : * in the worst case occurs when all extents are 1 block in length and each
929 : * block is 1KB in size.
930 : *
931 : * With XFS_MAX_EXTCNT_DATA_FORK_SMALL representing maximum extent count and
932 : * with 1KB sized blocks, a file can reach upto,
933 : * 1KB * (2^31) = 2TB
934 : *
935 : * This is much larger than the theoretical maximum size of a directory
936 : * i.e. XFS_DIR2_SPACE_SIZE * XFS_DIR2_MAX_SPACES = ~96GB.
937 : *
938 : * Hence, a directory inode can never overflow its data fork extent counter.
939 : */
940 : #define XFS_MAX_EXTCNT_DATA_FORK_LARGE ((xfs_extnum_t)((1ULL << 48) - 1))
941 : #define XFS_MAX_EXTCNT_ATTR_FORK_LARGE ((xfs_extnum_t)((1ULL << 32) - 1))
942 : #define XFS_MAX_EXTCNT_DATA_FORK_SMALL ((xfs_extnum_t)((1ULL << 31) - 1))
943 : #define XFS_MAX_EXTCNT_ATTR_FORK_SMALL ((xfs_extnum_t)((1ULL << 15) - 1))
944 :
945 : /*
946 : * When we upgrade an inode to the large extent counts, the maximum value by
947 : * which the extent count can increase is bound by the change in size of the
948 : * on-disk field. No upgrade operation should ever be adding more than a few
949 : * tens of extents, so if we get a really large value it is a sign of a code bug
950 : * or corruption.
951 : */
952 : #define XFS_MAX_EXTCNT_UPGRADE_NR \
953 : min(XFS_MAX_EXTCNT_ATTR_FORK_LARGE - XFS_MAX_EXTCNT_ATTR_FORK_SMALL, \
954 : XFS_MAX_EXTCNT_DATA_FORK_LARGE - XFS_MAX_EXTCNT_DATA_FORK_SMALL)
955 :
956 : /*
957 : * Inode minimum and maximum sizes.
958 : */
959 : #define XFS_DINODE_MIN_LOG 8
960 : #define XFS_DINODE_MAX_LOG 11
961 : #define XFS_DINODE_MIN_SIZE (1 << XFS_DINODE_MIN_LOG)
962 : #define XFS_DINODE_MAX_SIZE (1 << XFS_DINODE_MAX_LOG)
963 :
964 : /*
965 : * Inode size for given fs.
966 : */
967 : #define XFS_DINODE_SIZE(mp) \
968 : (xfs_has_v3inodes(mp) ? \
969 : sizeof(struct xfs_dinode) : \
970 : offsetof(struct xfs_dinode, di_crc))
971 : #define XFS_LITINO(mp) \
972 : ((mp)->m_sb.sb_inodesize - XFS_DINODE_SIZE(mp))
973 :
974 : /*
975 : * Inode data & attribute fork sizes, per inode.
976 : */
977 : #define XFS_DFORK_BOFF(dip) ((int)((dip)->di_forkoff << 3))
978 :
979 : #define XFS_DFORK_DSIZE(dip,mp) \
980 : ((dip)->di_forkoff ? XFS_DFORK_BOFF(dip) : XFS_LITINO(mp))
981 : #define XFS_DFORK_ASIZE(dip,mp) \
982 : ((dip)->di_forkoff ? XFS_LITINO(mp) - XFS_DFORK_BOFF(dip) : 0)
983 : #define XFS_DFORK_SIZE(dip,mp,w) \
984 : ((w) == XFS_DATA_FORK ? \
985 : XFS_DFORK_DSIZE(dip, mp) : \
986 : XFS_DFORK_ASIZE(dip, mp))
987 :
988 : #define XFS_DFORK_MAXEXT(dip, mp, w) \
989 : (XFS_DFORK_SIZE(dip, mp, w) / sizeof(struct xfs_bmbt_rec))
990 :
991 : /*
992 : * Return pointers to the data or attribute forks.
993 : */
994 : #define XFS_DFORK_DPTR(dip) \
995 : ((char *)dip + xfs_dinode_size(dip->di_version))
996 : #define XFS_DFORK_APTR(dip) \
997 : (XFS_DFORK_DPTR(dip) + XFS_DFORK_BOFF(dip))
998 : #define XFS_DFORK_PTR(dip,w) \
999 : ((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR(dip) : XFS_DFORK_APTR(dip))
1000 :
1001 : #define XFS_DFORK_FORMAT(dip,w) \
1002 : ((w) == XFS_DATA_FORK ? \
1003 : (dip)->di_format : \
1004 : (dip)->di_aformat)
1005 :
1006 : /*
1007 : * For block and character special files the 32bit dev_t is stored at the
1008 : * beginning of the data fork.
1009 : */
1010 : static inline xfs_dev_t xfs_dinode_get_rdev(struct xfs_dinode *dip)
1011 : {
1012 262552500 : return be32_to_cpu(*(__be32 *)XFS_DFORK_DPTR(dip));
1013 : }
1014 :
1015 : static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
1016 : {
1017 7116093 : *(__be32 *)XFS_DFORK_DPTR(dip) = cpu_to_be32(rdev);
1018 7116093 : }
1019 :
1020 : /*
1021 : * Values for di_flags
1022 : */
1023 : #define XFS_DIFLAG_REALTIME_BIT 0 /* file's blocks come from rt area */
1024 : #define XFS_DIFLAG_PREALLOC_BIT 1 /* file space has been preallocated */
1025 : #define XFS_DIFLAG_NEWRTBM_BIT 2 /* for rtbitmap inode, new format */
1026 : #define XFS_DIFLAG_IMMUTABLE_BIT 3 /* inode is immutable */
1027 : #define XFS_DIFLAG_APPEND_BIT 4 /* inode is append-only */
1028 : #define XFS_DIFLAG_SYNC_BIT 5 /* inode is written synchronously */
1029 : #define XFS_DIFLAG_NOATIME_BIT 6 /* do not update atime */
1030 : #define XFS_DIFLAG_NODUMP_BIT 7 /* do not dump */
1031 : #define XFS_DIFLAG_RTINHERIT_BIT 8 /* create with realtime bit set */
1032 : #define XFS_DIFLAG_PROJINHERIT_BIT 9 /* create with parents projid */
1033 : #define XFS_DIFLAG_NOSYMLINKS_BIT 10 /* disallow symlink creation */
1034 : #define XFS_DIFLAG_EXTSIZE_BIT 11 /* inode extent size allocator hint */
1035 : #define XFS_DIFLAG_EXTSZINHERIT_BIT 12 /* inherit inode extent size */
1036 : #define XFS_DIFLAG_NODEFRAG_BIT 13 /* do not reorganize/defragment */
1037 : #define XFS_DIFLAG_FILESTREAM_BIT 14 /* use filestream allocator */
1038 : /* Do not use bit 15, di_flags is legacy and unchanging now */
1039 :
1040 : #define XFS_DIFLAG_REALTIME (1 << XFS_DIFLAG_REALTIME_BIT)
1041 : #define XFS_DIFLAG_PREALLOC (1 << XFS_DIFLAG_PREALLOC_BIT)
1042 : #define XFS_DIFLAG_NEWRTBM (1 << XFS_DIFLAG_NEWRTBM_BIT)
1043 : #define XFS_DIFLAG_IMMUTABLE (1 << XFS_DIFLAG_IMMUTABLE_BIT)
1044 : #define XFS_DIFLAG_APPEND (1 << XFS_DIFLAG_APPEND_BIT)
1045 : #define XFS_DIFLAG_SYNC (1 << XFS_DIFLAG_SYNC_BIT)
1046 : #define XFS_DIFLAG_NOATIME (1 << XFS_DIFLAG_NOATIME_BIT)
1047 : #define XFS_DIFLAG_NODUMP (1 << XFS_DIFLAG_NODUMP_BIT)
1048 : #define XFS_DIFLAG_RTINHERIT (1 << XFS_DIFLAG_RTINHERIT_BIT)
1049 : #define XFS_DIFLAG_PROJINHERIT (1 << XFS_DIFLAG_PROJINHERIT_BIT)
1050 : #define XFS_DIFLAG_NOSYMLINKS (1 << XFS_DIFLAG_NOSYMLINKS_BIT)
1051 : #define XFS_DIFLAG_EXTSIZE (1 << XFS_DIFLAG_EXTSIZE_BIT)
1052 : #define XFS_DIFLAG_EXTSZINHERIT (1 << XFS_DIFLAG_EXTSZINHERIT_BIT)
1053 : #define XFS_DIFLAG_NODEFRAG (1 << XFS_DIFLAG_NODEFRAG_BIT)
1054 : #define XFS_DIFLAG_FILESTREAM (1 << XFS_DIFLAG_FILESTREAM_BIT)
1055 :
1056 : #define XFS_DIFLAG_ANY \
1057 : (XFS_DIFLAG_REALTIME | XFS_DIFLAG_PREALLOC | XFS_DIFLAG_NEWRTBM | \
1058 : XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND | XFS_DIFLAG_SYNC | \
1059 : XFS_DIFLAG_NOATIME | XFS_DIFLAG_NODUMP | XFS_DIFLAG_RTINHERIT | \
1060 : XFS_DIFLAG_PROJINHERIT | XFS_DIFLAG_NOSYMLINKS | XFS_DIFLAG_EXTSIZE | \
1061 : XFS_DIFLAG_EXTSZINHERIT | XFS_DIFLAG_NODEFRAG | XFS_DIFLAG_FILESTREAM)
1062 :
1063 : /*
1064 : * Values for di_flags2 These start by being exposed to userspace in the upper
1065 : * 16 bits of the XFS_XFLAG_s range.
1066 : */
1067 : #define XFS_DIFLAG2_DAX_BIT 0 /* use DAX for this inode */
1068 : #define XFS_DIFLAG2_REFLINK_BIT 1 /* file's blocks may be shared */
1069 : #define XFS_DIFLAG2_COWEXTSIZE_BIT 2 /* copy on write extent size hint */
1070 : #define XFS_DIFLAG2_BIGTIME_BIT 3 /* big timestamps */
1071 : #define XFS_DIFLAG2_NREXT64_BIT 4 /* large extent counters */
1072 :
1073 : #define XFS_DIFLAG2_DAX (1 << XFS_DIFLAG2_DAX_BIT)
1074 : #define XFS_DIFLAG2_REFLINK (1 << XFS_DIFLAG2_REFLINK_BIT)
1075 : #define XFS_DIFLAG2_COWEXTSIZE (1 << XFS_DIFLAG2_COWEXTSIZE_BIT)
1076 : #define XFS_DIFLAG2_BIGTIME (1 << XFS_DIFLAG2_BIGTIME_BIT)
1077 : #define XFS_DIFLAG2_NREXT64 (1 << XFS_DIFLAG2_NREXT64_BIT)
1078 :
1079 : #define XFS_DIFLAG2_ANY \
1080 : (XFS_DIFLAG2_DAX | XFS_DIFLAG2_REFLINK | XFS_DIFLAG2_COWEXTSIZE | \
1081 : XFS_DIFLAG2_BIGTIME | XFS_DIFLAG2_NREXT64)
1082 :
1083 : static inline bool xfs_dinode_has_bigtime(const struct xfs_dinode *dip)
1084 : {
1085 7714693322 : return dip->di_version >= 3 &&
1086 3857259077 : (dip->di_flags2 & cpu_to_be64(XFS_DIFLAG2_BIGTIME));
1087 : }
1088 :
1089 : static inline bool xfs_dinode_has_large_extent_counts(
1090 : const struct xfs_dinode *dip)
1091 : {
1092 7254860913 : return dip->di_version >= 3 &&
1093 3630389555 : (dip->di_flags2 & cpu_to_be64(XFS_DIFLAG2_NREXT64));
1094 : }
1095 :
1096 : /*
1097 : * Inode number format:
1098 : * low inopblog bits - offset in block
1099 : * next agblklog bits - block number in ag
1100 : * next agno_log bits - ag number
1101 : * high agno_log-agblklog-inopblog bits - 0
1102 : */
1103 : #define XFS_INO_MASK(k) (uint32_t)((1ULL << (k)) - 1)
1104 : #define XFS_INO_OFFSET_BITS(mp) (mp)->m_sb.sb_inopblog
1105 : #define XFS_INO_AGBNO_BITS(mp) (mp)->m_sb.sb_agblklog
1106 : #define XFS_INO_AGINO_BITS(mp) ((mp)->m_ino_geo.agino_log)
1107 : #define XFS_INO_AGNO_BITS(mp) (mp)->m_agno_log
1108 : #define XFS_INO_BITS(mp) \
1109 : XFS_INO_AGNO_BITS(mp) + XFS_INO_AGINO_BITS(mp)
1110 : #define XFS_INO_TO_AGNO(mp,i) \
1111 : ((xfs_agnumber_t)((i) >> XFS_INO_AGINO_BITS(mp)))
1112 : #define XFS_INO_TO_AGINO(mp,i) \
1113 : ((xfs_agino_t)(i) & XFS_INO_MASK(XFS_INO_AGINO_BITS(mp)))
1114 : #define XFS_INO_TO_AGBNO(mp,i) \
1115 : (((xfs_agblock_t)(i) >> XFS_INO_OFFSET_BITS(mp)) & \
1116 : XFS_INO_MASK(XFS_INO_AGBNO_BITS(mp)))
1117 : #define XFS_INO_TO_OFFSET(mp,i) \
1118 : ((int)(i) & XFS_INO_MASK(XFS_INO_OFFSET_BITS(mp)))
1119 : #define XFS_INO_TO_FSB(mp,i) \
1120 : XFS_AGB_TO_FSB(mp, XFS_INO_TO_AGNO(mp,i), XFS_INO_TO_AGBNO(mp,i))
1121 : #define XFS_AGINO_TO_INO(mp,a,i) \
1122 : (((xfs_ino_t)(a) << XFS_INO_AGINO_BITS(mp)) | (i))
1123 : #define XFS_AGINO_TO_AGBNO(mp,i) ((i) >> XFS_INO_OFFSET_BITS(mp))
1124 : #define XFS_AGINO_TO_OFFSET(mp,i) \
1125 : ((i) & XFS_INO_MASK(XFS_INO_OFFSET_BITS(mp)))
1126 : #define XFS_OFFBNO_TO_AGINO(mp,b,o) \
1127 : ((xfs_agino_t)(((b) << XFS_INO_OFFSET_BITS(mp)) | (o)))
1128 : #define XFS_FSB_TO_INO(mp, b) ((xfs_ino_t)((b) << XFS_INO_OFFSET_BITS(mp)))
1129 : #define XFS_AGB_TO_AGINO(mp, b) ((xfs_agino_t)((b) << XFS_INO_OFFSET_BITS(mp)))
1130 :
1131 : #define XFS_MAXINUMBER ((xfs_ino_t)((1ULL << 56) - 1ULL))
1132 : #define XFS_MAXINUMBER_32 ((xfs_ino_t)((1ULL << 32) - 1ULL))
1133 :
1134 : /*
1135 : * RealTime Device format definitions
1136 : */
1137 :
1138 : /* Min and max rt extent sizes, specified in bytes */
1139 : #define XFS_MAX_RTEXTSIZE (1024 * 1024 * 1024) /* 1GB */
1140 : #define XFS_DFL_RTEXTSIZE (64 * 1024) /* 64kB */
1141 : #define XFS_MIN_RTEXTSIZE (4 * 1024) /* 4kB */
1142 :
1143 : #define XFS_BLOCKSIZE(mp) ((mp)->m_sb.sb_blocksize)
1144 : #define XFS_BLOCKMASK(mp) ((mp)->m_blockmask)
1145 : #define XFS_BLOCKWSIZE(mp) ((mp)->m_blockwsize)
1146 : #define XFS_BLOCKWMASK(mp) ((mp)->m_blockwmask)
1147 :
1148 : /*
1149 : * RT Summary and bit manipulation macros.
1150 : */
1151 : #define XFS_SUMOFFS(mp,ls,bb) ((int)((ls) * (mp)->m_sb.sb_rbmblocks + (bb)))
1152 : #define XFS_SUMOFFSTOBLOCK(mp,s) \
1153 : (((s) * (uint)sizeof(xfs_suminfo_t)) >> (mp)->m_sb.sb_blocklog)
1154 : #define XFS_SUMPTR(mp,bp,so) \
1155 : ((xfs_suminfo_t *)((bp)->b_addr + \
1156 : (((so) * (uint)sizeof(xfs_suminfo_t)) & XFS_BLOCKMASK(mp))))
1157 :
1158 : #define XFS_BITTOBLOCK(mp,bi) ((bi) >> (mp)->m_blkbit_log)
1159 : #define XFS_BLOCKTOBIT(mp,bb) ((bb) << (mp)->m_blkbit_log)
1160 : #define XFS_BITTOWORD(mp,bi) \
1161 : ((int)(((bi) >> XFS_NBWORDLOG) & XFS_BLOCKWMASK(mp)))
1162 :
1163 : #define XFS_RTMIN(a,b) ((a) < (b) ? (a) : (b))
1164 : #define XFS_RTMAX(a,b) ((a) > (b) ? (a) : (b))
1165 :
1166 : #define XFS_RTLOBIT(w) xfs_lowbit32(w)
1167 : #define XFS_RTHIBIT(w) xfs_highbit32(w)
1168 :
1169 : #define XFS_RTBLOCKLOG(b) xfs_highbit64(b)
1170 :
1171 : /*
1172 : * Dquot and dquot block format definitions
1173 : */
1174 : #define XFS_DQUOT_MAGIC 0x4451 /* 'DQ' */
1175 : #define XFS_DQUOT_VERSION (uint8_t)0x01 /* latest version number */
1176 :
1177 : #define XFS_DQTYPE_USER (1u << 0) /* user dquot record */
1178 : #define XFS_DQTYPE_PROJ (1u << 1) /* project dquot record */
1179 : #define XFS_DQTYPE_GROUP (1u << 2) /* group dquot record */
1180 : #define XFS_DQTYPE_BIGTIME (1u << 7) /* large expiry timestamps */
1181 :
1182 : /* bitmask to determine if this is a user/group/project dquot */
1183 : #define XFS_DQTYPE_REC_MASK (XFS_DQTYPE_USER | \
1184 : XFS_DQTYPE_PROJ | \
1185 : XFS_DQTYPE_GROUP)
1186 :
1187 : #define XFS_DQTYPE_ANY (XFS_DQTYPE_REC_MASK | \
1188 : XFS_DQTYPE_BIGTIME)
1189 :
1190 : /*
1191 : * XFS Quota Timers
1192 : * ================
1193 : *
1194 : * Traditional quota grace period expiration timers are an unsigned 32-bit
1195 : * seconds counter; time zero is the Unix epoch, Jan 1 00:00:01 UTC 1970.
1196 : * Note that an expiration value of zero means that the quota limit has not
1197 : * been reached, and therefore no expiration has been set. Therefore, the
1198 : * ondisk min and max defined here can be used directly to constrain the incore
1199 : * quota expiration timestamps on a Unix system.
1200 : *
1201 : * When bigtime is enabled, we trade two bits of precision to expand the
1202 : * expiration timeout range to match that of big inode timestamps. The min and
1203 : * max recorded here are the on-disk limits, not a Unix timestamp.
1204 : *
1205 : * The grace period for each quota type is stored in the root dquot (id = 0)
1206 : * and is applied to a non-root dquot when it exceeds the soft or hard limits.
1207 : * The length of quota grace periods are unsigned 32-bit quantities measured in
1208 : * units of seconds. A value of zero means to use the default period.
1209 : */
1210 :
1211 : /*
1212 : * Smallest possible ondisk quota expiration value with traditional timestamps.
1213 : * This corresponds exactly with the incore expiration Jan 1 00:00:01 UTC 1970.
1214 : */
1215 : #define XFS_DQ_LEGACY_EXPIRY_MIN ((int64_t)1)
1216 :
1217 : /*
1218 : * Largest possible ondisk quota expiration value with traditional timestamps.
1219 : * This corresponds exactly with the incore expiration Feb 7 06:28:15 UTC 2106.
1220 : */
1221 : #define XFS_DQ_LEGACY_EXPIRY_MAX ((int64_t)U32_MAX)
1222 :
1223 : /*
1224 : * Smallest possible ondisk quota expiration value with bigtime timestamps.
1225 : * This corresponds (after conversion to a Unix timestamp) with the incore
1226 : * expiration of Jan 1 00:00:04 UTC 1970.
1227 : */
1228 : #define XFS_DQ_BIGTIME_EXPIRY_MIN (XFS_DQ_LEGACY_EXPIRY_MIN)
1229 :
1230 : /*
1231 : * Largest supported ondisk quota expiration value with bigtime timestamps.
1232 : * This corresponds (after conversion to a Unix timestamp) with an incore
1233 : * expiration of Jul 2 20:20:24 UTC 2486.
1234 : *
1235 : * The ondisk field supports values up to -1U, which corresponds to an incore
1236 : * expiration in 2514. This is beyond the maximum the bigtime inode timestamp,
1237 : * so we cap the maximum bigtime quota expiration to the max inode timestamp.
1238 : */
1239 : #define XFS_DQ_BIGTIME_EXPIRY_MAX ((int64_t)4074815106U)
1240 :
1241 : /*
1242 : * The following conversion factors assist in converting a quota expiration
1243 : * timestamp between the incore and ondisk formats.
1244 : */
1245 : #define XFS_DQ_BIGTIME_SHIFT (2)
1246 : #define XFS_DQ_BIGTIME_SLACK ((int64_t)(1ULL << XFS_DQ_BIGTIME_SHIFT) - 1)
1247 :
1248 : /* Convert an incore quota expiration timestamp to an ondisk bigtime value. */
1249 : static inline uint32_t xfs_dq_unix_to_bigtime(time64_t unix_seconds)
1250 : {
1251 : /*
1252 : * Round the expiration timestamp up to the nearest bigtime timestamp
1253 : * that we can store, to give users the most time to fix problems.
1254 : */
1255 23727 : return ((uint64_t)unix_seconds + XFS_DQ_BIGTIME_SLACK) >>
1256 : XFS_DQ_BIGTIME_SHIFT;
1257 : }
1258 :
1259 : /* Convert an ondisk bigtime quota expiration value to an incore timestamp. */
1260 : static inline time64_t xfs_dq_bigtime_to_unix(uint32_t ondisk_seconds)
1261 : {
1262 684 : return (time64_t)ondisk_seconds << XFS_DQ_BIGTIME_SHIFT;
1263 : }
1264 :
1265 : /*
1266 : * Default quota grace periods, ranging from zero (use the compiled defaults)
1267 : * to ~136 years. These are applied to a non-root dquot that has exceeded
1268 : * either limit.
1269 : */
1270 : #define XFS_DQ_GRACE_MIN ((int64_t)0)
1271 : #define XFS_DQ_GRACE_MAX ((int64_t)U32_MAX)
1272 :
1273 : /*
1274 : * This is the main portion of the on-disk representation of quota information
1275 : * for a user. We pad this with some more expansion room to construct the on
1276 : * disk structure.
1277 : */
1278 : struct xfs_disk_dquot {
1279 : __be16 d_magic; /* dquot magic = XFS_DQUOT_MAGIC */
1280 : __u8 d_version; /* dquot version */
1281 : __u8 d_type; /* XFS_DQTYPE_USER/PROJ/GROUP */
1282 : __be32 d_id; /* user,project,group id */
1283 : __be64 d_blk_hardlimit;/* absolute limit on disk blks */
1284 : __be64 d_blk_softlimit;/* preferred limit on disk blks */
1285 : __be64 d_ino_hardlimit;/* maximum # allocated inodes */
1286 : __be64 d_ino_softlimit;/* preferred inode limit */
1287 : __be64 d_bcount; /* disk blocks owned by the user */
1288 : __be64 d_icount; /* inodes owned by the user */
1289 : __be32 d_itimer; /* zero if within inode limits if not,
1290 : this is when we refuse service */
1291 : __be32 d_btimer; /* similar to above; for disk blocks */
1292 : __be16 d_iwarns; /* warnings issued wrt num inodes */
1293 : __be16 d_bwarns; /* warnings issued wrt disk blocks */
1294 : __be32 d_pad0; /* 64 bit align */
1295 : __be64 d_rtb_hardlimit;/* absolute limit on realtime blks */
1296 : __be64 d_rtb_softlimit;/* preferred limit on RT disk blks */
1297 : __be64 d_rtbcount; /* realtime blocks owned */
1298 : __be32 d_rtbtimer; /* similar to above; for RT disk blocks */
1299 : __be16 d_rtbwarns; /* warnings issued wrt RT disk blocks */
1300 : __be16 d_pad;
1301 : };
1302 :
1303 : /*
1304 : * This is what goes on disk. This is separated from the xfs_disk_dquot because
1305 : * carrying the unnecessary padding would be a waste of memory.
1306 : */
1307 : struct xfs_dqblk {
1308 : struct xfs_disk_dquot dd_diskdq; /* portion living incore as well */
1309 : char dd_fill[4];/* filling for posterity */
1310 :
1311 : /*
1312 : * These two are only present on filesystems with the CRC bits set.
1313 : */
1314 : __be32 dd_crc; /* checksum */
1315 : __be64 dd_lsn; /* last modification in log */
1316 : uuid_t dd_uuid; /* location information */
1317 : };
1318 :
1319 : #define XFS_DQUOT_CRC_OFF offsetof(struct xfs_dqblk, dd_crc)
1320 :
1321 : /*
1322 : * This defines the unit of allocation of dquots.
1323 : *
1324 : * Currently, it is just one file system block, and a 4K blk contains 30
1325 : * (136 * 30 = 4080) dquots. It's probably not worth trying to make
1326 : * this more dynamic.
1327 : *
1328 : * However, if this number is changed, we have to make sure that we don't
1329 : * implicitly assume that we do allocations in chunks of a single filesystem
1330 : * block in the dquot/xqm code.
1331 : *
1332 : * This is part of the ondisk format because the structure size is not a power
1333 : * of two, which leaves slack at the end of the disk block.
1334 : */
1335 : #define XFS_DQUOT_CLUSTER_SIZE_FSB (xfs_filblks_t)1
1336 :
1337 : /*
1338 : * Remote symlink format and access functions.
1339 : */
1340 : #define XFS_SYMLINK_MAGIC 0x58534c4d /* XSLM */
1341 :
1342 : struct xfs_dsymlink_hdr {
1343 : __be32 sl_magic;
1344 : __be32 sl_offset;
1345 : __be32 sl_bytes;
1346 : __be32 sl_crc;
1347 : uuid_t sl_uuid;
1348 : __be64 sl_owner;
1349 : __be64 sl_blkno;
1350 : __be64 sl_lsn;
1351 : };
1352 :
1353 : #define XFS_SYMLINK_CRC_OFF offsetof(struct xfs_dsymlink_hdr, sl_crc)
1354 :
1355 : #define XFS_SYMLINK_MAXLEN 1024
1356 : /*
1357 : * The maximum pathlen is 1024 bytes. Since the minimum file system
1358 : * blocksize is 512 bytes, we can get a max of 3 extents back from
1359 : * bmapi when crc headers are taken into account.
1360 : */
1361 : #define XFS_SYMLINK_MAPS 3
1362 :
1363 : #define XFS_SYMLINK_BUF_SPACE(mp, bufsize) \
1364 : ((bufsize) - (xfs_has_crc((mp)) ? \
1365 : sizeof(struct xfs_dsymlink_hdr) : 0))
1366 :
1367 :
1368 : /*
1369 : * Allocation Btree format definitions
1370 : *
1371 : * There are two on-disk btrees, one sorted by blockno and one sorted
1372 : * by blockcount and blockno. All blocks look the same to make the code
1373 : * simpler; if we have time later, we'll make the optimizations.
1374 : */
1375 : #define XFS_ABTB_MAGIC 0x41425442 /* 'ABTB' for bno tree */
1376 : #define XFS_ABTB_CRC_MAGIC 0x41423342 /* 'AB3B' */
1377 : #define XFS_ABTC_MAGIC 0x41425443 /* 'ABTC' for cnt tree */
1378 : #define XFS_ABTC_CRC_MAGIC 0x41423343 /* 'AB3C' */
1379 :
1380 : /*
1381 : * Data record/key structure
1382 : */
1383 : typedef struct xfs_alloc_rec {
1384 : __be32 ar_startblock; /* starting block number */
1385 : __be32 ar_blockcount; /* count of free blocks */
1386 : } xfs_alloc_rec_t, xfs_alloc_key_t;
1387 :
1388 : typedef struct xfs_alloc_rec_incore {
1389 : xfs_agblock_t ar_startblock; /* starting block number */
1390 : xfs_extlen_t ar_blockcount; /* count of free blocks */
1391 : } xfs_alloc_rec_incore_t;
1392 :
1393 : /* btree pointer type */
1394 : typedef __be32 xfs_alloc_ptr_t;
1395 :
1396 : /*
1397 : * Block numbers in the AG:
1398 : * SB is sector 0, AGF is sector 1, AGI is sector 2, AGFL is sector 3.
1399 : */
1400 : #define XFS_BNO_BLOCK(mp) ((xfs_agblock_t)(XFS_AGFL_BLOCK(mp) + 1))
1401 : #define XFS_CNT_BLOCK(mp) ((xfs_agblock_t)(XFS_BNO_BLOCK(mp) + 1))
1402 :
1403 :
1404 : /*
1405 : * Inode Allocation Btree format definitions
1406 : *
1407 : * There is a btree for the inode map per allocation group.
1408 : */
1409 : #define XFS_IBT_MAGIC 0x49414254 /* 'IABT' */
1410 : #define XFS_IBT_CRC_MAGIC 0x49414233 /* 'IAB3' */
1411 : #define XFS_FIBT_MAGIC 0x46494254 /* 'FIBT' */
1412 : #define XFS_FIBT_CRC_MAGIC 0x46494233 /* 'FIB3' */
1413 :
1414 : typedef uint64_t xfs_inofree_t;
1415 : #define XFS_INODES_PER_CHUNK (NBBY * sizeof(xfs_inofree_t))
1416 : #define XFS_INODES_PER_CHUNK_LOG (XFS_NBBYLOG + 3)
1417 : #define XFS_INOBT_ALL_FREE ((xfs_inofree_t)-1)
1418 : #define XFS_INOBT_MASK(i) ((xfs_inofree_t)1 << (i))
1419 :
1420 : #define XFS_INOBT_HOLEMASK_FULL 0 /* holemask for full chunk */
1421 : #define XFS_INOBT_HOLEMASK_BITS (NBBY * sizeof(uint16_t))
1422 : #define XFS_INODES_PER_HOLEMASK_BIT \
1423 : (XFS_INODES_PER_CHUNK / (NBBY * sizeof(uint16_t)))
1424 :
1425 3513842697 : static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
1426 : {
1427 3877591573 : return ((n >= XFS_INODES_PER_CHUNK ? 0 : XFS_INOBT_MASK(n)) - 1) << i;
1428 : }
1429 :
1430 : /*
1431 : * The on-disk inode record structure has two formats. The original "full"
1432 : * format uses a 4-byte freecount. The "sparse" format uses a 1-byte freecount
1433 : * and replaces the 3 high-order freecount bytes wth the holemask and inode
1434 : * count.
1435 : *
1436 : * The holemask of the sparse record format allows an inode chunk to have holes
1437 : * that refer to blocks not owned by the inode record. This facilitates inode
1438 : * allocation in the event of severe free space fragmentation.
1439 : */
1440 : typedef struct xfs_inobt_rec {
1441 : __be32 ir_startino; /* starting inode number */
1442 : union {
1443 : struct {
1444 : __be32 ir_freecount; /* count of free inodes */
1445 : } f;
1446 : struct {
1447 : __be16 ir_holemask;/* hole mask for sparse chunks */
1448 : __u8 ir_count; /* total inode count */
1449 : __u8 ir_freecount; /* count of free inodes */
1450 : } sp;
1451 : } ir_u;
1452 : __be64 ir_free; /* free inode mask */
1453 : } xfs_inobt_rec_t;
1454 :
1455 : typedef struct xfs_inobt_rec_incore {
1456 : xfs_agino_t ir_startino; /* starting inode number */
1457 : uint16_t ir_holemask; /* hole mask for sparse chunks */
1458 : uint8_t ir_count; /* total inode count */
1459 : uint8_t ir_freecount; /* count of free inodes (set bits) */
1460 : xfs_inofree_t ir_free; /* free inode mask */
1461 : } xfs_inobt_rec_incore_t;
1462 :
1463 : static inline bool xfs_inobt_issparse(uint16_t holemask)
1464 : {
1465 : /* non-zero holemask represents a sparse rec. */
1466 : return holemask;
1467 : }
1468 :
1469 : /*
1470 : * Key structure
1471 : */
1472 : typedef struct xfs_inobt_key {
1473 : __be32 ir_startino; /* starting inode number */
1474 : } xfs_inobt_key_t;
1475 :
1476 : /* btree pointer type */
1477 : typedef __be32 xfs_inobt_ptr_t;
1478 :
1479 : /*
1480 : * block numbers in the AG.
1481 : */
1482 : #define XFS_IBT_BLOCK(mp) ((xfs_agblock_t)(XFS_CNT_BLOCK(mp) + 1))
1483 : #define XFS_FIBT_BLOCK(mp) ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
1484 :
1485 : /*
1486 : * Reverse mapping btree format definitions
1487 : *
1488 : * There is a btree for the reverse map per allocation group
1489 : */
1490 : #define XFS_RMAP_CRC_MAGIC 0x524d4233 /* 'RMB3' */
1491 :
1492 : /*
1493 : * Ownership info for an extent. This is used to create reverse-mapping
1494 : * entries.
1495 : */
1496 : #define XFS_OWNER_INFO_ATTR_FORK (1 << 0)
1497 : #define XFS_OWNER_INFO_BMBT_BLOCK (1 << 1)
1498 : struct xfs_owner_info {
1499 : uint64_t oi_owner;
1500 : xfs_fileoff_t oi_offset;
1501 : unsigned int oi_flags;
1502 : };
1503 :
1504 : /*
1505 : * Special owner types.
1506 : *
1507 : * Seeing as we only support up to 8EB, we have the upper bit of the owner field
1508 : * to tell us we have a special owner value. We use these for static metadata
1509 : * allocated at mkfs/growfs time, as well as for freespace management metadata.
1510 : */
1511 : #define XFS_RMAP_OWN_NULL (-1ULL) /* No owner, for growfs */
1512 : #define XFS_RMAP_OWN_UNKNOWN (-2ULL) /* Unknown owner, for EFI recovery */
1513 : #define XFS_RMAP_OWN_FS (-3ULL) /* static fs metadata */
1514 : #define XFS_RMAP_OWN_LOG (-4ULL) /* static fs metadata */
1515 : #define XFS_RMAP_OWN_AG (-5ULL) /* AG freespace btree blocks */
1516 : #define XFS_RMAP_OWN_INOBT (-6ULL) /* Inode btree blocks */
1517 : #define XFS_RMAP_OWN_INODES (-7ULL) /* Inode chunk */
1518 : #define XFS_RMAP_OWN_REFC (-8ULL) /* refcount tree */
1519 : #define XFS_RMAP_OWN_COW (-9ULL) /* cow allocations */
1520 : #define XFS_RMAP_OWN_MIN (-10ULL) /* guard */
1521 :
1522 : #define XFS_RMAP_NON_INODE_OWNER(owner) (!!((owner) & (1ULL << 63)))
1523 :
1524 : /*
1525 : * Data record structure
1526 : */
1527 : struct xfs_rmap_rec {
1528 : __be32 rm_startblock; /* extent start block */
1529 : __be32 rm_blockcount; /* extent length */
1530 : __be64 rm_owner; /* extent owner */
1531 : __be64 rm_offset; /* offset within the owner */
1532 : };
1533 :
1534 : /*
1535 : * rmap btree record
1536 : * rm_offset:63 is the attribute fork flag
1537 : * rm_offset:62 is the bmbt block flag
1538 : * rm_offset:61 is the unwritten extent flag (same as l0:63 in bmbt)
1539 : * rm_offset:54-60 aren't used and should be zero
1540 : * rm_offset:0-53 is the block offset within the inode
1541 : */
1542 : #define XFS_RMAP_OFF_ATTR_FORK ((uint64_t)1ULL << 63)
1543 : #define XFS_RMAP_OFF_BMBT_BLOCK ((uint64_t)1ULL << 62)
1544 : #define XFS_RMAP_OFF_UNWRITTEN ((uint64_t)1ULL << 61)
1545 :
1546 : #define XFS_RMAP_LEN_MAX ((uint32_t)~0U)
1547 : #define XFS_RMAP_OFF_FLAGS (XFS_RMAP_OFF_ATTR_FORK | \
1548 : XFS_RMAP_OFF_BMBT_BLOCK | \
1549 : XFS_RMAP_OFF_UNWRITTEN)
1550 : #define XFS_RMAP_OFF_MASK ((uint64_t)0x3FFFFFFFFFFFFFULL)
1551 :
1552 : #define XFS_RMAP_OFF(off) ((off) & XFS_RMAP_OFF_MASK)
1553 :
1554 : #define XFS_RMAP_IS_BMBT_BLOCK(off) (!!((off) & XFS_RMAP_OFF_BMBT_BLOCK))
1555 : #define XFS_RMAP_IS_ATTR_FORK(off) (!!((off) & XFS_RMAP_OFF_ATTR_FORK))
1556 : #define XFS_RMAP_IS_UNWRITTEN(len) (!!((off) & XFS_RMAP_OFF_UNWRITTEN))
1557 :
1558 : #define RMAPBT_STARTBLOCK_BITLEN 32
1559 : #define RMAPBT_BLOCKCOUNT_BITLEN 32
1560 : #define RMAPBT_OWNER_BITLEN 64
1561 : #define RMAPBT_ATTRFLAG_BITLEN 1
1562 : #define RMAPBT_BMBTFLAG_BITLEN 1
1563 : #define RMAPBT_EXNTFLAG_BITLEN 1
1564 : #define RMAPBT_UNUSED_OFFSET_BITLEN 7
1565 : #define RMAPBT_OFFSET_BITLEN 54
1566 :
1567 : /*
1568 : * Key structure
1569 : *
1570 : * We don't use the length for lookups
1571 : */
1572 : struct xfs_rmap_key {
1573 : __be32 rm_startblock; /* extent start block */
1574 : __be64 rm_owner; /* extent owner */
1575 : __be64 rm_offset; /* offset within the owner */
1576 : } __attribute__((packed));
1577 :
1578 : /* btree pointer type */
1579 : typedef __be32 xfs_rmap_ptr_t;
1580 :
1581 : #define XFS_RMAP_BLOCK(mp) \
1582 : (xfs_has_finobt(((mp))) ? \
1583 : XFS_FIBT_BLOCK(mp) + 1 : \
1584 : XFS_IBT_BLOCK(mp) + 1)
1585 :
1586 : /*
1587 : * Reference Count Btree format definitions
1588 : *
1589 : */
1590 : #define XFS_REFC_CRC_MAGIC 0x52334643 /* 'R3FC' */
1591 :
1592 : unsigned int xfs_refc_block(struct xfs_mount *mp);
1593 :
1594 : /*
1595 : * Data record/key structure
1596 : *
1597 : * Each record associates a range of physical blocks (starting at
1598 : * rc_startblock and ending rc_blockcount blocks later) with a reference
1599 : * count (rc_refcount). Extents that are being used to stage a copy on
1600 : * write (CoW) operation are recorded in the refcount btree with a
1601 : * refcount of 1. All other records must have a refcount > 1 and must
1602 : * track an extent mapped only by file data forks.
1603 : *
1604 : * Extents with a single owner (attributes, metadata, non-shared file
1605 : * data) are not tracked here. Free space is also not tracked here.
1606 : * This is consistent with pre-reflink XFS.
1607 : */
1608 :
1609 : /*
1610 : * Extents that are being used to stage a copy on write are stored
1611 : * in the refcount btree with a refcount of 1 and the upper bit set
1612 : * on the startblock. This speeds up mount time deletion of stale
1613 : * staging extents because they're all at the right side of the tree.
1614 : */
1615 : #define XFS_REFC_COWFLAG (1U << 31)
1616 : #define REFCNTBT_COWFLAG_BITLEN 1
1617 : #define REFCNTBT_AGBLOCK_BITLEN 31
1618 :
1619 : struct xfs_refcount_rec {
1620 : __be32 rc_startblock; /* starting block number */
1621 : __be32 rc_blockcount; /* count of blocks */
1622 : __be32 rc_refcount; /* number of inodes linked here */
1623 : };
1624 :
1625 : struct xfs_refcount_key {
1626 : __be32 rc_startblock; /* starting block number */
1627 : };
1628 :
1629 : #define MAXREFCOUNT ((xfs_nlink_t)~0U)
1630 : #define MAXREFCEXTLEN ((xfs_extlen_t)~0U)
1631 :
1632 : /* btree pointer type */
1633 : typedef __be32 xfs_refcount_ptr_t;
1634 :
1635 :
1636 : /*
1637 : * BMAP Btree format definitions
1638 : *
1639 : * This includes both the root block definition that sits inside an inode fork
1640 : * and the record/pointer formats for the leaf/node in the blocks.
1641 : */
1642 : #define XFS_BMAP_MAGIC 0x424d4150 /* 'BMAP' */
1643 : #define XFS_BMAP_CRC_MAGIC 0x424d4133 /* 'BMA3' */
1644 :
1645 : /*
1646 : * Bmap root header, on-disk form only.
1647 : */
1648 : typedef struct xfs_bmdr_block {
1649 : __be16 bb_level; /* 0 is a leaf */
1650 : __be16 bb_numrecs; /* current # of data records */
1651 : } xfs_bmdr_block_t;
1652 :
1653 : /*
1654 : * Bmap btree record and extent descriptor.
1655 : * l0:63 is an extent flag (value 1 indicates non-normal).
1656 : * l0:9-62 are startoff.
1657 : * l0:0-8 and l1:21-63 are startblock.
1658 : * l1:0-20 are blockcount.
1659 : */
1660 : #define BMBT_EXNTFLAG_BITLEN 1
1661 : #define BMBT_STARTOFF_BITLEN 54
1662 : #define BMBT_STARTBLOCK_BITLEN 52
1663 : #define BMBT_BLOCKCOUNT_BITLEN 21
1664 :
1665 : #define BMBT_STARTOFF_MASK ((1ULL << BMBT_STARTOFF_BITLEN) - 1)
1666 : #define BMBT_BLOCKCOUNT_MASK ((1ULL << BMBT_BLOCKCOUNT_BITLEN) - 1)
1667 :
1668 : #define XFS_MAX_BMBT_EXTLEN ((xfs_extlen_t)(BMBT_BLOCKCOUNT_MASK))
1669 :
1670 : /*
1671 : * bmbt records have a file offset (block) field that is 54 bits wide, so this
1672 : * is the largest xfs_fileoff_t that we ever expect to see.
1673 : */
1674 : #define XFS_MAX_FILEOFF (BMBT_STARTOFF_MASK + BMBT_BLOCKCOUNT_MASK)
1675 :
1676 : typedef struct xfs_bmbt_rec {
1677 : __be64 l0, l1;
1678 : } xfs_bmbt_rec_t;
1679 :
1680 : typedef uint64_t xfs_bmbt_rec_base_t; /* use this for casts */
1681 : typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
1682 :
1683 : /*
1684 : * Values and macros for delayed-allocation startblock fields.
1685 : */
1686 : #define STARTBLOCKVALBITS 17
1687 : #define STARTBLOCKMASKBITS (15 + 20)
1688 : #define STARTBLOCKMASK \
1689 : (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
1690 :
1691 : static inline int isnullstartblock(xfs_fsblock_t x)
1692 : {
1693 16097025334 : return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
1694 : }
1695 :
1696 67804685 : static inline xfs_fsblock_t nullstartblock(int k)
1697 : {
1698 67804685 : ASSERT(k < (1 << STARTBLOCKVALBITS));
1699 67804685 : return STARTBLOCKMASK | (k);
1700 : }
1701 :
1702 : static inline xfs_filblks_t startblockval(xfs_fsblock_t x)
1703 : {
1704 51133916 : return (xfs_filblks_t)((x) & ~STARTBLOCKMASK);
1705 : }
1706 :
1707 : /*
1708 : * Key structure for non-leaf levels of the tree.
1709 : */
1710 : typedef struct xfs_bmbt_key {
1711 : __be64 br_startoff; /* starting file offset */
1712 : } xfs_bmbt_key_t, xfs_bmdr_key_t;
1713 :
1714 : /* btree pointer type */
1715 : typedef __be64 xfs_bmbt_ptr_t, xfs_bmdr_ptr_t;
1716 :
1717 :
1718 : /*
1719 : * Generic Btree block format definitions
1720 : *
1721 : * This is a combination of the actual format used on disk for short and long
1722 : * format btrees. The first three fields are shared by both format, but the
1723 : * pointers are different and should be used with care.
1724 : *
1725 : * To get the size of the actual short or long form headers please use the size
1726 : * macros below. Never use sizeof(xfs_btree_block).
1727 : *
1728 : * The blkno, crc, lsn, owner and uuid fields are only available in filesystems
1729 : * with the crc feature bit, and all accesses to them must be conditional on
1730 : * that flag.
1731 : */
1732 : /* short form block header */
1733 : struct xfs_btree_block_shdr {
1734 : __be32 bb_leftsib;
1735 : __be32 bb_rightsib;
1736 :
1737 : __be64 bb_blkno;
1738 : __be64 bb_lsn;
1739 : uuid_t bb_uuid;
1740 : __be32 bb_owner;
1741 : __le32 bb_crc;
1742 : };
1743 :
1744 : /* long form block header */
1745 : struct xfs_btree_block_lhdr {
1746 : __be64 bb_leftsib;
1747 : __be64 bb_rightsib;
1748 :
1749 : __be64 bb_blkno;
1750 : __be64 bb_lsn;
1751 : uuid_t bb_uuid;
1752 : __be64 bb_owner;
1753 : __le32 bb_crc;
1754 : __be32 bb_pad; /* padding for alignment */
1755 : };
1756 :
1757 : struct xfs_btree_block {
1758 : __be32 bb_magic; /* magic number for block type */
1759 : __be16 bb_level; /* 0 is a leaf */
1760 : __be16 bb_numrecs; /* current # of data records */
1761 : union {
1762 : struct xfs_btree_block_shdr s;
1763 : struct xfs_btree_block_lhdr l;
1764 : } bb_u; /* rest */
1765 : };
1766 :
1767 : /* size of a short form block */
1768 : #define XFS_BTREE_SBLOCK_LEN \
1769 : (offsetof(struct xfs_btree_block, bb_u) + \
1770 : offsetof(struct xfs_btree_block_shdr, bb_blkno))
1771 : /* size of a long form block */
1772 : #define XFS_BTREE_LBLOCK_LEN \
1773 : (offsetof(struct xfs_btree_block, bb_u) + \
1774 : offsetof(struct xfs_btree_block_lhdr, bb_blkno))
1775 :
1776 : /* sizes of CRC enabled btree blocks */
1777 : #define XFS_BTREE_SBLOCK_CRC_LEN \
1778 : (offsetof(struct xfs_btree_block, bb_u) + \
1779 : sizeof(struct xfs_btree_block_shdr))
1780 : #define XFS_BTREE_LBLOCK_CRC_LEN \
1781 : (offsetof(struct xfs_btree_block, bb_u) + \
1782 : sizeof(struct xfs_btree_block_lhdr))
1783 :
1784 : #define XFS_BTREE_SBLOCK_CRC_OFF \
1785 : offsetof(struct xfs_btree_block, bb_u.s.bb_crc)
1786 : #define XFS_BTREE_LBLOCK_CRC_OFF \
1787 : offsetof(struct xfs_btree_block, bb_u.l.bb_crc)
1788 :
1789 : /*
1790 : * On-disk XFS access control list structure.
1791 : */
1792 : struct xfs_acl_entry {
1793 : __be32 ae_tag;
1794 : __be32 ae_id;
1795 : __be16 ae_perm;
1796 : __be16 ae_pad; /* fill the implicit hole in the structure */
1797 : };
1798 :
1799 : struct xfs_acl {
1800 : __be32 acl_cnt;
1801 : struct xfs_acl_entry acl_entry[];
1802 : };
1803 :
1804 : /*
1805 : * The number of ACL entries allowed is defined by the on-disk format.
1806 : * For v4 superblocks, that is limited to 25 entries. For v5 superblocks, it is
1807 : * limited only by the maximum size of the xattr that stores the information.
1808 : */
1809 : #define XFS_ACL_MAX_ENTRIES(mp) \
1810 : (xfs_has_crc(mp) \
1811 : ? (XFS_XATTR_SIZE_MAX - sizeof(struct xfs_acl)) / \
1812 : sizeof(struct xfs_acl_entry) \
1813 : : 25)
1814 :
1815 : #define XFS_ACL_SIZE(cnt) \
1816 : (sizeof(struct xfs_acl) + \
1817 : sizeof(struct xfs_acl_entry) * cnt)
1818 :
1819 : #define XFS_ACL_MAX_SIZE(mp) \
1820 : XFS_ACL_SIZE(XFS_ACL_MAX_ENTRIES((mp)))
1821 :
1822 :
1823 : /* On-disk XFS extended attribute names */
1824 : #define SGI_ACL_FILE "SGI_ACL_FILE"
1825 : #define SGI_ACL_DEFAULT "SGI_ACL_DEFAULT"
1826 : #define SGI_ACL_FILE_SIZE (sizeof(SGI_ACL_FILE)-1)
1827 : #define SGI_ACL_DEFAULT_SIZE (sizeof(SGI_ACL_DEFAULT)-1)
1828 :
1829 : #endif /* __XFS_FORMAT_H__ */
|
