Commit 4141956a authored by Dave Chinner's avatar Dave Chinner Committed by Ben Myers
Browse files

xfs: vectorise directory leaf operations 



Next step in the vectorisation process is the leaf block
encode/decode operations. Most of the operations on leaves are
handled by the data block vectors, so there are relatively few of
them here.

Because of all the shuffling of code and having to pass more state
to some functions, this patch doesn't directly reduce the size of
the binary. It does open up many more opportunities for factoring
and optimisation, however.

   text    data     bss     dec     hex filename
 794490   96802    1096  892388   d9de4 fs/xfs/xfs.o.orig
 792986   96802    1096  890884   d9804 fs/xfs/xfs.o.p1
 792350   96802    1096  890248   d9588 fs/xfs/xfs.o.p2
 789293   96802    1096  887191   d8997 fs/xfs/xfs.o.p3
 789005   96802    1096  886903   d8997 fs/xfs/xfs.o.p4
 789061   96802    1096  886959   d88af fs/xfs/xfs.o.p5

Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarBen Myers <bpm@sgi.com>
parent 2ca98774

fs/xfs/xfs_da_btree.c

+10 −9
Original line number Diff line number Diff line
@@ -605,7 +605,7 @@ xfs_da3_root_split( 


		leaf = (xfs_dir2_leaf_t *)oldroot;

		xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);

		ents = xfs_dir3_leaf_ents_p(leaf);

		ents = dp->d_ops->leaf_ents_p(leaf);



		ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||

		       leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
