Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs

* 'for-linus' of git://oss.sgi.com/xfs/xfs: (184 commits)
  [XFS] Fix race in xfs_write() between direct and buffered I/O with DMAPI
  [XFS] handle unaligned data in xfs_bmbt_disk_get_all
  [XFS] avoid memory allocations in xfs_fs_vcmn_err
  [XFS] Fix speculative allocation beyond eof
  [XFS] Remove XFS_BUF_SHUT() and friends
  [XFS] Use the incore inode size in xfs_file_readdir()
  [XFS] set b_error from bio error in xfs_buf_bio_end_io
  [XFS] use inode_change_ok for setattr permission checking
  [XFS] add a FMODE flag to make XFS invisible I/O less hacky
  [XFS] resync headers with libxfs
  [XFS] simplify projid check in xfs_rename
  [XFS] replace b_fspriv with b_mount
  [XFS] Remove unused tracing code
  [XFS] Remove unnecessary assertion
  [XFS] Remove unused variable in ktrace_free()
  [XFS] Check return value of xfs_buf_get_noaddr()
  [XFS] Fix hang after disallowed rename across directory quota domains
  [XFS] Fix compile with CONFIG_COMPAT enabled
  move inode tracing out of xfs_vnode.
  move vn_iowait / vn_iowake into xfs_aops.c
  ...

1 files changed, 241 insertions, 169 deletions

diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index a1aab9275d5a..138308e70d14 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -393,8 +393,8 @@ xfs_bmap_count_leaves(
 
 STATIC void
 xfs_bmap_disk_count_leaves(
-        xfs_extnum_t            idx,
-        xfs_bmbt_block_t        *block,
+        struct xfs_mount        *mp,
+        struct xfs_btree_block  *block,
         int                     numrecs,
         int                     *count);
 
@@ -402,6 +402,53 @@ xfs_bmap_disk_count_leaves(
  * Bmap internal routines.
  */
 
+STATIC int                              /* error */
+xfs_bmbt_lookup_eq(
+        struct xfs_btree_cur    *cur,
+        xfs_fileoff_t           off,
+        xfs_fsblock_t           bno,
+        xfs_filblks_t           len,
+        int                     *stat)  /* success/failure */
+{
+        cur->bc_rec.b.br_startoff = off;
+        cur->bc_rec.b.br_startblock = bno;
+        cur->bc_rec.b.br_blockcount = len;
+        return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);
+}
+
+STATIC int                              /* error */
+xfs_bmbt_lookup_ge(
+        struct xfs_btree_cur    *cur,
+        xfs_fileoff_t           off,
+        xfs_fsblock_t           bno,
+        xfs_filblks_t           len,
+        int                     *stat)  /* success/failure */
+{
+        cur->bc_rec.b.br_startoff = off;
+        cur->bc_rec.b.br_startblock = bno;
+        cur->bc_rec.b.br_blockcount = len;
+        return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat);
+}
+
+/*
+* Update the record referred to by cur to the value given
+ * by [off, bno, len, state].
+ * This either works (return 0) or gets an EFSCORRUPTED error.
+ */
+STATIC int
+xfs_bmbt_update(
+        struct xfs_btree_cur    *cur,
+        xfs_fileoff_t           off,
+        xfs_fsblock_t           bno,
+        xfs_filblks_t           len,
+        xfs_exntst_t            state)
+{
+        union xfs_btree_rec     rec;
+
+        xfs_bmbt_disk_set_allf(&rec.bmbt, off, bno, len, state);
+        return xfs_btree_update(cur, &rec);
+}
+
 /*
  * Called from xfs_bmap_add_attrfork to handle btree format files.
  */
