xfs
[Top] [All Lists]

[PATCH 07/18] xfs: convert directory db conversion to xfs_da_geometry

To: xfs@xxxxxxxxxxx
Subject: [PATCH 07/18] xfs: convert directory db conversion to xfs_da_geometry
From: Dave Chinner <david@xxxxxxxxxxxxx>
Date: Thu, 8 May 2014 18:19:37 +1000
Delivered-to: xfs@xxxxxxxxxxx
In-reply-to: <1399537188-26509-1-git-send-email-david@xxxxxxxxxxxxx>
References: <1399537188-26509-1-git-send-email-david@xxxxxxxxxxxxx>
From: Dave Chinner <dchinner@xxxxxxxxxx>

Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
---
 fs/xfs/xfs_da_btree.h     | 22 ++++++++++------------
 fs/xfs/xfs_da_format.c    |  4 ++--
 fs/xfs/xfs_dir2.c         | 13 +++++++++----
 fs/xfs/xfs_dir2_block.c   | 15 +++++++++------
 fs/xfs/xfs_dir2_data.c    |  3 ++-
 fs/xfs/xfs_dir2_leaf.c    | 30 +++++++++++++++++-------------
 fs/xfs/xfs_dir2_node.c    | 27 ++++++++++++++++-----------
 fs/xfs/xfs_dir2_readdir.c | 45 ++++++++++++++++++++++++++-------------------
 fs/xfs/xfs_dir2_sf.c      |  4 ++--
 9 files changed, 93 insertions(+), 70 deletions(-)

diff --git a/fs/xfs/xfs_da_btree.h b/fs/xfs/xfs_da_btree.h
index 0c625f6..ce2580c 100644
--- a/fs/xfs/xfs_da_btree.h
+++ b/fs/xfs/xfs_da_btree.h
@@ -185,19 +185,18 @@ xfs_dir2_byte_to_dataptr(xfs_dir2_off_t by)
  * Convert byte in space to (DB) block
  */
 static inline xfs_dir2_db_t
