1 files changed, 96 insertions, 94 deletions

diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index cb434d732681..da43d304fca2 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -195,17 +195,18 @@ xfs_dir2_free_try_read(
 
 static int
 xfs_dir3_free_get_buf(
-        struct xfs_trans        *tp,
-        struct xfs_inode        *dp,
+        xfs_da_args_t           *args,
         xfs_dir2_db_t           fbno,
         struct xfs_buf          **bpp)
 {
+        struct xfs_trans        *tp = args->trans;
+        struct xfs_inode        *dp = args->dp;
         struct xfs_mount        *mp = dp->i_mount;
         struct xfs_buf          *bp;
         int                     error;
         struct xfs_dir3_icfree_hdr hdr;
 
-        error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(mp, fbno),
+        error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, fbno),
                                    -1, &bp, XFS_DATA_FORK);
         if (error)
                 return error;
@@ -240,8 +241,7 @@ xfs_dir3_free_get_buf(
  */
 STATIC void
 xfs_dir2_free_log_bests(
-        struct xfs_trans        *tp,
-        struct xfs_inode        *dp,
+        struct xfs_da_args      *args,
         struct xfs_buf          *bp,
         int                     first,          /* first entry to log */
         int                     last)           /* last entry to log */
@@ -250,10 +250,10 @@ xfs_dir2_free_log_bests(
         __be16                  *bests;
 
         free = bp->b_addr;
-        bests = dp->d_ops->free_bests_p(free);
+        bests = args->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,
+        xfs_trans_log_buf(args->trans, bp,
                 (uint)((char *)&bests[first] - (char *)free),
                 (uint)((char *)&bests[last] - (char *)free +
                        sizeof(bests[0]) - 1));
@@ -264,8 +264,7 @@ xfs_dir2_free_log_bests(
  */
 static void
 xfs_dir2_free_log_header(
-        struct xfs_trans        *tp,
-        struct xfs_inode        *dp,
+        struct xfs_da_args      *args,
         struct xfs_buf          *bp)
 {
 #ifdef DEBUG
@@ -275,7 +274,8 @@ 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, dp->d_ops->free_hdr_size - 1);
+        xfs_trans_log_buf(args->trans, bp, 0,
+                          args->dp->d_ops->free_hdr_size - 1);
 }
 
 /*
@@ -315,20 +315,20 @@ xfs_dir2_leaf_to_node(
         if ((error = xfs_dir2_grow_inode(args, XFS_DIR2_FREE_SPACE, &fdb))) {
                 return error;
         }
-        ASSERT(fdb == XFS_DIR2_FREE_FIRSTDB(mp));
+        ASSERT(fdb == xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET));
         /*
          * Get the buffer for the new freespace block.
          */
-        error = xfs_dir3_free_get_buf(tp, dp, fdb, &fbp);
+        error = xfs_dir3_free_get_buf(args, fdb, &fbp);
         if (error)
                 return error;
 
         free = fbp->b_addr;
         dp->d_ops->free_hdr_from_disk(&freehdr, free);
         leaf = lbp->b_addr;
-        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
+        ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
         ASSERT(be32_to_cpu(ltp->bestcount) <=
-                                (uint)dp->i_d.di_size / mp->m_dirblksize);
+                                (uint)dp->i_d.di_size / args->geo->blksize);
 
         /*
          * Copy freespace entries from the leaf block to the new block.
@@ -349,8 +349,8 @@ xfs_dir2_leaf_to_node(
         freehdr.nvalid = be32_to_cpu(ltp->bestcount);
 
         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);
+        xfs_dir2_free_log_bests(args, fbp, 0, freehdr.nvalid - 1);
+        xfs_dir2_free_log_header(args, fbp);
 
         /*
          * Converting the leaf to a leafnode is just a matter of changing the
@@ -364,7 +364,7 @@ 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, dp, lbp);
+        xfs_dir3_leaf_log_header(args, lbp);
         xfs_dir3_leaf_check(dp, lbp);
         return 0;
 }
@@ -415,7 +415,7 @@ xfs_dir2_leafn_add(
          * a compact.
          */
 
-        if (leafhdr.count == dp->d_ops->leaf_max_ents(mp)) {
+        if (leafhdr.count == dp->d_ops->leaf_max_ents(args->geo)) {
                 if (!leafhdr.stale)
                         return XFS_ERROR(ENOSPC);
                 compact = leafhdr.stale > 1;
@@ -450,12 +450,12 @@ xfs_dir2_leafn_add(
                                        highstale, &lfloglow, &lfloghigh);
 
         lep->hashval = cpu_to_be32(args->hashval);
-        lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(mp,
+        lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(args->geo,
                                 args->blkno, args->index));
 
         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_log_header(args, bp);
+        xfs_dir3_leaf_log_ents(args, bp, lfloglow, lfloghigh);
         xfs_dir3_leaf_check(dp, bp);
         return 0;
 }
@@ -471,7 +471,8 @@ xfs_dir2_free_hdr_check(
 
         dp->d_ops->free_hdr_from_disk(&hdr, bp->b_addr);
 
-        ASSERT((hdr.firstdb % dp->d_ops->free_max_bests(dp->i_mount)) == 0);
+        ASSERT((hdr.firstdb %
+                dp->d_ops->free_max_bests(dp->i_mount->m_dir_geo)) == 0);
         ASSERT(hdr.firstdb <= db);
         ASSERT(db < hdr.firstdb + hdr.nvalid);
 }
@@ -576,7 +577,8 @@ xfs_dir2_leafn_lookup_for_addname(
                 /*
                  * Pull the data block number from the entry.
                  */
-                newdb = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
+                newdb = xfs_dir2_dataptr_to_db(args->geo,
+                                               be32_to_cpu(lep->address));
                 /*
                  * For addname, we're looking for a place to put the new entry.
                  * We want to use a data block with an entry of equal
@@ -593,7 +595,7 @@ xfs_dir2_leafn_lookup_for_addname(
                          * Convert the data block to the free block
                          * holding its freespace information.
                          */
-                        newfdb = dp->d_ops->db_to_fdb(mp, newdb);
+                        newfdb = dp->d_ops->db_to_fdb(args->geo, newdb);
                         /*
                          * If it's not the one we have in hand, read it in.
                          */
@@ -605,7 +607,8 @@ xfs_dir2_leafn_lookup_for_addname(
                                         xfs_trans_brelse(tp, curbp);
 
                                 error = xfs_dir2_free_read(tp, dp,
-                                                xfs_dir2_db_to_da(mp, newfdb),
+                                                xfs_dir2_db_to_da(args->geo,
+                                                                  newfdb),
                                                 &curbp);
                                 if (error)
                                         return error;
@@ -616,7 +619,7 @@ xfs_dir2_leafn_lookup_for_addname(
                         /*
                          * Get the index for our entry.
                          */
-                        fi = dp->d_ops->db_to_fdindex(mp, curdb);
+                        fi = dp->d_ops->db_to_fdindex(args->geo, curdb);
                         /*
                          * If it has room, return it.
                          */
@@ -721,7 +724,8 @@ xfs_dir2_leafn_lookup_for_entry(
                 /*
                  * Pull the data block number from the entry.
                  */
-                newdb = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
+                newdb = xfs_dir2_dataptr_to_db(args->geo,
+                                               be32_to_cpu(lep->address));
                 /*
                  * Not adding a new entry, so we really want to find
                  * the name given to us.
@@ -746,7 +750,8 @@ xfs_dir2_leafn_lookup_for_entry(
                                 curbp = state->extrablk.bp;
                         } else {
                                 error = xfs_dir3_data_read(tp, dp,
-                                                xfs_dir2_db_to_da(mp, newdb),
+                                                xfs_dir2_db_to_da(args->geo,
+                                                                  newdb),
                                                 -1, &curbp);
                                 if (error)
                                         return error;
@@ -758,7 +763,8 @@ xfs_dir2_leafn_lookup_for_entry(
                  * Point to the data entry.
                  */
                 dep = (xfs_dir2_data_entry_t *)((char *)curbp->b_addr +
-                        xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address)));
+                        xfs_dir2_dataptr_to_off(args->geo,
+                                                be32_to_cpu(lep->address)));
                 /*
                  * Compare the entry and if it's an exact match, return
                  * EEXIST immediately. If it's the first case-insensitive
@@ -844,7 +850,6 @@ xfs_dir3_leafn_moveents(
         int                             start_d,/* destination leaf index */
         int                             count)  /* count of leaves to copy */
 {
-        struct xfs_trans                *tp = args->trans;
         int                             stale;  /* count stale leaves copied */
 
         trace_xfs_dir2_leafn_moveents(args, start_s, start_d, count);
@@ -863,7 +868,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, args->dp, bp_d, start_d + count,
+                xfs_dir3_leaf_log_ents(args, bp_d, start_d + count,
                                        count + dhdr->count - 1);
         }
         /*
@@ -885,8 +890,7 @@ xfs_dir3_leafn_moveents(
          */
         memcpy(&dents[start_d], &sents[start_s],
                 count * sizeof(xfs_dir2_leaf_entry_t));
-        xfs_dir3_leaf_log_ents(tp, args->dp, bp_d,
-                               start_d, start_d + count - 1);
+        xfs_dir3_leaf_log_ents(args, bp_d, start_d, start_d + count - 1);
 
         /*
          * If there are source entries after the ones we copied,
@@ -895,8 +899,7 @@ 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, args->dp, bp_s,
-                                       start_s, start_s + count - 1);
+                xfs_dir3_leaf_log_ents(args, bp_s, start_s, start_s + count - 1);
         }
 
         /*
@@ -1032,8 +1035,8 @@ xfs_dir2_leafn_rebalance(
         /* log the changes made when moving the entries */
         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_log_header(args, blk1->bp);
+        xfs_dir3_leaf_log_header(args, blk2->bp);
 
         xfs_dir3_leaf_check(dp, blk1->bp);
         xfs_dir3_leaf_check(dp, blk2->bp);
@@ -1076,7 +1079,6 @@ xfs_dir3_data_block_free(
         struct xfs_buf          *fbp,
         int                     longest)
 {
-        struct xfs_trans        *tp = args->trans;
         int                     logfree = 0;
         __be16                  *bests;
         struct xfs_dir3_icfree_hdr freehdr;
@@ -1090,7 +1092,7 @@ xfs_dir3_data_block_free(
                  * value.
                  */
                 bests[findex] = cpu_to_be16(longest);
-                xfs_dir2_free_log_bests(tp, dp, fbp, findex, findex);
+                xfs_dir2_free_log_bests(args, fbp, findex, findex);
                 return 0;
         }
 
@@ -1118,7 +1120,7 @@ xfs_dir3_data_block_free(
         }
 
         dp->d_ops->free_hdr_to_disk(free, &freehdr);
-        xfs_dir2_free_log_header(tp, dp, fbp);
+        xfs_dir2_free_log_header(args, fbp);
 
         /*
          * If there are no useful entries left in the block, get rid of the
@@ -1142,7 +1144,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, dp, fbp, findex, findex);
+                xfs_dir2_free_log_bests(args, fbp, findex, findex);
         return 0;
 }
 
@@ -1193,9 +1195,9 @@ xfs_dir2_leafn_remove(
         /*
          * Extract the data block and offset from the entry.
          */
-        db = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
+        db = xfs_dir2_dataptr_to_db(args->geo, be32_to_cpu(lep->address));
         ASSERT(dblk->blkno == db);
-        off = xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address));
+        off = xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address));
         ASSERT(dblk->index == off);
 
         /*
@@ -1204,10 +1206,10 @@ xfs_dir2_leafn_remove(
          */
         leafhdr.stale++;
         dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
