Pileus Git - ~andy/linux/blob - fs/xfs/xfs_btree.c

   1 /*
   2  * Copyright (c) 2000-2002,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 #include "xfs.h"
  19 #include "xfs_fs.h"
  20 #include "xfs_types.h"
  21 #include "xfs_bit.h"
  22 #include "xfs_log.h"
  23 #include "xfs_inum.h"
  24 #include "xfs_trans.h"
  25 #include "xfs_sb.h"
  26 #include "xfs_ag.h"
  27 #include "xfs_dir2.h"
  28 #include "xfs_dmapi.h"
  29 #include "xfs_mount.h"
  30 #include "xfs_bmap_btree.h"
  31 #include "xfs_alloc_btree.h"
  32 #include "xfs_ialloc_btree.h"
  33 #include "xfs_dir2_sf.h"
  34 #include "xfs_attr_sf.h"
  35 #include "xfs_dinode.h"
  36 #include "xfs_inode.h"
  37 #include "xfs_btree.h"
  38 #include "xfs_ialloc.h"
  39 #include "xfs_error.h"
  40
  41 /*
  42  * Cursor allocation zone.
  43  */
  44 kmem_zone_t     *xfs_btree_cur_zone;
  45
  46 /*
  47  * Btree magic numbers.
  48  */
  49 const __uint32_t xfs_magics[XFS_BTNUM_MAX] = {
  50         XFS_ABTB_MAGIC, XFS_ABTC_MAGIC, XFS_BMAP_MAGIC, XFS_IBT_MAGIC
  51 };
  52
  53 /*
  54  * Checking routine: return maxrecs for the block.
  55  */
  56 STATIC int                              /* number of records fitting in block */
  57 xfs_btree_maxrecs(
  58         xfs_btree_cur_t         *cur,   /* btree cursor */
  59         xfs_btree_block_t       *block) /* generic btree block pointer */
  60 {
  61         switch (cur->bc_btnum) {
  62         case XFS_BTNUM_BNO:
  63         case XFS_BTNUM_CNT:
  64                 return (int)XFS_ALLOC_BLOCK_MAXRECS(
  65                                 be16_to_cpu(block->bb_level), cur);
  66         case XFS_BTNUM_BMAP:
  67                 return (int)XFS_BMAP_BLOCK_IMAXRECS(
  68                                 be16_to_cpu(block->bb_level), cur);
  69         case XFS_BTNUM_INO:
  70                 return (int)XFS_INOBT_BLOCK_MAXRECS(
  71                                 be16_to_cpu(block->bb_level), cur);
  72         default:
  73                 ASSERT(0);
  74                 return 0;
  75         }
  76 }
  77
  78 /*
  79  * External routines.
  80  */
  81
  82 #ifdef DEBUG
  83 /*
  84  * Debug routine: check that block header is ok.
  85  */
  86 void
  87 xfs_btree_check_block(
  88         xfs_btree_cur_t         *cur,   /* btree cursor */
  89         xfs_btree_block_t       *block, /* generic btree block pointer */
  90         int                     level,  /* level of the btree block */
  91         xfs_buf_t               *bp)    /* buffer containing block, if any */
  92 {
  93         if (XFS_BTREE_LONG_PTRS(cur->bc_btnum))
  94                 xfs_btree_check_lblock(cur, (xfs_btree_lblock_t *)block, level,
  95                         bp);
  96         else
  97                 xfs_btree_check_sblock(cur, (xfs_btree_sblock_t *)block, level,
  98                         bp);
  99 }
 100
 101 /*
 102  * Debug routine: check that keys are in the right order.
 103  */
 104 void
 105 xfs_btree_check_key(
 106         xfs_btnum_t     btnum,          /* btree identifier */
 107         void            *ak1,           /* pointer to left (lower) key */
 108         void            *ak2)           /* pointer to right (higher) key */
 109 {
 110         switch (btnum) {
 111         case XFS_BTNUM_BNO: {
 112                 xfs_alloc_key_t *k1;
 113                 xfs_alloc_key_t *k2;
 114
 115                 k1 = ak1;
 116                 k2 = ak2;
 117                 ASSERT(be32_to_cpu(k1->ar_startblock) < be32_to_cpu(k2->ar_startblock));
 118                 break;
 119             }
 120         case XFS_BTNUM_CNT: {
 121                 xfs_alloc_key_t *k1;
 122                 xfs_alloc_key_t *k2;
 123
 124                 k1 = ak1;
 125                 k2 = ak2;
 126                 ASSERT(be32_to_cpu(k1->ar_blockcount) < be32_to_cpu(k2->ar_blockcount) ||
 127                        (k1->ar_blockcount == k2->ar_blockcount &&
 128                         be32_to_cpu(k1->ar_startblock) < be32_to_cpu(k2->ar_startblock)));
 129                 break;
 130             }
 131         case XFS_BTNUM_BMAP: {
 132                 xfs_bmbt_key_t  *k1;
 133                 xfs_bmbt_key_t  *k2;
 134
 135                 k1 = ak1;
 136                 k2 = ak2;
 137                 ASSERT(be64_to_cpu(k1->br_startoff) < be64_to_cpu(k2->br_startoff));
 138                 break;
 139             }
 140         case XFS_BTNUM_INO: {
 141                 xfs_inobt_key_t *k1;
 142                 xfs_inobt_key_t *k2;
 143
 144                 k1 = ak1;
 145                 k2 = ak2;
 146                 ASSERT(be32_to_cpu(k1->ir_startino) < be32_to_cpu(k2->ir_startino));
 147                 break;
 148             }
 149         default:
 150                 ASSERT(0);
 151         }
 152 }
 153 #endif  /* DEBUG */
 154
 155 /*
 156  * Checking routine: check that long form block header is ok.
 157  */
 158 /* ARGSUSED */
 159 int                                     /* error (0 or EFSCORRUPTED) */
 160 xfs_btree_check_lblock(
 161         xfs_btree_cur_t         *cur,   /* btree cursor */
 162         xfs_btree_lblock_t      *block, /* btree long form block pointer */
 163         int                     level,  /* level of the btree block */
 164         xfs_buf_t               *bp)    /* buffer for block, if any */
 165 {
 166         int                     lblock_ok; /* block passes checks */
 167         xfs_mount_t             *mp;    /* file system mount point */
 168
 169         mp = cur->bc_mp;
 170         lblock_ok =
 171                 be32_to_cpu(block->bb_magic) == xfs_magics[cur->bc_btnum] &&
 172                 be16_to_cpu(block->bb_level) == level &&
 173                 be16_to_cpu(block->bb_numrecs) <=
 174                         xfs_btree_maxrecs(cur, (xfs_btree_block_t *)block) &&
 175                 block->bb_leftsib &&
 176                 (be64_to_cpu(block->bb_leftsib) == NULLDFSBNO ||
 177                  XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_leftsib))) &&
 178                 block->bb_rightsib &&
 179                 (be64_to_cpu(block->bb_rightsib) == NULLDFSBNO ||
 180                  XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_rightsib)));
 181         if (unlikely(XFS_TEST_ERROR(!lblock_ok, mp, XFS_ERRTAG_BTREE_CHECK_LBLOCK,
 182                         XFS_RANDOM_BTREE_CHECK_LBLOCK))) {
 183                 if (bp)
 184                         xfs_buftrace("LBTREE ERROR", bp);
 185                 XFS_ERROR_REPORT("xfs_btree_check_lblock", XFS_ERRLEVEL_LOW,
 186                                  mp);
 187                 return XFS_ERROR(EFSCORRUPTED);
 188         }
 189         return 0;
 190 }
 191
 192 /*
 193  * Checking routine: check that (long) pointer is ok.
 194  */
 195 int                                     /* error (0 or EFSCORRUPTED) */
 196 xfs_btree_check_lptr(
 197         xfs_btree_cur_t *cur,           /* btree cursor */
 198         xfs_dfsbno_t    ptr,            /* btree block disk address */
 199         int             level)          /* btree block level */
 200 {
 201         xfs_mount_t     *mp;            /* file system mount point */
 202
 203         mp = cur->bc_mp;
 204         XFS_WANT_CORRUPTED_RETURN(
 205                 level > 0 &&
 206                 ptr != NULLDFSBNO &&
 207                 XFS_FSB_SANITY_CHECK(mp, ptr));
 208         return 0;
 209 }
 210
 211 #ifdef DEBUG
 212 /*
 213  * Debug routine: check that records are in the right order.
 214  */
 215 void
 216 xfs_btree_check_rec(
 217         xfs_btnum_t     btnum,          /* btree identifier */
 218         void            *ar1,           /* pointer to left (lower) record */
 219         void            *ar2)           /* pointer to right (higher) record */
 220 {
 221         switch (btnum) {
 222         case XFS_BTNUM_BNO: {
 223                 xfs_alloc_rec_t *r1;
 224                 xfs_alloc_rec_t *r2;
 225
 226                 r1 = ar1;
 227                 r2 = ar2;
 228                 ASSERT(be32_to_cpu(r1->ar_startblock) +
 229                        be32_to_cpu(r1->ar_blockcount) <=
 230                        be32_to_cpu(r2->ar_startblock));
 231                 break;
 232             }
 233         case XFS_BTNUM_CNT: {
 234                 xfs_alloc_rec_t *r1;
 235                 xfs_alloc_rec_t *r2;
 236
 237                 r1 = ar1;
 238                 r2 = ar2;
 239                 ASSERT(be32_to_cpu(r1->ar_blockcount) < be32_to_cpu(r2->ar_blockcount) ||
 240                        (r1->ar_blockcount == r2->ar_blockcount &&
 241                         be32_to_cpu(r1->ar_startblock) < be32_to_cpu(r2->ar_startblock)));
 242                 break;
 243             }
 244         case XFS_BTNUM_BMAP: {
 245                 xfs_bmbt_rec_t  *r1;
 246                 xfs_bmbt_rec_t  *r2;
 247
 248                 r1 = ar1;
 249                 r2 = ar2;
 250                 ASSERT(xfs_bmbt_disk_get_startoff(r1) +
 251                        xfs_bmbt_disk_get_blockcount(r1) <=
 252                        xfs_bmbt_disk_get_startoff(r2));
 253                 break;
 254             }
 255         case XFS_BTNUM_INO: {
 256                 xfs_inobt_rec_t *r1;
 257                 xfs_inobt_rec_t *r2;
 258
 259                 r1 = ar1;
 260                 r2 = ar2;
 261                 ASSERT(be32_to_cpu(r1->ir_startino) + XFS_INODES_PER_CHUNK <=
 262                        be32_to_cpu(r2->ir_startino));
 263                 break;
 264             }
 265         default:
 266                 ASSERT(0);
 267         }
 268 }
 269 #endif  /* DEBUG */
 270
 271 /*
 272  * Checking routine: check that block header is ok.
 273  */
 274 /* ARGSUSED */
 275 int                                     /* error (0 or EFSCORRUPTED) */
 276 xfs_btree_check_sblock(
 277         xfs_btree_cur_t         *cur,   /* btree cursor */
 278         xfs_btree_sblock_t      *block, /* btree short form block pointer */
 279         int                     level,  /* level of the btree block */
 280         xfs_buf_t               *bp)    /* buffer containing block */
 281 {
 282         xfs_buf_t               *agbp;  /* buffer for ag. freespace struct */
 283         xfs_agf_t               *agf;   /* ag. freespace structure */
 284         xfs_agblock_t           agflen; /* native ag. freespace length */
 285         int                     sblock_ok; /* block passes checks */
 286
 287         agbp = cur->bc_private.a.agbp;
 288         agf = XFS_BUF_TO_AGF(agbp);
 289         agflen = be32_to_cpu(agf->agf_length);
 290         sblock_ok =
 291                 be32_to_cpu(block->bb_magic) == xfs_magics[cur->bc_btnum] &&
 292                 be16_to_cpu(block->bb_level) == level &&
 293                 be16_to_cpu(block->bb_numrecs) <=
 294                         xfs_btree_maxrecs(cur, (xfs_btree_block_t *)block) &&
 295                 (be32_to_cpu(block->bb_leftsib) == NULLAGBLOCK ||
 296                  be32_to_cpu(block->bb_leftsib) < agflen) &&
 297                 block->bb_leftsib &&
 298                 (be32_to_cpu(block->bb_rightsib) == NULLAGBLOCK ||
 299                  be32_to_cpu(block->bb_rightsib) < agflen) &&
 300                 block->bb_rightsib;
 301         if (unlikely(XFS_TEST_ERROR(!sblock_ok, cur->bc_mp,
 302                         XFS_ERRTAG_BTREE_CHECK_SBLOCK,
 303                         XFS_RANDOM_BTREE_CHECK_SBLOCK))) {
 304                 if (bp)
 305                         xfs_buftrace("SBTREE ERROR", bp);
 306                 XFS_ERROR_REPORT("xfs_btree_check_sblock", XFS_ERRLEVEL_LOW,
 307                                  cur->bc_mp);
 308                 return XFS_ERROR(EFSCORRUPTED);
 309         }
 310         return 0;
 311 }
 312
 313 /*
 314  * Checking routine: check that (short) pointer is ok.
 315  */
 316 int                                     /* error (0 or EFSCORRUPTED) */
 317 xfs_btree_check_sptr(
 318         xfs_btree_cur_t *cur,           /* btree cursor */
 319         xfs_agblock_t   ptr,            /* btree block disk address */
 320         int             level)          /* btree block level */
 321 {
 322         xfs_buf_t       *agbp;          /* buffer for ag. freespace struct */
 323         xfs_agf_t       *agf;           /* ag. freespace structure */
 324
 325         agbp = cur->bc_private.a.agbp;
 326         agf = XFS_BUF_TO_AGF(agbp);
 327         XFS_WANT_CORRUPTED_RETURN(
 328                 level > 0 &&
 329                 ptr != NULLAGBLOCK && ptr != 0 &&
 330                 ptr < be32_to_cpu(agf->agf_length));
 331         return 0;
 332 }
 333
 334 /*
 335  * Delete the btree cursor.
 336  */
 337 void
 338 xfs_btree_del_cursor(
 339         xfs_btree_cur_t *cur,           /* btree cursor */
 340         int             error)          /* del because of error */
 341 {
 342         int             i;              /* btree level */
 343
 344         /*
 345          * Clear the buffer pointers, and release the buffers.
 346          * If we're doing this in the face of an error, we
 347          * need to make sure to inspect all of the entries
 348          * in the bc_bufs array for buffers to be unlocked.
 349          * This is because some of the btree code works from
 350          * level n down to 0, and if we get an error along
 351          * the way we won't have initialized all the entries
 352          * down to 0.
 353          */
 354         for (i = 0; i < cur->bc_nlevels; i++) {
 355                 if (cur->bc_bufs[i])
 356                         xfs_btree_setbuf(cur, i, NULL);
 357                 else if (!error)
 358                         break;
 359         }
 360         /*
 361          * Can't free a bmap cursor without having dealt with the
 362          * allocated indirect blocks' accounting.
 363          */
 364         ASSERT(cur->bc_btnum != XFS_BTNUM_BMAP ||
 365                cur->bc_private.b.allocated == 0);
 366         /*
 367          * Free the cursor.
 368          */
 369         kmem_zone_free(xfs_btree_cur_zone, cur);
 370 }
 371
 372 /*
 373  * Duplicate the btree cursor.
 374  * Allocate a new one, copy the record, re-get the buffers.
 375  */
 376 int                                     /* error */
 377 xfs_btree_dup_cursor(
 378         xfs_btree_cur_t *cur,           /* input cursor */
 379         xfs_btree_cur_t **ncur)         /* output cursor */
 380 {
 381         xfs_buf_t       *bp;            /* btree block's buffer pointer */
 382         int             error;          /* error return value */
 383         int             i;              /* level number of btree block */
 384         xfs_mount_t     *mp;            /* mount structure for filesystem */
 385         xfs_btree_cur_t *new;           /* new cursor value */
 386         xfs_trans_t     *tp;            /* transaction pointer, can be NULL */
 387
 388         tp = cur->bc_tp;
 389         mp = cur->bc_mp;
 390
 391         /*
 392          * Allocate a new cursor like the old one.
 393          */
 394         new = cur->bc_ops->dup_cursor(cur);
 395
 396         /*
 397          * Copy the record currently in the cursor.
 398          */
 399         new->bc_rec = cur->bc_rec;
 400
 401         /*
 402          * For each level current, re-get the buffer and copy the ptr value.
 403          */
 404         for (i = 0; i < new->bc_nlevels; i++) {
 405                 new->bc_ptrs[i] = cur->bc_ptrs[i];
 406                 new->bc_ra[i] = cur->bc_ra[i];
 407                 if ((bp = cur->bc_bufs[i])) {
 408                         if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
 409                                 XFS_BUF_ADDR(bp), mp->m_bsize, 0, &bp))) {
 410                                 xfs_btree_del_cursor(new, error);
 411                                 *ncur = NULL;
 412                                 return error;
 413                         }
 414                         new->bc_bufs[i] = bp;
 415                         ASSERT(bp);
 416                         ASSERT(!XFS_BUF_GETERROR(bp));
 417                 } else
 418                         new->bc_bufs[i] = NULL;
 419         }
 420         *ncur = new;
 421         return 0;
 422 }
 423
 424 /*
 425  * Retrieve the block pointer from the cursor at the given level.
 426  * This may be a bmap btree root or from a buffer.
 427  */
 428 STATIC xfs_btree_block_t *              /* generic btree block pointer */
 429 xfs_btree_get_block(
 430         xfs_btree_cur_t         *cur,   /* btree cursor */
 431         int                     level,  /* level in btree */
 432         xfs_buf_t               **bpp)  /* buffer containing the block */
 433 {
 434         xfs_btree_block_t       *block; /* return value */
 435         xfs_buf_t               *bp;    /* return buffer */
 436         xfs_ifork_t             *ifp;   /* inode fork pointer */
 437         int                     whichfork; /* data or attr fork */
 438
 439         if (cur->bc_btnum == XFS_BTNUM_BMAP && level == cur->bc_nlevels - 1) {
 440                 whichfork = cur->bc_private.b.whichfork;
 441                 ifp = XFS_IFORK_PTR(cur->bc_private.b.ip, whichfork);
 442                 block = (xfs_btree_block_t *)ifp->if_broot;
 443                 bp = NULL;
 444         } else {
 445                 bp = cur->bc_bufs[level];
 446                 block = XFS_BUF_TO_BLOCK(bp);
 447         }
 448         ASSERT(block != NULL);
 449         *bpp = bp;
 450         return block;
 451 }
 452
 453 /*
 454  * Get a buffer for the block, return it with no data read.
 455  * Long-form addressing.
 456  */
 457 xfs_buf_t *                             /* buffer for fsbno */
 458 xfs_btree_get_bufl(
 459         xfs_mount_t     *mp,            /* file system mount point */
 460         xfs_trans_t     *tp,            /* transaction pointer */
 461         xfs_fsblock_t   fsbno,          /* file system block number */
 462         uint            lock)           /* lock flags for get_buf */
 463 {
 464         xfs_buf_t       *bp;            /* buffer pointer (return value) */
 465         xfs_daddr_t             d;              /* real disk block address */
 466
 467         ASSERT(fsbno != NULLFSBLOCK);
 468         d = XFS_FSB_TO_DADDR(mp, fsbno);
 469         bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
 470         ASSERT(bp);
 471         ASSERT(!XFS_BUF_GETERROR(bp));
 472         return bp;
 473 }
 474
 475 /*
 476  * Get a buffer for the block, return it with no data read.
 477  * Short-form addressing.
 478  */
 479 xfs_buf_t *                             /* buffer for agno/agbno */
 480 xfs_btree_get_bufs(
 481         xfs_mount_t     *mp,            /* file system mount point */
 482         xfs_trans_t     *tp,            /* transaction pointer */
 483         xfs_agnumber_t  agno,           /* allocation group number */
 484         xfs_agblock_t   agbno,          /* allocation group block number */
 485         uint            lock)           /* lock flags for get_buf */
 486 {
 487         xfs_buf_t       *bp;            /* buffer pointer (return value) */
 488         xfs_daddr_t             d;              /* real disk block address */
 489
 490         ASSERT(agno != NULLAGNUMBER);
 491         ASSERT(agbno != NULLAGBLOCK);
 492         d = XFS_AGB_TO_DADDR(mp, agno, agbno);
 493         bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
 494         ASSERT(bp);
 495         ASSERT(!XFS_BUF_GETERROR(bp));
 496         return bp;
 497 }
 498
 499 /*
 500  * Check for the cursor referring to the last block at the given level.
 501  */
 502 int                                     /* 1=is last block, 0=not last block */
 503 xfs_btree_islastblock(
 504         xfs_btree_cur_t         *cur,   /* btree cursor */
 505         int                     level)  /* level to check */
 506 {
 507         xfs_btree_block_t       *block; /* generic btree block pointer */
 508         xfs_buf_t               *bp;    /* buffer containing block */
 509
 510         block = xfs_btree_get_block(cur, level, &bp);
 511         xfs_btree_check_block(cur, block, level, bp);
 512         if (XFS_BTREE_LONG_PTRS(cur->bc_btnum))
 513                 return be64_to_cpu(block->bb_u.l.bb_rightsib) == NULLDFSBNO;
 514         else
 515                 return be32_to_cpu(block->bb_u.s.bb_rightsib) == NULLAGBLOCK;
 516 }
 517
 518 /*
 519  * Change the cursor to point to the first record at the given level.
 520  * Other levels are unaffected.
 521  */
 522 int                                     /* success=1, failure=0 */
 523 xfs_btree_firstrec(
 524         xfs_btree_cur_t         *cur,   /* btree cursor */
 525         int                     level)  /* level to change */
 526 {
 527         xfs_btree_block_t       *block; /* generic btree block pointer */
 528         xfs_buf_t               *bp;    /* buffer containing block */
 529
 530         /*
 531          * Get the block pointer for this level.
 532          */
 533         block = xfs_btree_get_block(cur, level, &bp);
 534         xfs_btree_check_block(cur, block, level, bp);
 535         /*
 536          * It's empty, there is no such record.
 537          */
 538         if (!block->bb_numrecs)
 539                 return 0;
 540         /*
 541          * Set the ptr value to 1, that's the first record/key.
 542          */
 543         cur->bc_ptrs[level] = 1;
 544         return 1;
 545 }
 546
 547 /*
 548  * Change the cursor to point to the last record in the current block
 549  * at the given level.  Other levels are unaffected.
 550  */
 551 int                                     /* success=1, failure=0 */
 552 xfs_btree_lastrec(
 553         xfs_btree_cur_t         *cur,   /* btree cursor */
 554         int                     level)  /* level to change */
 555 {
 556         xfs_btree_block_t       *block; /* generic btree block pointer */
 557         xfs_buf_t               *bp;    /* buffer containing block */
 558
 559         /*
 560          * Get the block pointer for this level.
 561          */
 562         block = xfs_btree_get_block(cur, level, &bp);
 563         xfs_btree_check_block(cur, block, level, bp);
 564         /*
 565          * It's empty, there is no such record.
 566          */
 567         if (!block->bb_numrecs)
 568                 return 0;
 569         /*
 570          * Set the ptr value to numrecs, that's the last record/key.
 571          */
 572         cur->bc_ptrs[level] = be16_to_cpu(block->bb_numrecs);
 573         return 1;
 574 }
 575
 576 /*
 577  * Compute first and last byte offsets for the fields given.
 578  * Interprets the offsets table, which contains struct field offsets.
 579  */
 580 void
 581 xfs_btree_offsets(
 582         __int64_t       fields,         /* bitmask of fields */
 583         const short     *offsets,       /* table of field offsets */
 584         int             nbits,          /* number of bits to inspect */
 585         int             *first,         /* output: first byte offset */
 586         int             *last)          /* output: last byte offset */
 587 {
 588         int             i;              /* current bit number */
 589         __int64_t       imask;          /* mask for current bit number */
 590
 591         ASSERT(fields != 0);
 592         /*
 593          * Find the lowest bit, so the first byte offset.
 594          */
 595         for (i = 0, imask = 1LL; ; i++, imask <<= 1) {
 596                 if (imask & fields) {
 597                         *first = offsets[i];
 598                         break;
 599                 }
 600         }
 601         /*
 602          * Find the highest bit, so the last byte offset.
 603          */
 604         for (i = nbits - 1, imask = 1LL << i; ; i--, imask >>= 1) {
 605                 if (imask & fields) {
 606                         *last = offsets[i + 1] - 1;
 607                         break;
 608                 }
 609         }
 610 }
 611
 612 /*
 613  * Get a buffer for the block, return it read in.
 614  * Long-form addressing.
 615  */
 616 int                                     /* error */
 617 xfs_btree_read_bufl(
 618         xfs_mount_t     *mp,            /* file system mount point */
 619         xfs_trans_t     *tp,            /* transaction pointer */
 620         xfs_fsblock_t   fsbno,          /* file system block number */
 621         uint            lock,           /* lock flags for read_buf */
 622         xfs_buf_t       **bpp,          /* buffer for fsbno */
 623         int             refval)         /* ref count value for buffer */
 624 {
 625         xfs_buf_t       *bp;            /* return value */
 626         xfs_daddr_t             d;              /* real disk block address */
 627         int             error;
 628
 629         ASSERT(fsbno != NULLFSBLOCK);
 630         d = XFS_FSB_TO_DADDR(mp, fsbno);
 631         if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, d,
 632                         mp->m_bsize, lock, &bp))) {
 633                 return error;
 634         }
 635         ASSERT(!bp || !XFS_BUF_GETERROR(bp));
 636         if (bp != NULL) {
 637                 XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, refval);
 638         }
 639         *bpp = bp;
 640         return 0;
 641 }
 642
 643 /*
 644  * Get a buffer for the block, return it read in.
 645  * Short-form addressing.
 646  */
 647 int                                     /* error */
 648 xfs_btree_read_bufs(
 649         xfs_mount_t     *mp,            /* file system mount point */
 650         xfs_trans_t     *tp,            /* transaction pointer */
 651         xfs_agnumber_t  agno,           /* allocation group number */
 652         xfs_agblock_t   agbno,          /* allocation group block number */
 653         uint            lock,           /* lock flags for read_buf */
 654         xfs_buf_t       **bpp,          /* buffer for agno/agbno */
 655         int             refval)         /* ref count value for buffer */
 656 {
 657         xfs_buf_t       *bp;            /* return value */
 658         xfs_daddr_t     d;              /* real disk block address */
 659         int             error;
 660
 661         ASSERT(agno != NULLAGNUMBER);
 662         ASSERT(agbno != NULLAGBLOCK);
 663         d = XFS_AGB_TO_DADDR(mp, agno, agbno);
 664         if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, d,
 665                                         mp->m_bsize, lock, &bp))) {
 666                 return error;
 667         }
 668         ASSERT(!bp || !XFS_BUF_GETERROR(bp));
 669         if (bp != NULL) {
 670                 switch (refval) {
 671                 case XFS_ALLOC_BTREE_REF:
 672                         XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, refval);
 673                         break;
 674                 case XFS_INO_BTREE_REF:
 675                         XFS_BUF_SET_VTYPE_REF(bp, B_FS_INOMAP, refval);
 676                         break;
 677                 }
 678         }
 679         *bpp = bp;
 680         return 0;
 681 }
 682
 683 /*
 684  * Read-ahead the block, don't wait for it, don't return a buffer.
 685  * Long-form addressing.
 686  */
 687 /* ARGSUSED */
 688 void
 689 xfs_btree_reada_bufl(
 690         xfs_mount_t     *mp,            /* file system mount point */
 691         xfs_fsblock_t   fsbno,          /* file system block number */
 692         xfs_extlen_t    count)          /* count of filesystem blocks */
 693 {
 694         xfs_daddr_t             d;
 695
 696         ASSERT(fsbno != NULLFSBLOCK);
 697         d = XFS_FSB_TO_DADDR(mp, fsbno);
 698         xfs_baread(mp->m_ddev_targp, d, mp->m_bsize * count);
 699 }
 700
 701 /*
 702  * Read-ahead the block, don't wait for it, don't return a buffer.
 703  * Short-form addressing.
 704  */
 705 /* ARGSUSED */
 706 void
 707 xfs_btree_reada_bufs(
 708         xfs_mount_t     *mp,            /* file system mount point */
 709         xfs_agnumber_t  agno,           /* allocation group number */
 710         xfs_agblock_t   agbno,          /* allocation group block number */
 711         xfs_extlen_t    count)          /* count of filesystem blocks */
 712 {
 713         xfs_daddr_t             d;
 714
 715         ASSERT(agno != NULLAGNUMBER);
 716         ASSERT(agbno != NULLAGBLOCK);
 717         d = XFS_AGB_TO_DADDR(mp, agno, agbno);
 718         xfs_baread(mp->m_ddev_targp, d, mp->m_bsize * count);
 719 }
 720
 721 /*
 722  * Read-ahead btree blocks, at the given level.
 723  * Bits in lr are set from XFS_BTCUR_{LEFT,RIGHT}RA.
 724  */
 725 int
 726 xfs_btree_readahead_core(
 727         xfs_btree_cur_t         *cur,           /* btree cursor */
 728         int                     lev,            /* level in btree */
 729         int                     lr)             /* left/right bits */
 730 {
 731         xfs_alloc_block_t       *a;
 732         xfs_bmbt_block_t        *b;
 733         xfs_inobt_block_t       *i;
 734         int                     rval = 0;
 735
 736         ASSERT(cur->bc_bufs[lev] != NULL);
 737         cur->bc_ra[lev] |= lr;
 738         switch (cur->bc_btnum) {
 739         case XFS_BTNUM_BNO:
 740         case XFS_BTNUM_CNT:
 741                 a = XFS_BUF_TO_ALLOC_BLOCK(cur->bc_bufs[lev]);
 742                 if ((lr & XFS_BTCUR_LEFTRA) && be32_to_cpu(a->bb_leftsib) != NULLAGBLOCK) {
 743                         xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno,
 744                                 be32_to_cpu(a->bb_leftsib), 1);
 745                         rval++;
 746                 }
 747                 if ((lr & XFS_BTCUR_RIGHTRA) && be32_to_cpu(a->bb_rightsib) != NULLAGBLOCK) {
 748                         xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno,
 749                                 be32_to_cpu(a->bb_rightsib), 1);
 750                         rval++;
 751                 }
 752                 break;
 753         case XFS_BTNUM_BMAP:
 754                 b = XFS_BUF_TO_BMBT_BLOCK(cur->bc_bufs[lev]);
 755                 if ((lr & XFS_BTCUR_LEFTRA) && be64_to_cpu(b->bb_leftsib) != NULLDFSBNO) {
 756                         xfs_btree_reada_bufl(cur->bc_mp, be64_to_cpu(b->bb_leftsib), 1);
 757                         rval++;
 758                 }
 759                 if ((lr & XFS_BTCUR_RIGHTRA) && be64_to_cpu(b->bb_rightsib) != NULLDFSBNO) {
 760                         xfs_btree_reada_bufl(cur->bc_mp, be64_to_cpu(b->bb_rightsib), 1);
 761                         rval++;
 762                 }
 763                 break;
 764         case XFS_BTNUM_INO:
 765                 i = XFS_BUF_TO_INOBT_BLOCK(cur->bc_bufs[lev]);
 766                 if ((lr & XFS_BTCUR_LEFTRA) && be32_to_cpu(i->bb_leftsib) != NULLAGBLOCK) {
 767                         xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno,
 768                                 be32_to_cpu(i->bb_leftsib), 1);
 769                         rval++;
 770                 }
 771                 if ((lr & XFS_BTCUR_RIGHTRA) && be32_to_cpu(i->bb_rightsib) != NULLAGBLOCK) {
 772                         xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno,
 773                                 be32_to_cpu(i->bb_rightsib), 1);
 774                         rval++;
 775                 }
 776                 break;
 777         default:
 778                 ASSERT(0);
 779         }
 780         return rval;
 781 }
 782
 783 /*
 784  * Set the buffer for level "lev" in the cursor to bp, releasing
 785  * any previous buffer.
 786  */
 787 void
 788 xfs_btree_setbuf(
 789         xfs_btree_cur_t         *cur,   /* btree cursor */
 790         int                     lev,    /* level in btree */
 791         xfs_buf_t               *bp)    /* new buffer to set */
 792 {
 793         xfs_btree_block_t       *b;     /* btree block */
 794         xfs_buf_t               *obp;   /* old buffer pointer */
 795
 796         obp = cur->bc_bufs[lev];
 797         if (obp)
 798                 xfs_trans_brelse(cur->bc_tp, obp);
 799         cur->bc_bufs[lev] = bp;
 800         cur->bc_ra[lev] = 0;
 801         if (!bp)
 802                 return;
 803         b = XFS_BUF_TO_BLOCK(bp);
 804         if (XFS_BTREE_LONG_PTRS(cur->bc_btnum)) {
 805                 if (be64_to_cpu(b->bb_u.l.bb_leftsib) == NULLDFSBNO)
 806                         cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
 807                 if (be64_to_cpu(b->bb_u.l.bb_rightsib) == NULLDFSBNO)
 808                         cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
 809         } else {
 810                 if (be32_to_cpu(b->bb_u.s.bb_leftsib) == NULLAGBLOCK)
 811                         cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
 812                 if (be32_to_cpu(b->bb_u.s.bb_rightsib) == NULLAGBLOCK)
 813                         cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
 814         }
 815 }