-xfs_dir2_byte_to_db(struct xfs_mount *mp, xfs_dir2_off_t by)
+xfs_dir2_byte_to_db(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
 {
-       return (xfs_dir2_db_t)
-               (by >> (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog));
+       return (xfs_dir2_db_t)(by >> geo->blklog);
 }
 
 /*
  * Convert dataptr to a block number
  */
 static inline xfs_dir2_db_t
-xfs_dir2_dataptr_to_db(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
+xfs_dir2_dataptr_to_db(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp)
 {
-       return xfs_dir2_byte_to_db(mp, xfs_dir2_dataptr_to_byte(dp));
+       return xfs_dir2_byte_to_db(geo, xfs_dir2_dataptr_to_byte(dp));
 }
 
 /*
@@ -213,9 +212,9 @@ xfs_dir2_byte_to_off(struct xfs_da_geometry *geo, 
xfs_dir2_off_t by)
  * Convert dataptr to a byte offset in a block
  */
 static inline xfs_dir2_data_aoff_t
-xfs_dir2_dataptr_to_off(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
+xfs_dir2_dataptr_to_off(struct xfs_da_geometry *geo, xfs_dir2_dataptr_t dp)
 {
-       return xfs_dir2_byte_to_off(mp->m_dir_geo, 
xfs_dir2_dataptr_to_byte(dp));
+       return xfs_dir2_byte_to_off(geo, xfs_dir2_dataptr_to_byte(dp));
 }
 
 /*
@@ -241,20 +240,19 @@ xfs_dir2_db_to_da(struct xfs_da_geometry *geo, 
xfs_dir2_db_t db)
  * Convert byte in space to (DA) block
  */
 static inline xfs_dablk_t
-xfs_dir2_byte_to_da(struct xfs_mount *mp, xfs_dir2_off_t by)
+xfs_dir2_byte_to_da(struct xfs_da_geometry *geo, xfs_dir2_off_t by)
 {
-       return xfs_dir2_db_to_da(mp->m_dir_geo, xfs_dir2_byte_to_db(mp, by));
+       return xfs_dir2_db_to_da(geo, xfs_dir2_byte_to_db(geo, by));
 }
 
 /*
  * Convert block and offset to dataptr
  */
 static inline xfs_dir2_dataptr_t
-xfs_dir2_db_off_to_dataptr(struct xfs_mount *mp, xfs_dir2_db_t db,
+xfs_dir2_db_off_to_dataptr(struct xfs_da_geometry *geo, xfs_dir2_db_t db,
                           xfs_dir2_data_aoff_t o)
 {
-       return xfs_dir2_byte_to_dataptr(
-                               xfs_dir2_db_off_to_byte(mp->m_dir_geo, db, o));
+       return xfs_dir2_byte_to_dataptr(xfs_dir2_db_off_to_byte(geo, db, o));
 }
 
 /*
diff --git a/fs/xfs/xfs_da_format.c b/fs/xfs/xfs_da_format.c
index 313eea3..c782f2c 100644
--- a/fs/xfs/xfs_da_format.c
+++ b/fs/xfs/xfs_da_format.c
@@ -610,7 +610,7 @@ xfs_dir2_free_bests_p(struct xfs_dir2_free *free)
 static xfs_dir2_db_t
 xfs_dir2_db_to_fdb(struct xfs_mount *mp, xfs_dir2_db_t db)
 {
-       return xfs_dir2_byte_to_db(mp, XFS_DIR2_FREE_OFFSET) +
+       return xfs_dir2_byte_to_db(mp->m_dir_geo, XFS_DIR2_FREE_OFFSET) +
                        (db / xfs_dir2_free_max_bests(mp));
 }
 
@@ -642,7 +642,7 @@ xfs_dir3_free_bests_p(struct xfs_dir2_free *free)
 static xfs_dir2_db_t
 xfs_dir3_db_to_fdb(struct xfs_mount *mp, xfs_dir2_db_t db)
 {
-       return xfs_dir2_byte_to_db(mp, XFS_DIR2_FREE_OFFSET) +
+       return xfs_dir2_byte_to_db(mp->m_dir_geo, XFS_DIR2_FREE_OFFSET) +
                        (db / xfs_dir3_free_max_bests(mp));
 }
 
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index 725c95d..61011b7 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -117,9 +117,14 @@ xfs_da_mount(
        dageo->fsblog = mp->m_sb.sb_blocklog;
        dageo->blksize = 1 << dageo->blklog;
        dageo->fsbcount = 1 << mp->m_sb.sb_dirblklog;
-       dageo->datablk = xfs_dir2_byte_to_da(mp, XFS_DIR2_DATA_OFFSET);
-       dageo->leafblk = xfs_dir2_byte_to_da(mp, XFS_DIR2_LEAF_OFFSET);
-       dageo->freeblk = xfs_dir2_byte_to_da(mp, XFS_DIR2_FREE_OFFSET);
+
+       /*
+        * Now we've set up the block conversion variables, we can calculate the
+        * segment block constants using the geometry structure.
+        */
+       dageo->datablk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_DATA_OFFSET);
+       dageo->leafblk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_LEAF_OFFSET);
+       dageo->freeblk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_FREE_OFFSET);
        dageo->node_ents = (dageo->blksize - nodehdr_size) /
                                (uint)sizeof(xfs_da_node_entry_t);
        dageo->magicpct = (dageo->blksize * 37) / 100;
@@ -725,7 +730,7 @@ xfs_dir2_shrink_inode(
        /*
         * If it's not a data block, we're done.
         */
-       if (db >= xfs_dir2_byte_to_db(mp, XFS_DIR2_LEAF_OFFSET))
+       if (db >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET))
                return 0;
        /*
         * If the block isn't the last one in the directory, we're done.
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c
index dd9d005..bc08216 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/xfs_dir2_block.c
@@ -639,7 +639,8 @@ xfs_dir2_block_lookup(
         * Get the offset from the leaf entry, to point to the data.
         */
        dep = (xfs_dir2_data_entry_t *)((char *)hdr +
-               xfs_dir2_dataptr_to_off(mp, be32_to_cpu(blp[ent].address)));
+                       xfs_dir2_dataptr_to_off(args->geo,
+                                               be32_to_cpu(blp[ent].address)));
        /*
         * Fill in inode number, CI name if appropriate, release the block.
         */