@@ -1319,7 +1319,8 @@ xfs_da3_fixhashpath( 
			return;

		break;

	case XFS_DIR2_LEAFN_MAGIC:

		lasthash = xfs_dir2_leafn_lasthash(blk->bp, &count);

		lasthash = xfs_dir2_leafn_lasthash(state->args->dp,

						   blk->bp, &count);

		if (count == 0)

			return;

		break;
@@ -1536,7 +1537,8 @@ xfs_da3_node_lookup_int( 
		if (blk->magic == XFS_DIR2_LEAFN_MAGIC ||

		    blk->magic == XFS_DIR3_LEAFN_MAGIC) {

			blk->magic = XFS_DIR2_LEAFN_MAGIC;

			blk->hashval = xfs_dir2_leafn_lasthash(blk->bp, NULL);

			blk->hashval = xfs_dir2_leafn_lasthash(args->dp,

							       blk->bp, NULL);

			break;

		}
@@ -1702,7 +1704,7 @@ xfs_da3_blk_link( 
		before = xfs_attr_leaf_order(old_blk->bp, new_blk->bp);

		break;

	case XFS_DIR2_LEAFN_MAGIC:

		before = xfs_dir2_leafn_order(old_blk->bp, new_blk->bp);

		before = xfs_dir2_leafn_order(args->dp, old_blk->bp, new_blk->bp);

		break;

	case XFS_DA_NODE_MAGIC:

		before = xfs_da3_node_order(old_blk->bp, new_blk->bp);
@@ -1947,16 +1949,15 @@ xfs_da3_path_shift( 
			blk->magic = XFS_ATTR_LEAF_MAGIC;

			ASSERT(level == path->active-1);

			blk->index = 0;

			blk->hashval = xfs_attr_leaf_lasthash(blk->bp,

							      NULL);

			blk->hashval = xfs_attr_leaf_lasthash(blk->bp, NULL);

			break;

		case XFS_DIR2_LEAFN_MAGIC:

		case XFS_DIR3_LEAFN_MAGIC:

			blk->magic = XFS_DIR2_LEAFN_MAGIC;

			ASSERT(level == path->active-1);

			blk->index = 0;

			blk->hashval = xfs_dir2_leafn_lasthash(blk->bp,

							       NULL);

			blk->hashval = xfs_dir2_leafn_lasthash(args->dp,

							       blk->bp, NULL);

			break;

		default:

			ASSERT(0);
@@ -2223,7 +2224,7 @@ xfs_da3_swap_lastblock( 


		dead_leaf2 = (xfs_dir2_leaf_t *)dead_info;

		xfs_dir3_leaf_hdr_from_disk(&leafhdr, dead_leaf2);

		ents = xfs_dir3_leaf_ents_p(dead_leaf2);

		ents = ip->d_ops->leaf_ents_p(dead_leaf2);

		dead_level = 0;

		dead_hash = be32_to_cpu(ents[leafhdr.count - 1].hashval);

	} else {

fs/xfs/xfs_da_format.c

+75 −0
Original line number Diff line number Diff line
@@ -435,6 +435,48 @@ xfs_dir3_data_unused_p(struct xfs_dir2_data_hdr *hdr) 
		((char *)hdr + xfs_dir3_data_entry_offset());

}





/*

 * Directory Leaf block operations

 */

static int

xfs_dir2_leaf_hdr_size(void)

{

	return sizeof(struct xfs_dir2_leaf_hdr);

}



static int

xfs_dir2_max_leaf_ents(struct xfs_mount *mp)

{

	return (mp->m_dirblksize - xfs_dir2_leaf_hdr_size()) /

		(uint)sizeof(struct xfs_dir2_leaf_entry);

}



static struct xfs_dir2_leaf_entry *

xfs_dir2_leaf_ents_p(struct xfs_dir2_leaf *lp)

{

	return lp->__ents;

}



static int

xfs_dir3_leaf_hdr_size(void)

{

	return sizeof(struct xfs_dir3_leaf_hdr);

}



static inline int

xfs_dir3_max_leaf_ents(struct xfs_mount *mp)

{

	return (mp->m_dirblksize - xfs_dir3_leaf_hdr_size()) /

		(uint)sizeof(struct xfs_dir2_leaf_entry);

}



static inline struct xfs_dir2_leaf_entry *

xfs_dir3_leaf_ents_p(struct xfs_dir2_leaf *lp)

{

	return ((struct xfs_dir3_leaf *)lp)->__ents;

}



const struct xfs_dir_ops xfs_dir2_ops = {

	.sf_entsize = xfs_dir2_sf_entsize,

	.sf_nextentry = xfs_dir2_sf_nextentry,
@@ -462,6 +504,10 @@ const struct xfs_dir_ops xfs_dir2_ops = { 
	.data_entry_p = xfs_dir2_data_entry_p,

	.data_unused_p = xfs_dir2_data_unused_p,



	.leaf_hdr_size = xfs_dir2_leaf_hdr_size,

	.leaf_max_ents = xfs_dir2_max_leaf_ents,

	.leaf_ents_p = xfs_dir2_leaf_ents_p,



};



const struct xfs_dir_ops xfs_dir2_ftype_ops = {
@@ -490,6 +536,10 @@ const struct xfs_dir_ops xfs_dir2_ftype_ops = { 
	.data_first_entry_p = xfs_dir2_data_first_entry_p,

	.data_entry_p = xfs_dir2_data_entry_p,

	.data_unused_p = xfs_dir2_data_unused_p,



	.leaf_hdr_size = xfs_dir2_leaf_hdr_size,

	.leaf_max_ents = xfs_dir2_max_leaf_ents,

	.leaf_ents_p = xfs_dir2_leaf_ents_p,

};



const struct xfs_dir_ops xfs_dir3_ops = {
@@ -518,4 +568,29 @@ const struct xfs_dir_ops xfs_dir3_ops = { 
	.data_first_entry_p = xfs_dir3_data_first_entry_p,

	.data_entry_p = xfs_dir3_data_entry_p,

	.data_unused_p = xfs_dir3_data_unused_p,



	.leaf_hdr_size = xfs_dir3_leaf_hdr_size,

	.leaf_max_ents = xfs_dir3_max_leaf_ents,

	.leaf_ents_p = xfs_dir3_leaf_ents_p,

};



/*

 * Return the ops structure according to the current config.  If we are passed

 * an inode, then that overrides the default config we use which is based on

 * feature bits.

 */

const struct xfs_dir_ops *

xfs_dir_get_ops(

	struct xfs_mount	*mp,

	struct xfs_inode	*dp)

{

	if (dp)

		return dp->d_ops;

	if (mp->m_dir_inode_ops)

		return mp->m_dir_inode_ops;

	if (xfs_sb_version_hascrc(&mp->m_sb))

		return &xfs_dir3_ops;

	if (xfs_sb_version_hasftype(&mp->m_sb))

		return &xfs_dir2_ftype_ops;

	return &xfs_dir2_ops;

}

fs/xfs/xfs_da_format.h

+0 −30
Original line number Diff line number Diff line
@@ -551,36 +551,6 @@ struct xfs_dir3_leaf { 
extern void xfs_dir3_leaf_hdr_from_disk(struct xfs_dir3_icleaf_hdr *to,

					struct xfs_dir2_leaf *from);



static inline int

xfs_dir3_leaf_hdr_size(struct xfs_dir2_leaf *lp)

{

	if (lp->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||

	    lp->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC))

		return sizeof(struct xfs_dir3_leaf_hdr);

	return sizeof(struct xfs_dir2_leaf_hdr);

}



static inline int

xfs_dir3_max_leaf_ents(struct xfs_mount *mp, struct xfs_dir2_leaf *lp)

{

	return (mp->m_dirblksize - xfs_dir3_leaf_hdr_size(lp)) /

		(uint)sizeof(struct xfs_dir2_leaf_entry);

}



/*

 * Get address of the bestcount field in the single-leaf block.

 */

static inline struct xfs_dir2_leaf_entry *

xfs_dir3_leaf_ents_p(struct xfs_dir2_leaf *lp)

{

	if (lp->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||

	    lp->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) {

		struct xfs_dir3_leaf *lp3 = (struct xfs_dir3_leaf *)lp;

		return lp3->__ents;

	}

	return lp->__ents;

}



/*

 * Get address of the bestcount field in the single-leaf block.

 */

fs/xfs/xfs_dir2.c

+1 −6
Original line number Diff line number Diff line
@@ -113,12 +113,7 @@ xfs_dir_mount( 
	else

		mp->m_dirnameops = &xfs_default_nameops;



	if (xfs_sb_version_hascrc(&mp->m_sb))

		mp->m_dir_inode_ops = &xfs_dir3_ops;

	else if (xfs_sb_version_hasftype(&mp->m_sb))

		mp->m_dir_inode_ops = &xfs_dir2_ftype_ops;

	else

		mp->m_dir_inode_ops = &xfs_dir2_ops;

	mp->m_dir_inode_ops = xfs_dir_get_ops(mp, NULL);

}



/*

fs/xfs/xfs_dir2.h

+7 −3
Original line number Diff line number Diff line
@@ -74,11 +74,15 @@ struct xfs_dir_ops { 
		(*data_entry_p)(struct xfs_dir2_data_hdr *hdr);

	struct xfs_dir2_data_unused *

		(*data_unused_p)(struct xfs_dir2_data_hdr *hdr);



	int	(*leaf_hdr_size)(void);

	int	(*leaf_max_ents)(struct xfs_mount *mp);

	struct xfs_dir2_leaf_entry *

		(*leaf_ents_p)(struct xfs_dir2_leaf *lp);

};



extern const struct xfs_dir_ops xfs_dir2_ops;

extern const struct xfs_dir_ops xfs_dir2_ftype_ops;

extern const struct xfs_dir_ops xfs_dir3_ops;

extern const struct xfs_dir_ops *

	xfs_dir_get_ops(struct xfs_mount *mp, struct xfs_inode *dp);



/*

 * Generic directory interface routines

CRA Git | Maintained and supported by SUSTech CRA and CCSE