Re: [PATCH 06/16] xfs: convert directory db conversion to xfs_da_geometry

Brian Foster
2014-05-23T19:07:08Z

On Fri, May 23, 2014 at 10:03:42AM +1000, Dave Chinner wrote:
> From: Dave Chinner <dchinner@redhat.com>
>
> Signed-off-by: Dave Chinner <dchinner@redhat.com>
> ---
> 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 8db83fc..d35b31f 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));
> }

Same byte->db->da question here, though this one looks like it's only
used for the special hardcoded offsets. Otherwise, looks good...

Reviewed-by: Brian Foster <bfoster@redhat.com>

>
> /*
> * 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 f76008c..0bd3468 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;
> @@ -736,7 +741,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
>
> _______________________________________________
> xfs mailing list
> xfs@oss.sgi.com
> http://oss.sgi.com/mailman/listinfo/xfs