]>
git.ipfire.org Git - thirdparty/xfsprogs-dev.git/blob - db/btblock.c
2 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
30 * Definition of the possible btree block layouts.
41 sizeof(xfs_bmbt_key_t
),
42 sizeof(xfs_bmbt_rec_t
),
47 sizeof(xfs_alloc_key_t
),
48 sizeof(xfs_alloc_rec_t
),
53 sizeof(xfs_alloc_key_t
),
54 sizeof(xfs_alloc_rec_t
),
59 sizeof(xfs_inobt_key_t
),
60 sizeof(xfs_inobt_rec_t
),
65 sizeof(xfs_inobt_key_t
),
66 sizeof(xfs_inobt_rec_t
),
70 XFS_BTREE_LBLOCK_CRC_LEN
,
71 sizeof(xfs_bmbt_key_t
),
72 sizeof(xfs_bmbt_rec_t
),
76 XFS_BTREE_SBLOCK_CRC_LEN
,
77 sizeof(xfs_alloc_key_t
),
78 sizeof(xfs_alloc_rec_t
),
82 XFS_BTREE_SBLOCK_CRC_LEN
,
83 sizeof(xfs_alloc_key_t
),
84 sizeof(xfs_alloc_rec_t
),
88 XFS_BTREE_SBLOCK_CRC_LEN
,
89 sizeof(xfs_inobt_key_t
),
90 sizeof(xfs_inobt_rec_t
),
94 XFS_BTREE_SBLOCK_CRC_LEN
,
95 sizeof(xfs_inobt_key_t
),
96 sizeof(xfs_inobt_rec_t
),
100 XFS_BTREE_SBLOCK_CRC_LEN
,
101 2 * sizeof(struct xfs_rmap_key
),
102 sizeof(struct xfs_rmap_rec
),
110 * Find the right block defintion for a given ondisk block.
112 * We use the least significant bit of the magic number as index into
113 * the array of block defintions.
115 static struct xfs_db_btree
*
117 struct xfs_btree_block
*bb
)
119 struct xfs_db_btree
*btp
= &btrees
[0];
122 if (be32_to_cpu((bb
)->bb_magic
) == btp
->magic
)
125 } while (btp
->magic
!= 0);
130 /* calculate max records. Only for non-leaves. */
132 btblock_maxrecs(struct xfs_db_btree
*bt
, int blocksize
)
134 blocksize
-= bt
->block_len
;
136 return blocksize
/ (bt
->key_len
+ bt
->ptr_len
);
140 * Get the number of keys in a btree block.
142 * Note: can also be used to get the number of ptrs because there are
143 * always the same number of keys and ptrs in a block.
150 struct xfs_btree_block
*block
= obj
;
152 ASSERT(startoff
== 0);
154 if (block
->bb_level
== 0)
156 return be16_to_cpu(block
->bb_numrecs
);
160 * Get the number of keys in a btree block.
167 struct xfs_btree_block
*block
= obj
;
169 ASSERT(startoff
== 0);
171 if (block
->bb_level
!= 0)
173 return be16_to_cpu(block
->bb_numrecs
);
177 * Get the offset of the key at idx in a btree block.
185 struct xfs_btree_block
*block
= obj
;
186 struct xfs_db_btree
*bt
= block_to_bt(block
);
189 ASSERT(startoff
== 0);
190 ASSERT(block
->bb_level
!= 0);
192 offset
= bt
->block_len
+ (idx
- 1) * bt
->key_len
;
193 return bitize(offset
);
197 * Get the offset of the ptr at idx in a btree block.
205 struct xfs_btree_block
*block
= obj
;
206 struct xfs_db_btree
*bt
= block_to_bt(block
);
210 ASSERT(startoff
== 0);
211 ASSERT(block
->bb_level
!= 0);
213 maxrecs
= btblock_maxrecs(bt
, mp
->m_sb
.sb_blocksize
);
214 offset
= bt
->block_len
+
215 maxrecs
* bt
->key_len
+
216 (idx
- 1) * bt
->ptr_len
;
218 return bitize(offset
);
222 * Get the offset of the record at idx in a btree block.
230 struct xfs_btree_block
*block
= obj
;
231 struct xfs_db_btree
*bt
= block_to_bt(block
);
234 ASSERT(startoff
== 0);
235 ASSERT(block
->bb_level
== 0);
237 offset
= bt
->block_len
+ (idx
- 1) * bt
->rec_len
;
238 return bitize(offset
);
242 * Get the size of a btree block.
250 return bitize(mp
->m_sb
.sb_blocksize
);
258 const field_t bmapbta_hfld
[] = {
259 { "", FLDT_BMAPBTA
, OI(0), C1
, 0, TYP_NONE
},
262 const field_t bmapbtd_hfld
[] = {
263 { "", FLDT_BMAPBTD
, OI(0), C1
, 0, TYP_NONE
},
267 const field_t bmapbta_crc_hfld
[] = {
268 { "", FLDT_BMAPBTA_CRC
, OI(0), C1
, 0, TYP_NONE
},
271 const field_t bmapbtd_crc_hfld
[] = {
272 { "", FLDT_BMAPBTD_CRC
, OI(0), C1
, 0, TYP_NONE
},
276 #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
277 const field_t bmapbta_flds
[] = {
278 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
279 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
280 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
281 { "leftsib", FLDT_DFSBNO
, OI(OFF(u
.l
.bb_leftsib
)), C1
, 0, TYP_BMAPBTA
},
282 { "rightsib", FLDT_DFSBNO
, OI(OFF(u
.l
.bb_rightsib
)), C1
, 0, TYP_BMAPBTA
},
283 { "recs", FLDT_BMAPBTAREC
, btblock_rec_offset
, btblock_rec_count
,
284 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
285 { "keys", FLDT_BMAPBTAKEY
, btblock_key_offset
, btblock_key_count
,
286 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
287 { "ptrs", FLDT_BMAPBTAPTR
, btblock_ptr_offset
, btblock_key_count
,
288 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_BMAPBTA
},
291 const field_t bmapbtd_flds
[] = {
292 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
293 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
294 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
295 { "leftsib", FLDT_DFSBNO
, OI(OFF(u
.l
.bb_leftsib
)), C1
, 0, TYP_BMAPBTD
},
296 { "rightsib", FLDT_DFSBNO
, OI(OFF(u
.l
.bb_rightsib
)), C1
, 0, TYP_BMAPBTD
},
297 { "recs", FLDT_BMAPBTDREC
, btblock_rec_offset
, btblock_rec_count
,
298 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
299 { "keys", FLDT_BMAPBTDKEY
, btblock_key_offset
, btblock_key_count
,
300 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
301 { "ptrs", FLDT_BMAPBTDPTR
, btblock_ptr_offset
, btblock_key_count
,
302 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_BMAPBTD
},
305 /* crc enabled versions */
306 const field_t bmapbta_crc_flds
[] = {
307 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
308 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
309 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
310 { "leftsib", FLDT_DFSBNO
, OI(OFF(u
.l
.bb_leftsib
)), C1
, 0, TYP_BMAPBTA
},
311 { "rightsib", FLDT_DFSBNO
, OI(OFF(u
.l
.bb_rightsib
)), C1
, 0, TYP_BMAPBTA
},
312 { "bno", FLDT_DFSBNO
, OI(OFF(u
.l
.bb_blkno
)), C1
, 0, TYP_BMAPBTD
},
313 { "lsn", FLDT_UINT64X
, OI(OFF(u
.l
.bb_lsn
)), C1
, 0, TYP_NONE
},
314 { "uuid", FLDT_UUID
, OI(OFF(u
.l
.bb_uuid
)), C1
, 0, TYP_NONE
},
315 { "owner", FLDT_INO
, OI(OFF(u
.l
.bb_owner
)), C1
, 0, TYP_NONE
},
316 { "crc", FLDT_CRC
, OI(OFF(u
.l
.bb_crc
)), C1
, 0, TYP_NONE
},
317 { "recs", FLDT_BMAPBTAREC
, btblock_rec_offset
, btblock_rec_count
,
318 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
319 { "keys", FLDT_BMAPBTAKEY
, btblock_key_offset
, btblock_key_count
,
320 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
321 { "ptrs", FLDT_BMAPBTAPTR
, btblock_ptr_offset
, btblock_key_count
,
322 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_BMAPBTA
},
325 const field_t bmapbtd_crc_flds
[] = {
326 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
327 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
328 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
329 { "leftsib", FLDT_DFSBNO
, OI(OFF(u
.l
.bb_leftsib
)), C1
, 0, TYP_BMAPBTD
},
330 { "rightsib", FLDT_DFSBNO
, OI(OFF(u
.l
.bb_rightsib
)), C1
, 0, TYP_BMAPBTD
},
331 { "bno", FLDT_DFSBNO
, OI(OFF(u
.l
.bb_blkno
)), C1
, 0, TYP_BMAPBTD
},
332 { "lsn", FLDT_UINT64X
, OI(OFF(u
.l
.bb_lsn
)), C1
, 0, TYP_NONE
},
333 { "uuid", FLDT_UUID
, OI(OFF(u
.l
.bb_uuid
)), C1
, 0, TYP_NONE
},
334 { "owner", FLDT_INO
, OI(OFF(u
.l
.bb_owner
)), C1
, 0, TYP_NONE
},
335 { "crc", FLDT_CRC
, OI(OFF(u
.l
.bb_crc
)), C1
, 0, TYP_NONE
},
336 { "recs", FLDT_BMAPBTDREC
, btblock_rec_offset
, btblock_rec_count
,
337 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
338 { "keys", FLDT_BMAPBTDKEY
, btblock_key_offset
, btblock_key_count
,
339 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
340 { "ptrs", FLDT_BMAPBTDPTR
, btblock_ptr_offset
, btblock_key_count
,
341 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_BMAPBTD
},
346 #define KOFF(f) bitize(offsetof(xfs_bmbt_key_t, br_ ## f))
347 const field_t bmapbta_key_flds
[] = {
348 { "startoff", FLDT_DFILOFFA
, OI(KOFF(startoff
)), C1
, 0, TYP_ATTR
},
351 const field_t bmapbtd_key_flds
[] = {
352 { "startoff", FLDT_DFILOFFD
, OI(KOFF(startoff
)), C1
, 0, TYP_INODATA
},
357 #define BMBT_EXNTFLAG_BITOFF 0
358 #define BMBT_STARTOFF_BITOFF (BMBT_EXNTFLAG_BITOFF + BMBT_EXNTFLAG_BITLEN)
359 #define BMBT_STARTBLOCK_BITOFF (BMBT_STARTOFF_BITOFF + BMBT_STARTOFF_BITLEN)
360 #define BMBT_BLOCKCOUNT_BITOFF \
361 (BMBT_STARTBLOCK_BITOFF + BMBT_STARTBLOCK_BITLEN)
363 const field_t bmapbta_rec_flds
[] = {
364 { "startoff", FLDT_CFILEOFFA
, OI(BMBT_STARTOFF_BITOFF
), C1
, 0,
366 { "startblock", FLDT_CFSBLOCK
, OI(BMBT_STARTBLOCK_BITOFF
), C1
, 0,
368 { "blockcount", FLDT_CEXTLEN
, OI(BMBT_BLOCKCOUNT_BITOFF
), C1
, 0,
370 { "extentflag", FLDT_CEXTFLG
, OI(BMBT_EXNTFLAG_BITOFF
), C1
, 0,
374 const field_t bmapbtd_rec_flds
[] = {
375 { "startoff", FLDT_CFILEOFFD
, OI(BMBT_STARTOFF_BITOFF
), C1
, 0,
377 { "startblock", FLDT_CFSBLOCK
, OI(BMBT_STARTBLOCK_BITOFF
), C1
, 0,
379 { "blockcount", FLDT_CEXTLEN
, OI(BMBT_BLOCKCOUNT_BITOFF
), C1
, 0,
381 { "extentflag", FLDT_CEXTFLG
, OI(BMBT_EXNTFLAG_BITOFF
), C1
, 0,
388 * Inode allocation btree.
391 const field_t inobt_hfld
[] = {
392 { "", FLDT_INOBT
, OI(0), C1
, 0, TYP_NONE
},
396 const field_t inobt_crc_hfld
[] = {
397 { "", FLDT_INOBT_CRC
, OI(0), C1
, 0, TYP_NONE
},
401 const field_t inobt_spcrc_hfld
[] = {
402 { "", FLDT_INOBT_SPCRC
, OI(0), C1
, 0, TYP_NONE
},
406 #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
407 const field_t inobt_flds
[] = {
408 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
409 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
410 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
411 { "leftsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_leftsib
)), C1
, 0, TYP_INOBT
},
412 { "rightsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_rightsib
)), C1
, 0, TYP_INOBT
},
413 { "recs", FLDT_INOBTREC
, btblock_rec_offset
, btblock_rec_count
,
414 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
415 { "keys", FLDT_INOBTKEY
, btblock_key_offset
, btblock_key_count
,
416 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
417 { "ptrs", FLDT_INOBTPTR
, btblock_ptr_offset
, btblock_key_count
,
418 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_INOBT
},
421 const field_t inobt_crc_flds
[] = {
422 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
423 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
424 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
425 { "leftsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_leftsib
)), C1
, 0, TYP_INOBT
},
426 { "rightsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_rightsib
)), C1
, 0, TYP_INOBT
},
427 { "bno", FLDT_DFSBNO
, OI(OFF(u
.s
.bb_blkno
)), C1
, 0, TYP_INOBT
},
428 { "lsn", FLDT_UINT64X
, OI(OFF(u
.s
.bb_lsn
)), C1
, 0, TYP_NONE
},
429 { "uuid", FLDT_UUID
, OI(OFF(u
.s
.bb_uuid
)), C1
, 0, TYP_NONE
},
430 { "owner", FLDT_AGNUMBER
, OI(OFF(u
.s
.bb_owner
)), C1
, 0, TYP_NONE
},
431 { "crc", FLDT_CRC
, OI(OFF(u
.s
.bb_crc
)), C1
, 0, TYP_NONE
},
432 { "recs", FLDT_INOBTREC
, btblock_rec_offset
, btblock_rec_count
,
433 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
434 { "keys", FLDT_INOBTKEY
, btblock_key_offset
, btblock_key_count
,
435 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
436 { "ptrs", FLDT_INOBTPTR
, btblock_ptr_offset
, btblock_key_count
,
437 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_INOBT
},
440 const field_t inobt_spcrc_flds
[] = {
441 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
442 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
443 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
444 { "leftsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_leftsib
)), C1
, 0, TYP_INOBT
},
445 { "rightsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_rightsib
)), C1
, 0, TYP_INOBT
},
446 { "bno", FLDT_DFSBNO
, OI(OFF(u
.s
.bb_blkno
)), C1
, 0, TYP_INOBT
},
447 { "lsn", FLDT_UINT64X
, OI(OFF(u
.s
.bb_lsn
)), C1
, 0, TYP_NONE
},
448 { "uuid", FLDT_UUID
, OI(OFF(u
.s
.bb_uuid
)), C1
, 0, TYP_NONE
},
449 { "owner", FLDT_AGNUMBER
, OI(OFF(u
.s
.bb_owner
)), C1
, 0, TYP_NONE
},
450 { "crc", FLDT_CRC
, OI(OFF(u
.s
.bb_crc
)), C1
, 0, TYP_NONE
},
451 { "recs", FLDT_INOBTSPREC
, btblock_rec_offset
, btblock_rec_count
,
452 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
453 { "keys", FLDT_INOBTKEY
, btblock_key_offset
, btblock_key_count
,
454 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
455 { "ptrs", FLDT_INOBTPTR
, btblock_ptr_offset
, btblock_key_count
,
456 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_INOBT
},
462 #define KOFF(f) bitize(offsetof(xfs_inobt_key_t, ir_ ## f))
463 const field_t inobt_key_flds
[] = {
464 { "startino", FLDT_AGINO
, OI(KOFF(startino
)), C1
, 0, TYP_INODE
},
469 #define ROFF(f) bitize(offsetof(xfs_inobt_rec_t, f))
470 const field_t inobt_rec_flds
[] = {
471 { "startino", FLDT_AGINO
, OI(ROFF(ir_startino
)), C1
, 0, TYP_INODE
},
472 { "freecount", FLDT_INT32D
, OI(ROFF(ir_u
.f
.ir_freecount
)), C1
, 0, TYP_NONE
},
473 { "free", FLDT_INOFREE
, OI(ROFF(ir_free
)), C1
, 0, TYP_NONE
},
476 /* sparse inode on-disk format */
477 const field_t inobt_sprec_flds
[] = {
478 { "startino", FLDT_AGINO
, OI(ROFF(ir_startino
)), C1
, 0, TYP_INODE
},
479 { "holemask", FLDT_UINT16X
, OI(ROFF(ir_u
.sp
.ir_holemask
)), C1
, 0,
481 { "count", FLDT_UINT8D
, OI(ROFF(ir_u
.sp
.ir_count
)), C1
, 0, TYP_NONE
},
482 { "freecount", FLDT_INT8D
, OI(ROFF(ir_u
.sp
.ir_freecount
)), C1
, 0,
484 { "free", FLDT_INOFREE
, OI(ROFF(ir_free
)), C1
, 0, TYP_NONE
},
493 const field_t bnobt_hfld
[] = {
494 { "", FLDT_BNOBT
, OI(0), C1
, 0, TYP_NONE
},
498 const field_t bnobt_crc_hfld
[] = {
499 { "", FLDT_BNOBT_CRC
, OI(0), C1
, 0, TYP_NONE
},
503 #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
504 const field_t bnobt_flds
[] = {
505 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
506 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
507 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
508 { "leftsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_leftsib
)), C1
, 0, TYP_BNOBT
},
509 { "rightsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_rightsib
)), C1
, 0, TYP_BNOBT
},
510 { "recs", FLDT_BNOBTREC
, btblock_rec_offset
, btblock_rec_count
,
511 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
512 { "keys", FLDT_BNOBTKEY
, btblock_key_offset
, btblock_key_count
,
513 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
514 { "ptrs", FLDT_BNOBTPTR
, btblock_ptr_offset
, btblock_key_count
,
515 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_BNOBT
},
518 const field_t bnobt_crc_flds
[] = {
519 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
520 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
521 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
522 { "leftsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_leftsib
)), C1
, 0, TYP_BNOBT
},
523 { "rightsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_rightsib
)), C1
, 0, TYP_BNOBT
},
524 { "bno", FLDT_DFSBNO
, OI(OFF(u
.s
.bb_blkno
)), C1
, 0, TYP_BNOBT
},
525 { "lsn", FLDT_UINT64X
, OI(OFF(u
.s
.bb_lsn
)), C1
, 0, TYP_NONE
},
526 { "uuid", FLDT_UUID
, OI(OFF(u
.s
.bb_uuid
)), C1
, 0, TYP_NONE
},
527 { "owner", FLDT_AGNUMBER
, OI(OFF(u
.s
.bb_owner
)), C1
, 0, TYP_NONE
},
528 { "crc", FLDT_CRC
, OI(OFF(u
.s
.bb_crc
)), C1
, 0, TYP_NONE
},
529 { "recs", FLDT_BNOBTREC
, btblock_rec_offset
, btblock_rec_count
,
530 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
531 { "keys", FLDT_BNOBTKEY
, btblock_key_offset
, btblock_key_count
,
532 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
533 { "ptrs", FLDT_BNOBTPTR
, btblock_ptr_offset
, btblock_key_count
,
534 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_BNOBT
},
539 #define KOFF(f) bitize(offsetof(xfs_alloc_key_t, ar_ ## f))
540 const field_t bnobt_key_flds
[] = {
541 { "startblock", FLDT_AGBLOCK
, OI(KOFF(startblock
)), C1
, 0, TYP_DATA
},
542 { "blockcount", FLDT_EXTLEN
, OI(KOFF(blockcount
)), C1
, 0, TYP_NONE
},
547 #define ROFF(f) bitize(offsetof(xfs_alloc_rec_t, ar_ ## f))
548 const field_t bnobt_rec_flds
[] = {
549 { "startblock", FLDT_AGBLOCK
, OI(ROFF(startblock
)), C1
, 0, TYP_DATA
},
550 { "blockcount", FLDT_EXTLEN
, OI(ROFF(blockcount
)), C1
, 0, TYP_NONE
},
555 const field_t cntbt_hfld
[] = {
556 { "", FLDT_CNTBT
, OI(0), C1
, 0, TYP_NONE
},
560 const field_t cntbt_crc_hfld
[] = {
561 { "", FLDT_CNTBT_CRC
, OI(0), C1
, 0, TYP_NONE
},
565 #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
566 const field_t cntbt_flds
[] = {
567 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
568 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
569 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
570 { "leftsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_leftsib
)), C1
, 0, TYP_CNTBT
},
571 { "rightsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_rightsib
)), C1
, 0, TYP_CNTBT
},
572 { "recs", FLDT_CNTBTREC
, btblock_rec_offset
, btblock_rec_count
,
573 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
574 { "keys", FLDT_CNTBTKEY
, btblock_key_offset
, btblock_key_count
,
575 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
576 { "ptrs", FLDT_CNTBTPTR
, btblock_ptr_offset
, btblock_key_count
,
577 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_CNTBT
},
580 const field_t cntbt_crc_flds
[] = {
581 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
582 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
583 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
584 { "leftsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_leftsib
)), C1
, 0, TYP_CNTBT
},
585 { "rightsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_rightsib
)), C1
, 0, TYP_CNTBT
},
586 { "bno", FLDT_DFSBNO
, OI(OFF(u
.s
.bb_blkno
)), C1
, 0, TYP_CNTBT
},
587 { "lsn", FLDT_UINT64X
, OI(OFF(u
.s
.bb_lsn
)), C1
, 0, TYP_NONE
},
588 { "uuid", FLDT_UUID
, OI(OFF(u
.s
.bb_uuid
)), C1
, 0, TYP_NONE
},
589 { "owner", FLDT_AGNUMBER
, OI(OFF(u
.s
.bb_owner
)), C1
, 0, TYP_NONE
},
590 { "crc", FLDT_CRC
, OI(OFF(u
.s
.bb_crc
)), C1
, 0, TYP_NONE
},
591 { "recs", FLDT_CNTBTREC
, btblock_rec_offset
, btblock_rec_count
,
592 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
593 { "keys", FLDT_CNTBTKEY
, btblock_key_offset
, btblock_key_count
,
594 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
595 { "ptrs", FLDT_CNTBTPTR
, btblock_ptr_offset
, btblock_key_count
,
596 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_CNTBT
},
601 #define KOFF(f) bitize(offsetof(xfs_alloc_key_t, ar_ ## f))
602 const field_t cntbt_key_flds
[] = {
603 { "blockcount", FLDT_EXTLEN
, OI(KOFF(blockcount
)), C1
, 0, TYP_NONE
},
604 { "startblock", FLDT_AGBLOCK
, OI(KOFF(startblock
)), C1
, 0, TYP_DATA
},
609 #define ROFF(f) bitize(offsetof(xfs_alloc_rec_t, ar_ ## f))
610 const field_t cntbt_rec_flds
[] = {
611 { "startblock", FLDT_AGBLOCK
, OI(ROFF(startblock
)), C1
, 0, TYP_DATA
},
612 { "blockcount", FLDT_EXTLEN
, OI(ROFF(blockcount
)), C1
, 0, TYP_NONE
},
617 /* RMAP btree blocks */
618 const field_t rmapbt_crc_hfld
[] = {
619 { "", FLDT_RMAPBT_CRC
, OI(0), C1
, 0, TYP_NONE
},
623 #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
624 const field_t rmapbt_crc_flds
[] = {
625 { "magic", FLDT_UINT32X
, OI(OFF(magic
)), C1
, 0, TYP_NONE
},
626 { "level", FLDT_UINT16D
, OI(OFF(level
)), C1
, 0, TYP_NONE
},
627 { "numrecs", FLDT_UINT16D
, OI(OFF(numrecs
)), C1
, 0, TYP_NONE
},
628 { "leftsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_leftsib
)), C1
, 0, TYP_RMAPBT
},
629 { "rightsib", FLDT_AGBLOCK
, OI(OFF(u
.s
.bb_rightsib
)), C1
, 0, TYP_RMAPBT
},
630 { "bno", FLDT_DFSBNO
, OI(OFF(u
.s
.bb_blkno
)), C1
, 0, TYP_RMAPBT
},
631 { "lsn", FLDT_UINT64X
, OI(OFF(u
.s
.bb_lsn
)), C1
, 0, TYP_NONE
},
632 { "uuid", FLDT_UUID
, OI(OFF(u
.s
.bb_uuid
)), C1
, 0, TYP_NONE
},
633 { "owner", FLDT_AGNUMBER
, OI(OFF(u
.s
.bb_owner
)), C1
, 0, TYP_NONE
},
634 { "crc", FLDT_CRC
, OI(OFF(u
.s
.bb_crc
)), C1
, 0, TYP_NONE
},
635 { "recs", FLDT_RMAPBTREC
, btblock_rec_offset
, btblock_rec_count
,
636 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
637 { "keys", FLDT_RMAPBTKEY
, btblock_key_offset
, btblock_key_count
,
638 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
639 { "ptrs", FLDT_RMAPBTPTR
, btblock_ptr_offset
, btblock_key_count
,
640 FLD_ARRAY
|FLD_ABASE1
|FLD_COUNT
|FLD_OFFSET
, TYP_RMAPBT
},
645 #define KOFF(f) bitize(offsetof(struct xfs_rmap_key, rm_ ## f))
647 #define RMAPBK_STARTBLOCK_BITOFF 0
648 #define RMAPBK_OWNER_BITOFF (RMAPBK_STARTBLOCK_BITOFF + RMAPBT_STARTBLOCK_BITLEN)
649 #define RMAPBK_ATTRFLAG_BITOFF (RMAPBK_OWNER_BITOFF + RMAPBT_OWNER_BITLEN)
650 #define RMAPBK_BMBTFLAG_BITOFF (RMAPBK_ATTRFLAG_BITOFF + RMAPBT_ATTRFLAG_BITLEN)
651 #define RMAPBK_EXNTFLAG_BITOFF (RMAPBK_BMBTFLAG_BITOFF + RMAPBT_BMBTFLAG_BITLEN)
652 #define RMAPBK_UNUSED_OFFSET_BITOFF (RMAPBK_EXNTFLAG_BITOFF + RMAPBT_EXNTFLAG_BITLEN)
653 #define RMAPBK_OFFSET_BITOFF (RMAPBK_UNUSED_OFFSET_BITOFF + RMAPBT_UNUSED_OFFSET_BITLEN)
655 #define HI_KOFF(f) bitize(sizeof(struct xfs_rmap_key) + offsetof(struct xfs_rmap_key, rm_ ## f))
657 #define RMAPBK_STARTBLOCKHI_BITOFF (bitize(sizeof(struct xfs_rmap_key)))
658 #define RMAPBK_OWNERHI_BITOFF (RMAPBK_STARTBLOCKHI_BITOFF + RMAPBT_STARTBLOCK_BITLEN)
659 #define RMAPBK_ATTRFLAGHI_BITOFF (RMAPBK_OWNERHI_BITOFF + RMAPBT_OWNER_BITLEN)
660 #define RMAPBK_BMBTFLAGHI_BITOFF (RMAPBK_ATTRFLAGHI_BITOFF + RMAPBT_ATTRFLAG_BITLEN)
661 #define RMAPBK_EXNTFLAGHI_BITOFF (RMAPBK_BMBTFLAGHI_BITOFF + RMAPBT_BMBTFLAG_BITLEN)
662 #define RMAPBK_UNUSED_OFFSETHI_BITOFF (RMAPBK_EXNTFLAGHI_BITOFF + RMAPBT_EXNTFLAG_BITLEN)
663 #define RMAPBK_OFFSETHI_BITOFF (RMAPBK_UNUSED_OFFSETHI_BITOFF + RMAPBT_UNUSED_OFFSET_BITLEN)
665 const field_t rmapbt_key_flds
[] = {
666 { "startblock", FLDT_AGBLOCK
, OI(KOFF(startblock
)), C1
, 0, TYP_DATA
},
667 { "owner", FLDT_INT64D
, OI(KOFF(owner
)), C1
, 0, TYP_NONE
},
668 { "offset", FLDT_RFILEOFFD
, OI(RMAPBK_OFFSET_BITOFF
), C1
, 0, TYP_NONE
},
669 { "attrfork", FLDT_RATTRFORKFLG
, OI(RMAPBK_ATTRFLAG_BITOFF
), C1
, 0,
671 { "bmbtblock", FLDT_RBMBTFLG
, OI(RMAPBK_BMBTFLAG_BITOFF
), C1
, 0,
673 { "startblock_hi", FLDT_AGBLOCK
, OI(HI_KOFF(startblock
)), C1
, 0, TYP_DATA
},
674 { "owner_hi", FLDT_INT64D
, OI(HI_KOFF(owner
)), C1
, 0, TYP_NONE
},
675 { "offset_hi", FLDT_RFILEOFFD
, OI(RMAPBK_OFFSETHI_BITOFF
), C1
, 0, TYP_NONE
},
676 { "attrfork_hi", FLDT_RATTRFORKFLG
, OI(RMAPBK_ATTRFLAGHI_BITOFF
), C1
, 0,
678 { "bmbtblock_hi", FLDT_RBMBTFLG
, OI(RMAPBK_BMBTFLAGHI_BITOFF
), C1
, 0,
685 #define ROFF(f) bitize(offsetof(struct xfs_rmap_rec, rm_ ## f))
687 #define RMAPBT_STARTBLOCK_BITOFF 0
688 #define RMAPBT_BLOCKCOUNT_BITOFF (RMAPBT_STARTBLOCK_BITOFF + RMAPBT_STARTBLOCK_BITLEN)
689 #define RMAPBT_OWNER_BITOFF (RMAPBT_BLOCKCOUNT_BITOFF + RMAPBT_BLOCKCOUNT_BITLEN)
690 #define RMAPBT_ATTRFLAG_BITOFF (RMAPBT_OWNER_BITOFF + RMAPBT_OWNER_BITLEN)
691 #define RMAPBT_BMBTFLAG_BITOFF (RMAPBT_ATTRFLAG_BITOFF + RMAPBT_ATTRFLAG_BITLEN)
692 #define RMAPBT_EXNTFLAG_BITOFF (RMAPBT_BMBTFLAG_BITOFF + RMAPBT_BMBTFLAG_BITLEN)
693 #define RMAPBT_UNUSED_OFFSET_BITOFF (RMAPBT_EXNTFLAG_BITOFF + RMAPBT_EXNTFLAG_BITLEN)
694 #define RMAPBT_OFFSET_BITOFF (RMAPBT_UNUSED_OFFSET_BITOFF + RMAPBT_UNUSED_OFFSET_BITLEN)
696 const field_t rmapbt_rec_flds
[] = {
697 { "startblock", FLDT_AGBLOCK
, OI(RMAPBT_STARTBLOCK_BITOFF
), C1
, 0, TYP_DATA
},
698 { "blockcount", FLDT_REXTLEN
, OI(RMAPBT_BLOCKCOUNT_BITOFF
), C1
, 0, TYP_NONE
},
699 { "owner", FLDT_INT64D
, OI(RMAPBT_OWNER_BITOFF
), C1
, 0, TYP_NONE
},
700 { "offset", FLDT_RFILEOFFD
, OI(RMAPBT_OFFSET_BITOFF
), C1
, 0, TYP_NONE
},
701 { "extentflag", FLDT_REXTFLG
, OI(RMAPBT_EXNTFLAG_BITOFF
), C1
, 0,
703 { "attrfork", FLDT_RATTRFORKFLG
, OI(RMAPBT_ATTRFLAG_BITOFF
), C1
, 0,
705 { "bmbtblock", FLDT_RBMBTFLG
, OI(RMAPBT_BMBTFLAG_BITOFF
), C1
, 0,