xfs: move the dir2 data block fixed offsets to struct xfs_da_geometry

Source kernel commit: d73e1cee8add0d18d5401b81db2351b9e8af899a

Move the data block fixed offsets towards our structure for dir/attr
geometry parameters.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

diff --git a/db/check.c b/db/check.c
index 3d370ba96044de37407c65c6a616f181b44828ea..4b162def026bc8dfbcdad431f04a6283aeb3db29 100644 (file)
--- a/db/check.c
+++ b/db/check.c
@@ -2316,7 +2316,7 @@ process_data_dir_v2(
        }
        db = xfs_dir2_da_to_db(mp->m_dir_geo, dabno);
        bf = M_DIROPS(mp)->data_bestfree_p(data);
-       ptr = (char *)data + mp->m_dir_inode_ops->data_entry_offset;
+       ptr = (char *)data + mp->m_dir_geo->data_entry_offset;
        if (be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC ||
            be32_to_cpu(block->magic) == XFS_DIR3_BLOCK_MAGIC) {
                btp = xfs_dir2_block_tail_p(mp->m_dir_geo, block);
@@ -3626,7 +3626,7 @@ process_sf_dir_v2(
                dbprintf(_("dir %lld entry . %lld\n"), id->ino, id->ino);
        (*dot)++;
        sfe = xfs_dir2_sf_firstentry(sf);
-       offset = M_DIROPS(mp)->data_first_offset;
+       offset = mp->m_dir_geo->data_first_offset;
        for (i = sf->count - 1, i8 = 0; i >= 0; i--) {
                if ((intptr_t)sfe +
                    libxfs_dir2_sf_entsize(mp, sf, sfe->namelen) -

diff --git a/db/dir2.c b/db/dir2.c
index 80f8991f498807ead72a7526efe4754e9309c40b..503dcdfeceea8360355ba1a7477a86a9ed2af4a3 100644 (file)
--- a/db/dir2.c
+++ b/db/dir2.c
@@ -350,7 +350,7 @@ dir2_block_u_count(
 
        btp = xfs_dir2_block_tail_p(mp->m_dir_geo, block);
        return __dir2_data_entries_count(
-                       (char *)obj + mp->m_dir_inode_ops->data_entry_offset,
+                       (char *)obj + mp->m_dir_geo->data_entry_offset,
                        (char *)xfs_dir2_block_leaf_p(btp));
 }
 
@@ -369,7 +369,7 @@ dir2_block_u_offset(
               be32_to_cpu(block->magic) == XFS_DIR3_BLOCK_MAGIC);
        btp = xfs_dir2_block_tail_p(mp->m_dir_geo, block);
        ptr = __dir2_data_entry_offset(
-                       (char *)obj + mp->m_dir_inode_ops->data_entry_offset,
+                       (char *)obj + mp->m_dir_geo->data_entry_offset,
                        (char *)xfs_dir2_block_leaf_p(btp), idx);
        return bitize((int)(ptr - (char *)block));
 }
@@ -547,7 +547,7 @@ dir2_data_u_count(
                return 0;
 
        return __dir2_data_entries_count(
-                               (char *)data + mp->m_dir_inode_ops->data_entry_offset,
+                               (char *)data + mp->m_dir_geo->data_entry_offset,
                                (char *)data + mp->m_dir_geo->blksize);
 }
 
@@ -564,7 +564,7 @@ dir2_data_u_offset(
        ASSERT(be32_to_cpu(data->magic) == XFS_DIR2_DATA_MAGIC ||
               be32_to_cpu(data->magic) == XFS_DIR3_DATA_MAGIC);
        ptr = __dir2_data_entry_offset(
-                               (char *)data + mp->m_dir_inode_ops->data_entry_offset,
+                               (char *)data + mp->m_dir_geo->data_entry_offset,
                                (char *)data + mp->m_dir_geo->blksize, idx);
        return bitize((int)(ptr - (char *)data));
 }

diff --git a/db/metadump.c b/db/metadump.c
index 104477920d01b659344b8491b197fe2723ea580b..d542762e857fc98ce6bf5198aa29b9a2b83c06e0 100644 (file)
--- a/db/metadump.c
+++ b/db/metadump.c
@@ -1556,7 +1556,7 @@ process_dir_data_block(
                return;
        }
 
-       dir_offset = mp->m_dir_inode_ops->data_entry_offset;
+       dir_offset = mp->m_dir_geo->data_entry_offset;
        ptr = block + dir_offset;
        endptr = block + mp->m_dir_geo->blksize;
 

diff --git a/libxfs/xfs_da_btree.h b/libxfs/xfs_da_btree.h
index 40110acf9f8a760165c45c4c41a301692e630e4a..4ac2cc87c28f57aa11e1784f771c22dc3b4feba0 100644 (file)
--- a/libxfs/xfs_da_btree.h
+++ b/libxfs/xfs_da_btree.h
@@ -32,6 +32,9 @@ struct xfs_da_geometry {
        unsigned int    free_hdr_size;  /* dir2 free header size */
        unsigned int    free_max_bests; /* # of bests entries in dir2 free */
        xfs_dablk_t     freeblk;        /* blockno of free data v2 */
+
+       xfs_dir2_data_aoff_t data_first_offset;
+       size_t          data_entry_offset;
 };
 
 /*========================================================================

diff --git a/libxfs/xfs_da_format.c b/libxfs/xfs_da_format.c
index a731dc97cbbab2a026a5b18c4263731cb909b41d..e5e1947f2ab97b5a4f37347fc4f077443673f6d7 100644 (file)
--- a/libxfs/xfs_da_format.c
+++ b/libxfs/xfs_da_format.c
@@ -105,33 +105,18 @@ static const struct xfs_dir_ops xfs_dir2_ops = {
        .data_get_ftype = xfs_dir2_data_get_ftype,
        .data_put_ftype = xfs_dir2_data_put_ftype,
        .data_bestfree_p = xfs_dir2_data_bestfree_p,
-
-       .data_first_offset =  sizeof(struct xfs_dir2_data_hdr) +
-                               XFS_DIR2_DATA_ENTSIZE(1) +
-                               XFS_DIR2_DATA_ENTSIZE(2),
-       .data_entry_offset = sizeof(struct xfs_dir2_data_hdr),
 };
 
 static const struct xfs_dir_ops xfs_dir2_ftype_ops = {
        .data_get_ftype = xfs_dir3_data_get_ftype,
        .data_put_ftype = xfs_dir3_data_put_ftype,
        .data_bestfree_p = xfs_dir2_data_bestfree_p,
-
-       .data_first_offset =  sizeof(struct xfs_dir2_data_hdr) +
-                               XFS_DIR3_DATA_ENTSIZE(1) +
-                               XFS_DIR3_DATA_ENTSIZE(2),
-       .data_entry_offset = sizeof(struct xfs_dir2_data_hdr),
 };
 
 static const struct xfs_dir_ops xfs_dir3_ops = {
        .data_get_ftype = xfs_dir3_data_get_ftype,
        .data_put_ftype = xfs_dir3_data_put_ftype,
        .data_bestfree_p = xfs_dir3_data_bestfree_p,
-
-       .data_first_offset =  sizeof(struct xfs_dir3_data_hdr) +
-                               XFS_DIR3_DATA_ENTSIZE(1) +
-                               XFS_DIR3_DATA_ENTSIZE(2),
-       .data_entry_offset = sizeof(struct xfs_dir3_data_hdr),
 };
 
 /*

diff --git a/libxfs/xfs_dir2.c b/libxfs/xfs_dir2.c
index c25f31cb9abbc819054025f56e6171e264b4e572..4e30d8770bf69cdf8009a56cde14f0e379dbce2b 100644 (file)
--- a/libxfs/xfs_dir2.c
+++ b/libxfs/xfs_dir2.c
@@ -124,16 +124,24 @@ xfs_da_mount(
                dageo->node_hdr_size = sizeof(struct xfs_da3_node_hdr);
                dageo->leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr);
                dageo->free_hdr_size = sizeof(struct xfs_dir3_free_hdr);
+               dageo->data_entry_offset =
+                               sizeof(struct xfs_dir3_data_hdr);
        } else {
                dageo->node_hdr_size = sizeof(struct xfs_da_node_hdr);
                dageo->leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr);
                dageo->free_hdr_size = sizeof(struct xfs_dir2_free_hdr);
+               dageo->data_entry_offset =
+                               sizeof(struct xfs_dir2_data_hdr);
        }
        dageo->leaf_max_ents = (dageo->blksize - dageo->leaf_hdr_size) /
                        sizeof(struct xfs_dir2_leaf_entry);
        dageo->free_max_bests = (dageo->blksize - dageo->free_hdr_size) /
                        sizeof(xfs_dir2_data_off_t);
 
+       dageo->data_first_offset = dageo->data_entry_offset +
+                       xfs_dir2_data_entsize(mp, 1) +
+                       xfs_dir2_data_entsize(mp, 2);
+
        /*
         * Now we've set up the block conversion variables, we can calculate the
         * segment block constants using the geometry structure.

diff --git a/libxfs/xfs_dir2.h b/libxfs/xfs_dir2.h
index 3f46954e93700576bdb0e7c8f52f4f03ffe018a1..830c70a20761fb334a4aa7b433098a83c066d902 100644 (file)
--- a/libxfs/xfs_dir2.h
+++ b/libxfs/xfs_dir2.h
@@ -37,9 +37,6 @@ struct xfs_dir_ops {
                                uint8_t ftype);
        struct xfs_dir2_data_free *
                (*data_bestfree_p)(struct xfs_dir2_data_hdr *hdr);
-
-       xfs_dir2_data_aoff_t data_first_offset;
-       size_t  data_entry_offset;
 };
 
 extern const struct xfs_dir_ops *

diff --git a/libxfs/xfs_dir2_block.c b/libxfs/xfs_dir2_block.c
index 8a1739b263824bd6df308fc7c2fe06a767a93fa9..723c44520d8563a38081c0cb00d4e45d247c5bad 100644 (file)
--- a/libxfs/xfs_dir2_block.c
+++ b/libxfs/xfs_dir2_block.c
@@ -934,7 +934,7 @@ xfs_dir2_leaf_to_block(
        while (dp->i_d.di_size > args->geo->blksize) {
                int hdrsz;
 
-               hdrsz = dp->d_ops->data_entry_offset;
+               hdrsz = args->geo->data_entry_offset;
                bestsp = xfs_dir2_leaf_bests_p(ltp);
                if (be16_to_cpu(bestsp[be32_to_cpu(ltp->bestcount) - 1]) ==
                                            args->geo->blksize - hdrsz) {
@@ -1042,6 +1042,7 @@ xfs_dir2_sf_to_block(
        struct xfs_inode        *dp = args->dp;
        struct xfs_mount        *mp = dp->i_mount;
        struct xfs_ifork        *ifp = XFS_IFORK_PTR(dp, XFS_DATA_FORK);
+       struct xfs_da_geometry  *geo = args->geo;
        xfs_dir2_db_t           blkno;          /* dir-relative block # (0) */
        xfs_dir2_data_hdr_t     *hdr;           /* block header */
        xfs_dir2_leaf_entry_t   *blp;           /* block leaf entries */
@@ -1056,7 +1057,7 @@ xfs_dir2_sf_to_block(
        int                     needlog;        /* need to log block header */
        int                     needscan;       /* need to scan block freespc */
        int                     newoffset;      /* offset from current entry */
-       unsigned int            offset = dp->d_ops->data_entry_offset;
+       unsigned int            offset = geo->data_entry_offset;
        xfs_dir2_sf_entry_t     *sfep;          /* sf entry pointer */
        xfs_dir2_sf_hdr_t       *oldsfp;        /* old shortform header  */
        xfs_dir2_sf_hdr_t       *sfp;           /* shortform header  */

diff --git a/libxfs/xfs_dir2_data.c b/libxfs/xfs_dir2_data.c
index ea493c4947642a00af44cfc4ee9f85cd56bbe278..8e1af963e866afd151365645ef53c0ecced4ee1d 100644 (file)
--- a/libxfs/xfs_dir2_data.c
+++ b/libxfs/xfs_dir2_data.c
@@ -42,11 +42,10 @@ xfs_dir2_data_entry_tag_p(
  */
 static inline unsigned int
 xfs_dir2_data_max_leaf_entries(
-       const struct xfs_dir_ops        *ops,
        struct xfs_da_geometry          *geo)
 {
        return (geo->blksize - sizeof(struct xfs_dir2_block_tail) -
-               ops->data_entry_offset) /
+               geo->data_entry_offset) /
                        sizeof(struct xfs_dir2_leaf_entry);
 }
 
@@ -94,7 +93,7 @@ __xfs_dir3_data_check(
                return __this_address;
 
        hdr = bp->b_addr;
-       offset = ops->data_entry_offset;
+       offset = geo->data_entry_offset;
 
        switch (hdr->magic) {
        case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
@@ -103,7 +102,7 @@ __xfs_dir3_data_check(
                lep = xfs_dir2_block_leaf_p(btp);
 
                if (be32_to_cpu(btp->count) >=
-                   xfs_dir2_data_max_leaf_entries(ops, geo))
+                   xfs_dir2_data_max_leaf_entries(geo))
                        return __this_address;
                break;
        case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
@@ -583,9 +582,10 @@ xfs_dir2_data_freescan_int(
        struct xfs_dir2_data_hdr        *hdr,
        int                             *loghead)
 {
+       struct xfs_da_geometry          *geo = mp->m_dir_geo;
        struct xfs_dir2_data_free       *bf = ops->data_bestfree_p(hdr);
        void                            *addr = hdr;
-       unsigned int                    offset = ops->data_entry_offset;
+       unsigned int                    offset = geo->data_entry_offset;
        unsigned int                    end;
 
        ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
@@ -599,7 +599,7 @@ xfs_dir2_data_freescan_int(
        memset(bf, 0, sizeof(*bf) * XFS_DIR2_DATA_FD_COUNT);
        *loghead = 1;
 
-       end = xfs_dir3_data_end_offset(mp->m_dir_geo, addr);
+       end = xfs_dir3_data_end_offset(geo, addr);
        while (offset < end) {
                struct xfs_dir2_data_unused     *dup = addr + offset;
                struct xfs_dir2_data_entry      *dep = addr + offset;
@@ -646,6 +646,7 @@ xfs_dir3_data_init(
        struct xfs_trans                *tp = args->trans;
        struct xfs_inode                *dp = args->dp;
        struct xfs_mount                *mp = dp->i_mount;
+       struct xfs_da_geometry          *geo = args->geo;
        struct xfs_buf                  *bp;
        struct xfs_dir2_data_hdr        *hdr;
        struct xfs_dir2_data_unused     *dup;
@@ -680,9 +681,8 @@ xfs_dir3_data_init(
                hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);
 
        bf = dp->d_ops->data_bestfree_p(hdr);
-       bf[0].offset = cpu_to_be16(dp->d_ops->data_entry_offset);
-       bf[0].length =
-               cpu_to_be16(args->geo->blksize - dp->d_ops->data_entry_offset);
+       bf[0].offset = cpu_to_be16(geo->data_entry_offset);
+       bf[0].length = cpu_to_be16(geo->blksize - geo->data_entry_offset);
        for (i = 1; i < XFS_DIR2_DATA_FD_COUNT; i++) {
                bf[i].length = 0;
                bf[i].offset = 0;
@@ -691,7 +691,7 @@ xfs_dir3_data_init(
        /*
         * Set up an unused entry for the block's body.
         */
-       dup = bp->b_addr + dp->d_ops->data_entry_offset;
+       dup = bp->b_addr + geo->data_entry_offset;
        dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
        dup->length = bf[0].length;
        *xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16((char *)dup - (char *)hdr);
@@ -744,8 +744,7 @@ xfs_dir2_data_log_header(
               hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
 #endif
 
-       xfs_trans_log_buf(args->trans, bp, 0,
-                         args->dp->d_ops->data_entry_offset - 1);
+       xfs_trans_log_buf(args->trans, bp, 0, args->geo->data_entry_offset - 1);
 }
 
 /*
@@ -813,7 +812,7 @@ xfs_dir2_data_make_free(
         * If this isn't the start of the block, then back up to
         * the previous entry and see if it's free.
         */
-       if (offset > args->dp->d_ops->data_entry_offset) {
+       if (offset > args->geo->data_entry_offset) {
                __be16                  *tagp;  /* tag just before us */
 
                tagp = (__be16 *)((char *)hdr + offset) - 1;

diff --git a/libxfs/xfs_dir2_leaf.c b/libxfs/xfs_dir2_leaf.c
index fa201d1521963ba3f5c83f056b032343c47da57c..ec7d3864ee5cb0478d3052063f739980561d14f1 100644 (file)
--- a/libxfs/xfs_dir2_leaf.c
+++ b/libxfs/xfs_dir2_leaf.c
@@ -1341,6 +1341,7 @@ int                                               /* error */
 xfs_dir2_leaf_removename(
        xfs_da_args_t           *args)          /* operation arguments */
 {
+       struct xfs_da_geometry  *geo = args->geo;
        __be16                  *bestsp;        /* leaf block best freespace */
        xfs_dir2_data_hdr_t     *hdr;           /* data block header */
        xfs_dir2_db_t           db;             /* data block number */
@@ -1379,12 +1380,12 @@ xfs_dir2_leaf_removename(
         * Point to the leaf entry, use that to point to the data entry.
         */
        lep = &leafhdr.ents[index];
-       db = xfs_dir2_dataptr_to_db(args->geo, be32_to_cpu(lep->address));
+       db = xfs_dir2_dataptr_to_db(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)));
+               xfs_dir2_dataptr_to_off(geo, be32_to_cpu(lep->address)));
        needscan = needlog = 0;
        oldbest = be16_to_cpu(bf[0].length);
-       ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
+       ltp = xfs_dir2_leaf_tail_p(geo, leaf);
        bestsp = xfs_dir2_leaf_bests_p(ltp);
        if (be16_to_cpu(bestsp[db]) != oldbest) {
                xfs_buf_corruption_error(lbp);
@@ -1428,8 +1429,8 @@ xfs_dir2_leaf_removename(
         * If the data block is now empty then get rid of the data block.
         */
        if (be16_to_cpu(bf[0].length) ==
-                       args->geo->blksize - dp->d_ops->data_entry_offset) {
-               ASSERT(db != args->geo->datablk);
+           geo->blksize - geo->data_entry_offset) {
+               ASSERT(db != geo->datablk);
                if ((error = xfs_dir2_shrink_inode(args, db, dbp))) {
                        /*
                         * Nope, can't get rid of it because it caused
@@ -1471,7 +1472,7 @@ xfs_dir2_leaf_removename(
        /*
         * If the data block was not the first one, drop it.
         */
-       else if (db != args->geo->datablk)
+       else if (db != geo->datablk)
                dbp = NULL;
 
        xfs_dir3_leaf_check(dp, lbp);
@@ -1592,6 +1593,7 @@ xfs_dir2_leaf_trim_data(
        struct xfs_buf          *lbp,           /* leaf buffer */
        xfs_dir2_db_t           db)             /* data block number */
 {
+       struct xfs_da_geometry  *geo = args->geo;
        __be16                  *bestsp;        /* leaf bests table */
        struct xfs_buf          *dbp;           /* data block buffer */
        xfs_inode_t             *dp;            /* incore directory inode */
@@ -1605,13 +1607,13 @@ xfs_dir2_leaf_trim_data(
        /*
         * Read the offending data block.  We need its buffer.
         */
-       error = xfs_dir3_data_read(tp, dp, xfs_dir2_db_to_da(args->geo, db),
-                                  -1, &dbp);
+       error = xfs_dir3_data_read(tp, dp, xfs_dir2_db_to_da(geo, db), -1,
+                                  &dbp);
        if (error)
                return error;
 
        leaf = lbp->b_addr;
-       ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
+       ltp = xfs_dir2_leaf_tail_p(geo, leaf);
 
 #ifdef DEBUG
 {
@@ -1621,7 +1623,7 @@ xfs_dir2_leaf_trim_data(
        ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
               hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC));
        ASSERT(be16_to_cpu(bf[0].length) ==
-              args->geo->blksize - dp->d_ops->data_entry_offset);
+              geo->blksize - geo->data_entry_offset);
        ASSERT(db == be32_to_cpu(ltp->bestcount) - 1);
 }
 #endif

diff --git a/libxfs/xfs_dir2_node.c b/libxfs/xfs_dir2_node.c
index 9ed02ab6b3a3f5971734e108bb5f9417d0fcbe2b..a2b3870102b5445b4a250babcbec3850727106f4 100644 (file)
--- a/libxfs/xfs_dir2_node.c
+++ b/libxfs/xfs_dir2_node.c
@@ -1260,6 +1260,7 @@ xfs_dir2_leafn_remove(
        xfs_da_state_blk_t      *dblk,          /* data block */
        int                     *rval)          /* resulting block needs join */
 {
+       struct xfs_da_geometry  *geo = args->geo;
        xfs_dir2_data_hdr_t     *hdr;           /* data block header */
        xfs_dir2_db_t           db;             /* data block number */
        struct xfs_buf          *dbp;           /* data block buffer */
@@ -1290,9 +1291,9 @@ xfs_dir2_leafn_remove(
        /*
         * Extract the data block and offset from the entry.
         */
-       db = xfs_dir2_dataptr_to_db(args->geo, be32_to_cpu(lep->address));
+       db = xfs_dir2_dataptr_to_db(geo, be32_to_cpu(lep->address));
        ASSERT(dblk->blkno == db);
-       off = xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address));
+       off = xfs_dir2_dataptr_to_off(geo, be32_to_cpu(lep->address));
        ASSERT(dblk->index == off);
 
        /*
@@ -1343,9 +1344,8 @@ xfs_dir2_leafn_remove(
                 * Convert the data block number to a free block,
                 * read in the free block.
                 */
-               fdb = xfs_dir2_db_to_fdb(args->geo, db);
-               error = xfs_dir2_free_read(tp, dp,
-                                          xfs_dir2_db_to_da(args->geo, fdb),
+               fdb = xfs_dir2_db_to_fdb(geo, db);
+               error = xfs_dir2_free_read(tp, dp, xfs_dir2_db_to_da(geo, fdb),
                                           &fbp);
                if (error)
                        return error;
@@ -1355,22 +1355,20 @@ xfs_dir2_leafn_remove(
                struct xfs_dir3_icfree_hdr freehdr;
 
                xfs_dir2_free_hdr_from_disk(dp->i_mount, &freehdr, free);
-               ASSERT(freehdr.firstdb == args->geo->free_max_bests *
-                       (fdb - xfs_dir2_byte_to_db(args->geo,
-                                                  XFS_DIR2_FREE_OFFSET)));
+               ASSERT(freehdr.firstdb == geo->free_max_bests *
+                       (fdb - xfs_dir2_byte_to_db(geo, XFS_DIR2_FREE_OFFSET)));
        }
 #endif
                /*
                 * Calculate which entry we need to fix.
                 */
-               findex = xfs_dir2_db_to_fdindex(args->geo, db);
+               findex = xfs_dir2_db_to_fdindex(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 == args->geo->blksize -
-                              dp->d_ops->data_entry_offset) {
+               if (longest == geo->blksize - geo->data_entry_offset) {
                        /*
                         * Try to punch out the data block.
                         */
@@ -1402,9 +1400,9 @@ xfs_dir2_leafn_remove(
         * Return indication of whether this leaf block is empty enough
         * to justify trying to join it with a neighbor.
         */
-       *rval = (args->geo->leaf_hdr_size +
+       *rval = (geo->leaf_hdr_size +
                 (uint)sizeof(leafhdr.ents) * (leafhdr.count - leafhdr.stale)) <
-               args->geo->magicpct;
+               geo->magicpct;
        return 0;
 }
 

diff --git a/libxfs/xfs_dir2_sf.c b/libxfs/xfs_dir2_sf.c
index e4df15bc0bff68b4c928aba006111c7d9b50bf1a..47efddb85ee7698aecee46559bf057aed7526d84 100644 (file)
--- a/libxfs/xfs_dir2_sf.c
+++ b/libxfs/xfs_dir2_sf.c
@@ -266,7 +266,7 @@ xfs_dir2_block_to_sf(
        int                     logflags;       /* inode logging flags */
        struct xfs_dir2_sf_entry *sfep;         /* shortform entry */
        struct xfs_dir2_sf_hdr  *sfp;           /* shortform directory header */
-       unsigned int            offset = dp->d_ops->data_entry_offset;
+       unsigned int            offset = args->geo->data_entry_offset;
        unsigned int            end;
 
        trace_xfs_dir2_block_to_sf(args);
@@ -538,7 +538,7 @@ xfs_dir2_sf_addname_hard(
         * to insert the new entry.
         * If it's going to end up at the end then oldsfep will point there.
         */
-       for (offset = dp->d_ops->data_first_offset,
+       for (offset = args->geo->data_first_offset,
              oldsfep = xfs_dir2_sf_firstentry(oldsfp),
              add_datasize = xfs_dir2_data_entsize(mp, args->namelen),
              eof = (char *)oldsfep == &buf[old_isize];
@@ -616,7 +616,7 @@ xfs_dir2_sf_addname_pick(
 
        sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
        size = xfs_dir2_data_entsize(mp, args->namelen);
-       offset = dp->d_ops->data_first_offset;
+       offset = args->geo->data_first_offset;
        sfep = xfs_dir2_sf_firstentry(sfp);
        holefit = 0;
        /*
@@ -681,7 +681,7 @@ xfs_dir2_sf_check(
        xfs_dir2_sf_hdr_t       *sfp;           /* shortform structure */
 
        sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
-       offset = dp->d_ops->data_first_offset;
+       offset = args->geo->data_first_offset;
        ino = xfs_dir2_sf_get_parent_ino(sfp);
        i8count = ino > XFS_DIR2_MAX_SHORT_INUM;
 
@@ -714,7 +714,6 @@ xfs_dir2_sf_verify(
        struct xfs_dir2_sf_entry        *sfep;
        struct xfs_dir2_sf_entry        *next_sfep;
        char                            *endp;
-       const struct xfs_dir_ops        *dops;
        struct xfs_ifork                *ifp;
        xfs_ino_t                       ino;
        int                             i;
@@ -725,11 +724,6 @@ xfs_dir2_sf_verify(
        uint8_t                         filetype;
 
        ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_LOCAL);
-       /*
-        * xfs_iread calls us before xfs_setup_inode sets up ip->d_ops,
-        * so we can only trust the mountpoint to have the right pointer.
-        */
-       dops = xfs_dir_get_ops(mp, NULL);
 
        ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
        sfp = (struct xfs_dir2_sf_hdr *)ifp->if_u1.if_data;
@@ -750,7 +744,7 @@ xfs_dir2_sf_verify(
        error = xfs_dir_ino_validate(mp, ino);
        if (error)
                return __this_address;
-       offset = dops->data_first_offset;
+       offset = mp->m_dir_geo->data_first_offset;
 
        /* Check all reported entries */
        sfep = xfs_dir2_sf_firstentry(sfp);

diff --git a/repair/dir2.c b/repair/dir2.c
index 398176d98cb454a45c90ed32ba5d6a0bb203f085..623b3da0c376ba4881bdb6867caaa9c6ec4ab8a4 100644 (file)
--- a/repair/dir2.c
+++ b/repair/dir2.c
@@ -117,7 +117,7 @@ process_sf_dir2_fixoff(
 
        sfp = (struct xfs_dir2_sf_hdr *)XFS_DFORK_DPTR(dip);
        sfep = xfs_dir2_sf_firstentry(sfp);
-       offset = M_DIROPS(mp)->data_first_offset;
+       offset = mp->m_dir_geo->data_first_offset;
 
        for (i = 0; i < sfp->count; i++) {
                xfs_dir2_sf_put_offset(sfep, offset);
@@ -171,7 +171,7 @@ process_sf_dir2(
        max_size = XFS_DFORK_DSIZE(dip, mp);
        num_entries = sfp->count;
        ino_dir_size = be64_to_cpu(dip->di_size);
-       offset = M_DIROPS(mp)->data_first_offset;
+       offset = mp->m_dir_geo->data_first_offset;
        bad_offset = *repair = 0;
 
        ASSERT(ino_dir_size <= max_size);
@@ -580,7 +580,7 @@ process_dir2_data(
 
        d = bp->b_addr;
        bf = M_DIROPS(mp)->data_bestfree_p(d);
-       ptr = (char *)d + M_DIROPS(mp)->data_entry_offset;
+       ptr = (char *)d + mp->m_dir_geo->data_entry_offset;
        badbest = lastfree = freeseen = 0;
        if (be16_to_cpu(bf[0].length) == 0) {
                badbest |= be16_to_cpu(bf[0].offset) != 0;
@@ -646,7 +646,7 @@ process_dir2_data(
                        do_warn(_("\twould junk block\n"));
                return 1;
        }
-       ptr = (char *)d + M_DIROPS(mp)->data_entry_offset;
+       ptr = (char *)d + mp->m_dir_geo->data_entry_offset;
        /*
         * Process the entries now.
         */

diff --git a/repair/phase6.c b/repair/phase6.c
index 88fc23318faca3afb3bf8a6af91866784152a004..81eb62994a5044f2eae84a800d3ac216d82d0948 100644 (file)
--- a/repair/phase6.c
+++ b/repair/phase6.c
@@ -1527,7 +1527,7 @@ longform_dir2_entry_check_data(
 
        bp = *bpp;
        d = bp->b_addr;
-       ptr = (char *)d + M_DIROPS(mp)->data_entry_offset;
+       ptr = (char *)d + mp->m_dir_geo->data_entry_offset;
        nbad = 0;
        needscan = needlog = 0;
        junkit = 0;
@@ -1587,7 +1587,7 @@ longform_dir2_entry_check_data(
                                break;
 
                        /* check for block with no data entries */
-                       if ((ptr == (char *)d + M_DIROPS(mp)->data_entry_offset) &&
+                       if ((ptr == (char *)d + mp->m_dir_geo->data_entry_offset) &&
                            (ptr + be16_to_cpu(dup->length) >= endptr)) {
                                junkit = 1;
                                *num_illegal += 1;
@@ -1656,7 +1656,7 @@ longform_dir2_entry_check_data(
                        do_warn(_("would fix magic # to %#x\n"), wantmagic);
        }
        lastfree = 0;
-       ptr = (char *)d + M_DIROPS(mp)->data_entry_offset;
+       ptr = (char *)d + mp->m_dir_geo->data_entry_offset;
        /*
         * look at each entry.  reference inode pointed to by each
         * entry in the incore inode tree.
@@ -1831,7 +1831,7 @@ longform_dir2_entry_check_data(
                               (dep->name[0] == '.' && dep->namelen == 1));
                        add_inode_ref(current_irec, current_ino_offset);
                        if (da_bno != 0 ||
-                           dep != (void *)d + M_DIROPS(mp)->data_entry_offset) {
+                           dep != (void *)d + mp->m_dir_geo->data_entry_offset) {
                                /* "." should be the first entry */
                                nbad++;
                                if (entry_junked(