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