1
2
3
4
5
6#ifndef __XFS_FORMAT_H__
7#define __XFS_FORMAT_H__
8
9
10
11
12
13
14
15
16
17
18struct xfs_mount;
19struct xfs_trans;
20struct xfs_inode;
21struct xfs_buf;
22struct xfs_ifork;
23
24
25
26
27
28
29#define XFS_SB_MAGIC 0x58465342
30#define XFS_SB_VERSION_1 1
31#define XFS_SB_VERSION_2 2
32#define XFS_SB_VERSION_3 3
33#define XFS_SB_VERSION_4 4
34#define XFS_SB_VERSION_5 5
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
48#define XFS_SB_VERSION_MOREBITSBIT 0x8000
49
50
51
52
53
54
55
56#define XFS_XATTR_SIZE_MAX (1 << 16)
57
58
59
60
61
62
63#define XFS_SB_VERSION_OKBITS \
64 ((XFS_SB_VERSION_NUMBITS | XFS_SB_VERSION_ALLFBITS) & \
65 ~XFS_SB_VERSION_SHAREDBIT)
66
67
68
69
70
71
72
73
74#define XFS_SB_VERSION2_RESERVED1BIT 0x00000001
75#define XFS_SB_VERSION2_LAZYSBCOUNTBIT 0x00000002
76#define XFS_SB_VERSION2_RESERVED4BIT 0x00000004
77#define XFS_SB_VERSION2_ATTR2BIT 0x00000008
78#define XFS_SB_VERSION2_PARENTBIT 0x00000010
79#define XFS_SB_VERSION2_PROJID32BIT 0x00000080
80#define XFS_SB_VERSION2_CRCBIT 0x00000100
81#define XFS_SB_VERSION2_FTYPE 0x00000200
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
90#define XFSLABEL_MAX 12
91
92
93
94
95
96typedef struct xfs_sb {
97 uint32_t sb_magicnum;
98 uint32_t sb_blocksize;
99 xfs_rfsblock_t sb_dblocks;
100 xfs_rfsblock_t sb_rblocks;
101 xfs_rtblock_t sb_rextents;
102 uuid_t sb_uuid;
103 xfs_fsblock_t sb_logstart;
104 xfs_ino_t sb_rootino;
105 xfs_ino_t sb_rbmino;
106 xfs_ino_t sb_rsumino;
107 xfs_agblock_t sb_rextsize;
108 xfs_agblock_t sb_agblocks;
109 xfs_agnumber_t sb_agcount;
110 xfs_extlen_t sb_rbmblocks;
111 xfs_extlen_t sb_logblocks;
112 uint16_t sb_versionnum;
113 uint16_t sb_sectsize;
114 uint16_t sb_inodesize;
115 uint16_t sb_inopblock;
116 char sb_fname[XFSLABEL_MAX];
117 uint8_t sb_blocklog;
118 uint8_t sb_sectlog;
119 uint8_t sb_inodelog;
120 uint8_t sb_inopblog;
121 uint8_t sb_agblklog;
122 uint8_t sb_rextslog;
123 uint8_t sb_inprogress;
124 uint8_t sb_imax_pct;
125
126
127
128
129
130
131 uint64_t sb_icount;
132 uint64_t sb_ifree;
133 uint64_t sb_fdblocks;
134 uint64_t sb_frextents;
135
136
137
138 xfs_ino_t sb_uquotino;
139 xfs_ino_t sb_gquotino;
140 uint16_t sb_qflags;
141 uint8_t sb_flags;
142 uint8_t sb_shared_vn;
143 xfs_extlen_t sb_inoalignmt;
144 uint32_t sb_unit;
145 uint32_t sb_width;
146 uint8_t sb_dirblklog;
147 uint8_t sb_logsectlog;
148 uint16_t sb_logsectsize;
149 uint32_t sb_logsunit;
150 uint32_t sb_features2;
151
152
153
154
155
156
157
158
159
160
161 uint32_t sb_bad_features2;
162
163
164
165
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;
172 xfs_extlen_t sb_spino_align;
173
174 xfs_ino_t sb_pquotino;
175 xfs_lsn_t sb_lsn;
176 uuid_t sb_meta_uuid;
177
178
179} xfs_sb_t;
180
181#define XFS_SB_CRC_OFF offsetof(struct xfs_sb, sb_crc)
182
183
184
185
186
187typedef struct xfs_dsb {
188 __be32 sb_magicnum;
189 __be32 sb_blocksize;
190 __be64 sb_dblocks;
191 __be64 sb_rblocks;
192 __be64 sb_rextents;
193 uuid_t sb_uuid;
194 __be64 sb_logstart;
195 __be64 sb_rootino;
196 __be64 sb_rbmino;
197 __be64 sb_rsumino;
198 __be32 sb_rextsize;
199 __be32 sb_agblocks;
200 __be32 sb_agcount;
201 __be32 sb_rbmblocks;
202 __be32 sb_logblocks;
203 __be16 sb_versionnum;
204 __be16 sb_sectsize;
205 __be16 sb_inodesize;
206 __be16 sb_inopblock;
207 char sb_fname[XFSLABEL_MAX];
208 __u8 sb_blocklog;
209 __u8 sb_sectlog;
210 __u8 sb_inodelog;
211 __u8 sb_inopblog;
212 __u8 sb_agblklog;
213 __u8 sb_rextslog;
214 __u8 sb_inprogress;
215 __u8 sb_imax_pct;
216
217
218
219
220
221
222 __be64 sb_icount;
223 __be64 sb_ifree;
224 __be64 sb_fdblocks;
225 __be64 sb_frextents;
226
227
228
229 __be64 sb_uquotino;
230 __be64 sb_gquotino;
231 __be16 sb_qflags;
232 __u8 sb_flags;
233 __u8 sb_shared_vn;
234 __be32 sb_inoalignmt;
235 __be32 sb_unit;
236 __be32 sb_width;
237 __u8 sb_dirblklog;
238 __u8 sb_logsectlog;
239 __be16 sb_logsectsize;
240 __be32 sb_logsunit;
241 __be32 sb_features2;
242
243
244
245
246
247
248 __be32 sb_bad_features2;
249
250
251
252
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;
259 __be32 sb_spino_align;
260
261 __be64 sb_pquotino;
262 __be64 sb_lsn;
263 uuid_t sb_meta_uuid;
264
265
266} xfs_dsb_t;
267
268
269
270
271
272#define XFS_SBF_NOFLAGS 0x00
273#define XFS_SBF_READONLY 0x01
274
275
276
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
282static 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
289
290
291static inline bool xfs_sb_has_mismatched_features2(struct xfs_sb *sbp)
292{
293 return sbp->sb_bad_features2 != sbp->sb_features2;
294}
295
296static 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
302static inline void xfs_sb_version_addattr(struct xfs_sb *sbp)
303{
304 sbp->sb_versionnum |= XFS_SB_VERSION_ATTRBIT;
305}
306
307static inline void xfs_sb_version_addquota(struct xfs_sb *sbp)
308{
309 sbp->sb_versionnum |= XFS_SB_VERSION_QUOTABIT;
310}
311
312static 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
318static 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
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342#define XFS_SB_FEAT_COMPAT_ALL 0
343#define XFS_SB_FEAT_COMPAT_UNKNOWN ~XFS_SB_FEAT_COMPAT_ALL
344static inline bool
345xfs_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)
353#define XFS_SB_FEAT_RO_COMPAT_RMAPBT (1 << 1)
354#define XFS_SB_FEAT_RO_COMPAT_REFLINK (1 << 2)
355#define XFS_SB_FEAT_RO_COMPAT_INOBTCNT (1 << 3)
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
362static inline bool
363xfs_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)
371#define XFS_SB_FEAT_INCOMPAT_SPINODES (1 << 1)
372#define XFS_SB_FEAT_INCOMPAT_META_UUID (1 << 2)
373#define XFS_SB_FEAT_INCOMPAT_BIGTIME (1 << 3)
374#define XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR (1 << 4)
375#define XFS_SB_FEAT_INCOMPAT_ALL \
376 (XFS_SB_FEAT_INCOMPAT_FTYPE| \
377 XFS_SB_FEAT_INCOMPAT_SPINODES| \
378 XFS_SB_FEAT_INCOMPAT_META_UUID| \
379 XFS_SB_FEAT_INCOMPAT_BIGTIME| \
380 XFS_SB_FEAT_INCOMPAT_NEEDSREPAIR)
381
382#define XFS_SB_FEAT_INCOMPAT_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_ALL
383static inline bool
384xfs_sb_has_incompat_feature(
385 struct xfs_sb *sbp,
386 uint32_t feature)
387{
388 return (sbp->sb_features_incompat & feature) != 0;
389}
390
391#define XFS_SB_FEAT_INCOMPAT_LOG_ALL 0
392#define XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_LOG_ALL
393static inline bool
394xfs_sb_has_incompat_log_feature(
395 struct xfs_sb *sbp,
396 uint32_t feature)
397{
398 return (sbp->sb_features_log_incompat & feature) != 0;
399}
400
401static inline void
402xfs_sb_remove_incompat_log_features(
403 struct xfs_sb *sbp)
404{
405 sbp->sb_features_log_incompat &= ~XFS_SB_FEAT_INCOMPAT_LOG_ALL;
406}
407
408static inline void
409xfs_sb_add_incompat_log_features(
410 struct xfs_sb *sbp,
411 unsigned int features)
412{
413 sbp->sb_features_log_incompat |= features;
414}
415
416
417static inline bool
418xfs_is_quota_inode(struct xfs_sb *sbp, xfs_ino_t ino)
419{
420 return (ino == sbp->sb_uquotino ||
421 ino == sbp->sb_gquotino ||
422 ino == sbp->sb_pquotino);
423}
424
425#define XFS_SB_DADDR ((xfs_daddr_t)0)
426#define XFS_SB_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_SB_DADDR)
427
428#define XFS_HDR_BLOCK(mp,d) ((xfs_agblock_t)XFS_BB_TO_FSBT(mp,d))
429#define XFS_DADDR_TO_FSB(mp,d) XFS_AGB_TO_FSB(mp, \
430 xfs_daddr_to_agno(mp,d), xfs_daddr_to_agbno(mp,d))
431#define XFS_FSB_TO_DADDR(mp,fsbno) XFS_AGB_TO_DADDR(mp, \
432 XFS_FSB_TO_AGNO(mp,fsbno), XFS_FSB_TO_AGBNO(mp,fsbno))
433
434
435
436
437#define XFS_FSS_TO_BB(mp,sec) ((sec) << (mp)->m_sectbb_log)
438
439
440
441
442#define XFS_FSB_TO_BB(mp,fsbno) ((fsbno) << (mp)->m_blkbb_log)
443#define XFS_BB_TO_FSB(mp,bb) \
444 (((bb) + (XFS_FSB_TO_BB(mp,1) - 1)) >> (mp)->m_blkbb_log)
445#define XFS_BB_TO_FSBT(mp,bb) ((bb) >> (mp)->m_blkbb_log)
446
447
448
449
450#define XFS_FSB_TO_B(mp,fsbno) ((xfs_fsize_t)(fsbno) << (mp)->m_sb.sb_blocklog)
451#define XFS_B_TO_FSB(mp,b) \
452 ((((uint64_t)(b)) + (mp)->m_blockmask) >> (mp)->m_sb.sb_blocklog)
453#define XFS_B_TO_FSBT(mp,b) (((uint64_t)(b)) >> (mp)->m_sb.sb_blocklog)
454
455
456
457
458
459
460
461#define XFS_AGF_MAGIC 0x58414746
462#define XFS_AGI_MAGIC 0x58414749
463#define XFS_AGFL_MAGIC 0x5841464c
464#define XFS_AGF_VERSION 1
465#define XFS_AGI_VERSION 1
466
467#define XFS_AGF_GOOD_VERSION(v) ((v) == XFS_AGF_VERSION)
468#define XFS_AGI_GOOD_VERSION(v) ((v) == XFS_AGI_VERSION)
469
470
471
472
473
474#define XFS_BTNUM_AGF ((int)XFS_BTNUM_RMAPi + 1)
475
476
477
478
479
480
481
482typedef struct xfs_agf {
483
484
485
486 __be32 agf_magicnum;
487 __be32 agf_versionnum;
488 __be32 agf_seqno;
489 __be32 agf_length;
490
491
492
493 __be32 agf_roots[XFS_BTNUM_AGF];
494 __be32 agf_levels[XFS_BTNUM_AGF];
495
496 __be32 agf_flfirst;
497 __be32 agf_fllast;
498 __be32 agf_flcount;
499 __be32 agf_freeblks;
500
501 __be32 agf_longest;
502 __be32 agf_btreeblks;
503 uuid_t agf_uuid;
504
505 __be32 agf_rmap_blocks;
506 __be32 agf_refcount_blocks;
507
508 __be32 agf_refcount_root;
509 __be32 agf_refcount_level;
510
511
512
513
514
515
516 __be64 agf_spare64[14];
517
518
519 __be64 agf_lsn;
520 __be32 agf_crc;
521 __be32 agf_spare2;
522
523
524} xfs_agf_t;
525
526#define XFS_AGF_CRC_OFF offsetof(struct xfs_agf, agf_crc)
527
528#define XFS_AGF_MAGICNUM 0x00000001
529#define XFS_AGF_VERSIONNUM 0x00000002
530#define XFS_AGF_SEQNO 0x00000004
531#define XFS_AGF_LENGTH 0x00000008
532#define XFS_AGF_ROOTS 0x00000010
533#define XFS_AGF_LEVELS 0x00000020
534#define XFS_AGF_FLFIRST 0x00000040
535#define XFS_AGF_FLLAST 0x00000080
536#define XFS_AGF_FLCOUNT 0x00000100
537#define XFS_AGF_FREEBLKS 0x00000200
538#define XFS_AGF_LONGEST 0x00000400
539#define XFS_AGF_BTREEBLKS 0x00000800
540#define XFS_AGF_UUID 0x00001000
541#define XFS_AGF_RMAP_BLOCKS 0x00002000
542#define XFS_AGF_REFCOUNT_BLOCKS 0x00004000
543#define XFS_AGF_REFCOUNT_ROOT 0x00008000
544#define XFS_AGF_REFCOUNT_LEVEL 0x00010000
545#define XFS_AGF_SPARE64 0x00020000
546#define XFS_AGF_NUM_BITS 18
547#define XFS_AGF_ALL_BITS ((1 << XFS_AGF_NUM_BITS) - 1)
548
549#define XFS_AGF_FLAGS \
550 { XFS_AGF_MAGICNUM, "MAGICNUM" }, \
551 { XFS_AGF_VERSIONNUM, "VERSIONNUM" }, \
552 { XFS_AGF_SEQNO, "SEQNO" }, \
553 { XFS_AGF_LENGTH, "LENGTH" }, \
554 { XFS_AGF_ROOTS, "ROOTS" }, \
555 { XFS_AGF_LEVELS, "LEVELS" }, \
556 { XFS_AGF_FLFIRST, "FLFIRST" }, \
557 { XFS_AGF_FLLAST, "FLLAST" }, \
558 { XFS_AGF_FLCOUNT, "FLCOUNT" }, \
559 { XFS_AGF_FREEBLKS, "FREEBLKS" }, \
560 { XFS_AGF_LONGEST, "LONGEST" }, \
561 { XFS_AGF_BTREEBLKS, "BTREEBLKS" }, \
562 { XFS_AGF_UUID, "UUID" }, \
563 { XFS_AGF_RMAP_BLOCKS, "RMAP_BLOCKS" }, \
564 { XFS_AGF_REFCOUNT_BLOCKS, "REFCOUNT_BLOCKS" }, \
565 { XFS_AGF_REFCOUNT_ROOT, "REFCOUNT_ROOT" }, \
566 { XFS_AGF_REFCOUNT_LEVEL, "REFCOUNT_LEVEL" }, \
567 { XFS_AGF_SPARE64, "SPARE64" }
568
569
570#define XFS_AGF_DADDR(mp) ((xfs_daddr_t)(1 << (mp)->m_sectbb_log))
571#define XFS_AGF_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGF_DADDR(mp))
572
573
574
575
576#define XFS_AGI_UNLINKED_BUCKETS 64
577
578typedef struct xfs_agi {
579
580
581
582 __be32 agi_magicnum;
583 __be32 agi_versionnum;
584 __be32 agi_seqno;
585 __be32 agi_length;
586
587
588
589
590
591 __be32 agi_count;
592 __be32 agi_root;
593 __be32 agi_level;
594 __be32 agi_freecount;
595
596 __be32 agi_newino;
597 __be32 agi_dirino;
598
599
600
601
602 __be32 agi_unlinked[XFS_AGI_UNLINKED_BUCKETS];
603
604
605
606 uuid_t agi_uuid;
607 __be32 agi_crc;
608 __be32 agi_pad32;
609 __be64 agi_lsn;
610
611 __be32 agi_free_root;
612 __be32 agi_free_level;
613
614 __be32 agi_iblocks;
615 __be32 agi_fblocks;
616
617
618} xfs_agi_t;
619
620#define XFS_AGI_CRC_OFF offsetof(struct xfs_agi, agi_crc)
621
622#define XFS_AGI_MAGICNUM (1 << 0)
623#define XFS_AGI_VERSIONNUM (1 << 1)
624#define XFS_AGI_SEQNO (1 << 2)
625#define XFS_AGI_LENGTH (1 << 3)
626#define XFS_AGI_COUNT (1 << 4)
627#define XFS_AGI_ROOT (1 << 5)
628#define XFS_AGI_LEVEL (1 << 6)
629#define XFS_AGI_FREECOUNT (1 << 7)
630#define XFS_AGI_NEWINO (1 << 8)
631#define XFS_AGI_DIRINO (1 << 9)
632#define XFS_AGI_UNLINKED (1 << 10)
633#define XFS_AGI_NUM_BITS_R1 11
634#define XFS_AGI_ALL_BITS_R1 ((1 << XFS_AGI_NUM_BITS_R1) - 1)
635#define XFS_AGI_FREE_ROOT (1 << 11)
636#define XFS_AGI_FREE_LEVEL (1 << 12)
637#define XFS_AGI_IBLOCKS (1 << 13)
638#define XFS_AGI_NUM_BITS_R2 14
639
640
641#define XFS_AGI_DADDR(mp) ((xfs_daddr_t)(2 << (mp)->m_sectbb_log))
642#define XFS_AGI_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGI_DADDR(mp))
643
644
645
646
647
648#define XFS_AGFL_DADDR(mp) ((xfs_daddr_t)(3 << (mp)->m_sectbb_log))
649#define XFS_AGFL_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGFL_DADDR(mp))
650#define XFS_BUF_TO_AGFL(bp) ((struct xfs_agfl *)((bp)->b_addr))
651
652struct xfs_agfl {
653 __be32 agfl_magicnum;
654 __be32 agfl_seqno;
655 uuid_t agfl_uuid;
656 __be64 agfl_lsn;
657 __be32 agfl_crc;
658} __attribute__((packed));
659
660#define XFS_AGFL_CRC_OFF offsetof(struct xfs_agfl, agfl_crc)
661
662#define XFS_AGB_TO_FSB(mp,agno,agbno) \
663 (((xfs_fsblock_t)(agno) << (mp)->m_sb.sb_agblklog) | (agbno))
664#define XFS_FSB_TO_AGNO(mp,fsbno) \
665 ((xfs_agnumber_t)((fsbno) >> (mp)->m_sb.sb_agblklog))
666#define XFS_FSB_TO_AGBNO(mp,fsbno) \
667 ((xfs_agblock_t)((fsbno) & xfs_mask32lo((mp)->m_sb.sb_agblklog)))
668#define XFS_AGB_TO_DADDR(mp,agno,agbno) \
669 ((xfs_daddr_t)XFS_FSB_TO_BB(mp, \
670 (xfs_fsblock_t)(agno) * (mp)->m_sb.sb_agblocks + (agbno)))
671#define XFS_AG_DADDR(mp,agno,d) (XFS_AGB_TO_DADDR(mp, agno, 0) + (d))
672
673
674
675
676
677#define XFS_AG_CHECK_DADDR(mp,d,len) \
678 ((len) == 1 ? \
679 ASSERT((d) == XFS_SB_DADDR || \
680 xfs_daddr_to_agbno(mp, d) != XFS_SB_DADDR) : \
681 ASSERT(xfs_daddr_to_agno(mp, d) == \
682 xfs_daddr_to_agno(mp, (d) + (len) - 1)))
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702typedef __be64 xfs_timestamp_t;
703
704
705struct xfs_legacy_timestamp {
706 __be32 t_sec;
707 __be32 t_nsec;
708};
709
710
711
712
713
714#define XFS_LEGACY_TIME_MIN ((int64_t)S32_MIN)
715
716
717
718
719
720#define XFS_LEGACY_TIME_MAX ((int64_t)S32_MAX)
721
722
723
724
725
726
727#define XFS_BIGTIME_TIME_MIN ((int64_t)0)
728
729
730
731
732
733
734
735
736
737#define XFS_BIGTIME_TIME_MAX ((int64_t)((-1ULL / NSEC_PER_SEC) & ~0x3ULL))
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752#define XFS_BIGTIME_EPOCH_OFFSET (-(int64_t)S32_MIN)
753
754
755static inline uint64_t xfs_unix_to_bigtime(time64_t unix_seconds)
756{
757 return (uint64_t)unix_seconds + XFS_BIGTIME_EPOCH_OFFSET;
758}
759
760
761static inline time64_t xfs_bigtime_to_unix(uint64_t ondisk_seconds)
762{
763 return (time64_t)ondisk_seconds - XFS_BIGTIME_EPOCH_OFFSET;
764}
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782#define XFS_DINODE_MAGIC 0x494e
783typedef struct xfs_dinode {
784 __be16 di_magic;
785 __be16 di_mode;
786 __u8 di_version;
787 __u8 di_format;
788 __be16 di_onlink;
789 __be32 di_uid;
790 __be32 di_gid;
791 __be32 di_nlink;
792 __be16 di_projid_lo;
793 __be16 di_projid_hi;
794 __u8 di_pad[6];
795 __be16 di_flushiter;
796 xfs_timestamp_t di_atime;
797 xfs_timestamp_t di_mtime;
798 xfs_timestamp_t di_ctime;
799 __be64 di_size;
800 __be64 di_nblocks;
801 __be32 di_extsize;
802 __be32 di_nextents;
803 __be16 di_anextents;
804 __u8 di_forkoff;
805 __s8 di_aformat;
806 __be32 di_dmevmask;
807 __be16 di_dmstate;
808 __be16 di_flags;
809 __be32 di_gen;
810
811
812 __be32 di_next_unlinked;
813
814
815 __le32 di_crc;
816 __be64 di_changecount;
817 __be64 di_lsn;
818 __be64 di_flags2;
819 __be32 di_cowextsize;
820 __u8 di_pad2[12];
821
822
823 xfs_timestamp_t di_crtime;
824 __be64 di_ino;
825 uuid_t di_uuid;
826
827
828} xfs_dinode_t;
829
830#define XFS_DINODE_CRC_OFF offsetof(struct xfs_dinode, di_crc)
831
832#define DI_MAX_FLUSH 0xffff
833
834
835
836
837
838static inline uint xfs_dinode_size(int version)
839{
840 if (version == 3)
841 return sizeof(struct xfs_dinode);
842 return offsetof(struct xfs_dinode, di_crc);
843}
844
845
846
847
848
849#define XFS_MAXLINK ((1U << 31) - 1U)
850
851
852
853
854
855
856
857enum xfs_dinode_fmt {
858 XFS_DINODE_FMT_DEV,
859 XFS_DINODE_FMT_LOCAL,
860 XFS_DINODE_FMT_EXTENTS,
861 XFS_DINODE_FMT_BTREE,
862 XFS_DINODE_FMT_UUID
863};
864
865#define XFS_INODE_FORMAT_STR \
866 { XFS_DINODE_FMT_DEV, "dev" }, \
867 { XFS_DINODE_FMT_LOCAL, "local" }, \
868 { XFS_DINODE_FMT_EXTENTS, "extent" }, \
869 { XFS_DINODE_FMT_BTREE, "btree" }, \
870 { XFS_DINODE_FMT_UUID, "uuid" }
871
872
873
874
875#define XFS_DINODE_MIN_LOG 8
876#define XFS_DINODE_MAX_LOG 11
877#define XFS_DINODE_MIN_SIZE (1 << XFS_DINODE_MIN_LOG)
878#define XFS_DINODE_MAX_SIZE (1 << XFS_DINODE_MAX_LOG)
879
880
881
882
883#define XFS_DINODE_SIZE(mp) \
884 (xfs_has_v3inodes(mp) ? \
885 sizeof(struct xfs_dinode) : \
886 offsetof(struct xfs_dinode, di_crc))
887#define XFS_LITINO(mp) \
888 ((mp)->m_sb.sb_inodesize - XFS_DINODE_SIZE(mp))
889
890
891
892
893#define XFS_DFORK_BOFF(dip) ((int)((dip)->di_forkoff << 3))
894
895#define XFS_DFORK_DSIZE(dip,mp) \
896 ((dip)->di_forkoff ? XFS_DFORK_BOFF(dip) : XFS_LITINO(mp))
897#define XFS_DFORK_ASIZE(dip,mp) \
898 ((dip)->di_forkoff ? XFS_LITINO(mp) - XFS_DFORK_BOFF(dip) : 0)
899#define XFS_DFORK_SIZE(dip,mp,w) \
900 ((w) == XFS_DATA_FORK ? \
901 XFS_DFORK_DSIZE(dip, mp) : \
902 XFS_DFORK_ASIZE(dip, mp))
903
904#define XFS_DFORK_MAXEXT(dip, mp, w) \
905 (XFS_DFORK_SIZE(dip, mp, w) / sizeof(struct xfs_bmbt_rec))
906
907
908
909
910#define XFS_DFORK_DPTR(dip) \
911 ((char *)dip + xfs_dinode_size(dip->di_version))
912#define XFS_DFORK_APTR(dip) \
913 (XFS_DFORK_DPTR(dip) + XFS_DFORK_BOFF(dip))
914#define XFS_DFORK_PTR(dip,w) \
915 ((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR(dip) : XFS_DFORK_APTR(dip))
916
917#define XFS_DFORK_FORMAT(dip,w) \
918 ((w) == XFS_DATA_FORK ? \
919 (dip)->di_format : \
920 (dip)->di_aformat)
921#define XFS_DFORK_NEXTENTS(dip,w) \
922 ((w) == XFS_DATA_FORK ? \
923 be32_to_cpu((dip)->di_nextents) : \
924 be16_to_cpu((dip)->di_anextents))
925
926
927
928
929
930static inline xfs_dev_t xfs_dinode_get_rdev(struct xfs_dinode *dip)
931{
932 return be32_to_cpu(*(__be32 *)XFS_DFORK_DPTR(dip));
933}
934
935static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
936{
937 *(__be32 *)XFS_DFORK_DPTR(dip) = cpu_to_be32(rdev);
938}
939
940
941
942
943#define XFS_DIFLAG_REALTIME_BIT 0
944#define XFS_DIFLAG_PREALLOC_BIT 1
945#define XFS_DIFLAG_NEWRTBM_BIT 2
946#define XFS_DIFLAG_IMMUTABLE_BIT 3
947#define XFS_DIFLAG_APPEND_BIT 4
948#define XFS_DIFLAG_SYNC_BIT 5
949#define XFS_DIFLAG_NOATIME_BIT 6
950#define XFS_DIFLAG_NODUMP_BIT 7
951#define XFS_DIFLAG_RTINHERIT_BIT 8
952#define XFS_DIFLAG_PROJINHERIT_BIT 9
953#define XFS_DIFLAG_NOSYMLINKS_BIT 10
954#define XFS_DIFLAG_EXTSIZE_BIT 11
955#define XFS_DIFLAG_EXTSZINHERIT_BIT 12
956#define XFS_DIFLAG_NODEFRAG_BIT 13
957#define XFS_DIFLAG_FILESTREAM_BIT 14
958
959
960#define XFS_DIFLAG_REALTIME (1 << XFS_DIFLAG_REALTIME_BIT)
961#define XFS_DIFLAG_PREALLOC (1 << XFS_DIFLAG_PREALLOC_BIT)
962#define XFS_DIFLAG_NEWRTBM (1 << XFS_DIFLAG_NEWRTBM_BIT)
963#define XFS_DIFLAG_IMMUTABLE (1 << XFS_DIFLAG_IMMUTABLE_BIT)
964#define XFS_DIFLAG_APPEND (1 << XFS_DIFLAG_APPEND_BIT)
965#define XFS_DIFLAG_SYNC (1 << XFS_DIFLAG_SYNC_BIT)
966#define XFS_DIFLAG_NOATIME (1 << XFS_DIFLAG_NOATIME_BIT)
967#define XFS_DIFLAG_NODUMP (1 << XFS_DIFLAG_NODUMP_BIT)
968#define XFS_DIFLAG_RTINHERIT (1 << XFS_DIFLAG_RTINHERIT_BIT)
969#define XFS_DIFLAG_PROJINHERIT (1 << XFS_DIFLAG_PROJINHERIT_BIT)
970#define XFS_DIFLAG_NOSYMLINKS (1 << XFS_DIFLAG_NOSYMLINKS_BIT)
971#define XFS_DIFLAG_EXTSIZE (1 << XFS_DIFLAG_EXTSIZE_BIT)
972#define XFS_DIFLAG_EXTSZINHERIT (1 << XFS_DIFLAG_EXTSZINHERIT_BIT)
973#define XFS_DIFLAG_NODEFRAG (1 << XFS_DIFLAG_NODEFRAG_BIT)
974#define XFS_DIFLAG_FILESTREAM (1 << XFS_DIFLAG_FILESTREAM_BIT)
975
976#define XFS_DIFLAG_ANY \
977 (XFS_DIFLAG_REALTIME | XFS_DIFLAG_PREALLOC | XFS_DIFLAG_NEWRTBM | \
978 XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND | XFS_DIFLAG_SYNC | \
979 XFS_DIFLAG_NOATIME | XFS_DIFLAG_NODUMP | XFS_DIFLAG_RTINHERIT | \
980 XFS_DIFLAG_PROJINHERIT | XFS_DIFLAG_NOSYMLINKS | XFS_DIFLAG_EXTSIZE | \
981 XFS_DIFLAG_EXTSZINHERIT | XFS_DIFLAG_NODEFRAG | XFS_DIFLAG_FILESTREAM)
982
983
984
985
986
987#define XFS_DIFLAG2_DAX_BIT 0
988#define XFS_DIFLAG2_REFLINK_BIT 1
989#define XFS_DIFLAG2_COWEXTSIZE_BIT 2
990#define XFS_DIFLAG2_BIGTIME_BIT 3
991
992#define XFS_DIFLAG2_DAX (1 << XFS_DIFLAG2_DAX_BIT)
993#define XFS_DIFLAG2_REFLINK (1 << XFS_DIFLAG2_REFLINK_BIT)
994#define XFS_DIFLAG2_COWEXTSIZE (1 << XFS_DIFLAG2_COWEXTSIZE_BIT)
995#define XFS_DIFLAG2_BIGTIME (1 << XFS_DIFLAG2_BIGTIME_BIT)
996
997#define XFS_DIFLAG2_ANY \
998 (XFS_DIFLAG2_DAX | XFS_DIFLAG2_REFLINK | XFS_DIFLAG2_COWEXTSIZE | \
999 XFS_DIFLAG2_BIGTIME)
1000
1001static inline bool xfs_dinode_has_bigtime(const struct xfs_dinode *dip)
1002{
1003 return dip->di_version >= 3 &&
1004 (dip->di_flags2 & cpu_to_be64(XFS_DIFLAG2_BIGTIME));
1005}
1006
1007
1008
1009
1010
1011
1012
1013
1014#define XFS_INO_MASK(k) (uint32_t)((1ULL << (k)) - 1)
1015#define XFS_INO_OFFSET_BITS(mp) (mp)->m_sb.sb_inopblog
1016#define XFS_INO_AGBNO_BITS(mp) (mp)->m_sb.sb_agblklog
1017#define XFS_INO_AGINO_BITS(mp) ((mp)->m_ino_geo.agino_log)
1018#define XFS_INO_AGNO_BITS(mp) (mp)->m_agno_log
1019#define XFS_INO_BITS(mp) \
1020 XFS_INO_AGNO_BITS(mp) + XFS_INO_AGINO_BITS(mp)
1021#define XFS_INO_TO_AGNO(mp,i) \
1022 ((xfs_agnumber_t)((i) >> XFS_INO_AGINO_BITS(mp)))
1023#define XFS_INO_TO_AGINO(mp,i) \
1024 ((xfs_agino_t)(i) & XFS_INO_MASK(XFS_INO_AGINO_BITS(mp)))
1025#define XFS_INO_TO_AGBNO(mp,i) \
1026 (((xfs_agblock_t)(i) >> XFS_INO_OFFSET_BITS(mp)) & \
1027 XFS_INO_MASK(XFS_INO_AGBNO_BITS(mp)))
1028#define XFS_INO_TO_OFFSET(mp,i) \
1029 ((int)(i) & XFS_INO_MASK(XFS_INO_OFFSET_BITS(mp)))
1030#define XFS_INO_TO_FSB(mp,i) \
1031 XFS_AGB_TO_FSB(mp, XFS_INO_TO_AGNO(mp,i), XFS_INO_TO_AGBNO(mp,i))
1032#define XFS_AGINO_TO_INO(mp,a,i) \
1033 (((xfs_ino_t)(a) << XFS_INO_AGINO_BITS(mp)) | (i))
1034#define XFS_AGINO_TO_AGBNO(mp,i) ((i) >> XFS_INO_OFFSET_BITS(mp))
1035#define XFS_AGINO_TO_OFFSET(mp,i) \
1036 ((i) & XFS_INO_MASK(XFS_INO_OFFSET_BITS(mp)))
1037#define XFS_OFFBNO_TO_AGINO(mp,b,o) \
1038 ((xfs_agino_t)(((b) << XFS_INO_OFFSET_BITS(mp)) | (o)))
1039#define XFS_FSB_TO_INO(mp, b) ((xfs_ino_t)((b) << XFS_INO_OFFSET_BITS(mp)))
1040#define XFS_AGB_TO_AGINO(mp, b) ((xfs_agino_t)((b) << XFS_INO_OFFSET_BITS(mp)))
1041
1042#define XFS_MAXINUMBER ((xfs_ino_t)((1ULL << 56) - 1ULL))
1043#define XFS_MAXINUMBER_32 ((xfs_ino_t)((1ULL << 32) - 1ULL))
1044
1045
1046
1047
1048
1049
1050#define XFS_MAX_RTEXTSIZE (1024 * 1024 * 1024)
1051#define XFS_DFL_RTEXTSIZE (64 * 1024)
1052#define XFS_MIN_RTEXTSIZE (4 * 1024)
1053
1054#define XFS_BLOCKSIZE(mp) ((mp)->m_sb.sb_blocksize)
1055#define XFS_BLOCKMASK(mp) ((mp)->m_blockmask)
1056#define XFS_BLOCKWSIZE(mp) ((mp)->m_blockwsize)
1057#define XFS_BLOCKWMASK(mp) ((mp)->m_blockwmask)
1058
1059
1060
1061
1062#define XFS_SUMOFFS(mp,ls,bb) ((int)((ls) * (mp)->m_sb.sb_rbmblocks + (bb)))
1063#define XFS_SUMOFFSTOBLOCK(mp,s) \
1064 (((s) * (uint)sizeof(xfs_suminfo_t)) >> (mp)->m_sb.sb_blocklog)
1065#define XFS_SUMPTR(mp,bp,so) \
1066 ((xfs_suminfo_t *)((bp)->b_addr + \
1067 (((so) * (uint)sizeof(xfs_suminfo_t)) & XFS_BLOCKMASK(mp))))
1068
1069#define XFS_BITTOBLOCK(mp,bi) ((bi) >> (mp)->m_blkbit_log)
1070#define XFS_BLOCKTOBIT(mp,bb) ((bb) << (mp)->m_blkbit_log)
1071#define XFS_BITTOWORD(mp,bi) \
1072 ((int)(((bi) >> XFS_NBWORDLOG) & XFS_BLOCKWMASK(mp)))
1073
1074#define XFS_RTMIN(a,b) ((a) < (b) ? (a) : (b))
1075#define XFS_RTMAX(a,b) ((a) > (b) ? (a) : (b))
1076
1077#define XFS_RTLOBIT(w) xfs_lowbit32(w)
1078#define XFS_RTHIBIT(w) xfs_highbit32(w)
1079
1080#define XFS_RTBLOCKLOG(b) xfs_highbit64(b)
1081
1082
1083
1084
1085#define XFS_DQUOT_MAGIC 0x4451
1086#define XFS_DQUOT_VERSION (uint8_t)0x01
1087
1088#define XFS_DQTYPE_USER 0x01
1089#define XFS_DQTYPE_PROJ 0x02
1090#define XFS_DQTYPE_GROUP 0x04
1091#define XFS_DQTYPE_BIGTIME 0x80
1092
1093
1094#define XFS_DQTYPE_REC_MASK (XFS_DQTYPE_USER | \
1095 XFS_DQTYPE_PROJ | \
1096 XFS_DQTYPE_GROUP)
1097
1098#define XFS_DQTYPE_ANY (XFS_DQTYPE_REC_MASK | \
1099 XFS_DQTYPE_BIGTIME)
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126#define XFS_DQ_LEGACY_EXPIRY_MIN ((int64_t)1)
1127
1128
1129
1130
1131
1132#define XFS_DQ_LEGACY_EXPIRY_MAX ((int64_t)U32_MAX)
1133
1134
1135
1136
1137
1138
1139#define XFS_DQ_BIGTIME_EXPIRY_MIN (XFS_DQ_LEGACY_EXPIRY_MIN)
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150#define XFS_DQ_BIGTIME_EXPIRY_MAX ((int64_t)4074815106U)
1151
1152
1153
1154
1155
1156#define XFS_DQ_BIGTIME_SHIFT (2)
1157#define XFS_DQ_BIGTIME_SLACK ((int64_t)(1ULL << XFS_DQ_BIGTIME_SHIFT) - 1)
1158
1159
1160static inline uint32_t xfs_dq_unix_to_bigtime(time64_t unix_seconds)
1161{
1162
1163
1164
1165
1166 return ((uint64_t)unix_seconds + XFS_DQ_BIGTIME_SLACK) >>
1167 XFS_DQ_BIGTIME_SHIFT;
1168}
1169
1170
1171static inline time64_t xfs_dq_bigtime_to_unix(uint32_t ondisk_seconds)
1172{
1173 return (time64_t)ondisk_seconds << XFS_DQ_BIGTIME_SHIFT;
1174}
1175
1176
1177
1178
1179
1180
1181#define XFS_DQ_GRACE_MIN ((int64_t)0)
1182#define XFS_DQ_GRACE_MAX ((int64_t)U32_MAX)
1183
1184
1185
1186
1187
1188
1189struct xfs_disk_dquot {
1190 __be16 d_magic;
1191 __u8 d_version;
1192 __u8 d_type;
1193 __be32 d_id;
1194 __be64 d_blk_hardlimit;
1195 __be64 d_blk_softlimit;
1196 __be64 d_ino_hardlimit;
1197 __be64 d_ino_softlimit;
1198 __be64 d_bcount;
1199 __be64 d_icount;
1200 __be32 d_itimer;
1201
1202 __be32 d_btimer;
1203 __be16 d_iwarns;
1204 __be16 d_bwarns;
1205 __be32 d_pad0;
1206 __be64 d_rtb_hardlimit;
1207 __be64 d_rtb_softlimit;
1208 __be64 d_rtbcount;
1209 __be32 d_rtbtimer;
1210 __be16 d_rtbwarns;
1211 __be16 d_pad;
1212};
1213
1214
1215
1216
1217
1218typedef struct xfs_dqblk {
1219 struct xfs_disk_dquot dd_diskdq;
1220 char dd_fill[4];
1221
1222
1223
1224
1225 __be32 dd_crc;
1226 __be64 dd_lsn;
1227 uuid_t dd_uuid;
1228} xfs_dqblk_t;
1229
1230#define XFS_DQUOT_CRC_OFF offsetof(struct xfs_dqblk, dd_crc)
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246#define XFS_DQUOT_CLUSTER_SIZE_FSB (xfs_filblks_t)1
1247
1248
1249
1250
1251#define XFS_SYMLINK_MAGIC 0x58534c4d
1252
1253struct xfs_dsymlink_hdr {
1254 __be32 sl_magic;
1255 __be32 sl_offset;
1256 __be32 sl_bytes;
1257 __be32 sl_crc;
1258 uuid_t sl_uuid;
1259 __be64 sl_owner;
1260 __be64 sl_blkno;
1261 __be64 sl_lsn;
1262};
1263
1264#define XFS_SYMLINK_CRC_OFF offsetof(struct xfs_dsymlink_hdr, sl_crc)
1265
1266#define XFS_SYMLINK_MAXLEN 1024
1267
1268
1269
1270
1271
1272#define XFS_SYMLINK_MAPS 3
1273
1274#define XFS_SYMLINK_BUF_SPACE(mp, bufsize) \
1275 ((bufsize) - (xfs_has_crc((mp)) ? \
1276 sizeof(struct xfs_dsymlink_hdr) : 0))
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286#define XFS_ABTB_MAGIC 0x41425442
1287#define XFS_ABTB_CRC_MAGIC 0x41423342
1288#define XFS_ABTC_MAGIC 0x41425443
1289#define XFS_ABTC_CRC_MAGIC 0x41423343
1290
1291
1292
1293
1294typedef struct xfs_alloc_rec {
1295 __be32 ar_startblock;
1296 __be32 ar_blockcount;
1297} xfs_alloc_rec_t, xfs_alloc_key_t;
1298
1299typedef struct xfs_alloc_rec_incore {
1300 xfs_agblock_t ar_startblock;
1301 xfs_extlen_t ar_blockcount;
1302} xfs_alloc_rec_incore_t;
1303
1304
1305typedef __be32 xfs_alloc_ptr_t;
1306
1307
1308
1309
1310
1311#define XFS_BNO_BLOCK(mp) ((xfs_agblock_t)(XFS_AGFL_BLOCK(mp) + 1))
1312#define XFS_CNT_BLOCK(mp) ((xfs_agblock_t)(XFS_BNO_BLOCK(mp) + 1))
1313
1314
1315
1316
1317
1318
1319
1320#define XFS_IBT_MAGIC 0x49414254
1321#define XFS_IBT_CRC_MAGIC 0x49414233
1322#define XFS_FIBT_MAGIC 0x46494254
1323#define XFS_FIBT_CRC_MAGIC 0x46494233
1324
1325typedef uint64_t xfs_inofree_t;
1326#define XFS_INODES_PER_CHUNK (NBBY * sizeof(xfs_inofree_t))
1327#define XFS_INODES_PER_CHUNK_LOG (XFS_NBBYLOG + 3)
1328#define XFS_INOBT_ALL_FREE ((xfs_inofree_t)-1)
1329#define XFS_INOBT_MASK(i) ((xfs_inofree_t)1 << (i))
1330
1331#define XFS_INOBT_HOLEMASK_FULL 0
1332#define XFS_INOBT_HOLEMASK_BITS (NBBY * sizeof(uint16_t))
1333#define XFS_INODES_PER_HOLEMASK_BIT \
1334 (XFS_INODES_PER_CHUNK / (NBBY * sizeof(uint16_t)))
1335
1336static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
1337{
1338 return ((n >= XFS_INODES_PER_CHUNK ? 0 : XFS_INOBT_MASK(n)) - 1) << i;
1339}
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351typedef struct xfs_inobt_rec {
1352 __be32 ir_startino;
1353 union {
1354 struct {
1355 __be32 ir_freecount;
1356 } f;
1357 struct {
1358 __be16 ir_holemask;
1359 __u8 ir_count;
1360 __u8 ir_freecount;
1361 } sp;
1362 } ir_u;
1363 __be64 ir_free;
1364} xfs_inobt_rec_t;
1365
1366typedef struct xfs_inobt_rec_incore {
1367 xfs_agino_t ir_startino;
1368 uint16_t ir_holemask;
1369 uint8_t ir_count;
1370 uint8_t ir_freecount;
1371 xfs_inofree_t ir_free;
1372} xfs_inobt_rec_incore_t;
1373
1374static inline bool xfs_inobt_issparse(uint16_t holemask)
1375{
1376
1377 return holemask;
1378}
1379
1380
1381
1382
1383typedef struct xfs_inobt_key {
1384 __be32 ir_startino;
1385} xfs_inobt_key_t;
1386
1387
1388typedef __be32 xfs_inobt_ptr_t;
1389
1390
1391
1392
1393#define XFS_IBT_BLOCK(mp) ((xfs_agblock_t)(XFS_CNT_BLOCK(mp) + 1))
1394#define XFS_FIBT_BLOCK(mp) ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
1395
1396
1397
1398
1399
1400
1401#define XFS_RMAP_CRC_MAGIC 0x524d4233
1402
1403
1404
1405
1406
1407#define XFS_OWNER_INFO_ATTR_FORK (1 << 0)
1408#define XFS_OWNER_INFO_BMBT_BLOCK (1 << 1)
1409struct xfs_owner_info {
1410 uint64_t oi_owner;
1411 xfs_fileoff_t oi_offset;
1412 unsigned int oi_flags;
1413};
1414
1415
1416
1417
1418
1419
1420
1421
1422#define XFS_RMAP_OWN_NULL (-1ULL)
1423#define XFS_RMAP_OWN_UNKNOWN (-2ULL)
1424#define XFS_RMAP_OWN_FS (-3ULL)
1425#define XFS_RMAP_OWN_LOG (-4ULL)
1426#define XFS_RMAP_OWN_AG (-5ULL)
1427#define XFS_RMAP_OWN_INOBT (-6ULL)
1428#define XFS_RMAP_OWN_INODES (-7ULL)
1429#define XFS_RMAP_OWN_REFC (-8ULL)
1430#define XFS_RMAP_OWN_COW (-9ULL)
1431#define XFS_RMAP_OWN_MIN (-10ULL)
1432
1433#define XFS_RMAP_NON_INODE_OWNER(owner) (!!((owner) & (1ULL << 63)))
1434
1435
1436
1437
1438struct xfs_rmap_rec {
1439 __be32 rm_startblock;
1440 __be32 rm_blockcount;
1441 __be64 rm_owner;
1442 __be64 rm_offset;
1443};
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453#define XFS_RMAP_OFF_ATTR_FORK ((uint64_t)1ULL << 63)
1454#define XFS_RMAP_OFF_BMBT_BLOCK ((uint64_t)1ULL << 62)
1455#define XFS_RMAP_OFF_UNWRITTEN ((uint64_t)1ULL << 61)
1456
1457#define XFS_RMAP_LEN_MAX ((uint32_t)~0U)
1458#define XFS_RMAP_OFF_FLAGS (XFS_RMAP_OFF_ATTR_FORK | \
1459 XFS_RMAP_OFF_BMBT_BLOCK | \
1460 XFS_RMAP_OFF_UNWRITTEN)
1461#define XFS_RMAP_OFF_MASK ((uint64_t)0x3FFFFFFFFFFFFFULL)
1462
1463#define XFS_RMAP_OFF(off) ((off) & XFS_RMAP_OFF_MASK)
1464
1465#define XFS_RMAP_IS_BMBT_BLOCK(off) (!!((off) & XFS_RMAP_OFF_BMBT_BLOCK))
1466#define XFS_RMAP_IS_ATTR_FORK(off) (!!((off) & XFS_RMAP_OFF_ATTR_FORK))
1467#define XFS_RMAP_IS_UNWRITTEN(len) (!!((off) & XFS_RMAP_OFF_UNWRITTEN))
1468
1469#define RMAPBT_STARTBLOCK_BITLEN 32
1470#define RMAPBT_BLOCKCOUNT_BITLEN 32
1471#define RMAPBT_OWNER_BITLEN 64
1472#define RMAPBT_ATTRFLAG_BITLEN 1
1473#define RMAPBT_BMBTFLAG_BITLEN 1
1474#define RMAPBT_EXNTFLAG_BITLEN 1
1475#define RMAPBT_UNUSED_OFFSET_BITLEN 7
1476#define RMAPBT_OFFSET_BITLEN 54
1477
1478#define XFS_RMAP_ATTR_FORK (1 << 0)
1479#define XFS_RMAP_BMBT_BLOCK (1 << 1)
1480#define XFS_RMAP_UNWRITTEN (1 << 2)
1481#define XFS_RMAP_KEY_FLAGS (XFS_RMAP_ATTR_FORK | \
1482 XFS_RMAP_BMBT_BLOCK)
1483#define XFS_RMAP_REC_FLAGS (XFS_RMAP_UNWRITTEN)
1484struct xfs_rmap_irec {
1485 xfs_agblock_t rm_startblock;
1486 xfs_extlen_t rm_blockcount;
1487 uint64_t rm_owner;
1488 uint64_t rm_offset;
1489 unsigned int rm_flags;
1490};
1491
1492
1493
1494
1495
1496
1497struct xfs_rmap_key {
1498 __be32 rm_startblock;
1499 __be64 rm_owner;
1500 __be64 rm_offset;
1501} __attribute__((packed));
1502
1503
1504typedef __be32 xfs_rmap_ptr_t;
1505
1506#define XFS_RMAP_BLOCK(mp) \
1507 (xfs_has_finobt(((mp))) ? \
1508 XFS_FIBT_BLOCK(mp) + 1 : \
1509 XFS_IBT_BLOCK(mp) + 1)
1510
1511
1512
1513
1514
1515#define XFS_REFC_CRC_MAGIC 0x52334643
1516
1517unsigned int xfs_refc_block(struct xfs_mount *mp);
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540#define XFS_REFC_COW_START ((xfs_agblock_t)(1U << 31))
1541#define REFCNTBT_COWFLAG_BITLEN 1
1542#define REFCNTBT_AGBLOCK_BITLEN 31
1543
1544struct xfs_refcount_rec {
1545 __be32 rc_startblock;
1546 __be32 rc_blockcount;
1547 __be32 rc_refcount;
1548};
1549
1550struct xfs_refcount_key {
1551 __be32 rc_startblock;
1552};
1553
1554struct xfs_refcount_irec {
1555 xfs_agblock_t rc_startblock;
1556 xfs_extlen_t rc_blockcount;
1557 xfs_nlink_t rc_refcount;
1558};
1559
1560#define MAXREFCOUNT ((xfs_nlink_t)~0U)
1561#define MAXREFCEXTLEN ((xfs_extlen_t)~0U)
1562
1563
1564typedef __be32 xfs_refcount_ptr_t;
1565
1566
1567
1568
1569
1570
1571
1572
1573#define XFS_BMAP_MAGIC 0x424d4150
1574#define XFS_BMAP_CRC_MAGIC 0x424d4133
1575
1576
1577
1578
1579typedef struct xfs_bmdr_block {
1580 __be16 bb_level;
1581 __be16 bb_numrecs;
1582} xfs_bmdr_block_t;
1583
1584
1585
1586
1587
1588
1589
1590
1591#define BMBT_EXNTFLAG_BITLEN 1
1592#define BMBT_STARTOFF_BITLEN 54
1593#define BMBT_STARTBLOCK_BITLEN 52
1594#define BMBT_BLOCKCOUNT_BITLEN 21
1595
1596#define BMBT_STARTOFF_MASK ((1ULL << BMBT_STARTOFF_BITLEN) - 1)
1597#define BMBT_BLOCKCOUNT_MASK ((1ULL << BMBT_BLOCKCOUNT_BITLEN) - 1)
1598
1599
1600
1601
1602
1603#define XFS_MAX_FILEOFF (BMBT_STARTOFF_MASK + BMBT_BLOCKCOUNT_MASK)
1604
1605typedef struct xfs_bmbt_rec {
1606 __be64 l0, l1;
1607} xfs_bmbt_rec_t;
1608
1609typedef uint64_t xfs_bmbt_rec_base_t;
1610typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
1611
1612
1613
1614
1615#define STARTBLOCKVALBITS 17
1616#define STARTBLOCKMASKBITS (15 + 20)
1617#define STARTBLOCKMASK \
1618 (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
1619
1620static inline int isnullstartblock(xfs_fsblock_t x)
1621{
1622 return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
1623}
1624
1625static inline xfs_fsblock_t nullstartblock(int k)
1626{
1627 ASSERT(k < (1 << STARTBLOCKVALBITS));
1628 return STARTBLOCKMASK | (k);
1629}
1630
1631static inline xfs_filblks_t startblockval(xfs_fsblock_t x)
1632{
1633 return (xfs_filblks_t)((x) & ~STARTBLOCKMASK);
1634}
1635
1636
1637
1638
1639typedef struct xfs_bmbt_key {
1640 __be64 br_startoff;
1641} xfs_bmbt_key_t, xfs_bmdr_key_t;
1642
1643
1644typedef __be64 xfs_bmbt_ptr_t, xfs_bmdr_ptr_t;
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662struct xfs_btree_block_shdr {
1663 __be32 bb_leftsib;
1664 __be32 bb_rightsib;
1665
1666 __be64 bb_blkno;
1667 __be64 bb_lsn;
1668 uuid_t bb_uuid;
1669 __be32 bb_owner;
1670 __le32 bb_crc;
1671};
1672
1673
1674struct xfs_btree_block_lhdr {
1675 __be64 bb_leftsib;
1676 __be64 bb_rightsib;
1677
1678 __be64 bb_blkno;
1679 __be64 bb_lsn;
1680 uuid_t bb_uuid;
1681 __be64 bb_owner;
1682 __le32 bb_crc;
1683 __be32 bb_pad;
1684};
1685
1686struct xfs_btree_block {
1687 __be32 bb_magic;
1688 __be16 bb_level;
1689 __be16 bb_numrecs;
1690 union {
1691 struct xfs_btree_block_shdr s;
1692 struct xfs_btree_block_lhdr l;
1693 } bb_u;
1694};
1695
1696
1697#define XFS_BTREE_SBLOCK_LEN \
1698 (offsetof(struct xfs_btree_block, bb_u) + \
1699 offsetof(struct xfs_btree_block_shdr, bb_blkno))
1700
1701#define XFS_BTREE_LBLOCK_LEN \
1702 (offsetof(struct xfs_btree_block, bb_u) + \
1703 offsetof(struct xfs_btree_block_lhdr, bb_blkno))
1704
1705
1706#define XFS_BTREE_SBLOCK_CRC_LEN \
1707 (offsetof(struct xfs_btree_block, bb_u) + \
1708 sizeof(struct xfs_btree_block_shdr))
1709#define XFS_BTREE_LBLOCK_CRC_LEN \
1710 (offsetof(struct xfs_btree_block, bb_u) + \
1711 sizeof(struct xfs_btree_block_lhdr))
1712
1713#define XFS_BTREE_SBLOCK_CRC_OFF \
1714 offsetof(struct xfs_btree_block, bb_u.s.bb_crc)
1715#define XFS_BTREE_LBLOCK_CRC_OFF \
1716 offsetof(struct xfs_btree_block, bb_u.l.bb_crc)
1717
1718
1719
1720
1721struct xfs_acl_entry {
1722 __be32 ae_tag;
1723 __be32 ae_id;
1724 __be16 ae_perm;
1725 __be16 ae_pad;
1726};
1727
1728struct xfs_acl {
1729 __be32 acl_cnt;
1730 struct xfs_acl_entry acl_entry[];
1731};
1732
1733
1734
1735
1736
1737
1738#define XFS_ACL_MAX_ENTRIES(mp) \
1739 (xfs_has_crc(mp) \
1740 ? (XFS_XATTR_SIZE_MAX - sizeof(struct xfs_acl)) / \
1741 sizeof(struct xfs_acl_entry) \
1742 : 25)
1743
1744#define XFS_ACL_SIZE(cnt) \
1745 (sizeof(struct xfs_acl) + \
1746 sizeof(struct xfs_acl_entry) * cnt)
1747
1748#define XFS_ACL_MAX_SIZE(mp) \
1749 XFS_ACL_SIZE(XFS_ACL_MAX_ENTRIES((mp)))
1750
1751
1752
1753#define SGI_ACL_FILE "SGI_ACL_FILE"
1754#define SGI_ACL_DEFAULT "SGI_ACL_DEFAULT"
1755#define SGI_ACL_FILE_SIZE (sizeof(SGI_ACL_FILE)-1)
1756#define SGI_ACL_DEFAULT_SIZE (sizeof(SGI_ACL_DEFAULT)-1)
1757
1758#endif
1759