1 files changed, 170 insertions, 207 deletions

diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index 4c3dba7ffb74..48c7d18f68c3 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -18,22 +18,21 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_dir2_priv.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_cksum.h"
 
@@ -55,21 +54,21 @@ static int xfs_dir2_node_addname_int(xfs_da_args_t *args,
  * Check internal consistency of a leafn block.
  */
 #ifdef DEBUG
-#define xfs_dir3_leaf_check(mp, bp) \
+#define xfs_dir3_leaf_check(dp, bp) \
 do { \
-        if (!xfs_dir3_leafn_check((mp), (bp))) \
+        if (!xfs_dir3_leafn_check((dp), (bp))) \
                 ASSERT(0); \
 } while (0);
 
 static bool
 xfs_dir3_leafn_check(
-        struct xfs_mount        *mp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp)
 {
         struct xfs_dir2_leaf    *leaf = bp->b_addr;
         struct xfs_dir3_icleaf_hdr leafhdr;
 
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
 
         if (leafhdr.magic == XFS_DIR3_LEAFN_MAGIC) {
                 struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
@@ -78,10 +77,10 @@ xfs_dir3_leafn_check(
         } else if (leafhdr.magic != XFS_DIR2_LEAFN_MAGIC)
                 return false;
 
-        return xfs_dir3_leaf_check_int(mp, &leafhdr, leaf);
+        return xfs_dir3_leaf_check_int(dp->i_mount, dp, &leafhdr, leaf);
 }
 #else
-#define xfs_dir3_leaf_check(mp, bp)
+#define xfs_dir3_leaf_check(dp, bp)
 #endif
 
 static bool
@@ -193,53 +192,6 @@ xfs_dir2_free_try_read(
         return __xfs_dir3_free_read(tp, dp, fbno, -2, bpp);
 }
 
-
-void
-xfs_dir3_free_hdr_from_disk(
-        struct xfs_dir3_icfree_hdr      *to,
-        struct xfs_dir2_free            *from)
-{
-        if (from->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC)) {
-                to->magic = be32_to_cpu(from->hdr.magic);
-                to->firstdb = be32_to_cpu(from->hdr.firstdb);
-                to->nvalid = be32_to_cpu(from->hdr.nvalid);
-                to->nused = be32_to_cpu(from->hdr.nused);
-        } else {
-                struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)from;
-
-                to->magic = be32_to_cpu(hdr3->hdr.magic);
-                to->firstdb = be32_to_cpu(hdr3->firstdb);
-                to->nvalid = be32_to_cpu(hdr3->nvalid);
-                to->nused = be32_to_cpu(hdr3->nused);
-        }
-
-        ASSERT(to->magic == XFS_DIR2_FREE_MAGIC ||
-               to->magic == XFS_DIR3_FREE_MAGIC);
-}
-
-static void
-xfs_dir3_free_hdr_to_disk(
-        struct xfs_dir2_free            *to,
-        struct xfs_dir3_icfree_hdr      *from)
-{
-        ASSERT(from->magic == XFS_DIR2_FREE_MAGIC ||
-               from->magic == XFS_DIR3_FREE_MAGIC);
-
-        if (from->magic == XFS_DIR2_FREE_MAGIC) {
-                to->hdr.magic = cpu_to_be32(from->magic);
-                to->hdr.firstdb = cpu_to_be32(from->firstdb);
-                to->hdr.nvalid = cpu_to_be32(from->nvalid);
-                to->hdr.nused = cpu_to_be32(from->nused);
-        } else {
-                struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)to;
-
-                hdr3->hdr.magic = cpu_to_be32(from->magic);
-                hdr3->firstdb = cpu_to_be32(from->firstdb);
-                hdr3->nvalid = cpu_to_be32(from->nvalid);
-                hdr3->nused = cpu_to_be32(from->nused);
-        }
-}
-
 static int
 xfs_dir3_free_get_buf(
         struct xfs_trans        *tp,
@@ -277,7 +229,7 @@ xfs_dir3_free_get_buf(
                 uuid_copy(&hdr3->hdr.uuid, &mp->m_sb.sb_uuid);
         } else
                 hdr.magic = XFS_DIR2_FREE_MAGIC;
-        xfs_dir3_free_hdr_to_disk(bp->b_addr, &hdr);
+        dp->d_ops->free_hdr_to_disk(bp->b_addr, &hdr);
         *bpp = bp;
         return 0;
 }