@@ -723,7 +724,7 @@ xfs_dir2_block_lookup_int(
                 * Get pointer to the entry from the leaf.
                 */
                dep = (xfs_dir2_data_entry_t *)
-                       ((char *)hdr + xfs_dir2_dataptr_to_off(mp, addr));
+                       ((char *)hdr + xfs_dir2_dataptr_to_off(args->geo, 
addr));
                /*
                 * Compare name and if it's an exact match, return the index
                 * and buffer. If it's the first case-insensitive match, store
@@ -795,8 +796,9 @@ xfs_dir2_block_removename(
        /*
         * Point to the data entry using the leaf entry.
         */
-       dep = (xfs_dir2_data_entry_t *)
-             ((char *)hdr + xfs_dir2_dataptr_to_off(mp, 
be32_to_cpu(blp[ent].address)));
+       dep = (xfs_dir2_data_entry_t *)((char *)hdr +
+                       xfs_dir2_dataptr_to_off(args->geo,
+                                               be32_to_cpu(blp[ent].address)));
        /*
         * Mark the data entry's space free.
         */
@@ -870,8 +872,9 @@ xfs_dir2_block_replace(
        /*
         * Point to the data entry we need to change.
         */
-       dep = (xfs_dir2_data_entry_t *)
-             ((char *)hdr + xfs_dir2_dataptr_to_off(mp, 
be32_to_cpu(blp[ent].address)));
+       dep = (xfs_dir2_data_entry_t *)((char *)hdr +
+                       xfs_dir2_dataptr_to_off(args->geo,
+                                               be32_to_cpu(blp[ent].address)));
        ASSERT(be64_to_cpu(dep->inumber) != args->inumber);
        /*
         * Change the inode number to the new value.
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c
index 890c940..d355ec7 100644
--- a/fs/xfs/xfs_dir2_data.c
+++ b/fs/xfs/xfs_dir2_data.c
@@ -172,7 +172,8 @@ __xfs_dir3_data_check(
                lastfree = 0;
                if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
                    hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
-                       addr = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
+                       addr = xfs_dir2_db_off_to_dataptr(mp->m_dir_geo,
+                               mp->m_dirdatablk,
                                (xfs_dir2_data_aoff_t)
                                ((char *)dep - (char *)hdr));
                        name.name = dep->name;
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index 046ba4a..2b3ddd0 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -347,8 +347,8 @@ xfs_dir3_leaf_get_buf(
        int                     error;
 
        ASSERT(magic == XFS_DIR2_LEAF1_MAGIC || magic == XFS_DIR2_LEAFN_MAGIC);
-       ASSERT(bno >= xfs_dir2_byte_to_db(mp, XFS_DIR2_LEAF_OFFSET) &&
-              bno < xfs_dir2_byte_to_db(mp, XFS_DIR2_FREE_OFFSET));
+       ASSERT(bno >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET) &&
+              bno < xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET));
 
        error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, bno),
                               -1, &bp, XFS_DATA_FORK);
@@ -404,7 +404,7 @@ xfs_dir2_block_to_leaf(
                return error;
        }
        ldb = xfs_dir2_da_to_db(args->geo, blkno);
-       ASSERT(ldb == xfs_dir2_byte_to_db(mp, XFS_DIR2_LEAF_OFFSET));
+       ASSERT(ldb == xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET));
        /*
         * Initialize the leaf block, get a buffer for it.
         */
@@ -670,7 +670,7 @@ xfs_dir2_leaf_addname(
             index++, lep++) {
                if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR)
                        continue;
-               i = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
+               i = xfs_dir2_dataptr_to_db(args->geo, 
be32_to_cpu(lep->address));
                ASSERT(i < be32_to_cpu(ltp->bestcount));
                ASSERT(bestsp[i] != cpu_to_be16(NULLDATAOFF));
                if (be16_to_cpu(bestsp[i]) >= length) {
@@ -889,7 +889,8 @@ xfs_dir2_leaf_addname(
         * Fill in the new leaf entry.
         */
        lep->hashval = cpu_to_be32(args->hashval);
-       lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(mp, use_block,
+       lep->address = cpu_to_be32(
+                               xfs_dir2_db_off_to_dataptr(args->geo, use_block,
                                be16_to_cpu(*tagp)));
        /*
         * Log the leaf fields and give up the buffers.
@@ -1185,7 +1186,7 @@ xfs_dir2_leaf_lookup(
         */
        dep = (xfs_dir2_data_entry_t *)
              ((char *)dbp->b_addr +
-              xfs_dir2_dataptr_to_off(dp->i_mount, be32_to_cpu(lep->address)));
+              xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address)));
        /*
         * Return the found inode number & CI name if appropriate
         */
@@ -1260,7 +1261,8 @@ xfs_dir2_leaf_lookup_int(
                /*
                 * Get the new data block number.
                 */
-               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));
                /*
                 * If it's not the same as the old data block number,
                 * need to pitch the old one and read the new one.
@@ -1281,7 +1283,8 @@ xfs_dir2_leaf_lookup_int(
                 * Point to the data entry.
                 */
                dep = (xfs_dir2_data_entry_t *)((char *)dbp->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 name and if it's an exact match, return the index
                 * and buffer. If it's the first case-insensitive match, store
@@ -1380,9 +1383,9 @@ xfs_dir2_leaf_removename(
         * Point to the leaf entry, use that to point to the data entry.
         */
        lep = &ents[index];
-       db = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
-       dep = (xfs_dir2_data_entry_t *)
-             ((char *)hdr + xfs_dir2_dataptr_to_off(mp, 
be32_to_cpu(lep->address)));
+       db = xfs_dir2_dataptr_to_db(args->geo, be32_to_cpu(lep->address));
+       dep = (xfs_dir2_data_entry_t *)((char *)hdr +
+               xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address)));
        needscan = needlog = 0;
        oldbest = be16_to_cpu(bf[0].length);
        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
@@ -1515,7 +1518,7 @@ xfs_dir2_leaf_replace(
         */
        dep = (xfs_dir2_data_entry_t *)
              ((char *)dbp->b_addr +
-              xfs_dir2_dataptr_to_off(dp->i_mount, be32_to_cpu(lep->address)));
+              xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address)));
        ASSERT(args->inumber != be64_to_cpu(dep->inumber));
        /*
         * Put the new inode number in, log it.
@@ -1800,7 +1803,8 @@ xfs_dir2_node_to_leaf(
         * Get rid of the freespace block.
         */
        error = xfs_dir2_shrink_inode(args,
-                       xfs_dir2_byte_to_db(mp, XFS_DIR2_FREE_OFFSET), fbp);
+                       xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET),
+                       fbp);
        if (error) {
                /*
                 * This can't fail here because it can only happen when
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index 3b70d56..89777bf 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -316,7 +316,7 @@ xfs_dir2_leaf_to_node(
        if ((error = xfs_dir2_grow_inode(args, XFS_DIR2_FREE_SPACE, &fdb))) {
                return error;
        }
-       ASSERT(fdb == xfs_dir2_byte_to_db(mp, XFS_DIR2_FREE_OFFSET));
+       ASSERT(fdb == xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET));
        /*
         * Get the buffer for the new freespace block.
         */
@@ -451,7 +451,7 @@ 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);
@@ -577,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
@@ -723,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.
@@ -761,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
@@ -1196,9 +1199,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);
 
        /*
@@ -1260,7 +1263,8 @@ 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_byte_to_db(mp, 
XFS_DIR2_FREE_OFFSET)));
+                       (fdb - xfs_dir2_byte_to_db(args->geo,
+                                                  XFS_DIR2_FREE_OFFSET)));
        }
 #endif
                /*
@@ -1751,7 +1755,7 @@ xfs_dir2_node_addname_int(
                         * us a freespace block to start with.
                         */
                        if (++fbno == 0)
