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