@@ -288,6 +240,7 @@ xfs_dir3_free_get_buf(
 STATIC void
 xfs_dir2_free_log_bests(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp,
         int                     first,          /* first entry to log */
         int                     last)           /* last entry to log */
@@ -296,7 +249,7 @@ xfs_dir2_free_log_bests(
         __be16                  *bests;
 
         free = bp->b_addr;
-        bests = xfs_dir3_free_bests_p(tp->t_mountp, free);
+        bests = dp->d_ops->free_bests_p(free);
         ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
                free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
         xfs_trans_log_buf(tp, bp,
@@ -311,6 +264,7 @@ xfs_dir2_free_log_bests(
 static void
 xfs_dir2_free_log_header(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp)
 {
 #ifdef DEBUG
@@ -320,7 +274,7 @@ xfs_dir2_free_log_header(
         ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
                free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
 #endif
-        xfs_trans_log_buf(tp, bp, 0, xfs_dir3_free_hdr_size(tp->t_mountp) - 1);
+        xfs_trans_log_buf(tp, bp, 0, dp->d_ops->free_hdr_size - 1);
 }
 
 /*
@@ -369,7 +323,7 @@ xfs_dir2_leaf_to_node(
                 return error;
 
         free = fbp->b_addr;
-        xfs_dir3_free_hdr_from_disk(&freehdr, free);
+        dp->d_ops->free_hdr_from_disk(&freehdr, free);
         leaf = lbp->b_addr;
         ltp = xfs_dir2_leaf_tail_p(mp, leaf);
         ASSERT(be32_to_cpu(ltp->bestcount) <=
@@ -380,7 +334,7 @@ xfs_dir2_leaf_to_node(
          * Count active entries.
          */
         from = xfs_dir2_leaf_bests_p(ltp);
-        to = xfs_dir3_free_bests_p(mp, free);
+        to = dp->d_ops->free_bests_p(free);
         for (i = n = 0; i < be32_to_cpu(ltp->bestcount); i++, from++, to++) {
                 if ((off = be16_to_cpu(*from)) != NULLDATAOFF)
                         n++;
@@ -393,9 +347,9 @@ xfs_dir2_leaf_to_node(
         freehdr.nused = n;
         freehdr.nvalid = be32_to_cpu(ltp->bestcount);
 
-        xfs_dir3_free_hdr_to_disk(fbp->b_addr, &freehdr);
-        xfs_dir2_free_log_bests(tp, fbp, 0, freehdr.nvalid - 1);
-        xfs_dir2_free_log_header(tp, fbp);
+        dp->d_ops->free_hdr_to_disk(fbp->b_addr, &freehdr);
+        xfs_dir2_free_log_bests(tp, dp, fbp, 0, freehdr.nvalid - 1);
+        xfs_dir2_free_log_header(tp, dp, fbp);
 
         /*
          * Converting the leaf to a leafnode is just a matter of changing the
@@ -409,8 +363,8 @@ xfs_dir2_leaf_to_node(
                 leaf->hdr.info.magic = cpu_to_be16(XFS_DIR3_LEAFN_MAGIC);
         lbp->b_ops = &xfs_dir3_leafn_buf_ops;
         xfs_trans_buf_set_type(tp, lbp, XFS_BLFT_DIR_LEAFN_BUF);
-        xfs_dir3_leaf_log_header(tp, lbp);
-        xfs_dir3_leaf_check(mp, lbp);
+        xfs_dir3_leaf_log_header(tp, dp, lbp);
+        xfs_dir3_leaf_check(dp, lbp);
         return 0;
 }
 
@@ -443,8 +397,8 @@ xfs_dir2_leafn_add(
         mp = dp->i_mount;
         tp = args->trans;
         leaf = bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
 
         /*
          * Quick check just to make sure we are not going to index
@@ -460,7 +414,7 @@ xfs_dir2_leafn_add(
          * a compact.
          */
 
-        if (leafhdr.count == xfs_dir3_max_leaf_ents(mp, leaf)) {
+        if (leafhdr.count == dp->d_ops->leaf_max_ents(mp)) {
                 if (!leafhdr.stale)
                         return XFS_ERROR(ENOSPC);
                 compact = leafhdr.stale > 1;
@@ -498,30 +452,30 @@ xfs_dir2_leafn_add(
         lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(mp,
                                 args->blkno, args->index));
 
-        xfs_dir3_leaf_hdr_to_disk(leaf, &leafhdr);
-        xfs_dir3_leaf_log_header(tp, bp);
-        xfs_dir3_leaf_log_ents(tp, bp, lfloglow, lfloghigh);
-        xfs_dir3_leaf_check(mp, bp);
+        dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
+        xfs_dir3_leaf_log_header(tp, dp, bp);
+        xfs_dir3_leaf_log_ents(tp, dp, bp, lfloglow, lfloghigh);
+        xfs_dir3_leaf_check(dp, bp);
         return 0;
 }
 
 #ifdef DEBUG
 static void
 xfs_dir2_free_hdr_check(
-        struct xfs_mount *mp,
+        struct xfs_inode *dp,
         struct xfs_buf  *bp,
         xfs_dir2_db_t   db)
 {
         struct xfs_dir3_icfree_hdr hdr;
 
-        xfs_dir3_free_hdr_from_disk(&hdr, bp->b_addr);
+        dp->d_ops->free_hdr_from_disk(&hdr, bp->b_addr);
 
-        ASSERT((hdr.firstdb % xfs_dir3_free_max_bests(mp)) == 0);
+        ASSERT((hdr.firstdb % dp->d_ops->free_max_bests(dp->i_mount)) == 0);
         ASSERT(hdr.firstdb <= db);
         ASSERT(db < hdr.firstdb + hdr.nvalid);
 }
 #else
-#define xfs_dir2_free_hdr_check(mp, dp, db)
+#define xfs_dir2_free_hdr_check(dp, bp, db)
 #endif  /* DEBUG */
 
 /*
@@ -530,6 +484,7 @@ xfs_dir2_free_hdr_check(
  */
 xfs_dahash_t                                    /* hash value */
 xfs_dir2_leafn_lasthash(
+        struct xfs_inode *dp,
         struct xfs_buf  *bp,                    /* leaf buffer */
         int             *count)                 /* count of entries in leaf */
 {
@@ -537,7 +492,7 @@ xfs_dir2_leafn_lasthash(
         struct xfs_dir2_leaf_entry *ents;
         struct xfs_dir3_icleaf_hdr leafhdr;
 
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
 
         ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
                leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
@@ -547,7 +502,7 @@ xfs_dir2_leafn_lasthash(
         if (!leafhdr.count)
                 return 0;
 
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
         return be32_to_cpu(ents[leafhdr.count - 1].hashval);
 }
 
@@ -584,10 +539,10 @@ xfs_dir2_leafn_lookup_for_addname(
         tp = args->trans;
         mp = dp->i_mount;
         leaf = bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
 
-        xfs_dir3_leaf_check(mp, bp);
+        xfs_dir3_leaf_check(dp, bp);
         ASSERT(leafhdr.count > 0);
 
         /*
@@ -605,7 +560,7 @@ xfs_dir2_leafn_lookup_for_addname(
                 ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
                        free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
         }
-        length = xfs_dir3_data_entsize(mp, args->namelen);
+        length = dp->d_ops->data_entsize(args->namelen);
         /*
          * Loop over leaf entries with the right hash value.
          */
@@ -637,7 +592,7 @@ xfs_dir2_leafn_lookup_for_addname(
                          * Convert the data block to the free block
                          * holding its freespace information.
                          */
-                        newfdb = xfs_dir2_db_to_fdb(mp, newdb);
+                        newfdb = dp->d_ops->db_to_fdb(mp, newdb);
                         /*
                          * If it's not the one we have in hand, read it in.
                          */
@@ -655,16 +610,16 @@ xfs_dir2_leafn_lookup_for_addname(
                                         return error;
                                 free = curbp->b_addr;
 
-                                xfs_dir2_free_hdr_check(mp, curbp, curdb);
+                                xfs_dir2_free_hdr_check(dp, curbp, curdb);
                         }
                         /*
                          * Get the index for our entry.
                          */
-                        fi = xfs_dir2_db_to_fdindex(mp, curdb);
+                        fi = dp->d_ops->db_to_fdindex(mp, curdb);
                         /*
                          * If it has room, return it.
                          */
-                        bests = xfs_dir3_free_bests_p(mp, free);
+                        bests = dp->d_ops->free_bests_p(free);
                         if (unlikely(bests[fi] == cpu_to_be16(NULLDATAOFF))) {
                                 XFS_ERROR_REPORT("xfs_dir2_leafn_lookup_int",
                                                         XFS_ERRLEVEL_LOW, mp);
@@ -734,10 +689,10 @@ xfs_dir2_leafn_lookup_for_entry(
         tp = args->trans;
         mp = dp->i_mount;
         leaf = bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
 
-        xfs_dir3_leaf_check(mp, bp);
+        xfs_dir3_leaf_check(dp, bp);
         ASSERT(leafhdr.count > 0);
 
         /*
@@ -816,7 +771,7 @@ xfs_dir2_leafn_lookup_for_entry(
                                 xfs_trans_brelse(tp, state->extrablk.bp);
                         args->cmpresult = cmp;
                         args->inumber = be64_to_cpu(dep->inumber);
-                        args->filetype = xfs_dir3_dirent_get_ftype(mp, dep);
+                        args->filetype = dp->d_ops->data_get_ftype(dep);
                         *indexp = index;
                         state->extravalid = 1;
                         state->extrablk.bp = curbp;
@@ -907,7 +862,7 @@ xfs_dir3_leafn_moveents(
         if (start_d < dhdr->count) {
                 memmove(&dents[start_d + count], &dents[start_d],
                         (dhdr->count - start_d) * sizeof(xfs_dir2_leaf_entry_t));
-                xfs_dir3_leaf_log_ents(tp, bp_d, start_d + count,
+                xfs_dir3_leaf_log_ents(tp, args->dp, bp_d, start_d + count,
                                        count + dhdr->count - 1);
         }
         /*
@@ -929,7 +884,8 @@ xfs_dir3_leafn_moveents(
          */
         memcpy(&dents[start_d], &sents[start_s],
                 count * sizeof(xfs_dir2_leaf_entry_t));
-        xfs_dir3_leaf_log_ents(tp, bp_d, start_d, start_d + count - 1);
+        xfs_dir3_leaf_log_ents(tp, args->dp, bp_d,
+                               start_d, start_d + count - 1);
 
         /*
          * If there are source entries after the ones we copied,
@@ -938,7 +894,8 @@ xfs_dir3_leafn_moveents(
         if (start_s + count < shdr->count) {
                 memmove(&sents[start_s], &sents[start_s + count],
                         count * sizeof(xfs_dir2_leaf_entry_t));
-                xfs_dir3_leaf_log_ents(tp, bp_s, start_s, start_s + count - 1);
+                xfs_dir3_leaf_log_ents(tp, args->dp, bp_s,
+                                       start_s, start_s + count - 1);
         }
 
         /*
@@ -956,6 +913,7 @@ xfs_dir3_leafn_moveents(
  */
 int                                             /* sort order */
 xfs_dir2_leafn_order(
+        struct xfs_inode        *dp,
         struct xfs_buf          *leaf1_bp,              /* leaf1 buffer */
         struct xfs_buf          *leaf2_bp)              /* leaf2 buffer */
 {
@@ -966,10 +924,10 @@ xfs_dir2_leafn_order(
         struct xfs_dir3_icleaf_hdr hdr1;
         struct xfs_dir3_icleaf_hdr hdr2;
 
-        xfs_dir3_leaf_hdr_from_disk(&hdr1, leaf1);
-        xfs_dir3_leaf_hdr_from_disk(&hdr2, leaf2);
-        ents1 = xfs_dir3_leaf_ents_p(leaf1);
-        ents2 = xfs_dir3_leaf_ents_p(leaf2);
+        dp->d_ops->leaf_hdr_from_disk(&hdr1, leaf1);
+        dp->d_ops->leaf_hdr_from_disk(&hdr2, leaf2);
+        ents1 = dp->d_ops->leaf_ents_p(leaf1);
+        ents2 = dp->d_ops->leaf_ents_p(leaf2);
 
         if (hdr1.count > 0 && hdr2.count > 0 &&
             (be32_to_cpu(ents2[0].hashval) < be32_to_cpu(ents1[0].hashval) ||
@@ -1007,12 +965,13 @@ xfs_dir2_leafn_rebalance(
         struct xfs_dir2_leaf_entry *ents2;
         struct xfs_dir3_icleaf_hdr hdr1;
         struct xfs_dir3_icleaf_hdr hdr2;
+        struct xfs_inode        *dp = state->args->dp;
 
         args = state->args;
         /*
          * If the block order is wrong, swap the arguments.
          */
-        if ((swap = xfs_dir2_leafn_order(blk1->bp, blk2->bp))) {
+        if ((swap = xfs_dir2_leafn_order(dp, blk1->bp, blk2->bp))) {
                 xfs_da_state_blk_t      *tmp;   /* temp for block swap */
 
                 tmp = blk1;
@@ -1021,10 +980,10 @@ xfs_dir2_leafn_rebalance(
         }
         leaf1 = blk1->bp->b_addr;
         leaf2 = blk2->bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&hdr1, leaf1);
-        xfs_dir3_leaf_hdr_from_disk(&hdr2, leaf2);
-        ents1 = xfs_dir3_leaf_ents_p(leaf1);
-        ents2 = xfs_dir3_leaf_ents_p(leaf2);
+        dp->d_ops->leaf_hdr_from_disk(&hdr1, leaf1);
+        dp->d_ops->leaf_hdr_from_disk(&hdr2, leaf2);
+        ents1 = dp->d_ops->leaf_ents_p(leaf1);
+        ents2 = dp->d_ops->leaf_ents_p(leaf2);
 
         oldsum = hdr1.count + hdr2.count;
 #if defined(DEBUG) || defined(XFS_WARN)
@@ -1070,13 +1029,13 @@ xfs_dir2_leafn_rebalance(
         ASSERT(hdr1.stale + hdr2.stale == oldstale);
 
         /* log the changes made when moving the entries */
-        xfs_dir3_leaf_hdr_to_disk(leaf1, &hdr1);
-        xfs_dir3_leaf_hdr_to_disk(leaf2, &hdr2);
-        xfs_dir3_leaf_log_header(args->trans, blk1->bp);
-        xfs_dir3_leaf_log_header(args->trans, blk2->bp);
+        dp->d_ops->leaf_hdr_to_disk(leaf1, &hdr1);
+        dp->d_ops->leaf_hdr_to_disk(leaf2, &hdr2);
+        xfs_dir3_leaf_log_header(args->trans, dp, blk1->bp);
+        xfs_dir3_leaf_log_header(args->trans, dp, blk2->bp);
 
-        xfs_dir3_leaf_check(args->dp->i_mount, blk1->bp);
-        xfs_dir3_leaf_check(args->dp->i_mount, blk2->bp);
+        xfs_dir3_leaf_check(dp, blk1->bp);
+        xfs_dir3_leaf_check(dp, blk2->bp);
 
         /*
          * Mark whether we're inserting into the old or new leaf.
@@ -1097,11 +1056,11 @@ xfs_dir2_leafn_rebalance(
          * Finally sanity check just to make sure we are not returning a
          * negative index
          */
-        if(blk2->index < 0) {
+        if (blk2->index < 0) {
                 state->inleaf = 1;
                 blk2->index = 0;
-                xfs_alert(args->dp->i_mount,
-        "%s: picked the wrong leaf? reverting original leaf: blk1->index %d\n",
+                xfs_alert(dp->i_mount,
+        "%s: picked the wrong leaf? reverting original leaf: blk1->index %d",
                         __func__, blk1->index);
         }
 }
@@ -1120,17 +1079,17 @@ xfs_dir3_data_block_free(
         int                     logfree = 0;
         __be16                  *bests;
         struct xfs_dir3_icfree_hdr freehdr;
+        struct xfs_inode        *dp = args->dp;
 
-        xfs_dir3_free_hdr_from_disk(&freehdr, free);
-
-        bests = xfs_dir3_free_bests_p(tp->t_mountp, free);
+        dp->d_ops->free_hdr_from_disk(&freehdr, free);
+        bests = dp->d_ops->free_bests_p(free);
         if (hdr) {
                 /*
                  * Data block is not empty, just set the free entry to the new
                  * value.
                  */
                 bests[findex] = cpu_to_be16(longest);
-                xfs_dir2_free_log_bests(tp, fbp, findex, findex);
+                xfs_dir2_free_log_bests(tp, dp, fbp, findex, findex);
                 return 0;
         }
 
@@ -1157,8 +1116,8 @@ xfs_dir3_data_block_free(
                 logfree = 1;
         }
 
-        xfs_dir3_free_hdr_to_disk(free, &freehdr);
-        xfs_dir2_free_log_header(tp, fbp);
+        dp->d_ops->free_hdr_to_disk(free, &freehdr);
+        xfs_dir2_free_log_header(tp, dp, fbp);
 
         /*
          * If there are no useful entries left in the block, get rid of the
@@ -1182,7 +1141,7 @@ xfs_dir3_data_block_free(
 
         /* Log the free entry that changed, unless we got rid of it.  */
         if (logfree)
-                xfs_dir2_free_log_bests(tp, fbp, findex, findex);
+                xfs_dir2_free_log_bests(tp, dp, fbp, findex, findex);
         return 0;
 }
 
@@ -1222,8 +1181,8 @@ xfs_dir2_leafn_remove(
         tp = args->trans;
         mp = dp->i_mount;
         leaf = bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
 
         /*
          * Point to the entry we're removing.
@@ -1243,11 +1202,11 @@ xfs_dir2_leafn_remove(
          * Log the leaf block changes.
          */
         leafhdr.stale++;
-        xfs_dir3_leaf_hdr_to_disk(leaf, &leafhdr);
-        xfs_dir3_leaf_log_header(tp, bp);
+        dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
+        xfs_dir3_leaf_log_header(tp, dp, bp);
 
         lep->address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
-        xfs_dir3_leaf_log_ents(tp, bp, index, index);
+        xfs_dir3_leaf_log_ents(tp, dp, bp, index, index);
 
         /*
          * Make the data entry free.  Keep track of the longest freespace
@@ -1256,19 +1215,19 @@ xfs_dir2_leafn_remove(
         dbp = dblk->bp;
         hdr = dbp->b_addr;
         dep = (xfs_dir2_data_entry_t *)((char *)hdr + off);
-        bf = xfs_dir3_data_bestfree_p(hdr);
+        bf = dp->d_ops->data_bestfree_p(hdr);
         longest = be16_to_cpu(bf[0].length);
         needlog = needscan = 0;
-        xfs_dir2_data_make_free(tp, dbp, off,
-                xfs_dir3_data_entsize(mp, dep->namelen), &needlog, &needscan);
+        xfs_dir2_data_make_free(tp, dp, dbp, off,
+                dp->d_ops->data_entsize(dep->namelen), &needlog, &needscan);
         /*
          * Rescan the data block freespaces for bestfree.
          * Log the data block header if needed.
          */
         if (needscan)
-                xfs_dir2_data_freescan(mp, hdr, &needlog);
+                xfs_dir2_data_freescan(dp, hdr, &needlog);
         if (needlog)
-                xfs_dir2_data_log_header(tp, dbp);
+                xfs_dir2_data_log_header(tp, dp, dbp);
         xfs_dir3_data_check(dp, dbp);
         /*
          * If the longest data block freespace changes, need to update
@@ -1285,7 +1244,7 @@ xfs_dir2_leafn_remove(
                  * Convert the data block number to a free block,
                  * read in the free block.
                  */
-                fdb = xfs_dir2_db_to_fdb(mp, db);
+                fdb = dp->d_ops->db_to_fdb(mp, db);
                 error = xfs_dir2_free_read(tp, dp, xfs_dir2_db_to_da(mp, fdb),
                                            &fbp);
                 if (error)
@@ -1294,22 +1253,22 @@ xfs_dir2_leafn_remove(
 #ifdef DEBUG
         {
                 struct xfs_dir3_icfree_hdr freehdr;
-                xfs_dir3_free_hdr_from_disk(&freehdr, free);
-                ASSERT(freehdr.firstdb == xfs_dir3_free_max_bests(mp) *
+                dp->d_ops->free_hdr_from_disk(&freehdr, free);
+                ASSERT(freehdr.firstdb == dp->d_ops->free_max_bests(mp) *
                                           (fdb - XFS_DIR2_FREE_FIRSTDB(mp)));
         }
 #endif
                 /*
                  * Calculate which entry we need to fix.
                  */
-                findex = xfs_dir2_db_to_fdindex(mp, db);
+                findex = dp->d_ops->db_to_fdindex(mp, db);
                 longest = be16_to_cpu(bf[0].length);
                 /*
                  * If the data block is now empty we can get rid of it
                  * (usually).
                  */
                 if (longest == mp->m_dirblksize -
-                               xfs_dir3_data_entry_offset(hdr)) {
+                               dp->d_ops->data_entry_offset) {
                         /*
                          * Try to punch out the data block.
                          */
@@ -1336,12 +1295,12 @@ xfs_dir2_leafn_remove(
                         return error;
         }
 
-        xfs_dir3_leaf_check(mp, bp);
+        xfs_dir3_leaf_check(dp, bp);
         /*
          * Return indication of whether this leaf block is empty enough
          * to justify trying to join it with a neighbor.
          */
-        *rval = (xfs_dir3_leaf_hdr_size(leaf) +
+        *rval = (dp->d_ops->leaf_hdr_size +
                  (uint)sizeof(ents[0]) * (leafhdr.count - leafhdr.stale)) <
                 mp->m_dir_magicpct;
         return 0;
@@ -1360,13 +1319,14 @@ xfs_dir2_leafn_split(
         xfs_dablk_t             blkno;          /* new leaf block number */
         int                     error;          /* error return value */
         xfs_mount_t             *mp;            /* filesystem mount point */
+        struct xfs_inode        *dp;
 
         /*
          * Allocate space for a new leaf node.
          */
         args = state->args;
-        mp = args->dp->i_mount;
-        ASSERT(args != NULL);
+        dp = args->dp;
+        mp = dp->i_mount;
         ASSERT(oldblk->magic == XFS_DIR2_LEAFN_MAGIC);
         error = xfs_da_grow_inode(args, &blkno);
         if (error) {
@@ -1401,10 +1361,10 @@ xfs_dir2_leafn_split(
         /*
          * Update last hashval in each block since we added the name.
          */
-        oldblk->hashval = xfs_dir2_leafn_lasthash(oldblk->bp, NULL);
-        newblk->hashval = xfs_dir2_leafn_lasthash(newblk->bp, NULL);
-        xfs_dir3_leaf_check(mp, oldblk->bp);
-        xfs_dir3_leaf_check(mp, newblk->bp);
+        oldblk->hashval = xfs_dir2_leafn_lasthash(dp, oldblk->bp, NULL);
+        newblk->hashval = xfs_dir2_leafn_lasthash(dp, newblk->bp, NULL);
+        xfs_dir3_leaf_check(dp, oldblk->bp);
+        xfs_dir3_leaf_check(dp, newblk->bp);
         return error;
 }
 
@@ -1434,6 +1394,7 @@ xfs_dir2_leafn_toosmall(
         int                     rval;           /* result from path_shift */
         struct xfs_dir3_icleaf_hdr leafhdr;
         struct xfs_dir2_leaf_entry *ents;
+        struct xfs_inode        *dp = state->args->dp;
 
         /*
          * Check for the degenerate case of the block being over 50% full.
@@ -1442,12 +1403,12 @@ xfs_dir2_leafn_toosmall(
          */
         blk = &state->path.blk[state->path.active - 1];
         leaf = blk->bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
-        xfs_dir3_leaf_check(state->args->dp->i_mount, blk->bp);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
+        xfs_dir3_leaf_check(dp, blk->bp);
 
         count = leafhdr.count - leafhdr.stale;
-        bytes = xfs_dir3_leaf_hdr_size(leaf) + count * sizeof(ents[0]);
+        bytes = dp->d_ops->leaf_hdr_size + count * sizeof(ents[0]);
         if (bytes > (state->blocksize >> 1)) {
                 /*
                  * Blk over 50%, don't try to join.
@@ -1492,7 +1453,7 @@ xfs_dir2_leafn_toosmall(
                 /*
                  * Read the sibling leaf block.
                  */
-                error = xfs_dir3_leafn_read(state->args->trans, state->args->dp,
+                error = xfs_dir3_leafn_read(state->args->trans, dp,
                                             blkno, -1, &bp);
                 if (error)
                         return error;
@@ -1504,8 +1465,8 @@ xfs_dir2_leafn_toosmall(
                 bytes = state->blocksize - (state->blocksize >> 2);
 
                 leaf = bp->b_addr;
-                xfs_dir3_leaf_hdr_from_disk(&hdr2, leaf);
-                ents = xfs_dir3_leaf_ents_p(leaf);
+                dp->d_ops->leaf_hdr_from_disk(&hdr2, leaf);
+                ents = dp->d_ops->leaf_ents_p(leaf);
                 count += hdr2.count - hdr2.stale;
                 bytes -= count * sizeof(ents[0]);
 
@@ -1559,6 +1520,7 @@ xfs_dir2_leafn_unbalance(
         struct xfs_dir3_icleaf_hdr drophdr;
         struct xfs_dir2_leaf_entry *sents;
         struct xfs_dir2_leaf_entry *dents;
+        struct xfs_inode        *dp = state->args->dp;
 
         args = state->args;
         ASSERT(drop_blk->magic == XFS_DIR2_LEAFN_MAGIC);
@@ -1566,10 +1528,10 @@ xfs_dir2_leafn_unbalance(
         drop_leaf = drop_blk->bp->b_addr;
         save_leaf = save_blk->bp->b_addr;
 
-        xfs_dir3_leaf_hdr_from_disk(&savehdr, save_leaf);
-        xfs_dir3_leaf_hdr_from_disk(&drophdr, drop_leaf);
-        sents = xfs_dir3_leaf_ents_p(save_leaf);
-        dents = xfs_dir3_leaf_ents_p(drop_leaf);
+        dp->d_ops->leaf_hdr_from_disk(&savehdr, save_leaf);
+        dp->d_ops->leaf_hdr_from_disk(&drophdr, drop_leaf);
+        sents = dp->d_ops->leaf_ents_p(save_leaf);
+        dents = dp->d_ops->leaf_ents_p(drop_leaf);
 
         /*
          * If there are any stale leaf entries, take this opportunity
@@ -1584,7 +1546,7 @@ xfs_dir2_leafn_unbalance(
          * Move the entries from drop to the appropriate end of save.
          */
         drop_blk->hashval = be32_to_cpu(dents[drophdr.count - 1].hashval);
-        if (xfs_dir2_leafn_order(save_blk->bp, drop_blk->bp))
+        if (xfs_dir2_leafn_order(dp, save_blk->bp, drop_blk->bp))
                 xfs_dir3_leafn_moveents(args, drop_blk->bp, &drophdr, dents, 0,
                                         save_blk->bp, &savehdr, sents, 0,
                                         drophdr.count);
@@ -1595,13 +1557,13 @@ xfs_dir2_leafn_unbalance(
         save_blk->hashval = be32_to_cpu(sents[savehdr.count - 1].hashval);
 
         /* log the changes made when moving the entries */
-        xfs_dir3_leaf_hdr_to_disk(save_leaf, &savehdr);
-        xfs_dir3_leaf_hdr_to_disk(drop_leaf, &drophdr);
-        xfs_dir3_leaf_log_header(args->trans, save_blk->bp);
-        xfs_dir3_leaf_log_header(args->trans, drop_blk->bp);
+        dp->d_ops->leaf_hdr_to_disk(save_leaf, &savehdr);
+        dp->d_ops->leaf_hdr_to_disk(drop_leaf, &drophdr);
+        xfs_dir3_leaf_log_header(args->trans, dp, save_blk->bp);
+        xfs_dir3_leaf_log_header(args->trans, dp, drop_blk->bp);
 
-        xfs_dir3_leaf_check(args->dp->i_mount, save_blk->bp);
-        xfs_dir3_leaf_check(args->dp->i_mount, drop_blk->bp);
+        xfs_dir3_leaf_check(dp, save_blk->bp);
+        xfs_dir3_leaf_check(dp, drop_blk->bp);
 }
 
 /*
@@ -1712,7 +1674,7 @@ xfs_dir2_node_addname_int(
         dp = args->dp;
         mp = dp->i_mount;
         tp = args->trans;
-        length = xfs_dir3_data_entsize(mp, args->namelen);
+        length = dp->d_ops->data_entsize(args->namelen);
         /*
          * If we came in with a freespace block that means that lookup
          * found an entry with our hash value.  This is the freespace
@@ -1726,8 +1688,8 @@ xfs_dir2_node_addname_int(
                 ifbno = fblk->blkno;
                 free = fbp->b_addr;
                 findex = fblk->index;
-                bests = xfs_dir3_free_bests_p(mp, free);
-                xfs_dir3_free_hdr_from_disk(&freehdr, free);
+                bests = dp->d_ops->free_bests_p(free);
+                dp->d_ops->free_hdr_from_disk(&freehdr, free);
 
                 /*
                  * This means the free entry showed that the data block had
@@ -1819,8 +1781,8 @@ xfs_dir2_node_addname_int(
                  * and the freehdr are actually initialised if they are placed
                  * there, so we have to do it here to avoid warnings. Blech.
                  */
-                bests = xfs_dir3_free_bests_p(mp, free);
-                xfs_dir3_free_hdr_from_disk(&freehdr, free);
+                bests = dp->d_ops->free_bests_p(free);
+                dp->d_ops->free_hdr_from_disk(&freehdr, free);
                 if (be16_to_cpu(bests[findex]) != NULLDATAOFF &&
                     be16_to_cpu(bests[findex]) >= length)
                         dbno = freehdr.firstdb + findex;
@@ -1871,7 +1833,7 @@ xfs_dir2_node_addname_int(
                  * Get the freespace block corresponding to the data block
                  * that was just allocated.
                  */
-                fbno = xfs_dir2_db_to_fdb(mp, dbno);
+                fbno = dp->d_ops->db_to_fdb(mp, dbno);
                 error = xfs_dir2_free_try_read(tp, dp,
                                                xfs_dir2_db_to_da(mp, fbno),
                                                &fbp);
@@ -1888,12 +1850,12 @@ xfs_dir2_node_addname_int(
                         if (error)
                                 return error;
 
-                        if (unlikely(xfs_dir2_db_to_fdb(mp, dbno) != fbno)) {
+                        if (unlikely(dp->d_ops->db_to_fdb(mp, dbno) != fbno)) {
                                 xfs_alert(mp,
                         "%s: dir ino %llu needed freesp block %lld for\n"
                         "  data block %lld, got %lld ifbno %llu lastfbno %d",
                                         __func__, (unsigned long long)dp->i_ino,
-                                        (long long)xfs_dir2_db_to_fdb(mp, dbno),
+                                        (long long)dp->d_ops->db_to_fdb(mp, dbno),
                                         (long long)dbno, (long long)fbno,
                                         (unsigned long long)ifbno, lastfbno);
                                 if (fblk) {
@@ -1918,30 +1880,30 @@ xfs_dir2_node_addname_int(
                         if (error)
                                 return error;
                         free = fbp->b_addr;
-                        bests = xfs_dir3_free_bests_p(mp, free);
-                        xfs_dir3_free_hdr_from_disk(&freehdr, free);
+                        bests = dp->d_ops->free_bests_p(free);
+                        dp->d_ops->free_hdr_from_disk(&freehdr, free);
 
                         /*
                          * Remember the first slot as our empty slot.
                          */
                         freehdr.firstdb = (fbno - XFS_DIR2_FREE_FIRSTDB(mp)) *
-                                        xfs_dir3_free_max_bests(mp);
+                                        dp->d_ops->free_max_bests(mp);
                 } else {
                         free = fbp->b_addr;
-                        bests = xfs_dir3_free_bests_p(mp, free);
-                        xfs_dir3_free_hdr_from_disk(&freehdr, free);
+                        bests = dp->d_ops->free_bests_p(free);
+                        dp->d_ops->free_hdr_from_disk(&freehdr, free);
                 }
 
                 /*
                  * Set the freespace block index from the data block number.
                  */
-                findex = xfs_dir2_db_to_fdindex(mp, dbno);
+                findex = dp->d_ops->db_to_fdindex(mp, dbno);
                 /*
                  * If it's after the end of the current entries in the
                  * freespace block, extend that table.
                  */
                 if (findex >= freehdr.nvalid) {
-                        ASSERT(findex < xfs_dir3_free_max_bests(mp));
+                        ASSERT(findex < dp->d_ops->free_max_bests(mp));
                         freehdr.nvalid = findex + 1;
                         /*
                          * Tag new entry so nused will go up.
@@ -1954,8 +1916,8 @@ xfs_dir2_node_addname_int(
                  */
                 if (bests[findex] == cpu_to_be16(NULLDATAOFF)) {
                         freehdr.nused++;
-                        xfs_dir3_free_hdr_to_disk(fbp->b_addr, &freehdr);
-                        xfs_dir2_free_log_header(tp, fbp);
+                        dp->d_ops->free_hdr_to_disk(fbp->b_addr, &freehdr);
+                        xfs_dir2_free_log_header(tp, dp, fbp);
                 }
                 /*
                  * Update the real value in the table.
@@ -1963,7 +1925,7 @@ xfs_dir2_node_addname_int(
                  * change again.
                  */
                 hdr = dbp->b_addr;
-                bf = xfs_dir3_data_bestfree_p(hdr);
+                bf = dp->d_ops->data_bestfree_p(hdr);
                 bests[findex] = bf[0].length;
                 logfree = 1;
         }
@@ -1985,7 +1947,7 @@ xfs_dir2_node_addname_int(
                 if (error)
                         return error;
                 hdr = dbp->b_addr;
-                bf = xfs_dir3_data_bestfree_p(hdr);
+                bf = dp->d_ops->data_bestfree_p(hdr);
                 logfree = 0;
         }
         ASSERT(be16_to_cpu(bf[0].length) >= length);
@@ -1998,7 +1960,7 @@ xfs_dir2_node_addname_int(
         /*
          * Mark the first part of the unused space, inuse for us.
          */
-        xfs_dir2_data_use_free(tp, dbp, dup,
+        xfs_dir2_data_use_free(tp, dp, dbp, dup,
                 (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr), length,
                 &needlog, &needscan);
         /*
@@ -2008,24 +1970,24 @@ xfs_dir2_node_addname_int(
         dep->inumber = cpu_to_be64(args->inumber);
         dep->namelen = args->namelen;
         memcpy(dep->name, args->name, dep->namelen);
-        xfs_dir3_dirent_put_ftype(mp, dep, args->filetype);
-        tagp = xfs_dir3_data_entry_tag_p(mp, dep);
+        dp->d_ops->data_put_ftype(dep, args->filetype);
+        tagp = dp->d_ops->data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)hdr);
-        xfs_dir2_data_log_entry(tp, dbp, dep);
+        xfs_dir2_data_log_entry(tp, dp, dbp, dep);
         /*
          * Rescan the block for bestfree if needed.
          */
         if (needscan)
-                xfs_dir2_data_freescan(mp, hdr, &needlog);
+                xfs_dir2_data_freescan(dp, hdr, &needlog);
         /*
          * Log the data block header if needed.
          */
         if (needlog)
-                xfs_dir2_data_log_header(tp, dbp);
+                xfs_dir2_data_log_header(tp, dp, dbp);
         /*
          * If the freespace entry is now wrong, update it.
          */
-        bests = xfs_dir3_free_bests_p(mp, free); /* gcc is so stupid */
+        bests = dp->d_ops->free_bests_p(free); /* gcc is so stupid */
         if (be16_to_cpu(bests[findex]) != be16_to_cpu(bf[0].length)) {
                 bests[findex] = bf[0].length;
                 logfree = 1;
@@ -2034,7 +1996,7 @@ xfs_dir2_node_addname_int(
          * Log the freespace entry if needed.
          */
         if (logfree)
-                xfs_dir2_free_log_bests(tp, fbp, findex, findex);
+                xfs_dir2_free_log_bests(tp, dp, fbp, findex, findex);
         /*
          * Return the data block and offset in args, then drop the data block.
          */
@@ -2105,12 +2067,12 @@ xfs_dir2_node_lookup(
  */
 int                                             /* error */
 xfs_dir2_node_removename(
-        xfs_da_args_t           *args)          /* operation arguments */
+        struct xfs_da_args      *args)          /* operation arguments */
 {
-        xfs_da_state_blk_t      *blk;           /* leaf block */
+        struct xfs_da_state_blk *blk;           /* leaf block */
         int                     error;          /* error return value */
         int                     rval;           /* operation return value */
-        xfs_da_state_t          *state;         /* btree cursor */
+        struct xfs_da_state     *state;         /* btree cursor */
 
         trace_xfs_dir2_node_removename(args);
 
@@ -2122,19 +2084,18 @@ xfs_dir2_node_removename(
         state->mp = args->dp->i_mount;
         state->blocksize = state->mp->m_dirblksize;
         state->node_ents = state->mp->m_dir_node_ents;
-        /*
-         * Look up the entry we're deleting, set up the cursor.
-         */
+
+        /* Look up the entry we're deleting, set up the cursor. */
         error = xfs_da3_node_lookup_int(state, &rval);
         if (error)
-                rval = error;
-        /*
-         * Didn't find it, upper layer screwed up.
-         */
+                goto out_free;
+
+        /* Didn't find it, upper layer screwed up. */
         if (rval != EEXIST) {
-                xfs_da_state_free(state);
-                return rval;
+                error = rval;
+                goto out_free;
         }
+
         blk = &state->path.blk[state->path.active - 1];
         ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
         ASSERT(state->extravalid);
@@ -2145,7 +2106,7 @@ xfs_dir2_node_removename(
         error = xfs_dir2_leafn_remove(args, blk->bp, blk->index,
                 &state->extrablk, &rval);
         if (error)
-                return error;
+                goto out_free;
         /*
          * Fix the hash values up the btree.
          */
@@ -2160,6 +2121,7 @@ xfs_dir2_node_removename(
          */
         if (!error)
                 error = xfs_dir2_node_to_leaf(state);
+out_free:
         xfs_da_state_free(state);
         return error;
 }
@@ -2212,7 +2174,7 @@ xfs_dir2_node_replace(
                 blk = &state->path.blk[state->path.active - 1];
                 ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
                 leaf = blk->bp->b_addr;
-                ents = xfs_dir3_leaf_ents_p(leaf);
+                ents = args->dp->d_ops->leaf_ents_p(leaf);
                 lep = &ents[blk->index];
                 ASSERT(state->extravalid);
                 /*
@@ -2229,8 +2191,9 @@ xfs_dir2_node_replace(
                  * Fill in the new inode number and log the entry.
                  */
                 dep->inumber = cpu_to_be64(inum);
-                xfs_dir3_dirent_put_ftype(state->mp, dep, args->filetype);
-                xfs_dir2_data_log_entry(args->trans, state->extrablk.bp, dep);
+                args->dp->d_ops->data_put_ftype(dep, args->filetype);
+                xfs_dir2_data_log_entry(args->trans, args->dp,
+                                        state->extrablk.bp, dep);
                 rval = 0;
         }
         /*
@@ -2285,7 +2248,7 @@ xfs_dir2_node_trim_free(
         if (!bp)
                 return 0;
         free = bp->b_addr;
-        xfs_dir3_free_hdr_from_disk(&freehdr, free);
+        dp->d_ops->free_hdr_from_disk(&freehdr, free);
 
         /*
          * If there are used entries, there's nothing to do.