unsigned int    node_ents;      /* # of entries in a danode */
        unsigned int    magicpct;       /* 37% of block size in bytes */
        xfs_dablk_t     datablk;        /* blockno of dir data v2 */
+       unsigned int    leaf_hdr_size;  /* dir2 leaf header size */
        xfs_dablk_t     leafblk;        /* blockno of leaf data v2 */
        xfs_dablk_t     freeblk;        /* blockno of free data v2 */
 };
 
        .data_entry_p = xfs_dir2_data_entry_p,
        .data_unused_p = xfs_dir2_data_unused_p,
 
-       .leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr),
        .leaf_max_ents = xfs_dir2_max_leaf_ents,
 
        .free_hdr_size = sizeof(struct xfs_dir2_free_hdr),
        .data_entry_p = xfs_dir2_data_entry_p,
        .data_unused_p = xfs_dir2_data_unused_p,
 
-       .leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr),
        .leaf_max_ents = xfs_dir2_max_leaf_ents,
 
        .free_hdr_size = sizeof(struct xfs_dir2_free_hdr),
        .data_entry_p = xfs_dir3_data_entry_p,
        .data_unused_p = xfs_dir3_data_unused_p,
 
-       .leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr),
        .leaf_max_ents = xfs_dir3_max_leaf_ents,
 
        .free_hdr_size = sizeof(struct xfs_dir3_free_hdr),
 
        dageo->fsblog = mp->m_sb.sb_blocklog;
        dageo->blksize = xfs_dir2_dirblock_bytes(&mp->m_sb);
        dageo->fsbcount = 1 << mp->m_sb.sb_dirblklog;
-       if (xfs_sb_version_hascrc(&mp->m_sb))
+       if (xfs_sb_version_hascrc(&mp->m_sb)) {
                dageo->node_hdr_size = sizeof(struct xfs_da3_node_hdr);
-       else
+               dageo->leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr);
+       } else {
                dageo->node_hdr_size = sizeof(struct xfs_da_node_hdr);
+               dageo->leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr);
+       }
 
        /*
         * Now we've set up the block conversion variables, we can calculate the
 
        struct xfs_dir2_data_unused *
                (*data_unused_p)(struct xfs_dir2_data_hdr *hdr);
 
-       int     leaf_hdr_size;
        int     (*leaf_max_ents)(struct xfs_da_geometry *geo);
 
        int     free_hdr_size;
 
 
        xfs_trans_log_buf(args->trans, bp,
                          (uint)((char *)&leaf->hdr - (char *)leaf),
-                         args->dp->d_ops->leaf_hdr_size - 1);
+                         args->geo->leaf_hdr_size - 1);
 }
 
 /*
 
         * Return indication of whether this leaf block is empty enough
         * to justify trying to join it with a neighbor.
         */
-       *rval = (dp->d_ops->leaf_hdr_size +
+       *rval = (args->geo->leaf_hdr_size +
                 (uint)sizeof(leafhdr.ents) * (leafhdr.count - leafhdr.stale)) <
                args->geo->magicpct;
        return 0;
        xfs_dir3_leaf_check(dp, blk->bp);
 
        count = leafhdr.count - leafhdr.stale;
-       bytes = dp->d_ops->leaf_hdr_size + count * sizeof(ents[0]);
+       bytes = state->args->geo->leaf_hdr_size + count * sizeof(ents[0]);
        if (bytes > (state->args->geo->blksize >> 1)) {
                /*
                 * Blk over 50%, don't try to join.