@@ -422,15 +469,14 @@ xfs_bmap_add_attrfork_btree(
         if (ip->i_df.if_broot_bytes <= XFS_IFORK_DSIZE(ip))
                 *flags |= XFS_ILOG_DBROOT;
         else {
-                cur = xfs_btree_init_cursor(mp, tp, NULL, 0, XFS_BTNUM_BMAP, ip,
-                        XFS_DATA_FORK);
+                cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK);
                 cur->bc_private.b.flist = flist;
                 cur->bc_private.b.firstblock = *firstblock;
                 if ((error = xfs_bmbt_lookup_ge(cur, 0, 0, 0, &stat)))
                         goto error0;
                 /* must be at least one entry */
                 XFS_WANT_CORRUPTED_GOTO(stat == 1, error0);
-                if ((error = xfs_bmbt_newroot(cur, flags, &stat)))
+                if ((error = xfs_btree_new_iroot(cur, flags, &stat)))
                         goto error0;
                 if (stat == 0) {
                         xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
@@ -818,10 +864,10 @@ xfs_bmap_add_extent_delay_real(
                                         RIGHT.br_blockcount, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_delete(cur, &i)))
+                        if ((error = xfs_btree_delete(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_decrement(cur, 0, &i)))
+                        if ((error = xfs_btree_decrement(cur, 0, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                         if ((error = xfs_bmbt_update(cur, LEFT.br_startoff,
@@ -931,7 +977,7 @@ xfs_bmap_add_extent_delay_real(
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 0, done);
                         cur->bc_rec.b.br_state = XFS_EXT_NORM;
-                        if ((error = xfs_bmbt_insert(cur, &i)))
+                        if ((error = xfs_btree_insert(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                 }
@@ -1007,7 +1053,7 @@ xfs_bmap_add_extent_delay_real(
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 0, done);
                         cur->bc_rec.b.br_state = XFS_EXT_NORM;
-                        if ((error = xfs_bmbt_insert(cur, &i)))
+                        if ((error = xfs_btree_insert(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                 }
@@ -1097,7 +1143,7 @@ xfs_bmap_add_extent_delay_real(
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 0, done);
                         cur->bc_rec.b.br_state = XFS_EXT_NORM;
-                        if ((error = xfs_bmbt_insert(cur, &i)))
+                        if ((error = xfs_btree_insert(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                 }
@@ -1152,7 +1198,7 @@ xfs_bmap_add_extent_delay_real(
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 0, done);
                         cur->bc_rec.b.br_state = XFS_EXT_NORM;
-                        if ((error = xfs_bmbt_insert(cur, &i)))
+                        if ((error = xfs_btree_insert(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                 }
@@ -1379,16 +1425,16 @@ xfs_bmap_add_extent_unwritten_real(
                                         RIGHT.br_blockcount, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_delete(cur, &i)))
+                        if ((error = xfs_btree_delete(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_decrement(cur, 0, &i)))
+                        if ((error = xfs_btree_decrement(cur, 0, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_delete(cur, &i)))
+                        if ((error = xfs_btree_delete(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_decrement(cur, 0, &i)))
+                        if ((error = xfs_btree_decrement(cur, 0, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                         if ((error = xfs_bmbt_update(cur, LEFT.br_startoff,
@@ -1428,10 +1474,10 @@ xfs_bmap_add_extent_unwritten_real(
                                         &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_delete(cur, &i)))
+                        if ((error = xfs_btree_delete(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_decrement(cur, 0, &i)))
+                        if ((error = xfs_btree_decrement(cur, 0, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                         if ((error = xfs_bmbt_update(cur, LEFT.br_startoff,
@@ -1471,10 +1517,10 @@ xfs_bmap_add_extent_unwritten_real(
                                         RIGHT.br_blockcount, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_delete(cur, &i)))
+                        if ((error = xfs_btree_delete(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_decrement(cur, 0, &i)))
+                        if ((error = xfs_btree_decrement(cur, 0, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                         if ((error = xfs_bmbt_update(cur, new->br_startoff,
@@ -1557,7 +1603,7 @@ xfs_bmap_add_extent_unwritten_real(
                                 PREV.br_blockcount - new->br_blockcount,
                                 oldext)))
                                 goto done;
-                        if ((error = xfs_bmbt_decrement(cur, 0, &i)))
+                        if ((error = xfs_btree_decrement(cur, 0, &i)))
                                 goto done;
                         if (xfs_bmbt_update(cur, LEFT.br_startoff,
                                 LEFT.br_startblock,
@@ -1605,7 +1651,7 @@ xfs_bmap_add_extent_unwritten_real(
                                 oldext)))
                                 goto done;
                         cur->bc_rec.b = *new;
-                        if ((error = xfs_bmbt_insert(cur, &i)))
+                        if ((error = xfs_btree_insert(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                 }
@@ -1647,7 +1693,7 @@ xfs_bmap_add_extent_unwritten_real(
                                 PREV.br_blockcount - new->br_blockcount,
                                 oldext)))
                                 goto done;
-                        if ((error = xfs_bmbt_increment(cur, 0, &i)))
+                        if ((error = xfs_btree_increment(cur, 0, &i)))
                                 goto done;
                         if ((error = xfs_bmbt_update(cur, new->br_startoff,
                                 new->br_startblock,
@@ -1695,7 +1741,7 @@ xfs_bmap_add_extent_unwritten_real(
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 0, done);
                         cur->bc_rec.b.br_state = XFS_EXT_NORM;
-                        if ((error = xfs_bmbt_insert(cur, &i)))
+                        if ((error = xfs_btree_insert(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                 }
@@ -1743,7 +1789,7 @@ xfs_bmap_add_extent_unwritten_real(
                         cur->bc_rec.b = PREV;
                         cur->bc_rec.b.br_blockcount =
                                 new->br_startoff - PREV.br_startoff;
-                        if ((error = xfs_bmbt_insert(cur, &i)))
+                        if ((error = xfs_btree_insert(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                         /*
@@ -1758,7 +1804,7 @@ xfs_bmap_add_extent_unwritten_real(
                         XFS_WANT_CORRUPTED_GOTO(i == 0, done);
                         /* new middle extent - newext */
                         cur->bc_rec.b.br_state = new->br_state;
-                        if ((error = xfs_bmbt_insert(cur, &i)))
+                        if ((error = xfs_btree_insert(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                 }
@@ -2106,10 +2152,10 @@ xfs_bmap_add_extent_hole_real(
                                         right.br_blockcount, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_delete(cur, &i)))
+                        if ((error = xfs_btree_delete(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
-                        if ((error = xfs_bmbt_decrement(cur, 0, &i)))
+                        if ((error = xfs_btree_decrement(cur, 0, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                         if ((error = xfs_bmbt_update(cur, left.br_startoff,
@@ -2218,7 +2264,7 @@ xfs_bmap_add_extent_hole_real(
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 0, done);
                         cur->bc_rec.b.br_state = new->br_state;
-                        if ((error = xfs_bmbt_insert(cur, &i)))
+                        if ((error = xfs_btree_insert(cur, &i)))
                                 goto done;
                         XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                 }
@@ -2996,24 +3042,24 @@ xfs_bmap_btree_to_extents(
         int                     whichfork)  /* data or attr fork */
 {
         /* REFERENCED */
-        xfs_bmbt_block_t        *cblock;/* child btree block */
+        struct xfs_btree_block  *cblock;/* child btree block */
         xfs_fsblock_t           cbno;   /* child block number */
         xfs_buf_t               *cbp;   /* child block's buffer */
         int                     error;  /* error return value */
         xfs_ifork_t             *ifp;   /* inode fork data */
         xfs_mount_t             *mp;    /* mount point structure */
         __be64                  *pp;    /* ptr to block address */
-        xfs_bmbt_block_t        *rblock;/* root btree block */
+        struct xfs_btree_block  *rblock;/* root btree block */
 
+        mp = ip->i_mount;
         ifp = XFS_IFORK_PTR(ip, whichfork);
         ASSERT(ifp->if_flags & XFS_IFEXTENTS);
         ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE);
         rblock = ifp->if_broot;
         ASSERT(be16_to_cpu(rblock->bb_level) == 1);
         ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1);
-        ASSERT(XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes) == 1);
-        mp = ip->i_mount;
-        pp = XFS_BMAP_BROOT_PTR_ADDR(rblock, 1, ifp->if_broot_bytes);
+        ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1);
+        pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes);
         cbno = be64_to_cpu(*pp);
         *logflagsp = 0;
 #ifdef DEBUG
@@ -3023,8 +3069,8 @@ xfs_bmap_btree_to_extents(
         if ((error = xfs_btree_read_bufl(mp, tp, cbno, 0, &cbp,
                         XFS_BMAP_BTREE_REF)))
                 return error;
-        cblock = XFS_BUF_TO_BMBT_BLOCK(cbp);
-        if ((error = xfs_btree_check_lblock(cur, cblock, 0, cbp)))
+        cblock = XFS_BUF_TO_BLOCK(cbp);
+        if ((error = xfs_btree_check_block(cur, cblock, 0, cbp)))
                 return error;
         xfs_bmap_add_free(cbno, 1, cur->bc_private.b.flist, mp);
         ip->i_d.di_nblocks--;
@@ -3170,7 +3216,7 @@ xfs_bmap_del_extent(
                         flags |= XFS_ILOG_FEXT(whichfork);
                         break;
                 }
-                if ((error = xfs_bmbt_delete(cur, &i)))
+                if ((error = xfs_btree_delete(cur, &i)))
                         goto done;
                 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
                 break;
@@ -3254,10 +3300,10 @@ xfs_bmap_del_extent(
                                                 got.br_startblock, temp,
                                                 got.br_state)))
                                         goto done;
-                                if ((error = xfs_bmbt_increment(cur, 0, &i)))
+                                if ((error = xfs_btree_increment(cur, 0, &i)))
                                         goto done;
                                 cur->bc_rec.b = new;
-                                error = xfs_bmbt_insert(cur, &i);
+                                error = xfs_btree_insert(cur, &i);
                                 if (error && error != ENOSPC)
                                         goto done;
                                 /*
@@ -3404,11 +3450,11 @@ xfs_bmap_extents_to_btree(
         int                     *logflagsp,     /* inode logging flags */
         int                     whichfork)      /* data or attr fork */
 {
-        xfs_bmbt_block_t        *ablock;        /* allocated (child) bt block */
+        struct xfs_btree_block  *ablock;        /* allocated (child) bt block */
         xfs_buf_t               *abp;           /* buffer for ablock */
         xfs_alloc_arg_t         args;           /* allocation arguments */
         xfs_bmbt_rec_t          *arp;           /* child record pointer */
-        xfs_bmbt_block_t        *block;         /* btree root block */
+        struct xfs_btree_block  *block;         /* btree root block */
         xfs_btree_cur_t         *cur;           /* bmap btree cursor */
         xfs_bmbt_rec_host_t     *ep;            /* extent record pointer */
         int                     error;          /* error return value */
@@ -3428,6 +3474,7 @@ xfs_bmap_extents_to_btree(
          */
         xfs_iroot_realloc(ip, 1, whichfork);
         ifp->if_flags |= XFS_IFBROOT;
+
         /*
          * Fill in the root.
          */
@@ -3435,14 +3482,14 @@ xfs_bmap_extents_to_btree(
         block->bb_magic = cpu_to_be32(XFS_BMAP_MAGIC);
         block->bb_level = cpu_to_be16(1);
         block->bb_numrecs = cpu_to_be16(1);
-        block->bb_leftsib = cpu_to_be64(NULLDFSBNO);
-        block->bb_rightsib = cpu_to_be64(NULLDFSBNO);
+        block->bb_u.l.bb_leftsib = cpu_to_be64(NULLDFSBNO);
+        block->bb_u.l.bb_rightsib = cpu_to_be64(NULLDFSBNO);
+
         /*
          * Need a cursor.  Can't allocate until bb_level is filled in.
          */
         mp = ip->i_mount;
-        cur = xfs_btree_init_cursor(mp, tp, NULL, 0, XFS_BTNUM_BMAP, ip,
-                whichfork);
+        cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
         cur->bc_private.b.firstblock = *firstblock;
         cur->bc_private.b.flist = flist;
         cur->bc_private.b.flags = wasdel ? XFS_BTCUR_BPRV_WASDEL : 0;
@@ -3489,12 +3536,12 @@ xfs_bmap_extents_to_btree(
         /*
          * Fill in the child block.
          */
-        ablock = XFS_BUF_TO_BMBT_BLOCK(abp);
+        ablock = XFS_BUF_TO_BLOCK(abp);
         ablock->bb_magic = cpu_to_be32(XFS_BMAP_MAGIC);
         ablock->bb_level = 0;
-        ablock->bb_leftsib = cpu_to_be64(NULLDFSBNO);
-        ablock->bb_rightsib = cpu_to_be64(NULLDFSBNO);
-        arp = XFS_BMAP_REC_IADDR(ablock, 1, cur);
+        ablock->bb_u.l.bb_leftsib = cpu_to_be64(NULLDFSBNO);
+        ablock->bb_u.l.bb_rightsib = cpu_to_be64(NULLDFSBNO);
+        arp = XFS_BMBT_REC_ADDR(mp, ablock, 1);
         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
         for (cnt = i = 0; i < nextents; i++) {
                 ep = xfs_iext_get_ext(ifp, i);
@@ -3505,21 +3552,24 @@ xfs_bmap_extents_to_btree(
                 }
         }
         ASSERT(cnt == XFS_IFORK_NEXTENTS(ip, whichfork));
-        ablock->bb_numrecs = cpu_to_be16(cnt);
+        xfs_btree_set_numrecs(ablock, cnt);
+
         /*
          * Fill in the root key and pointer.
          */
-        kp = XFS_BMAP_KEY_IADDR(block, 1, cur);
-        arp = XFS_BMAP_REC_IADDR(ablock, 1, cur);
+        kp = XFS_BMBT_KEY_ADDR(mp, block, 1);
+        arp = XFS_BMBT_REC_ADDR(mp, ablock, 1);
         kp->br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(arp));
-        pp = XFS_BMAP_PTR_IADDR(block, 1, cur);
+        pp = XFS_BMBT_PTR_ADDR(mp, block, 1, xfs_bmbt_get_maxrecs(cur,
+                                                be16_to_cpu(block->bb_level)));
         *pp = cpu_to_be64(args.fsbno);
+
         /*
          * Do all this logging at the end so that
          * the root is at the right level.
          */
-        xfs_bmbt_log_block(cur, abp, XFS_BB_ALL_BITS);
-        xfs_bmbt_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs));
+        xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS);
+        xfs_btree_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs));
         ASSERT(*curp == NULL);
         *curp = cur;
         *logflagsp = XFS_ILOG_CORE | XFS_ILOG_FBROOT(whichfork);
@@ -4176,7 +4226,7 @@ xfs_bmap_compute_maxlevels(
                 maxleafents = MAXAEXTNUM;
                 sz = XFS_BMDR_SPACE_CALC(MINABTPTRS);
         }
-        maxrootrecs = (int)XFS_BTREE_BLOCK_MAXRECS(sz, xfs_bmdr, 0);
+        maxrootrecs = xfs_bmdr_maxrecs(mp, sz, 0);
         minleafrecs = mp->m_bmap_dmnr[0];
         minnoderecs = mp->m_bmap_dmnr[1];
         maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs;
@@ -4242,9 +4292,15 @@ xfs_bmap_finish(
          * We have a new transaction, so we should return committed=1,
          * even though we're returning an error.
          */
-        if (error) {
+        if (error)
                 return error;
-        }
+
+        /*
+         * transaction commit worked ok so we can drop the extra ticket
+         * reference that we gained in xfs_trans_dup()
+         */
+        xfs_log_ticket_put(ntp->t_ticket);
+
         if ((error = xfs_trans_reserve(ntp, 0, logres, 0, XFS_TRANS_PERM_LOG_RES,
                         logcount)))
                 return error;
@@ -4474,6 +4530,22 @@ xfs_bmap_one_block(
         return rval;
 }
 
+STATIC int
+xfs_bmap_sanity_check(
+        struct xfs_mount        *mp,
+        struct xfs_buf          *bp,
+        int                     level)
+{
+        struct xfs_btree_block  *block = XFS_BUF_TO_BLOCK(bp);
+
+        if (be32_to_cpu(block->bb_magic) != XFS_BMAP_MAGIC ||
+            be16_to_cpu(block->bb_level) != level ||
+            be16_to_cpu(block->bb_numrecs) == 0 ||
+            be16_to_cpu(block->bb_numrecs) > mp->m_bmap_dmxr[level != 0])
+                return 0;
+        return 1;
+}
+
 /*
  * Read in the extents to if_extents.
  * All inode fields are set up by caller, we just traverse the btree
@@ -4486,7 +4558,7 @@ xfs_bmap_read_extents(
         xfs_inode_t             *ip,    /* incore inode */
         int                     whichfork) /* data or attr fork */
 {
-        xfs_bmbt_block_t        *block; /* current btree block */
+        struct xfs_btree_block  *block; /* current btree block */
         xfs_fsblock_t           bno;    /* block # of "block" */
         xfs_buf_t               *bp;    /* buffer for "block" */
         int                     error;  /* error return value */
@@ -4510,7 +4582,7 @@ xfs_bmap_read_extents(
          */
         level = be16_to_cpu(block->bb_level);
         ASSERT(level > 0);
-        pp = XFS_BMAP_BROOT_PTR_ADDR(block, 1, ifp->if_broot_bytes);
+        pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
         bno = be64_to_cpu(*pp);
         ASSERT(bno != NULLDFSBNO);
         ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
@@ -4523,13 +4595,13 @@ xfs_bmap_read_extents(
                 if ((error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp,
                                 XFS_BMAP_BTREE_REF)))
                         return error;
-                block = XFS_BUF_TO_BMBT_BLOCK(bp);
+                block = XFS_BUF_TO_BLOCK(bp);
                 XFS_WANT_CORRUPTED_GOTO(
-                        XFS_BMAP_SANITY_CHECK(mp, block, level),
+                        xfs_bmap_sanity_check(mp, bp, level),
                         error0);
                 if (level == 0)
                         break;
-                pp = XFS_BTREE_PTR_ADDR(xfs_bmbt, block, 1, mp->m_bmap_dmxr[1]);
+                pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
                 bno = be64_to_cpu(*pp);
                 XFS_WANT_CORRUPTED_GOTO(XFS_FSB_SANITY_CHECK(mp, bno), error0);
                 xfs_trans_brelse(tp, bp);
@@ -4549,7 +4621,7 @@ xfs_bmap_read_extents(
                 xfs_extnum_t    start;
 
 
-                num_recs = be16_to_cpu(block->bb_numrecs);
+                num_recs = xfs_btree_get_numrecs(block);
                 if (unlikely(i + num_recs > room)) {
                         ASSERT(i + num_recs <= room);
                         xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
@@ -4561,18 +4633,18 @@ xfs_bmap_read_extents(
                         goto error0;
                 }
                 XFS_WANT_CORRUPTED_GOTO(
-                        XFS_BMAP_SANITY_CHECK(mp, block, 0),
+                        xfs_bmap_sanity_check(mp, bp, 0),
                         error0);
                 /*
                  * Read-ahead the next leaf block, if any.
                  */
-                nextbno = be64_to_cpu(block->bb_rightsib);
+                nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
                 if (nextbno != NULLFSBLOCK)
                         xfs_btree_reada_bufl(mp, nextbno, 1);
                 /*
                  * Copy records into the extent records.
                  */
-                frp = XFS_BTREE_REC_ADDR(xfs_bmbt, block, 1);
+                frp = XFS_BMBT_REC_ADDR(mp, block, 1);
                 start = i;
                 for (j = 0; j < num_recs; j++, i++, frp++) {
                         xfs_bmbt_rec_host_t *trp = xfs_iext_get_ext(ifp, i);
@@ -4603,7 +4675,7 @@ xfs_bmap_read_extents(
                 if ((error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp,
                                 XFS_BMAP_BTREE_REF)))
                         return error;
-                block = XFS_BUF_TO_BMBT_BLOCK(bp);
+                block = XFS_BUF_TO_BLOCK(bp);
         }
         ASSERT(i == (ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t)));
         ASSERT(i == XFS_IFORK_NEXTENTS(ip, whichfork));
@@ -5029,8 +5101,7 @@ xfs_bmapi(
                                 if (abno == NULLFSBLOCK)
                                         break;
                                 if ((ifp->if_flags & XFS_IFBROOT) && !cur) {
-                                        cur = xfs_btree_init_cursor(mp,
-                                                tp, NULL, 0, XFS_BTNUM_BMAP,
+                                        cur = xfs_bmbt_init_cursor(mp, tp,
                                                 ip, whichfork);
                                         cur->bc_private.b.firstblock =
                                                 *firstblock;
@@ -5147,9 +5218,8 @@ xfs_bmapi(
                          */
                         ASSERT(mval->br_blockcount <= len);
                         if ((ifp->if_flags & XFS_IFBROOT) && !cur) {
-                                cur = xfs_btree_init_cursor(mp,
-                                        tp, NULL, 0, XFS_BTNUM_BMAP,
-                                        ip, whichfork);
+                                cur = xfs_bmbt_init_cursor(mp,
+                                        tp, ip, whichfork);
                                 cur->bc_private.b.firstblock =
                                         *firstblock;
                                 cur->bc_private.b.flist = flist;
@@ -5440,8 +5510,7 @@ xfs_bunmapi(
         logflags = 0;
         if (ifp->if_flags & XFS_IFBROOT) {
                 ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE);
-                cur = xfs_btree_init_cursor(mp, tp, NULL, 0, XFS_BTNUM_BMAP, ip,
-                        whichfork);
+                cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
                 cur->bc_private.b.firstblock = *firstblock;
                 cur->bc_private.b.flist = flist;
                 cur->bc_private.b.flags = 0;
@@ -5742,14 +5811,17 @@ error0:
 STATIC int
 xfs_getbmapx_fix_eof_hole(
         xfs_inode_t             *ip,            /* xfs incore inode pointer */
-        struct getbmap          *out,           /* output structure */
+        struct getbmapx         *out,           /* output structure */
         int                     prealloced,     /* this is a file with
-                                                * preallocated data space */
+                                                 * preallocated data space */
         __int64_t               end,            /* last block requested */
         xfs_fsblock_t           startblock)
 {
         __int64_t               fixlen;
         xfs_mount_t             *mp;            /* file system mount point */
+        xfs_ifork_t             *ifp;           /* inode fork pointer */
+        xfs_extnum_t            lastx;          /* last extent pointer */
+        xfs_fileoff_t           fileblock;
 
         if (startblock == HOLESTARTBLOCK) {
                 mp = ip->i_mount;
@@ -5763,21 +5835,33 @@ xfs_getbmapx_fix_eof_hole(
                         out->bmv_length = fixlen;
                 }
         } else {
-                out->bmv_block = XFS_FSB_TO_DB(ip, startblock);
+                if (startblock == DELAYSTARTBLOCK)
+                        out->bmv_block = -2;
+                else
+                        out->bmv_block = XFS_FSB_TO_DB(ip, startblock);
+                fileblock = XFS_BB_TO_FSB(ip->i_mount, out->bmv_offset);
+                ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
+                if (xfs_iext_bno_to_ext(ifp, fileblock, &lastx) &&
+                   (lastx == (ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t))-1))
+                        out->bmv_oflags |= BMV_OF_LAST;
         }
 
         return 1;
 }
 
 /*
- * Fcntl interface to xfs_bmapi.
+ * Get inode's extents as described in bmv, and format for output.
+ * Calls formatter to fill the user's buffer until all extents
+ * are mapped, until the passed-in bmv->bmv_count slots have
+ * been filled, or until the formatter short-circuits the loop,
+ * if it is tracking filled-in extents on its own.
  */
 int                                             /* error code */
 xfs_getbmap(
         xfs_inode_t             *ip,
-        struct getbmap          *bmv,           /* user bmap structure */
-        void                    __user *ap,     /* pointer to user's array */
-        int                     interface)      /* interface flags */
+        struct getbmapx         *bmv,           /* user bmap structure */
+        xfs_bmap_format_t       formatter,      /* format to user */
+        void                    *arg)           /* formatter arg */
 {
         __int64_t               bmvend;         /* last block requested */
         int                     error;          /* return value */
@@ -5790,19 +5874,17 @@ xfs_getbmap(
         int                     nexleft;        /* # of user extents left */
         int                     subnex;         /* # of bmapi's can do */
         int                     nmap;           /* number of map entries */
-        struct getbmap          out;            /* output structure */
+        struct getbmapx         out;            /* output structure */
         int                     whichfork;      /* data or attr fork */
         int                     prealloced;     /* this is a file with
                                                  * preallocated data space */
-        int                     sh_unwritten;   /* true, if unwritten */
-                                                /* extents listed separately */
+        int                     iflags;         /* interface flags */
         int                     bmapi_flags;    /* flags for xfs_bmapi */
-        __int32_t               oflags;         /* getbmapx bmv_oflags field */
 
         mp = ip->i_mount;
+        iflags = bmv->bmv_iflags;
 
-        whichfork = interface & BMV_IF_ATTRFORK ? XFS_ATTR_FORK : XFS_DATA_FORK;
-        sh_unwritten = (interface & BMV_IF_PREALLOC) != 0;
+        whichfork = iflags & BMV_IF_ATTRFORK ? XFS_ATTR_FORK : XFS_DATA_FORK;
 
         /*      If the BMV_IF_NO_DMAPI_READ interface bit specified, do not
          *      generate a DMAPI read event.  Otherwise, if the DM_EVENT_READ
@@ -5817,7 +5899,7 @@ xfs_getbmap(
          *      could misinterpret holes in a DMAPI file as true holes,
          *      when in fact they may represent offline user data.
          */
-        if ((interface & BMV_IF_NO_DMAPI_READ) == 0 &&
+        if ((iflags & BMV_IF_NO_DMAPI_READ) == 0 &&
             DM_EVENT_ENABLED(ip, DM_EVENT_READ) &&
             whichfork == XFS_DATA_FORK) {
                 error = XFS_SEND_DATA(mp, DM_EVENT_READ, ip, 0, 0, 0, NULL);
@@ -5873,8 +5955,9 @@ xfs_getbmap(
 
         xfs_ilock(ip, XFS_IOLOCK_SHARED);
 
-        if (whichfork == XFS_DATA_FORK &&
-                (ip->i_delayed_blks || ip->i_size > ip->i_d.di_size)) {
+        if (((iflags & BMV_IF_DELALLOC) == 0) &&
+            (whichfork == XFS_DATA_FORK) &&
+            (ip->i_delayed_blks || ip->i_size > ip->i_d.di_size)) {
                 /* xfs_fsize_t last_byte = xfs_file_last_byte(ip); */
                 error = xfs_flush_pages(ip, (xfs_off_t)0,
                                                -1, 0, FI_REMAPF);
@@ -5884,7 +5967,8 @@ xfs_getbmap(
                 }
         }
 
-        ASSERT(whichfork == XFS_ATTR_FORK || ip->i_delayed_blks == 0);
+        ASSERT(whichfork == XFS_ATTR_FORK || (iflags & BMV_IF_DELALLOC) ||
+               ip->i_delayed_blks == 0);
 
         lock = xfs_ilock_map_shared(ip);
 
@@ -5896,7 +5980,7 @@ xfs_getbmap(
                 nex = XFS_IFORK_NEXTENTS(ip, whichfork) * 2 + 1;
 
         bmapi_flags = XFS_BMAPI_AFLAG(whichfork) |
-                        ((sh_unwritten) ? 0 : XFS_BMAPI_IGSTATE);
+                        ((iflags & BMV_IF_PREALLOC) ? 0 : XFS_BMAPI_IGSTATE);
 
         /*
          * Allocate enough space to handle "subnex" maps at a time.
@@ -5906,9 +5990,12 @@ xfs_getbmap(
 
         bmv->bmv_entries = 0;
 
-        if (XFS_IFORK_NEXTENTS(ip, whichfork) == 0) {
-                error = 0;
-                goto unlock_and_return;
+        if ((XFS_IFORK_NEXTENTS(ip, whichfork) == 0)) {
+                if (((iflags & BMV_IF_DELALLOC) == 0) ||
+                    whichfork == XFS_ATTR_FORK) {
+                        error = 0;
+                        goto unlock_and_return;
+                }
         }
 
         nexleft = nex;
@@ -5924,52 +6011,40 @@ xfs_getbmap(
                 ASSERT(nmap <= subnex);
 
                 for (i = 0; i < nmap && nexleft && bmv->bmv_length; i++) {
-                        nexleft--;
-                        oflags = (map[i].br_state == XFS_EXT_UNWRITTEN) ?
-                                        BMV_OF_PREALLOC : 0;
+                        out.bmv_oflags = 0;
+                        if (map[i].br_state == XFS_EXT_UNWRITTEN)
+                                out.bmv_oflags |= BMV_OF_PREALLOC;
+                        else if (map[i].br_startblock == DELAYSTARTBLOCK)
+                                out.bmv_oflags |= BMV_OF_DELALLOC;
                         out.bmv_offset = XFS_FSB_TO_BB(mp, map[i].br_startoff);
                         out.bmv_length = XFS_FSB_TO_BB(mp, map[i].br_blockcount);
-                        ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
+                        out.bmv_unused1 = out.bmv_unused2 = 0;
+                        ASSERT(((iflags & BMV_IF_DELALLOC) != 0) ||
+                              (map[i].br_startblock != DELAYSTARTBLOCK));
                         if (map[i].br_startblock == HOLESTARTBLOCK &&
                             whichfork == XFS_ATTR_FORK) {
                                 /* came to the end of attribute fork */
+                                out.bmv_oflags |= BMV_OF_LAST;
                                 goto unlock_and_return;
                         } else {
+                                int full = 0;   /* user array is full */
+
                                 if (!xfs_getbmapx_fix_eof_hole(ip, &out,
                                                         prealloced, bmvend,
                                                         map[i].br_startblock)) {
                                         goto unlock_and_return;
                                 }
 
-                                /* return either getbmap/getbmapx structure. */
-                                if (interface & BMV_IF_EXTENDED) {
-                                        struct  getbmapx        outx;
-
-                                        GETBMAP_CONVERT(out,outx);
-                                        outx.bmv_oflags = oflags;
-                                        outx.bmv_unused1 = outx.bmv_unused2 = 0;
-                                        if (copy_to_user(ap, &outx,
-                                                        sizeof(outx))) {
-                                                error = XFS_ERROR(EFAULT);
-                                                goto unlock_and_return;
-                                        }
-                                } else {
-                                        if (copy_to_user(ap, &out,
-                                                        sizeof(out))) {
-                                                error = XFS_ERROR(EFAULT);
-                                                goto unlock_and_return;
-                                        }
-                                }
+                                /* format results & advance arg */
+                                error = formatter(&arg, &out, &full);
+                                if (error || full)
+                                        goto unlock_and_return;
+                                nexleft--;
                                 bmv->bmv_offset =
                                         out.bmv_offset + out.bmv_length;
                                 bmv->bmv_length = MAX((__int64_t)0,
                                         (__int64_t)(bmvend - bmv->bmv_offset));
                                 bmv->bmv_entries++;
-                                ap = (interface & BMV_IF_EXTENDED) ?
-                                                (void __user *)
-                                        ((struct getbmapx __user *)ap + 1) :
-                                                (void __user *)
-                                        ((struct getbmap __user *)ap + 1);
                         }
                 }
         } while (nmap && nexleft && bmv->bmv_length);
@@ -6131,7 +6206,7 @@ xfs_bmap_get_bp(
 
 void
 xfs_check_block(
-        xfs_bmbt_block_t        *block,
+        struct xfs_btree_block  *block,
         xfs_mount_t             *mp,
         int                     root,
         short                   sz)
@@ -6143,36 +6218,29 @@ xfs_check_block(
         ASSERT(be16_to_cpu(block->bb_level) > 0);
 
         prevp = NULL;
-        for( i = 1; i <= be16_to_cpu(block->bb_numrecs); i++) {
+        for( i = 1; i <= xfs_btree_get_numrecs(block); i++) {
                 dmxr = mp->m_bmap_dmxr[0];
-
-                if (root) {
-                        keyp = XFS_BMAP_BROOT_KEY_ADDR(block, i, sz);
-                } else {
-                        keyp = XFS_BTREE_KEY_ADDR(xfs_bmbt, block, i);
-                }
+                keyp = XFS_BMBT_KEY_ADDR(mp, block, i);
 
                 if (prevp) {
-                        xfs_btree_check_key(XFS_BTNUM_BMAP, prevp, keyp);
+                        ASSERT(be64_to_cpu(prevp->br_startoff) <
+                               be64_to_cpu(keyp->br_startoff));
                 }
                 prevp = keyp;
 
                 /*
                  * Compare the block numbers to see if there are dups.
                  */
+                if (root)
+                        pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, i, sz);
+                else
+                        pp = XFS_BMBT_PTR_ADDR(mp, block, i, dmxr);
 
-                if (root) {
-                        pp = XFS_BMAP_BROOT_PTR_ADDR(block, i, sz);
-                } else {
-                        pp = XFS_BTREE_PTR_ADDR(xfs_bmbt, block, i, dmxr);
-                }
                 for (j = i+1; j <= be16_to_cpu(block->bb_numrecs); j++) {
-                        if (root) {
-                                thispa = XFS_BMAP_BROOT_PTR_ADDR(block, j, sz);
-                        } else {
-                                thispa = XFS_BTREE_PTR_ADDR(xfs_bmbt, block, j,
-                                                            dmxr);
-                        }
+                        if (root)
+                                thispa = XFS_BMAP_BROOT_PTR_ADDR(mp, block, j, sz);
+                        else
+                                thispa = XFS_BMBT_PTR_ADDR(mp, block, j, dmxr);
                         if (*thispa == *pp) {
                                 cmn_err(CE_WARN, "%s: thispa(%d) == pp(%d) %Ld",
                                         __func__, j, i,
@@ -6195,7 +6263,7 @@ xfs_bmap_check_leaf_extents(
         xfs_inode_t             *ip,            /* incore inode pointer */
         int                     whichfork)      /* data or attr fork */
 {
-        xfs_bmbt_block_t        *block; /* current btree block */
+        struct xfs_btree_block  *block; /* current btree block */
         xfs_fsblock_t           bno;    /* block # of "block" */
         xfs_buf_t               *bp;    /* buffer for "block" */
         int                     error;  /* error return value */
@@ -6223,7 +6291,7 @@ xfs_bmap_check_leaf_extents(
         level = be16_to_cpu(block->bb_level);
         ASSERT(level > 0);
         xfs_check_block(block, mp, 1, ifp->if_broot_bytes);
-        pp = XFS_BMAP_BROOT_PTR_ADDR(block, 1, ifp->if_broot_bytes);
+        pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
         bno = be64_to_cpu(*pp);
 
         ASSERT(bno != NULLDFSBNO);
@@ -6245,9 +6313,9 @@ xfs_bmap_check_leaf_extents(
                 if (!bp && (error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp,
                                 XFS_BMAP_BTREE_REF)))
                         goto error_norelse;
-                block = XFS_BUF_TO_BMBT_BLOCK(bp);
+                block = XFS_BUF_TO_BLOCK(bp);
                 XFS_WANT_CORRUPTED_GOTO(
-                        XFS_BMAP_SANITY_CHECK(mp, block, level),
+                        xfs_bmap_sanity_check(mp, bp, level),
                         error0);
                 if (level == 0)
                         break;
@@ -6258,7 +6326,7 @@ xfs_bmap_check_leaf_extents(
                  */
 
                 xfs_check_block(block, mp, 0, 0);
-                pp = XFS_BTREE_PTR_ADDR(xfs_bmbt, block, 1, mp->m_bmap_dmxr[1]);
+                pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
                 bno = be64_to_cpu(*pp);
                 XFS_WANT_CORRUPTED_GOTO(XFS_FSB_SANITY_CHECK(mp, bno), error0);
                 if (bp_release) {
@@ -6280,13 +6348,13 @@ xfs_bmap_check_leaf_extents(
                 xfs_extnum_t    num_recs;
 
 
-                num_recs = be16_to_cpu(block->bb_numrecs);
+                num_recs = xfs_btree_get_numrecs(block);
 
                 /*
                  * Read-ahead the next leaf block, if any.
                  */
 
-                nextbno = be64_to_cpu(block->bb_rightsib);
+                nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
 
                 /*
                  * Check all the extents to make sure they are OK.
@@ -6294,13 +6362,17 @@ xfs_bmap_check_leaf_extents(
                  * conform with the first entry in this one.
                  */
 
-                ep = XFS_BTREE_REC_ADDR(xfs_bmbt, block, 1);
+                ep = XFS_BMBT_REC_ADDR(mp, block, 1);
                 if (i) {
-                        xfs_btree_check_rec(XFS_BTNUM_BMAP, &last, ep);
+                        ASSERT(xfs_bmbt_disk_get_startoff(&last) +
+                               xfs_bmbt_disk_get_blockcount(&last) <=
+                               xfs_bmbt_disk_get_startoff(ep));
                 }
                 for (j = 1; j < num_recs; j++) {
-                        nextp = XFS_BTREE_REC_ADDR(xfs_bmbt, block, j + 1);
-                        xfs_btree_check_rec(XFS_BTNUM_BMAP, ep, nextp);
+                        nextp = XFS_BMBT_REC_ADDR(mp, block, j + 1);
+                        ASSERT(xfs_bmbt_disk_get_startoff(ep) +
+                               xfs_bmbt_disk_get_blockcount(ep) <=
+                               xfs_bmbt_disk_get_startoff(nextp));
                         ep = nextp;
                 }
 
@@ -6326,7 +6398,7 @@ xfs_bmap_check_leaf_extents(
                 if (!bp && (error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp,
                                 XFS_BMAP_BTREE_REF)))
                         goto error_norelse;
-                block = XFS_BUF_TO_BMBT_BLOCK(bp);
+                block = XFS_BUF_TO_BLOCK(bp);
         }
         if (bp_release) {
                 bp_release = 0;
@@ -6356,7 +6428,7 @@ xfs_bmap_count_blocks(
         int                     whichfork,      /* data or attr fork */
         int                     *count)         /* out: count of blocks */
 {
-        xfs_bmbt_block_t        *block; /* current btree block */
+        struct xfs_btree_block  *block; /* current btree block */
         xfs_fsblock_t           bno;    /* block # of "block" */
         xfs_ifork_t             *ifp;   /* fork structure */
         int                     level;  /* btree level, for checking */
@@ -6379,7 +6451,7 @@ xfs_bmap_count_blocks(
         block = ifp->if_broot;
         level = be16_to_cpu(block->bb_level);
         ASSERT(level > 0);
-        pp = XFS_BMAP_BROOT_PTR_ADDR(block, 1, ifp->if_broot_bytes);
+        pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
         bno = be64_to_cpu(*pp);
         ASSERT(bno != NULLDFSBNO);
         ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
@@ -6413,29 +6485,29 @@ xfs_bmap_count_tree(
         __be64                  *pp;
         xfs_fsblock_t           bno = blockno;
         xfs_fsblock_t           nextbno;
-        xfs_bmbt_block_t        *block, *nextblock;
+        struct xfs_btree_block  *block, *nextblock;
         int                     numrecs;
 
         if ((error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, XFS_BMAP_BTREE_REF)))
                 return error;
         *count += 1;
-        block = XFS_BUF_TO_BMBT_BLOCK(bp);
+        block = XFS_BUF_TO_BLOCK(bp);
 
         if (--level) {
                 /* Not at node above leafs, count this level of nodes */
-                nextbno = be64_to_cpu(block->bb_rightsib);
+                nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
                 while (nextbno != NULLFSBLOCK) {
                         if ((error = xfs_btree_read_bufl(mp, tp, nextbno,
                                 0, &nbp, XFS_BMAP_BTREE_REF)))
                                 return error;
                         *count += 1;
-                        nextblock = XFS_BUF_TO_BMBT_BLOCK(nbp);
-                        nextbno = be64_to_cpu(nextblock->bb_rightsib);
+                        nextblock = XFS_BUF_TO_BLOCK(nbp);
+                        nextbno = be64_to_cpu(nextblock->bb_u.l.bb_rightsib);
                         xfs_trans_brelse(tp, nbp);
                 }
 
                 /* Dive to the next level */
-                pp = XFS_BTREE_PTR_ADDR(xfs_bmbt, block, 1, mp->m_bmap_dmxr[1]);
+                pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
                 bno = be64_to_cpu(*pp);
                 if (unlikely((error =
                      xfs_bmap_count_tree(mp, tp, ifp, bno, level, count)) < 0)) {
@@ -6448,9 +6520,9 @@ xfs_bmap_count_tree(
         } else {
                 /* count all level 1 nodes and their leaves */
                 for (;;) {
-                        nextbno = be64_to_cpu(block->bb_rightsib);
+                        nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
                         numrecs = be16_to_cpu(block->bb_numrecs);
-                        xfs_bmap_disk_count_leaves(0, block, numrecs, count);
+                        xfs_bmap_disk_count_leaves(mp, block, numrecs, count);
                         xfs_trans_brelse(tp, bp);
                         if (nextbno == NULLFSBLOCK)
                                 break;
@@ -6459,7 +6531,7 @@ xfs_bmap_count_tree(
                                 XFS_BMAP_BTREE_REF)))
                                 return error;
                         *count += 1;
-                        block = XFS_BUF_TO_BMBT_BLOCK(bp);
+                        block = XFS_BUF_TO_BLOCK(bp);
                 }
         }
         return 0;
@@ -6489,8 +6561,8 @@ xfs_bmap_count_leaves(
  */
 STATIC void
 xfs_bmap_disk_count_leaves(
-        xfs_extnum_t            idx,
-        xfs_bmbt_block_t        *block,
+        struct xfs_mount        *mp,
+        struct xfs_btree_block  *block,
         int                     numrecs,
         int                     *count)
 {
@@ -6498,7 +6570,7 @@ xfs_bmap_disk_count_leaves(
         xfs_bmbt_rec_t  *frp;
 
         for (b = 1; b <= numrecs; b++) {
-                frp = XFS_BTREE_REC_ADDR(xfs_bmbt, block, idx + b);
+                frp = XFS_BMBT_REC_ADDR(mp, block, b);
                 *count += xfs_bmbt_disk_get_blockcount(frp);
         }
 }