]> git.ipfire.org Git - thirdparty/xfsprogs-dev.git/blame - db/btblock.c
projects / thirdparty / xfsprogs-dev.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
xfs_db: print freecount in xfs_inobt_rec as unsigned
[thirdparty/xfsprogs-dev.git] / db / btblock.c
CommitLineData
959ef981 1// SPDX-License-Identifier: GPL-2.0
49b31417
BN		 2/*
3 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
49b31417
BN		 5 */
6
6b803e5a 7#include "libxfs.h"
49b31417
BN		 8#include "type.h"
9#include "faddr.h"
10#include "fprint.h"
11#include "field.h"
12#include "btblock.h"
13#include "print.h"
14#include "bit.h"
15#include "init.h"
58615a7a
DW		 16#include "io.h"
17#include "output.h"
49b31417 18
49b31417
BN		 19/*
20 * Definition of the possible btree block layouts.
21 */
00ff2b10 22static struct xfs_db_btree {
4e503735 23 uint32_t magic;
49b31417
BN		 24 size_t block_len;
25 size_t key_len;
26 size_t rec_len;
27 size_t ptr_len;
28} btrees[] = {
4e503735 29 { XFS_BMAP_MAGIC,
b3563c19 30 XFS_BTREE_LBLOCK_LEN,
49b31417
BN		 31 sizeof(xfs_bmbt_key_t),
32 sizeof(xfs_bmbt_rec_t),
33 sizeof(__be64),
34 },
4e503735 35 { XFS_ABTB_MAGIC,
b3563c19 36 XFS_BTREE_SBLOCK_LEN,
49b31417
BN		 37 sizeof(xfs_alloc_key_t),
38 sizeof(xfs_alloc_rec_t),
39 sizeof(__be32),
40 },
4e503735 41 { XFS_ABTC_MAGIC,
b3563c19 42 XFS_BTREE_SBLOCK_LEN,
49b31417
BN		 43 sizeof(xfs_alloc_key_t),
44 sizeof(xfs_alloc_rec_t),
45 sizeof(__be32),
46 },
4e503735 47 { XFS_IBT_MAGIC,
b3563c19 48 XFS_BTREE_SBLOCK_LEN,
49b31417
BN		 49 sizeof(xfs_inobt_key_t),
50 sizeof(xfs_inobt_rec_t),
51 sizeof(__be32),
52 },
2a0cd7ad
BF		 53 { XFS_FIBT_MAGIC,
54 XFS_BTREE_SBLOCK_LEN,
55 sizeof(xfs_inobt_key_t),
56 sizeof(xfs_inobt_rec_t),
57 sizeof(__be32),
58 },
4e503735 59 { XFS_BMAP_CRC_MAGIC,
c2907bd7
DC		 60 XFS_BTREE_LBLOCK_CRC_LEN,
61 sizeof(xfs_bmbt_key_t),
62 sizeof(xfs_bmbt_rec_t),
63 sizeof(__be64),
64 },
4e503735 65 { XFS_ABTB_CRC_MAGIC,
c2907bd7
DC		 66 XFS_BTREE_SBLOCK_CRC_LEN,
67 sizeof(xfs_alloc_key_t),
68 sizeof(xfs_alloc_rec_t),
69 sizeof(__be32),
70 },
4e503735 71 { XFS_ABTC_CRC_MAGIC,
c2907bd7
DC		 72 XFS_BTREE_SBLOCK_CRC_LEN,
73 sizeof(xfs_alloc_key_t),
74 sizeof(xfs_alloc_rec_t),
75 sizeof(__be32),
76 },
4e503735 77 { XFS_IBT_CRC_MAGIC,
c2907bd7
DC		 78 XFS_BTREE_SBLOCK_CRC_LEN,
79 sizeof(xfs_inobt_key_t),
80 sizeof(xfs_inobt_rec_t),
81 sizeof(__be32),
82 },
2a0cd7ad
BF		 83 { XFS_FIBT_CRC_MAGIC,
84 XFS_BTREE_SBLOCK_CRC_LEN,
85 sizeof(xfs_inobt_key_t),
86 sizeof(xfs_inobt_rec_t),
87 sizeof(__be32),
88 },
a9d7b986
DW		 89 { XFS_RMAP_CRC_MAGIC,
90 XFS_BTREE_SBLOCK_CRC_LEN,
91 2 * sizeof(struct xfs_rmap_key),
92 sizeof(struct xfs_rmap_rec),
93 sizeof(__be32),
94 },
9fb2cb27
DW		 95 { XFS_REFC_CRC_MAGIC,
96 XFS_BTREE_SBLOCK_CRC_LEN,
97 sizeof(struct xfs_refcount_key),
98 sizeof(struct xfs_refcount_rec),
99 sizeof(__be32),
100 },
4e503735
DC		 101 { 0,
102 },
49b31417
BN		 103};
104
105/*
58615a7a 106 * Find the right block definition for a given ondisk block.
49b31417 107 */
4e503735
DC		 108static struct xfs_db_btree *
109block_to_bt(
110 struct xfs_btree_block *bb)
111{
58615a7a
DW		 112 struct xfs_db_btree *btp;
113 uint32_t magic;
114 bool crc;
115
116 magic = be32_to_cpu((bb)->bb_magic);
117 for (btp = &btrees[0]; btp->magic != 0; btp++) {
118 if (magic == btp->magic)
119 return btp;
120 }
121
122 /* Magic is invalid/unknown. Guess based on iocur type */
123 crc = xfs_sb_version_hascrc(&mp->m_sb);
124 switch (iocur_top->typ->typnm) {
125 case TYP_BMAPBTA:
126 case TYP_BMAPBTD:
127 magic = crc ? XFS_BMAP_CRC_MAGIC : XFS_BMAP_MAGIC;
128 break;
129 case TYP_BNOBT:
130 magic = crc ? XFS_ABTB_CRC_MAGIC : XFS_ABTB_MAGIC;
131 break;
132 case TYP_CNTBT:
133 magic = crc ? XFS_ABTC_CRC_MAGIC : XFS_ABTC_MAGIC;
134 break;
135 case TYP_INOBT:
136 magic = crc ? XFS_IBT_CRC_MAGIC : XFS_IBT_MAGIC;
137 break;
138 case TYP_FINOBT:
139 magic = crc ? XFS_FIBT_CRC_MAGIC : XFS_FIBT_MAGIC;
140 break;
141 case TYP_RMAPBT:
142 magic = crc ? XFS_RMAP_CRC_MAGIC : 0;
143 break;
144 case TYP_REFCBT:
145 magic = crc ? XFS_REFC_CRC_MAGIC : 0;
146 break;
147 default:
148 ASSERT(0);
149 }
150
151 ASSERT(magic);
152 dbprintf(_("Bad btree magic 0x%x; coercing to %s.\n"),
153 be32_to_cpu((bb)->bb_magic),
154 iocur_top->typ->name);
4e503735 155
58615a7a
DW		 156 for (btp = &btrees[0]; btp->magic != 0; btp++) {
157 if (magic == btp->magic)
4e503735 158 return btp;
58615a7a 159 }
4e503735
DC		 160
161 return NULL;
162}
49b31417
BN		 163
164/* calculate max records. Only for non-leaves. */
165static int
166btblock_maxrecs(struct xfs_db_btree *bt, int blocksize)
167{
168 blocksize -= bt->block_len;
169
170 return blocksize / (bt->key_len + bt->ptr_len);
171}
172
173/*
174 * Get the number of keys in a btree block.
175 *
176 * Note: can also be used to get the number of ptrs because there are
177 * always the same number of keys and ptrs in a block.
178 */
179static int
180btblock_key_count(
181 void *obj,
182 int startoff)
183{
184 struct xfs_btree_block *block = obj;
185
186 ASSERT(startoff == 0);
187
188 if (block->bb_level == 0)
189 return 0;
190 return be16_to_cpu(block->bb_numrecs);
191}
192
193/*
194 * Get the number of keys in a btree block.
195 */
196static int
197btblock_rec_count(
198 void *obj,
199 int startoff)
200{
201 struct xfs_btree_block *block = obj;
202
203 ASSERT(startoff == 0);
204
205 if (block->bb_level != 0)
206 return 0;
207 return be16_to_cpu(block->bb_numrecs);
208}
209
210/*
211 * Get the offset of the key at idx in a btree block.
212 */
213static int
214btblock_key_offset(
215 void *obj,
216 int startoff,
217 int idx)
218{
219 struct xfs_btree_block *block = obj;
220 struct xfs_db_btree *bt = block_to_bt(block);
221 int offset;
222
223 ASSERT(startoff == 0);
224 ASSERT(block->bb_level != 0);
225
226 offset = bt->block_len + (idx - 1) * bt->key_len;
227 return bitize(offset);
228}
229
230/*
231 * Get the offset of the ptr at idx in a btree block.
232 */
233static int
234btblock_ptr_offset(
235 void *obj,
236 int startoff,
237 int idx)
238{
239 struct xfs_btree_block *block = obj;
240 struct xfs_db_btree *bt = block_to_bt(block);
241 int offset;
242 int maxrecs;
243
244 ASSERT(startoff == 0);
245 ASSERT(block->bb_level != 0);
246
247 maxrecs = btblock_maxrecs(bt, mp->m_sb.sb_blocksize);
248 offset = bt->block_len +
249 maxrecs * bt->key_len +
250 (idx - 1) * bt->ptr_len;
251
252 return bitize(offset);
253}
254
255/*
256 * Get the offset of the record at idx in a btree block.
257 */
258static int
259btblock_rec_offset(
260 void *obj,
261 int startoff,
262 int idx)
263{
264 struct xfs_btree_block *block = obj;
265 struct xfs_db_btree *bt = block_to_bt(block);
266 int offset;
267
268 ASSERT(startoff == 0);
269 ASSERT(block->bb_level == 0);
270
271 offset = bt->block_len + (idx - 1) * bt->rec_len;
272 return bitize(offset);
273}
274
275/*
276 * Get the size of a btree block.
277 */
278int
279btblock_size(
280 void *obj,
281 int startoff,
282 int idx)
283{
284 return bitize(mp->m_sb.sb_blocksize);
285}
286
287
288/*
289 * Bmap btree.
290 */
291
292const field_t bmapbta_hfld[] = {
293 { "", FLDT_BMAPBTA, OI(0), C1, 0, TYP_NONE },
294 { NULL }
295};
296const field_t bmapbtd_hfld[] = {
297 { "", FLDT_BMAPBTD, OI(0), C1, 0, TYP_NONE },
298 { NULL }
299};
300
c2907bd7
DC		 301const field_t bmapbta_crc_hfld[] = {
302 { "", FLDT_BMAPBTA_CRC, OI(0), C1, 0, TYP_NONE },
303 { NULL }
304};
305const field_t bmapbtd_crc_hfld[] = {
306 { "", FLDT_BMAPBTD_CRC, OI(0), C1, 0, TYP_NONE },
307 { NULL }
308};
309
b3563c19 310#define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
49b31417
BN		 311const field_t bmapbta_flds[] = {
312 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
313 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
314 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
b3563c19
BN		 315 { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTA },
316 { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTA },
49b31417
BN		 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 },
323 { NULL }
324};
325const field_t bmapbtd_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 },
c77d2d02
CH		 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 },
49b31417
BN		 331 { "recs", FLDT_BMAPBTDREC, btblock_rec_offset, btblock_rec_count,
332 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
333 { "keys", FLDT_BMAPBTDKEY, btblock_key_offset, btblock_key_count,
334 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
335 { "ptrs", FLDT_BMAPBTDPTR, btblock_ptr_offset, btblock_key_count,
336 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTD },
337 { NULL }
338};
c2907bd7
DC		 339/* crc enabled versions */
340const field_t bmapbta_crc_flds[] = {
341 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
342 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
343 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
344 { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTA },
345 { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTA },
346 { "bno", FLDT_DFSBNO, OI(OFF(u.l.bb_blkno)), C1, 0, TYP_BMAPBTD },
347 { "lsn", FLDT_UINT64X, OI(OFF(u.l.bb_lsn)), C1, 0, TYP_NONE },
348 { "uuid", FLDT_UUID, OI(OFF(u.l.bb_uuid)), C1, 0, TYP_NONE },
349 { "owner", FLDT_INO, OI(OFF(u.l.bb_owner)), C1, 0, TYP_NONE },
0522f1cc 350 { "crc", FLDT_CRC, OI(OFF(u.l.bb_crc)), C1, 0, TYP_NONE },
c2907bd7
DC		 351 { "recs", FLDT_BMAPBTAREC, btblock_rec_offset, btblock_rec_count,
352 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
353 { "keys", FLDT_BMAPBTAKEY, btblock_key_offset, btblock_key_count,
354 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
355 { "ptrs", FLDT_BMAPBTAPTR, btblock_ptr_offset, btblock_key_count,
356 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTA },
357 { NULL }
358};
359const field_t bmapbtd_crc_flds[] = {
360 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
361 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
362 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
363 { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTD },
364 { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTD },
365 { "bno", FLDT_DFSBNO, OI(OFF(u.l.bb_blkno)), C1, 0, TYP_BMAPBTD },
366 { "lsn", FLDT_UINT64X, OI(OFF(u.l.bb_lsn)), C1, 0, TYP_NONE },
367 { "uuid", FLDT_UUID, OI(OFF(u.l.bb_uuid)), C1, 0, TYP_NONE },
368 { "owner", FLDT_INO, OI(OFF(u.l.bb_owner)), C1, 0, TYP_NONE },
0522f1cc 369 { "crc", FLDT_CRC, OI(OFF(u.l.bb_crc)), C1, 0, TYP_NONE },
c2907bd7
DC		 370 { "recs", FLDT_BMAPBTDREC, btblock_rec_offset, btblock_rec_count,
371 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
372 { "keys", FLDT_BMAPBTDKEY, btblock_key_offset, btblock_key_count,
373 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
374 { "ptrs", FLDT_BMAPBTDPTR, btblock_ptr_offset, btblock_key_count,
375 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTD },
376 { NULL }
377};
49b31417
BN		 378#undef OFF
379
380#define KOFF(f) bitize(offsetof(xfs_bmbt_key_t, br_ ## f))
381const field_t bmapbta_key_flds[] = {
382 { "startoff", FLDT_DFILOFFA, OI(KOFF(startoff)), C1, 0, TYP_ATTR },
383 { NULL }
384};
385const field_t bmapbtd_key_flds[] = {
386 { "startoff", FLDT_DFILOFFD, OI(KOFF(startoff)), C1, 0, TYP_INODATA },
387 { NULL }
388};
389#undef KOFF
390
49b31417
BN		 391#define BMBT_EXNTFLAG_BITOFF 0
392#define BMBT_STARTOFF_BITOFF (BMBT_EXNTFLAG_BITOFF + BMBT_EXNTFLAG_BITLEN)
393#define BMBT_STARTBLOCK_BITOFF (BMBT_STARTOFF_BITOFF + BMBT_STARTOFF_BITLEN)
394#define BMBT_BLOCKCOUNT_BITOFF \
395 (BMBT_STARTBLOCK_BITOFF + BMBT_STARTBLOCK_BITLEN)
396
49b31417
BN		 397const field_t bmapbta_rec_flds[] = {
398 { "startoff", FLDT_CFILEOFFA, OI(BMBT_STARTOFF_BITOFF), C1, 0,
399 TYP_ATTR },
400 { "startblock", FLDT_CFSBLOCK, OI(BMBT_STARTBLOCK_BITOFF), C1, 0,
401 TYP_ATTR },
402 { "blockcount", FLDT_CEXTLEN, OI(BMBT_BLOCKCOUNT_BITOFF), C1, 0,
403 TYP_NONE },
404 { "extentflag", FLDT_CEXTFLG, OI(BMBT_EXNTFLAG_BITOFF), C1, 0,
405 TYP_NONE },
406 { NULL }
407};
408const field_t bmapbtd_rec_flds[] = {
409 { "startoff", FLDT_CFILEOFFD, OI(BMBT_STARTOFF_BITOFF), C1, 0,
410 TYP_INODATA },
411 { "startblock", FLDT_CFSBLOCK, OI(BMBT_STARTBLOCK_BITOFF), C1, 0,
412 TYP_INODATA },
413 { "blockcount", FLDT_CEXTLEN, OI(BMBT_BLOCKCOUNT_BITOFF), C1, 0,
414 TYP_NONE },
415 { "extentflag", FLDT_CEXTFLG, OI(BMBT_EXNTFLAG_BITOFF), C1, 0,
416 TYP_NONE },
417 { NULL }
418};
419
420
421/*
422 * Inode allocation btree.
423 */
424
425const field_t inobt_hfld[] = {
426 { "", FLDT_INOBT, OI(0), C1, 0, TYP_NONE },
427 { NULL }
428};
429
c2907bd7
DC		 430const field_t inobt_crc_hfld[] = {
431 { "", FLDT_INOBT_CRC, OI(0), C1, 0, TYP_NONE },
432 { NULL }
433};
434
061e316e
BF		 435const field_t inobt_spcrc_hfld[] = {
436 { "", FLDT_INOBT_SPCRC, OI(0), C1, 0, TYP_NONE },
437 { NULL }
438};
439
b3563c19 440#define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
49b31417
BN		 441const field_t inobt_flds[] = {
442 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
443 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
444 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
b3563c19
BN		 445 { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_INOBT },
446 { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_INOBT },
49b31417
BN		 447 { "recs", FLDT_INOBTREC, btblock_rec_offset, btblock_rec_count,
448 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
449 { "keys", FLDT_INOBTKEY, btblock_key_offset, btblock_key_count,
450 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
451 { "ptrs", FLDT_INOBTPTR, btblock_ptr_offset, btblock_key_count,
452 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_INOBT },
453 { NULL }
454};
c2907bd7
DC		 455const field_t inobt_crc_flds[] = {
456 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
457 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
458 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
459 { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_INOBT },
460 { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_INOBT },
461 { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_INOBT },
462 { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE },
463 { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE },
464 { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE },
0522f1cc 465 { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE },
c2907bd7
DC		 466 { "recs", FLDT_INOBTREC, btblock_rec_offset, btblock_rec_count,
467 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
468 { "keys", FLDT_INOBTKEY, btblock_key_offset, btblock_key_count,
469 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
470 { "ptrs", FLDT_INOBTPTR, btblock_ptr_offset, btblock_key_count,
471 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_INOBT },
472 { NULL }
473};
061e316e
BF		 474const field_t inobt_spcrc_flds[] = {
475 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
476 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
477 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
478 { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_INOBT },
479 { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_INOBT },
480 { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_INOBT },
481 { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE },
482 { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE },
483 { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE },
484 { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE },
485 { "recs", FLDT_INOBTSPREC, btblock_rec_offset, btblock_rec_count,
486 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
487 { "keys", FLDT_INOBTKEY, btblock_key_offset, btblock_key_count,
488 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
489 { "ptrs", FLDT_INOBTPTR, btblock_ptr_offset, btblock_key_count,
490 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_INOBT },
491 { NULL }
492};
493
49b31417
BN		 494#undef OFF
495
496#define KOFF(f) bitize(offsetof(xfs_inobt_key_t, ir_ ## f))
497const field_t inobt_key_flds[] = {
498 { "startino", FLDT_AGINO, OI(KOFF(startino)), C1, 0, TYP_INODE },
499 { NULL }
500};
501#undef KOFF
502
11640e30 503#define ROFF(f) bitize(offsetof(xfs_inobt_rec_t, f))
49b31417 504const field_t inobt_rec_flds[] = {
11640e30
BF		 505 { "startino", FLDT_AGINO, OI(ROFF(ir_startino)), C1, 0, TYP_INODE },
506 { "freecount", FLDT_INT32D, OI(ROFF(ir_u.f.ir_freecount)), C1, 0, TYP_NONE },
507 { "free", FLDT_INOFREE, OI(ROFF(ir_free)), C1, 0, TYP_NONE },
49b31417
BN		 508 { NULL }
509};
061e316e
BF		 510/* sparse inode on-disk format */
511const field_t inobt_sprec_flds[] = {
512 { "startino", FLDT_AGINO, OI(ROFF(ir_startino)), C1, 0, TYP_INODE },
513 { "holemask", FLDT_UINT16X, OI(ROFF(ir_u.sp.ir_holemask)), C1, 0,
514 TYP_NONE },
515 { "count", FLDT_UINT8D, OI(ROFF(ir_u.sp.ir_count)), C1, 0, TYP_NONE },
cb5de90b 516 { "freecount", FLDT_UINT8D, OI(ROFF(ir_u.sp.ir_freecount)), C1, 0,
061e316e
BF		 517 TYP_NONE },
518 { "free", FLDT_INOFREE, OI(ROFF(ir_free)), C1, 0, TYP_NONE },
519 { NULL }
520};
49b31417
BN		 521#undef ROFF
522
523
524/*
525 * Allocation btrees.
526 */
527const field_t bnobt_hfld[] = {
528 { "", FLDT_BNOBT, OI(0), C1, 0, TYP_NONE },
529 { NULL }
530};
531
c2907bd7
DC		 532const field_t bnobt_crc_hfld[] = {
533 { "", FLDT_BNOBT_CRC, OI(0), C1, 0, TYP_NONE },
534 { NULL }
535};
536
b3563c19 537#define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
49b31417
BN		 538const field_t bnobt_flds[] = {
539 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
540 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
541 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
b3563c19
BN		 542 { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_BNOBT },
543 { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_BNOBT },
49b31417
BN		 544 { "recs", FLDT_BNOBTREC, btblock_rec_offset, btblock_rec_count,
545 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
546 { "keys", FLDT_BNOBTKEY, btblock_key_offset, btblock_key_count,
547 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
548 { "ptrs", FLDT_BNOBTPTR, btblock_ptr_offset, btblock_key_count,
549 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BNOBT },
550 { NULL }
551};
c2907bd7
DC		 552const field_t bnobt_crc_flds[] = {
553 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
554 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
555 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
556 { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_BNOBT },
557 { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_BNOBT },
558 { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_BNOBT },
559 { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE },
560 { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE },
561 { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE },
0522f1cc 562 { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE },
c2907bd7
DC		 563 { "recs", FLDT_BNOBTREC, btblock_rec_offset, btblock_rec_count,
564 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
565 { "keys", FLDT_BNOBTKEY, btblock_key_offset, btblock_key_count,
566 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
567 { "ptrs", FLDT_BNOBTPTR, btblock_ptr_offset, btblock_key_count,
568 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BNOBT },
569 { NULL }
570};
49b31417
BN		 571#undef OFF
572
573#define KOFF(f) bitize(offsetof(xfs_alloc_key_t, ar_ ## f))
574const field_t bnobt_key_flds[] = {
575 { "startblock", FLDT_AGBLOCK, OI(KOFF(startblock)), C1, 0, TYP_DATA },
576 { "blockcount", FLDT_EXTLEN, OI(KOFF(blockcount)), C1, 0, TYP_NONE },
577 { NULL }
578};
579#undef KOFF
580
581#define ROFF(f) bitize(offsetof(xfs_alloc_rec_t, ar_ ## f))
582const field_t bnobt_rec_flds[] = {
583 { "startblock", FLDT_AGBLOCK, OI(ROFF(startblock)), C1, 0, TYP_DATA },
584 { "blockcount", FLDT_EXTLEN, OI(ROFF(blockcount)), C1, 0, TYP_NONE },
585 { NULL }
586};
587#undef ROFF
588
589const field_t cntbt_hfld[] = {
590 { "", FLDT_CNTBT, OI(0), C1, 0, TYP_NONE },
591 { NULL }
592};
593
c2907bd7
DC		 594const field_t cntbt_crc_hfld[] = {
595 { "", FLDT_CNTBT_CRC, OI(0), C1, 0, TYP_NONE },
596 { NULL }
597};
598
b3563c19 599#define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
49b31417
BN		 600const field_t cntbt_flds[] = {
601 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
602 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
603 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
b3563c19
BN		 604 { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_CNTBT },
605 { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_CNTBT },
49b31417
BN		 606 { "recs", FLDT_CNTBTREC, btblock_rec_offset, btblock_rec_count,
607 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
608 { "keys", FLDT_CNTBTKEY, btblock_key_offset, btblock_key_count,
609 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
610 { "ptrs", FLDT_CNTBTPTR, btblock_ptr_offset, btblock_key_count,
611 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_CNTBT },
612 { NULL }
613};
c2907bd7
DC		 614const field_t cntbt_crc_flds[] = {
615 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
616 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
617 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
618 { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_CNTBT },
619 { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_CNTBT },
620 { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_CNTBT },
621 { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE },
622 { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE },
623 { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE },
0522f1cc 624 { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE },
c2907bd7
DC		 625 { "recs", FLDT_CNTBTREC, btblock_rec_offset, btblock_rec_count,
626 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
627 { "keys", FLDT_CNTBTKEY, btblock_key_offset, btblock_key_count,
628 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
629 { "ptrs", FLDT_CNTBTPTR, btblock_ptr_offset, btblock_key_count,
630 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_CNTBT },
631 { NULL }
632};
49b31417
BN		 633#undef OFF
634
635#define KOFF(f) bitize(offsetof(xfs_alloc_key_t, ar_ ## f))
636const field_t cntbt_key_flds[] = {
637 { "blockcount", FLDT_EXTLEN, OI(KOFF(blockcount)), C1, 0, TYP_NONE },
638 { "startblock", FLDT_AGBLOCK, OI(KOFF(startblock)), C1, 0, TYP_DATA },
639 { NULL }
640};
641#undef KOFF
642
643#define ROFF(f) bitize(offsetof(xfs_alloc_rec_t, ar_ ## f))
644const field_t cntbt_rec_flds[] = {
645 { "startblock", FLDT_AGBLOCK, OI(ROFF(startblock)), C1, 0, TYP_DATA },
646 { "blockcount", FLDT_EXTLEN, OI(ROFF(blockcount)), C1, 0, TYP_NONE },
647 { NULL }
648};
649#undef ROFF
a9d7b986
DW		 650
651/* RMAP btree blocks */
652const field_t rmapbt_crc_hfld[] = {
653 { "", FLDT_RMAPBT_CRC, OI(0), C1, 0, TYP_NONE },
654 { NULL }
655};
656
657#define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
658const field_t rmapbt_crc_flds[] = {
659 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
660 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
661 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
662 { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_RMAPBT },
663 { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_RMAPBT },
664 { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_RMAPBT },
665 { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE },
666 { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE },
667 { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE },
668 { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE },
669 { "recs", FLDT_RMAPBTREC, btblock_rec_offset, btblock_rec_count,
670 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
671 { "keys", FLDT_RMAPBTKEY, btblock_key_offset, btblock_key_count,
672 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
673 { "ptrs", FLDT_RMAPBTPTR, btblock_ptr_offset, btblock_key_count,
674 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_RMAPBT },
675 { NULL }
676};
677#undef OFF
678
679#define KOFF(f) bitize(offsetof(struct xfs_rmap_key, rm_ ## f))
680
681#define RMAPBK_STARTBLOCK_BITOFF 0
682#define RMAPBK_OWNER_BITOFF (RMAPBK_STARTBLOCK_BITOFF + RMAPBT_STARTBLOCK_BITLEN)
683#define RMAPBK_ATTRFLAG_BITOFF (RMAPBK_OWNER_BITOFF + RMAPBT_OWNER_BITLEN)
684#define RMAPBK_BMBTFLAG_BITOFF (RMAPBK_ATTRFLAG_BITOFF + RMAPBT_ATTRFLAG_BITLEN)
685#define RMAPBK_EXNTFLAG_BITOFF (RMAPBK_BMBTFLAG_BITOFF + RMAPBT_BMBTFLAG_BITLEN)
686#define RMAPBK_UNUSED_OFFSET_BITOFF (RMAPBK_EXNTFLAG_BITOFF + RMAPBT_EXNTFLAG_BITLEN)
687#define RMAPBK_OFFSET_BITOFF (RMAPBK_UNUSED_OFFSET_BITOFF + RMAPBT_UNUSED_OFFSET_BITLEN)
688
689#define HI_KOFF(f) bitize(sizeof(struct xfs_rmap_key) + offsetof(struct xfs_rmap_key, rm_ ## f))
690
691#define RMAPBK_STARTBLOCKHI_BITOFF (bitize(sizeof(struct xfs_rmap_key)))
692#define RMAPBK_OWNERHI_BITOFF (RMAPBK_STARTBLOCKHI_BITOFF + RMAPBT_STARTBLOCK_BITLEN)
693#define RMAPBK_ATTRFLAGHI_BITOFF (RMAPBK_OWNERHI_BITOFF + RMAPBT_OWNER_BITLEN)
694#define RMAPBK_BMBTFLAGHI_BITOFF (RMAPBK_ATTRFLAGHI_BITOFF + RMAPBT_ATTRFLAG_BITLEN)
695#define RMAPBK_EXNTFLAGHI_BITOFF (RMAPBK_BMBTFLAGHI_BITOFF + RMAPBT_BMBTFLAG_BITLEN)
696#define RMAPBK_UNUSED_OFFSETHI_BITOFF (RMAPBK_EXNTFLAGHI_BITOFF + RMAPBT_EXNTFLAG_BITLEN)
697#define RMAPBK_OFFSETHI_BITOFF (RMAPBK_UNUSED_OFFSETHI_BITOFF + RMAPBT_UNUSED_OFFSET_BITLEN)
698
699const field_t rmapbt_key_flds[] = {
700 { "startblock", FLDT_AGBLOCK, OI(KOFF(startblock)), C1, 0, TYP_DATA },
701 { "owner", FLDT_INT64D, OI(KOFF(owner)), C1, 0, TYP_NONE },
702 { "offset", FLDT_RFILEOFFD, OI(RMAPBK_OFFSET_BITOFF), C1, 0, TYP_NONE },
703 { "attrfork", FLDT_RATTRFORKFLG, OI(RMAPBK_ATTRFLAG_BITOFF), C1, 0,
704 TYP_NONE },
705 { "bmbtblock", FLDT_RBMBTFLG, OI(RMAPBK_BMBTFLAG_BITOFF), C1, 0,
706 TYP_NONE },
707 { "startblock_hi", FLDT_AGBLOCK, OI(HI_KOFF(startblock)), C1, 0, TYP_DATA },
708 { "owner_hi", FLDT_INT64D, OI(HI_KOFF(owner)), C1, 0, TYP_NONE },
709 { "offset_hi", FLDT_RFILEOFFD, OI(RMAPBK_OFFSETHI_BITOFF), C1, 0, TYP_NONE },
710 { "attrfork_hi", FLDT_RATTRFORKFLG, OI(RMAPBK_ATTRFLAGHI_BITOFF), C1, 0,
711 TYP_NONE },
712 { "bmbtblock_hi", FLDT_RBMBTFLG, OI(RMAPBK_BMBTFLAGHI_BITOFF), C1, 0,
713 TYP_NONE },
714 { NULL }
715};
716#undef HI_KOFF
717#undef KOFF
718
a9d7b986
DW		 719#define RMAPBT_STARTBLOCK_BITOFF 0
720#define RMAPBT_BLOCKCOUNT_BITOFF (RMAPBT_STARTBLOCK_BITOFF + RMAPBT_STARTBLOCK_BITLEN)
721#define RMAPBT_OWNER_BITOFF (RMAPBT_BLOCKCOUNT_BITOFF + RMAPBT_BLOCKCOUNT_BITLEN)
722#define RMAPBT_ATTRFLAG_BITOFF (RMAPBT_OWNER_BITOFF + RMAPBT_OWNER_BITLEN)
723#define RMAPBT_BMBTFLAG_BITOFF (RMAPBT_ATTRFLAG_BITOFF + RMAPBT_ATTRFLAG_BITLEN)
724#define RMAPBT_EXNTFLAG_BITOFF (RMAPBT_BMBTFLAG_BITOFF + RMAPBT_BMBTFLAG_BITLEN)
725#define RMAPBT_UNUSED_OFFSET_BITOFF (RMAPBT_EXNTFLAG_BITOFF + RMAPBT_EXNTFLAG_BITLEN)
726#define RMAPBT_OFFSET_BITOFF (RMAPBT_UNUSED_OFFSET_BITOFF + RMAPBT_UNUSED_OFFSET_BITLEN)
727
728const field_t rmapbt_rec_flds[] = {
729 { "startblock", FLDT_AGBLOCK, OI(RMAPBT_STARTBLOCK_BITOFF), C1, 0, TYP_DATA },
730 { "blockcount", FLDT_REXTLEN, OI(RMAPBT_BLOCKCOUNT_BITOFF), C1, 0, TYP_NONE },
731 { "owner", FLDT_INT64D, OI(RMAPBT_OWNER_BITOFF), C1, 0, TYP_NONE },
732 { "offset", FLDT_RFILEOFFD, OI(RMAPBT_OFFSET_BITOFF), C1, 0, TYP_NONE },
733 { "extentflag", FLDT_REXTFLG, OI(RMAPBT_EXNTFLAG_BITOFF), C1, 0,
734 TYP_NONE },
735 { "attrfork", FLDT_RATTRFORKFLG, OI(RMAPBT_ATTRFLAG_BITOFF), C1, 0,
736 TYP_NONE },
737 { "bmbtblock", FLDT_RBMBTFLG, OI(RMAPBT_BMBTFLAG_BITOFF), C1, 0,
738 TYP_NONE },
739 { NULL }
740};
9fb2cb27
DW		 741
742/* refcount btree blocks */
743const field_t refcbt_crc_hfld[] = {
744 { "", FLDT_REFCBT_CRC, OI(0), C1, 0, TYP_NONE },
745 { NULL }
746};
747
748#define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f))
749const field_t refcbt_crc_flds[] = {
750 { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
751 { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
752 { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
753 { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_REFCBT },
754 { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_REFCBT },
755 { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_REFCBT },
756 { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE },
757 { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE },
758 { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE },
759 { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE },
760 { "recs", FLDT_REFCBTREC, btblock_rec_offset, btblock_rec_count,
761 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
762 { "keys", FLDT_REFCBTKEY, btblock_key_offset, btblock_key_count,
763 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
764 { "ptrs", FLDT_REFCBTPTR, btblock_ptr_offset, btblock_key_count,
765 FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_REFCBT },
766 { NULL }
767};
768#undef OFF
769
770#define REFCNTBT_COWFLAG_BITOFF 0
771#define REFCNTBT_STARTBLOCK_BITOFF (REFCNTBT_COWFLAG_BITOFF + REFCNTBT_COWFLAG_BITLEN)
772
9fb2cb27
DW		 773const field_t refcbt_key_flds[] = {
774 { "startblock", FLDT_CAGBLOCK, OI(REFCNTBT_STARTBLOCK_BITOFF), C1, 0, TYP_DATA },
775 { "cowflag", FLDT_CCOWFLG, OI(REFCNTBT_COWFLAG_BITOFF), C1, 0, TYP_DATA },
776 { NULL }
777};
9fb2cb27
DW		 778
779#define ROFF(f) bitize(offsetof(struct xfs_refcount_rec, rc_ ## f))
780const field_t refcbt_rec_flds[] = {
781 { "startblock", FLDT_CAGBLOCK, OI(REFCNTBT_STARTBLOCK_BITOFF), C1, 0, TYP_DATA },
782 { "blockcount", FLDT_EXTLEN, OI(ROFF(blockcount)), C1, 0, TYP_NONE },
783 { "refcount", FLDT_UINT32D, OI(ROFF(refcount)), C1, 0, TYP_DATA },
784 { "cowflag", FLDT_CCOWFLG, OI(REFCNTBT_COWFLAG_BITOFF), C1, 0, TYP_DATA },
785 { NULL }
786};
787#undef ROFF
Unnamed repository; edit this file 'description' to name the repository.