-        xfs_dir3_leaf_log_header(tp, dp, bp);
+        xfs_dir3_leaf_log_header(args, bp);
 
         lep->address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
-        xfs_dir3_leaf_log_ents(tp, dp, bp, index, index);
+        xfs_dir3_leaf_log_ents(args, bp, index, index);
 
         /*
          * Make the data entry free.  Keep track of the longest freespace
@@ -1219,7 +1221,7 @@ xfs_dir2_leafn_remove(
         bf = dp->d_ops->data_bestfree_p(hdr);
         longest = be16_to_cpu(bf[0].length);
         needlog = needscan = 0;
-        xfs_dir2_data_make_free(tp, dp, dbp, off,
+        xfs_dir2_data_make_free(args, dbp, off,
                 dp->d_ops->data_entsize(dep->namelen), &needlog, &needscan);
         /*
          * Rescan the data block freespaces for bestfree.
@@ -1228,7 +1230,7 @@ xfs_dir2_leafn_remove(
         if (needscan)
                 xfs_dir2_data_freescan(dp, hdr, &needlog);
         if (needlog)
-                xfs_dir2_data_log_header(tp, dp, dbp);
+                xfs_dir2_data_log_header(args, dbp);
         xfs_dir3_data_check(dp, dbp);
         /*
          * If the longest data block freespace changes, need to update
@@ -1245,8 +1247,9 @@ xfs_dir2_leafn_remove(
                  * Convert the data block number to a free block,
                  * read in the free block.
                  */
