db/btblock.c

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