-                               fbno = xfs_dir2_byte_to_db(mp,
+                               fbno = xfs_dir2_byte_to_db(args->geo,
                                                        XFS_DIR2_FREE_OFFSET);
                        /*
                         * If it's ifbno we already looked at it.
@@ -1893,7 +1897,7 @@ xfs_dir2_node_addname_int(
                         * Remember the first slot as our empty slot.
                         */
                        freehdr.firstdb =
-                               (fbno - xfs_dir2_byte_to_db(mp,
+                               (fbno - xfs_dir2_byte_to_db(args->geo,
                                                        XFS_DIR2_FREE_OFFSET)) *
                                        dp->d_ops->free_max_bests(mp);
                } else {
@@ -2194,7 +2198,8 @@ 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.
diff --git a/fs/xfs/xfs_dir2_readdir.c b/fs/xfs/xfs_dir2_readdir.c
index 57e9247..c2a6387 100644
--- a/fs/xfs/xfs_dir2_readdir.c
+++ b/fs/xfs/xfs_dir2_readdir.c
@@ -87,8 +87,10 @@ xfs_dir2_sf_getdents(
        xfs_dir2_dataptr_t      dot_offset;
        xfs_dir2_dataptr_t      dotdot_offset;
        xfs_ino_t               ino;
+       struct xfs_da_geometry  *geo;
 
        mp = dp->i_mount;
+       geo = mp->m_dir_geo;
 
        ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
        /*
@@ -109,7 +111,7 @@ xfs_dir2_sf_getdents(
        /*
         * If the block number in the offset is out of range, we're done.
         */
-       if (xfs_dir2_dataptr_to_db(mp, ctx->pos) > mp->m_dirdatablk)
+       if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > mp->m_dirdatablk)
                return 0;
 
        /*
@@ -118,9 +120,9 @@ xfs_dir2_sf_getdents(
         * XXX(hch): the second argument is sometimes 0 and sometimes
         * mp->m_dirdatablk.
         */
-       dot_offset = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
+       dot_offset = xfs_dir2_db_off_to_dataptr(geo, mp->m_dirdatablk,
                                                dp->d_ops->data_dot_offset);
-       dotdot_offset = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
+       dotdot_offset = xfs_dir2_db_off_to_dataptr(geo, mp->m_dirdatablk,
                                                dp->d_ops->data_dotdot_offset);
 
        /*
@@ -149,7 +151,7 @@ xfs_dir2_sf_getdents(
        for (i = 0; i < sfp->count; i++) {
                __uint8_t filetype;
 
-               off = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
+               off = xfs_dir2_db_off_to_dataptr(geo, mp->m_dirdatablk,
                                xfs_dir2_sf_get_offset(sfep));
 
                if (ctx->pos > off) {
@@ -166,7 +168,7 @@ xfs_dir2_sf_getdents(
                sfep = dp->d_ops->sf_nextentry(sfp, sfep);
        }
 
-       ctx->pos = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0) &
+       ctx->pos = xfs_dir2_db_off_to_dataptr(geo, mp->m_dirdatablk + 1, 0) &
                        0x7fffffff;
        return 0;
 }
@@ -190,12 +192,14 @@ xfs_dir2_block_getdents(
        char                    *ptr;           /* current data entry */
        int                     wantoff;        /* starting block offset */
        xfs_off_t               cook;
+       struct xfs_da_geometry  *geo;
 
        mp = dp->i_mount;
+       geo = mp->m_dir_geo;
        /*
         * If the block number in the offset is out of range, we're done.
         */
-       if (xfs_dir2_dataptr_to_db(mp, ctx->pos) > mp->m_dirdatablk)
+       if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > mp->m_dirdatablk)
                return 0;
 
        error = xfs_dir3_block_read(NULL, dp, &bp);
@@ -206,7 +210,7 @@ xfs_dir2_block_getdents(
         * Extract the byte offset we start at from the seek pointer.
         * We'll skip entries before this.
         */
-       wantoff = xfs_dir2_dataptr_to_off(mp, ctx->pos);
+       wantoff = xfs_dir2_dataptr_to_off(geo, ctx->pos);
        hdr = bp->b_addr;
        xfs_dir3_data_check(dp, bp);
        /*
@@ -244,7 +248,7 @@ xfs_dir2_block_getdents(
                if ((char *)dep - (char *)hdr < wantoff)
                        continue;
 
-               cook = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
+               cook = xfs_dir2_db_off_to_dataptr(geo, mp->m_dirdatablk,
                                            (char *)dep - (char *)hdr);
 
                ctx->pos = cook & 0x7fffffff;
@@ -264,7 +268,7 @@ xfs_dir2_block_getdents(
         * Reached the end of the block.
         * Set the offset to a non-existent block 1 and return.
         */
-       ctx->pos = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0) &
+       ctx->pos = xfs_dir2_db_off_to_dataptr(geo, mp->m_dirdatablk + 1, 0) &
                        0x7fffffff;
        xfs_trans_brelse(NULL, bp);
        return 0;
@@ -300,6 +304,7 @@ xfs_dir2_leaf_readbuf(
        int                     length;
        int                     i;
        int                     j;
+       struct xfs_da_geometry  *geo = mp->m_dir_geo;
 
        /*
         * If we have a buffer, we need to release it and
@@ -342,14 +347,14 @@ xfs_dir2_leaf_readbuf(
         * run out of data blocks, get some more mappings.
         */
        if (1 + mip->ra_want > mip->map_blocks &&
-           mip->map_off < xfs_dir2_byte_to_da(mp, XFS_DIR2_LEAF_OFFSET)) {
+           mip->map_off < xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET)) {
                /*
                 * Get more bmaps, fill in after the ones
                 * we already have in the table.
                 */
                mip->nmap = mip->map_size - mip->map_valid;
                error = xfs_bmapi_read(dp, mip->map_off,
-                               xfs_dir2_byte_to_da(mp, XFS_DIR2_LEAF_OFFSET) -
+                               xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET) -
                                                                mip->map_off,
                                &map[mip->map_valid], &mip->nmap, 0);
 
@@ -370,7 +375,7 @@ xfs_dir2_leaf_readbuf(
                        i = mip->map_valid + mip->nmap - 1;
                        mip->map_off = map[i].br_startoff + 
map[i].br_blockcount;
                } else
-                       mip->map_off = xfs_dir2_byte_to_da(mp,
+                       mip->map_off = xfs_dir2_byte_to_da(geo,
                                                        XFS_DIR2_LEAF_OFFSET);
 
                /*
@@ -396,14 +401,14 @@ xfs_dir2_leaf_readbuf(
         * No valid mappings, so no more data blocks.
         */
        if (!mip->map_valid) {
-               *curoff = xfs_dir2_da_to_byte(mp->m_dir_geo, mip->map_off);
+               *curoff = xfs_dir2_da_to_byte(geo, mip->map_off);
                goto out;
        }
 
        /*
         * Read the directory block starting at the first mapping.
         */
-       mip->curdb = xfs_dir2_da_to_db(mp->m_dir_geo, map->br_startoff);
+       mip->curdb = xfs_dir2_da_to_db(geo, map->br_startoff);
        error = xfs_dir3_data_read(NULL, dp, map->br_startoff,
                        map->br_blockcount >= mp->m_dirblkfsbs ?
                            XFS_FSB_TO_DADDR(mp, map->br_startblock) : -1, &bp);
@@ -504,6 +509,7 @@ xfs_dir2_leaf_getdents(
        xfs_dir2_off_t          newoff;         /* new curoff after new blk */
        char                    *ptr = NULL;    /* pointer to current data */
        struct xfs_dir2_leaf_map_info *map_info;
+       struct xfs_da_geometry  *geo;
 
        /*
         * If the offset is at or past the largest allowed value,
@@ -513,6 +519,7 @@ xfs_dir2_leaf_getdents(
                return 0;
 
        mp = dp->i_mount;
+       geo = mp->m_dir_geo;
 
        /*
         * Set up to bmap a number of blocks based on the caller's
@@ -536,8 +543,8 @@ xfs_dir2_leaf_getdents(
         * Force this conversion through db so we truncate the offset
         * down to get the start of the data block.
         */
-       map_info->map_off = xfs_dir2_db_to_da(mp->m_dir_geo,
-                                             xfs_dir2_byte_to_db(mp, curoff));
+       map_info->map_off = xfs_dir2_db_to_da(geo,
+                                             xfs_dir2_byte_to_db(geo, curoff));
 
        /*
         * Loop over directory entries until we reach the end offset.
@@ -571,7 +578,7 @@ xfs_dir2_leaf_getdents(
                         * Make sure we're in the right block.
                         */
                        else if (curoff > newoff)
-                               ASSERT(xfs_dir2_byte_to_db(mp, curoff) ==
+                               ASSERT(xfs_dir2_byte_to_db(geo, curoff) ==
                                       map_info->curdb);
                        hdr = bp->b_addr;
                        xfs_dir3_data_check(dp, bp);
@@ -608,8 +615,8 @@ xfs_dir2_leaf_getdents(
                                 * Now set our real offset.
                                 */
                                curoff =
-                                       xfs_dir2_db_off_to_byte(mp->m_dir_geo,
-                                           xfs_dir2_byte_to_db(mp, curoff),
+                                       xfs_dir2_db_off_to_byte(geo,
+                                           xfs_dir2_byte_to_db(geo, curoff),
                                            (char *)ptr - (char *)hdr);
                                if (ptr >= (char *)hdr + mp->m_dirblksize) {
                                        continue;
diff --git a/fs/xfs/xfs_dir2_sf.c b/fs/xfs/xfs_dir2_sf.c
index 7aab8ec..4dc4193 100644
--- a/fs/xfs/xfs_dir2_sf.c
+++ b/fs/xfs/xfs_dir2_sf.c
@@ -104,8 +104,8 @@ xfs_dir2_block_sfsize(
                /*
                 * Calculate the pointer to the entry at hand.
                 */
-               dep = (xfs_dir2_data_entry_t *)
-                     ((char *)hdr + xfs_dir2_dataptr_to_off(mp, addr));
+               dep = (xfs_dir2_data_entry_t *)((char *)hdr +
+                               xfs_dir2_dataptr_to_off(mp->m_dir_geo, addr));
                /*
                 * Detect . and .., so we can special-case them.
                 * . is not included in sf directories.
-- 
1.9.0

<Prev in Thread] Current Thread [Next in Thread>