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
  29 /*
  30  * Definition of the possible btree block layouts.
  31  */
  32 struct xfs_db_btree {
  33         uint32_t                magic;
  34         size_t                  block_len;
  35         size_t                  key_len;
  36         size_t                  rec_len;
  37         size_t                  ptr_len;
  38 } btrees[] = {
  39         {       XFS_BMAP_MAGIC,
  40                 XFS_BTREE_LBLOCK_LEN,
  41                 sizeof(xfs_bmbt_key_t),
  42                 sizeof(xfs_bmbt_rec_t),
  43                 sizeof(__be64),
  44         },
  45         {       XFS_ABTB_MAGIC,
  46                 XFS_BTREE_SBLOCK_LEN,
  47                 sizeof(xfs_alloc_key_t),
  48                 sizeof(xfs_alloc_rec_t),
  49                 sizeof(__be32),
  50         },
  51         {       XFS_ABTC_MAGIC,
  52                 XFS_BTREE_SBLOCK_LEN,
  53                 sizeof(xfs_alloc_key_t),
  54                 sizeof(xfs_alloc_rec_t),
  55                 sizeof(__be32),
  56         },
  57         {       XFS_IBT_MAGIC,
  58                 XFS_BTREE_SBLOCK_LEN,
  59                 sizeof(xfs_inobt_key_t),
  60                 sizeof(xfs_inobt_rec_t),
  61                 sizeof(__be32),
  62         },
  63         {       XFS_FIBT_MAGIC,
  64                 XFS_BTREE_SBLOCK_LEN,
  65                 sizeof(xfs_inobt_key_t),
  66                 sizeof(xfs_inobt_rec_t),
  67                 sizeof(__be32),
  68         },
  69         {       XFS_BMAP_CRC_MAGIC,
  70                 XFS_BTREE_LBLOCK_CRC_LEN,
  71                 sizeof(xfs_bmbt_key_t),
  72                 sizeof(xfs_bmbt_rec_t),
  73                 sizeof(__be64),
  74         },
  75         {       XFS_ABTB_CRC_MAGIC,
  76                 XFS_BTREE_SBLOCK_CRC_LEN,
  77                 sizeof(xfs_alloc_key_t),
  78                 sizeof(xfs_alloc_rec_t),
  79                 sizeof(__be32),
  80         },
  81         {       XFS_ABTC_CRC_MAGIC,
  82                 XFS_BTREE_SBLOCK_CRC_LEN,
  83                 sizeof(xfs_alloc_key_t),
  84                 sizeof(xfs_alloc_rec_t),
  85                 sizeof(__be32),
  86         },
  87         {       XFS_IBT_CRC_MAGIC,
  88                 XFS_BTREE_SBLOCK_CRC_LEN,
  89                 sizeof(xfs_inobt_key_t),
  90                 sizeof(xfs_inobt_rec_t),
  91                 sizeof(__be32),
  92         },
  93         {       XFS_FIBT_CRC_MAGIC,
  94                 XFS_BTREE_SBLOCK_CRC_LEN,
  95                 sizeof(xfs_inobt_key_t),
  96                 sizeof(xfs_inobt_rec_t),
  97                 sizeof(__be32),
  98         },
  99         {       0,
 100         },
 101 };
 102
 103 /*
 104  * Find the right block defintion for a given ondisk block.
 105  *
 106  * We use the least significant bit of the magic number as index into
 107  * the array of block defintions.
 108  */
 109 static struct xfs_db_btree *
 110 block_to_bt(
 111         struct xfs_btree_block  *bb)
 112 {
 113         struct xfs_db_btree *btp = &btrees[0];
 114
 115         do {
 116                 if (be32_to_cpu((bb)->bb_magic) == btp->magic)
 117                         return btp;
 118                 btp++;
 119         } while (btp->magic != 0);
 120
 121         return NULL;
 122 }
 123
 124 /* calculate max records.  Only for non-leaves. */
 125 static int
 126 btblock_maxrecs(struct xfs_db_btree *bt, int blocksize)
 127 {
 128         blocksize -= bt->block_len;
 129
 130         return blocksize / (bt->key_len + bt->ptr_len);
 131 }
 132
 133 /*
 134  * Get the number of keys in a btree block.
 135  *
 136  * Note: can also be used to get the number of ptrs because there are
 137  * always the same number of keys and ptrs in a block.
 138  */
 139 static int
 140 btblock_key_count(
 141         void                    *obj,
 142         int                     startoff)
 143 {
 144         struct xfs_btree_block  *block = obj;
 145
 146         ASSERT(startoff == 0);
 147
 148         if (block->bb_level == 0)
 149                 return 0;
 150         return be16_to_cpu(block->bb_numrecs);
 151 }
 152
 153 /*
 154  * Get the number of keys in a btree block.
 155  */
 156 static int
 157 btblock_rec_count(
 158         void                    *obj,
 159         int                     startoff)
 160 {
 161         struct xfs_btree_block  *block = obj;
 162
 163         ASSERT(startoff == 0);
 164
 165         if (block->bb_level != 0)
 166                 return 0;
 167         return be16_to_cpu(block->bb_numrecs);
 168 }
 169
 170 /*
 171  * Get the offset of the key at idx in a btree block.
 172  */
 173 static int
 174 btblock_key_offset(
 175         void                    *obj,
 176         int                     startoff,
 177         int                     idx)
 178 {
 179         struct xfs_btree_block  *block = obj;
 180         struct xfs_db_btree     *bt = block_to_bt(block);
 181         int                     offset;
 182
 183         ASSERT(startoff == 0);
 184         ASSERT(block->bb_level != 0);
 185
 186         offset = bt->block_len + (idx - 1) * bt->key_len;
 187         return bitize(offset);
 188 }
 189
 190 /*
 191  * Get the offset of the ptr at idx in a btree block.
 192  */
 193 static int
 194 btblock_ptr_offset(
 195         void                    *obj,
 196         int                     startoff,
 197         int                     idx)
 198 {
 199         struct xfs_btree_block  *block = obj;
 200         struct xfs_db_btree     *bt = block_to_bt(block);
 201         int                     offset;
 202         int                     maxrecs;
 203
 204         ASSERT(startoff == 0);
 205         ASSERT(block->bb_level != 0);
 206
 207         maxrecs = btblock_maxrecs(bt, mp->m_sb.sb_blocksize);
 208         offset = bt->block_len +
 209                         maxrecs * bt->key_len +
 210                         (idx - 1) * bt->ptr_len;
 211
 212         return bitize(offset);
 213 }
 214
 215 /*
 216  * Get the offset of the record at idx in a btree block.
 217  */
 218 static int
 219 btblock_rec_offset(
 220         void                    *obj,
 221         int                     startoff,
 222         int                     idx)
 223 {
 224         struct xfs_btree_block  *block = obj;
 225         struct xfs_db_btree     *bt = block_to_bt(block);
 226         int                     offset;
 227
 228         ASSERT(startoff == 0);
 229         ASSERT(block->bb_level == 0);
 230
 231         offset = bt->block_len + (idx - 1) * bt->rec_len;
 232         return bitize(offset);
 233 }
 234
 235 /*
 236  * Get the size of a btree block.
 237  */
 238 int
 239 btblock_size(
 240         void    *obj,
 241         int     startoff,
 242         int     idx)
 243 {
 244         return bitize(mp->m_sb.sb_blocksize);
 245 }
 246
 247
 248 /*
 249  * Bmap btree.
 250  */
 251
 252 const field_t   bmapbta_hfld[] = {
 253         { "", FLDT_BMAPBTA, OI(0), C1, 0, TYP_NONE },
 254         { NULL }
 255 };
 256 const field_t   bmapbtd_hfld[] = {
 257         { "", FLDT_BMAPBTD, OI(0), C1, 0, TYP_NONE },
 258         { NULL }
 259 };
 260
 261 const field_t   bmapbta_crc_hfld[] = {
 262         { "", FLDT_BMAPBTA_CRC, OI(0), C1, 0, TYP_NONE },
 263         { NULL }
 264 };
 265 const field_t   bmapbtd_crc_hfld[] = {
 266         { "", FLDT_BMAPBTD_CRC, OI(0), C1, 0, TYP_NONE },
 267         { NULL }
 268 };
 269
 270 #define OFF(f)  bitize(offsetof(struct xfs_btree_block, bb_ ## f))
 271 const field_t   bmapbta_flds[] = {
 272         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 273         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 274         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 275         { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTA },
 276         { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTA },
 277         { "recs", FLDT_BMAPBTAREC, btblock_rec_offset, btblock_rec_count,
 278           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 279         { "keys", FLDT_BMAPBTAKEY, btblock_key_offset, btblock_key_count,
 280           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 281         { "ptrs", FLDT_BMAPBTAPTR, btblock_ptr_offset, btblock_key_count,
 282           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTA },
 283         { NULL }
 284 };
 285 const field_t   bmapbtd_flds[] = {
 286         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 287         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 288         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 289         { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTD },
 290         { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTD },
 291         { "recs", FLDT_BMAPBTDREC, btblock_rec_offset, btblock_rec_count,
 292           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 293         { "keys", FLDT_BMAPBTDKEY, btblock_key_offset, btblock_key_count,
 294           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 295         { "ptrs", FLDT_BMAPBTDPTR, btblock_ptr_offset, btblock_key_count,
 296           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTD },
 297         { NULL }
 298 };
 299 /* crc enabled versions */
 300 const field_t   bmapbta_crc_flds[] = {
 301         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 302         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 303         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 304         { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTA },
 305         { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTA },
 306         { "bno", FLDT_DFSBNO, OI(OFF(u.l.bb_blkno)), C1, 0, TYP_BMAPBTD },
 307         { "lsn", FLDT_UINT64X, OI(OFF(u.l.bb_lsn)), C1, 0, TYP_NONE },
 308         { "uuid", FLDT_UUID, OI(OFF(u.l.bb_uuid)), C1, 0, TYP_NONE },
 309         { "owner", FLDT_INO, OI(OFF(u.l.bb_owner)), C1, 0, TYP_NONE },
 310         { "crc", FLDT_CRC, OI(OFF(u.l.bb_crc)), C1, 0, TYP_NONE },
 311         { "recs", FLDT_BMAPBTAREC, btblock_rec_offset, btblock_rec_count,
 312           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 313         { "keys", FLDT_BMAPBTAKEY, btblock_key_offset, btblock_key_count,
 314           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 315         { "ptrs", FLDT_BMAPBTAPTR, btblock_ptr_offset, btblock_key_count,
 316           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTA },
 317         { NULL }
 318 };
 319 const field_t   bmapbtd_crc_flds[] = {
 320         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 321         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 322         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 323         { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTD },
 324         { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTD },
 325         { "bno", FLDT_DFSBNO, OI(OFF(u.l.bb_blkno)), C1, 0, TYP_BMAPBTD },
 326         { "lsn", FLDT_UINT64X, OI(OFF(u.l.bb_lsn)), C1, 0, TYP_NONE },
 327         { "uuid", FLDT_UUID, OI(OFF(u.l.bb_uuid)), C1, 0, TYP_NONE },
 328         { "owner", FLDT_INO, OI(OFF(u.l.bb_owner)), C1, 0, TYP_NONE },
 329         { "crc", FLDT_CRC, OI(OFF(u.l.bb_crc)), C1, 0, TYP_NONE },
 330         { "recs", FLDT_BMAPBTDREC, btblock_rec_offset, btblock_rec_count,
 331           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 332         { "keys", FLDT_BMAPBTDKEY, btblock_key_offset, btblock_key_count,
 333           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 334         { "ptrs", FLDT_BMAPBTDPTR, btblock_ptr_offset, btblock_key_count,
 335           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTD },
 336         { NULL }
 337 };
 338 #undef OFF
 339
 340 #define KOFF(f) bitize(offsetof(xfs_bmbt_key_t, br_ ## f))
 341 const field_t   bmapbta_key_flds[] = {
 342         { "startoff", FLDT_DFILOFFA, OI(KOFF(startoff)), C1, 0, TYP_ATTR },
 343         { NULL }
 344 };
 345 const field_t   bmapbtd_key_flds[] = {
 346         { "startoff", FLDT_DFILOFFD, OI(KOFF(startoff)), C1, 0, TYP_INODATA },
 347         { NULL }
 348 };
 349 #undef KOFF
 350
 351 #define BMBT_EXNTFLAG_BITOFF    0
 352 #define BMBT_STARTOFF_BITOFF    (BMBT_EXNTFLAG_BITOFF + BMBT_EXNTFLAG_BITLEN)
 353 #define BMBT_STARTBLOCK_BITOFF  (BMBT_STARTOFF_BITOFF + BMBT_STARTOFF_BITLEN)
 354 #define BMBT_BLOCKCOUNT_BITOFF  \
 355         (BMBT_STARTBLOCK_BITOFF + BMBT_STARTBLOCK_BITLEN)
 356
 357 const field_t   bmapbta_rec_flds[] = {
 358         { "startoff", FLDT_CFILEOFFA, OI(BMBT_STARTOFF_BITOFF), C1, 0,
 359           TYP_ATTR },
 360         { "startblock", FLDT_CFSBLOCK, OI(BMBT_STARTBLOCK_BITOFF), C1, 0,
 361           TYP_ATTR },
 362         { "blockcount", FLDT_CEXTLEN, OI(BMBT_BLOCKCOUNT_BITOFF), C1, 0,
 363           TYP_NONE },
 364         { "extentflag", FLDT_CEXTFLG, OI(BMBT_EXNTFLAG_BITOFF), C1, 0,
 365           TYP_NONE },
 366         { NULL }
 367 };
 368 const field_t   bmapbtd_rec_flds[] = {
 369         { "startoff", FLDT_CFILEOFFD, OI(BMBT_STARTOFF_BITOFF), C1, 0,
 370           TYP_INODATA },
 371         { "startblock", FLDT_CFSBLOCK, OI(BMBT_STARTBLOCK_BITOFF), C1, 0,
 372           TYP_INODATA },
 373         { "blockcount", FLDT_CEXTLEN, OI(BMBT_BLOCKCOUNT_BITOFF), C1, 0,
 374           TYP_NONE },
 375         { "extentflag", FLDT_CEXTFLG, OI(BMBT_EXNTFLAG_BITOFF), C1, 0,
 376           TYP_NONE },
 377         { NULL }
 378 };
 379
 380
 381 /*
 382  * Inode allocation btree.
 383  */
 384
 385 const field_t   inobt_hfld[] = {
 386         { "", FLDT_INOBT, OI(0), C1, 0, TYP_NONE },
 387         { NULL }
 388 };
 389
 390 const field_t   inobt_crc_hfld[] = {
 391         { "", FLDT_INOBT_CRC, OI(0), C1, 0, TYP_NONE },
 392         { NULL }
 393 };
 394
 395 const field_t   inobt_spcrc_hfld[] = {
 396         { "", FLDT_INOBT_SPCRC, OI(0), C1, 0, TYP_NONE },
 397         { NULL }
 398 };
 399
 400 #define OFF(f)  bitize(offsetof(struct xfs_btree_block, bb_ ## f))
 401 const field_t   inobt_flds[] = {
 402         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 403         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 404         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 405         { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_INOBT },
 406         { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_INOBT },
 407         { "recs", FLDT_INOBTREC, btblock_rec_offset, btblock_rec_count,
 408           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 409         { "keys", FLDT_INOBTKEY, btblock_key_offset, btblock_key_count,
 410           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 411         { "ptrs", FLDT_INOBTPTR, btblock_ptr_offset, btblock_key_count,
 412           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_INOBT },
 413         { NULL }
 414 };
 415 const field_t   inobt_crc_flds[] = {
 416         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 417         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 418         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 419         { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_INOBT },
 420         { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_INOBT },
 421         { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_INOBT },
 422         { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE },
 423         { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE },
 424         { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE },
 425         { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE },
 426         { "recs", FLDT_INOBTREC, btblock_rec_offset, btblock_rec_count,
 427           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 428         { "keys", FLDT_INOBTKEY, btblock_key_offset, btblock_key_count,
 429           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 430         { "ptrs", FLDT_INOBTPTR, btblock_ptr_offset, btblock_key_count,
 431           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_INOBT },
 432         { NULL }
 433 };
 434 const field_t   inobt_spcrc_flds[] = {
 435         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 436         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 437         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 438         { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_INOBT },
 439         { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_INOBT },
 440         { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_INOBT },
 441         { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE },
 442         { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE },
 443         { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE },
 444         { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE },
 445         { "recs", FLDT_INOBTSPREC, btblock_rec_offset, btblock_rec_count,
 446           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 447         { "keys", FLDT_INOBTKEY, btblock_key_offset, btblock_key_count,
 448           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 449         { "ptrs", FLDT_INOBTPTR, btblock_ptr_offset, btblock_key_count,
 450           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_INOBT },
 451         { NULL }
 452 };
 453
 454 #undef OFF
 455
 456 #define KOFF(f) bitize(offsetof(xfs_inobt_key_t, ir_ ## f))
 457 const field_t   inobt_key_flds[] = {
 458         { "startino", FLDT_AGINO, OI(KOFF(startino)), C1, 0, TYP_INODE },
 459         { NULL }
 460 };
 461 #undef KOFF
 462
 463 #define ROFF(f) bitize(offsetof(xfs_inobt_rec_t, f))
 464 const field_t   inobt_rec_flds[] = {
 465         { "startino", FLDT_AGINO, OI(ROFF(ir_startino)), C1, 0, TYP_INODE },
 466         { "freecount", FLDT_INT32D, OI(ROFF(ir_u.f.ir_freecount)), C1, 0, TYP_NONE },
 467         { "free", FLDT_INOFREE, OI(ROFF(ir_free)), C1, 0, TYP_NONE },
 468         { NULL }
 469 };
 470 /* sparse inode on-disk format */
 471 const field_t   inobt_sprec_flds[] = {
 472         { "startino", FLDT_AGINO, OI(ROFF(ir_startino)), C1, 0, TYP_INODE },
 473         { "holemask", FLDT_UINT16X, OI(ROFF(ir_u.sp.ir_holemask)), C1, 0,
 474           TYP_NONE },
 475         { "count", FLDT_UINT8D, OI(ROFF(ir_u.sp.ir_count)), C1, 0, TYP_NONE },
 476         { "freecount", FLDT_INT8D, OI(ROFF(ir_u.sp.ir_freecount)), C1, 0,
 477           TYP_NONE },
 478         { "free", FLDT_INOFREE, OI(ROFF(ir_free)), C1, 0, TYP_NONE },
 479         { NULL }
 480 };
 481 #undef ROFF
 482
 483
 484 /*
 485  * Allocation btrees.
 486  */
 487 const field_t   bnobt_hfld[] = {
 488         { "", FLDT_BNOBT, OI(0), C1, 0, TYP_NONE },
 489         { NULL }
 490 };
 491
 492 const field_t   bnobt_crc_hfld[] = {
 493         { "", FLDT_BNOBT_CRC, OI(0), C1, 0, TYP_NONE },
 494         { NULL }
 495 };
 496
 497 #define OFF(f)  bitize(offsetof(struct xfs_btree_block, bb_ ## f))
 498 const field_t   bnobt_flds[] = {
 499         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 500         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 501         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 502         { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_BNOBT },
 503         { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_BNOBT },
 504         { "recs", FLDT_BNOBTREC, btblock_rec_offset, btblock_rec_count,
 505           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 506         { "keys", FLDT_BNOBTKEY, btblock_key_offset, btblock_key_count,
 507           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 508         { "ptrs", FLDT_BNOBTPTR, btblock_ptr_offset, btblock_key_count,
 509           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BNOBT },
 510         { NULL }
 511 };
 512 const field_t   bnobt_crc_flds[] = {
 513         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 514         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 515         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 516         { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_BNOBT },
 517         { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_BNOBT },
 518         { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_BNOBT },
 519         { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE },
 520         { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE },
 521         { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE },
 522         { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE },
 523         { "recs", FLDT_BNOBTREC, btblock_rec_offset, btblock_rec_count,
 524           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 525         { "keys", FLDT_BNOBTKEY, btblock_key_offset, btblock_key_count,
 526           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 527         { "ptrs", FLDT_BNOBTPTR, btblock_ptr_offset, btblock_key_count,
 528           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BNOBT },
 529         { NULL }
 530 };
 531 #undef OFF
 532
 533 #define KOFF(f) bitize(offsetof(xfs_alloc_key_t, ar_ ## f))
 534 const field_t   bnobt_key_flds[] = {
 535         { "startblock", FLDT_AGBLOCK, OI(KOFF(startblock)), C1, 0, TYP_DATA },
 536         { "blockcount", FLDT_EXTLEN, OI(KOFF(blockcount)), C1, 0, TYP_NONE },
 537         { NULL }
 538 };
 539 #undef KOFF
 540
 541 #define ROFF(f) bitize(offsetof(xfs_alloc_rec_t, ar_ ## f))
 542 const field_t   bnobt_rec_flds[] = {
 543         { "startblock", FLDT_AGBLOCK, OI(ROFF(startblock)), C1, 0, TYP_DATA },
 544         { "blockcount", FLDT_EXTLEN, OI(ROFF(blockcount)), C1, 0, TYP_NONE },
 545         { NULL }
 546 };
 547 #undef ROFF
 548
 549 const field_t   cntbt_hfld[] = {
 550         { "", FLDT_CNTBT, OI(0), C1, 0, TYP_NONE },
 551         { NULL }
 552 };
 553
 554 const field_t   cntbt_crc_hfld[] = {
 555         { "", FLDT_CNTBT_CRC, OI(0), C1, 0, TYP_NONE },
 556         { NULL }
 557 };
 558
 559 #define OFF(f)  bitize(offsetof(struct xfs_btree_block, bb_ ## f))
 560 const field_t   cntbt_flds[] = {
 561         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 562         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 563         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 564         { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_CNTBT },
 565         { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_CNTBT },
 566         { "recs", FLDT_CNTBTREC, btblock_rec_offset, btblock_rec_count,
 567           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 568         { "keys", FLDT_CNTBTKEY, btblock_key_offset, btblock_key_count,
 569           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 570         { "ptrs", FLDT_CNTBTPTR, btblock_ptr_offset, btblock_key_count,
 571           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_CNTBT },
 572         { NULL }
 573 };
 574 const field_t   cntbt_crc_flds[] = {
 575         { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE },
 576         { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE },
 577         { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE },
 578         { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_CNTBT },
 579         { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_CNTBT },
 580         { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_CNTBT },
 581         { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE },
 582         { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE },
 583         { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE },
 584         { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE },
 585         { "recs", FLDT_CNTBTREC, btblock_rec_offset, btblock_rec_count,
 586           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 587         { "keys", FLDT_CNTBTKEY, btblock_key_offset, btblock_key_count,
 588           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE },
 589         { "ptrs", FLDT_CNTBTPTR, btblock_ptr_offset, btblock_key_count,
 590           FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_CNTBT },
 591         { NULL }
 592 };
 593 #undef OFF
 594
 595 #define KOFF(f) bitize(offsetof(xfs_alloc_key_t, ar_ ## f))
 596 const field_t   cntbt_key_flds[] = {
 597         { "blockcount", FLDT_EXTLEN, OI(KOFF(blockcount)), C1, 0, TYP_NONE },
 598         { "startblock", FLDT_AGBLOCK, OI(KOFF(startblock)), C1, 0, TYP_DATA },
 599         { NULL }
 600 };
 601 #undef KOFF
 602
 603 #define ROFF(f) bitize(offsetof(xfs_alloc_rec_t, ar_ ## f))
 604 const field_t   cntbt_rec_flds[] = {
 605         { "startblock", FLDT_AGBLOCK, OI(ROFF(startblock)), C1, 0, TYP_DATA },
 606         { "blockcount", FLDT_EXTLEN, OI(ROFF(blockcount)), C1, 0, TYP_NONE },
 607         { NULL }
 608 };
 609 #undef ROFF