-                fdb = dp->d_ops->db_to_fdb(mp, db);
-                error = xfs_dir2_free_read(tp, dp, xfs_dir2_db_to_da(mp, fdb),
+                fdb = dp->d_ops->db_to_fdb(args->geo, db);
+                error = xfs_dir2_free_read(tp, dp,
+                                           xfs_dir2_db_to_da(args->geo, fdb),
                                            &fbp);
                 if (error)
                         return error;
@@ -1255,20 +1258,21 @@ xfs_dir2_leafn_remove(
         {
                 struct xfs_dir3_icfree_hdr freehdr;
                 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)));
+                ASSERT(freehdr.firstdb == dp->d_ops->free_max_bests(args->geo) *
+                        (fdb - xfs_dir2_byte_to_db(args->geo,
+                                                   XFS_DIR2_FREE_OFFSET)));
         }
 #endif
                 /*
                  * Calculate which entry we need to fix.
                  */
-                findex = dp->d_ops->db_to_fdindex(mp, db);
+                findex = dp->d_ops->db_to_fdindex(args->geo, 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 -
+                if (longest == args->geo->blksize -
                                dp->d_ops->data_entry_offset) {
                         /*
                          * Try to punch out the data block.
@@ -1303,7 +1307,7 @@ xfs_dir2_leafn_remove(
          */
         *rval = (dp->d_ops->leaf_hdr_size +
                  (uint)sizeof(ents[0]) * (leafhdr.count - leafhdr.stale)) <
-                mp->m_dir_magicpct;
+                args->geo->magicpct;
         return 0;
 }
 
@@ -1336,7 +1340,7 @@ xfs_dir2_leafn_split(
         /*
          * Initialize the new leaf block.
          */
-        error = xfs_dir3_leaf_get_buf(args, xfs_dir2_da_to_db(mp, blkno),
+        error = xfs_dir3_leaf_get_buf(args, xfs_dir2_da_to_db(args->geo, blkno),
                                       &newblk->bp, XFS_DIR2_LEAFN_MAGIC);
         if (error)
                 return error;
@@ -1410,7 +1414,7 @@ xfs_dir2_leafn_toosmall(
 
         count = leafhdr.count - leafhdr.stale;
         bytes = dp->d_ops->leaf_hdr_size + count * sizeof(ents[0]);
-        if (bytes > (state->blocksize >> 1)) {
+        if (bytes > (state->args->geo->blksize >> 1)) {
                 /*
                  * Blk over 50%, don't try to join.
                  */
@@ -1463,7 +1467,8 @@ xfs_dir2_leafn_toosmall(
                  * Count bytes in the two blocks combined.
                  */
                 count = leafhdr.count - leafhdr.stale;
-                bytes = state->blocksize - (state->blocksize >> 2);
+                bytes = state->args->geo->blksize -
+                        (state->args->geo->blksize >> 2);
 
                 leaf = bp->b_addr;
                 dp->d_ops->leaf_hdr_from_disk(&hdr2, leaf);
@@ -1560,8 +1565,8 @@ xfs_dir2_leafn_unbalance(
         /* log the changes made when moving the entries */
         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_log_header(args, save_blk->bp);
+        xfs_dir3_leaf_log_header(args, drop_blk->bp);
 
         xfs_dir3_leaf_check(dp, save_blk->bp);
         xfs_dir3_leaf_check(dp, drop_blk->bp);
@@ -1587,8 +1592,6 @@ xfs_dir2_node_addname(
         state = xfs_da_state_alloc();
         state->args = args;
         state->mp = args->dp->i_mount;
-        state->blocksize = state->mp->m_dirblksize;
-        state->node_ents = state->mp->m_dir_node_ents;
         /*
          * Look up the name.  We're not supposed to find it, but
          * this gives us the insertion point.
@@ -1727,9 +1730,9 @@ xfs_dir2_node_addname_int(
         if (dbno == -1) {
                 xfs_fileoff_t   fo;             /* freespace block number */
 
-                if ((error = xfs_bmap_last_offset(tp, dp, &fo, XFS_DATA_FORK)))
+                if ((error = xfs_bmap_last_offset(dp, &fo, XFS_DATA_FORK)))
                         return error;
-                lastfbno = xfs_dir2_da_to_db(mp, (xfs_dablk_t)fo);
+                lastfbno = xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)fo);
                 fbno = ifbno;
         }
         /*
@@ -1747,7 +1750,8 @@ xfs_dir2_node_addname_int(
                          * us a freespace block to start with.
                          */
                         if (++fbno == 0)
-                                fbno = XFS_DIR2_FREE_FIRSTDB(mp);
+                                fbno = xfs_dir2_byte_to_db(args->geo,
+                                                        XFS_DIR2_FREE_OFFSET);
                         /*
                          * If it's ifbno we already looked at it.
                          */
@@ -1765,8 +1769,8 @@ xfs_dir2_node_addname_int(
                          * to avoid it.
                          */
                         error = xfs_dir2_free_try_read(tp, dp,
-                                                xfs_dir2_db_to_da(mp, fbno),
-                                                &fbp);
+                                        xfs_dir2_db_to_da(args->geo, fbno),
+                                        &fbp);
                         if (error)
                                 return error;
                         if (!fbp)
@@ -1834,10 +1838,10 @@ xfs_dir2_node_addname_int(
                  * Get the freespace block corresponding to the data block
                  * that was just allocated.
                  */
-                fbno = dp->d_ops->db_to_fdb(mp, dbno);
+                fbno = dp->d_ops->db_to_fdb(args->geo, dbno);
                 error = xfs_dir2_free_try_read(tp, dp,
-                                               xfs_dir2_db_to_da(mp, fbno),
-                                               &fbp);
+                                       xfs_dir2_db_to_da(args->geo, fbno),
+                                       &fbp);
                 if (error)
                         return error;
 
@@ -1851,12 +1855,13 @@ xfs_dir2_node_addname_int(
                         if (error)
                                 return error;
 
-                        if (unlikely(dp->d_ops->db_to_fdb(mp, dbno) != fbno)) {
+                        if (dp->d_ops->db_to_fdb(args->geo, 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)dp->d_ops->db_to_fdb(mp, dbno),
+                                        (long long)dp->d_ops->db_to_fdb(
+                                                                args->geo, dbno),
                                         (long long)dbno, (long long)fbno,
                                         (unsigned long long)ifbno, lastfbno);
                                 if (fblk) {
@@ -1877,7 +1882,7 @@ xfs_dir2_node_addname_int(
                         /*
                          * Get a buffer for the new block.
                          */
-                        error = xfs_dir3_free_get_buf(tp, dp, fbno, &fbp);
+                        error = xfs_dir3_free_get_buf(args, fbno, &fbp);
                         if (error)
                                 return error;
                         free = fbp->b_addr;
@@ -1887,8 +1892,10 @@ xfs_dir2_node_addname_int(
                         /*
                          * Remember the first slot as our empty slot.
                          */
-                        freehdr.firstdb = (fbno - XFS_DIR2_FREE_FIRSTDB(mp)) *
-                                        dp->d_ops->free_max_bests(mp);
+                        freehdr.firstdb =
+                                (fbno - xfs_dir2_byte_to_db(args->geo,
+                                                        XFS_DIR2_FREE_OFFSET)) *
+                                        dp->d_ops->free_max_bests(args->geo);
                 } else {
                         free = fbp->b_addr;
                         bests = dp->d_ops->free_bests_p(free);
@@ -1898,13 +1905,13 @@ xfs_dir2_node_addname_int(
                 /*
                  * Set the freespace block index from the data block number.
                  */
-                findex = dp->d_ops->db_to_fdindex(mp, dbno);
+                findex = dp->d_ops->db_to_fdindex(args->geo, dbno);
                 /*
                  * If it's after the end of the current entries in the
                  * freespace block, extend that table.
                  */
                 if (findex >= freehdr.nvalid) {
-                        ASSERT(findex < dp->d_ops->free_max_bests(mp));
+                        ASSERT(findex < dp->d_ops->free_max_bests(args->geo));
                         freehdr.nvalid = findex + 1;
                         /*
                          * Tag new entry so nused will go up.
@@ -1918,7 +1925,7 @@ xfs_dir2_node_addname_int(
                 if (bests[findex] == cpu_to_be16(NULLDATAOFF)) {
                         freehdr.nused++;
                         dp->d_ops->free_hdr_to_disk(fbp->b_addr, &freehdr);
-                        xfs_dir2_free_log_header(tp, dp, fbp);
+                        xfs_dir2_free_log_header(args, fbp);
                 }
                 /*
                  * Update the real value in the table.
@@ -1943,7 +1950,8 @@ xfs_dir2_node_addname_int(
                 /*
                  * Read the data block in.
                  */
-                error = xfs_dir3_data_read(tp, dp, xfs_dir2_db_to_da(mp, dbno),
+                error = xfs_dir3_data_read(tp, dp,
+                                           xfs_dir2_db_to_da(args->geo, dbno),
                                            -1, &dbp);
                 if (error)
                         return error;
@@ -1961,7 +1969,7 @@ xfs_dir2_node_addname_int(
         /*
          * Mark the first part of the unused space, inuse for us.
          */
-        xfs_dir2_data_use_free(tp, dp, dbp, dup,
+        xfs_dir2_data_use_free(args, dbp, dup,
                 (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr), length,
                 &needlog, &needscan);
         /*
@@ -1974,7 +1982,7 @@ xfs_dir2_node_addname_int(
         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, dp, dbp, dep);
+        xfs_dir2_data_log_entry(args, dbp, dep);
         /*
          * Rescan the block for bestfree if needed.
          */
@@ -1984,7 +1992,7 @@ xfs_dir2_node_addname_int(
          * Log the data block header if needed.
          */
         if (needlog)
-                xfs_dir2_data_log_header(tp, dp, dbp);
+                xfs_dir2_data_log_header(args, dbp);
         /*
          * If the freespace entry is now wrong, update it.
          */
@@ -1997,7 +2005,7 @@ xfs_dir2_node_addname_int(
          * Log the freespace entry if needed.
          */
         if (logfree)
-                xfs_dir2_free_log_bests(tp, dp, fbp, findex, findex);
+                xfs_dir2_free_log_bests(args, fbp, findex, findex);
         /*
          * Return the data block and offset in args, then drop the data block.
          */
@@ -2028,8 +2036,6 @@ xfs_dir2_node_lookup(
         state = xfs_da_state_alloc();
         state->args = args;
         state->mp = args->dp->i_mount;
-        state->blocksize = state->mp->m_dirblksize;
-        state->node_ents = state->mp->m_dir_node_ents;
         /*
          * Fill in the path to the entry in the cursor.
          */
@@ -2083,8 +2089,6 @@ xfs_dir2_node_removename(
         state = xfs_da_state_alloc();
         state->args = args;
         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. */
         error = xfs_da3_node_lookup_int(state, &rval);
@@ -2153,8 +2157,6 @@ xfs_dir2_node_replace(
         state = xfs_da_state_alloc();
         state->args = args;
         state->mp = args->dp->i_mount;
-        state->blocksize = state->mp->m_dirblksize;
-        state->node_ents = state->mp->m_dir_node_ents;
         inum = args->inumber;
         /*
          * Lookup the entry to change in the btree.
@@ -2186,15 +2188,15 @@ xfs_dir2_node_replace(
                        hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC));
                 dep = (xfs_dir2_data_entry_t *)
                       ((char *)hdr +
-                       xfs_dir2_dataptr_to_off(state->mp, be32_to_cpu(lep->address)));
+                       xfs_dir2_dataptr_to_off(args->geo,
+                                               be32_to_cpu(lep->address)));
                 ASSERT(inum != be64_to_cpu(dep->inumber));
                 /*
                  * Fill in the new inode number and log the entry.
                  */
                 dep->inumber = cpu_to_be64(inum);
                 args->dp->d_ops->data_put_ftype(dep, args->filetype);
-                xfs_dir2_data_log_entry(args->trans, args->dp,
-                                        state->extrablk.bp, dep);
+                xfs_dir2_data_log_entry(args, state->extrablk.bp, dep);
                 rval = 0;
         }
         /*
@@ -2262,9 +2264,9 @@ xfs_dir2_node_trim_free(
         /*
          * Blow the block away.
          */
-        if ((error =
-            xfs_dir2_shrink_inode(args, xfs_dir2_da_to_db(mp, (xfs_dablk_t)fo),
-                    bp))) {
+        error = xfs_dir2_shrink_inode(args,
+                        xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)fo), bp);
+        if (error) {
                 /*
                  * Can't fail with ENOSPC since that only happens with no
                  * space reservation, when breaking up an extent into two