Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 69ef921b authored by Christoph Hellwig's avatar Christoph Hellwig
Browse files

xfs: byteswap constants instead of variables 



Micro-optimize various comparisms by always byteswapping the constant
instead of the variable, which allows to do the swap at compile instead
of runtime.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarAlex Elder <aelder@sgi.com>
Reviewed-by: default avatarDave Chinner <dchinner@redhat.com>
parent 218106a1

fs/xfs/xfs_alloc.c

+1 −1
Original line number Diff line number Diff line
@@ -2127,7 +2127,7 @@ xfs_read_agf( 
	 * Validate the magic number of the agf block.

	 */

	agf_ok =

		be32_to_cpu(agf->agf_magicnum) == XFS_AGF_MAGIC &&

		agf->agf_magicnum == cpu_to_be32(XFS_AGF_MAGIC) &&

		XFS_AGF_GOOD_VERSION(be32_to_cpu(agf->agf_versionnum)) &&

		be32_to_cpu(agf->agf_freeblks) <= be32_to_cpu(agf->agf_length) &&

		be32_to_cpu(agf->agf_flfirst) < XFS_AGFL_SIZE(mp) &&

fs/xfs/xfs_attr.c

+9 −10
Original line number Diff line number Diff line
@@ -1203,7 +1203,7 @@ xfs_attr_leaf_list(xfs_attr_list_context_t *context) 
		return XFS_ERROR(error);

	ASSERT(bp != NULL);

	leaf = bp->data;

	if (unlikely(be16_to_cpu(leaf->hdr.info.magic) != XFS_ATTR_LEAF_MAGIC)) {

	if (unlikely(leaf->hdr.info.magic != cpu_to_be16(XFS_ATTR_LEAF_MAGIC))) {

		XFS_CORRUPTION_ERROR("xfs_attr_leaf_list", XFS_ERRLEVEL_LOW,

				     context->dp->i_mount, leaf);

		xfs_da_brelse(NULL, bp);
@@ -1610,9 +1610,8 @@ xfs_attr_node_removename(xfs_da_args_t *args) 
						     XFS_ATTR_FORK);

		if (error)

			goto out;

		ASSERT(be16_to_cpu(((xfs_attr_leafblock_t *)

				      bp->data)->hdr.info.magic)

						       == XFS_ATTR_LEAF_MAGIC);

		ASSERT((((xfs_attr_leafblock_t *)bp->data)->hdr.info.magic) ==

		       cpu_to_be16(XFS_ATTR_LEAF_MAGIC));



		if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {

			xfs_bmap_init(args->flist, args->firstblock);
@@ -1877,11 +1876,11 @@ xfs_attr_node_list(xfs_attr_list_context_t *context) 
				return(XFS_ERROR(EFSCORRUPTED));

			}

			node = bp->data;

			if (be16_to_cpu(node->hdr.info.magic)

							== XFS_ATTR_LEAF_MAGIC)

			if (node->hdr.info.magic ==

			    cpu_to_be16(XFS_ATTR_LEAF_MAGIC))

				break;

			if (unlikely(be16_to_cpu(node->hdr.info.magic)

							!= XFS_DA_NODE_MAGIC)) {

			if (unlikely(node->hdr.info.magic !=

				     cpu_to_be16(XFS_DA_NODE_MAGIC))) {

				XFS_CORRUPTION_ERROR("xfs_attr_node_list(3)",

						     XFS_ERRLEVEL_LOW,

						     context->dp->i_mount,
@@ -1916,8 +1915,8 @@ xfs_attr_node_list(xfs_attr_list_context_t *context) 
	 */

	for (;;) {

		leaf = bp->data;

		if (unlikely(be16_to_cpu(leaf->hdr.info.magic)

						!= XFS_ATTR_LEAF_MAGIC)) {

		if (unlikely(leaf->hdr.info.magic !=

			     cpu_to_be16(XFS_ATTR_LEAF_MAGIC))) {

			XFS_CORRUPTION_ERROR("xfs_attr_node_list(4)",

					     XFS_ERRLEVEL_LOW,

					     context->dp->i_mount, leaf);

fs/xfs/xfs_attr_leaf.c

+30 −30
Original line number Diff line number Diff line
@@ -731,7 +731,7 @@ xfs_attr_shortform_allfit(xfs_dabuf_t *bp, xfs_inode_t *dp) 
	int bytes, i;



	leaf = bp->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));



	entry = &leaf->entries[0];

	bytes = sizeof(struct xfs_attr_sf_hdr);
@@ -777,7 +777,7 @@ xfs_attr_leaf_to_shortform(xfs_dabuf_t *bp, xfs_da_args_t *args, int forkoff) 
	ASSERT(bp != NULL);

	memcpy(tmpbuffer, bp->data, XFS_LBSIZE(dp->i_mount));

	leaf = (xfs_attr_leafblock_t *)tmpbuffer;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	memset(bp->data, 0, XFS_LBSIZE(dp->i_mount));



	/*
@@ -872,7 +872,7 @@ xfs_attr_leaf_to_node(xfs_da_args_t *args) 
		goto out;

	node = bp1->data;

	leaf = bp2->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	/* both on-disk, don't endian-flip twice */

	node->btree[0].hashval =

		leaf->entries[be16_to_cpu(leaf->hdr.count)-1 ].hashval;
@@ -997,7 +997,7 @@ xfs_attr_leaf_add(xfs_dabuf_t *bp, xfs_da_args_t *args) 
	int tablesize, entsize, sum, tmp, i;



	leaf = bp->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	ASSERT((args->index >= 0)

		&& (args->index <= be16_to_cpu(leaf->hdr.count)));

	hdr = &leaf->hdr;
@@ -1070,7 +1070,7 @@ xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex) 
	int tmp, i;



	leaf = bp->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	hdr = &leaf->hdr;

	ASSERT((mapindex >= 0) && (mapindex < XFS_ATTR_LEAF_MAPSIZE));

	ASSERT((args->index >= 0) && (args->index <= be16_to_cpu(hdr->count)));
@@ -1256,8 +1256,8 @@ xfs_attr_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1, 
	ASSERT(blk2->magic == XFS_ATTR_LEAF_MAGIC);

	leaf1 = blk1->bp->data;

	leaf2 = blk2->bp->data;

	ASSERT(be16_to_cpu(leaf1->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(be16_to_cpu(leaf2->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	args = state->args;



	/*
@@ -1533,7 +1533,7 @@ xfs_attr_leaf_toosmall(xfs_da_state_t *state, int *action) 
	 */

	blk = &state->path.blk[ state->path.active-1 ];

	info = blk->bp->data;

	ASSERT(be16_to_cpu(info->magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	leaf = (xfs_attr_leafblock_t *)info;

	count = be16_to_cpu(leaf->hdr.count);

	bytes = sizeof(xfs_attr_leaf_hdr_t) +
@@ -1596,7 +1596,7 @@ xfs_attr_leaf_toosmall(xfs_da_state_t *state, int *action) 
		bytes  = state->blocksize - (state->blocksize>>2);

		bytes -= be16_to_cpu(leaf->hdr.usedbytes);

		leaf = bp->data;

		ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

		ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

		count += be16_to_cpu(leaf->hdr.count);

		bytes -= be16_to_cpu(leaf->hdr.usedbytes);

		bytes -= count * sizeof(xfs_attr_leaf_entry_t);
@@ -1650,7 +1650,7 @@ xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args) 
	xfs_mount_t *mp;



	leaf = bp->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	hdr = &leaf->hdr;

	mp = args->trans->t_mountp;

	ASSERT((be16_to_cpu(hdr->count) > 0)
@@ -1813,8 +1813,8 @@ xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk, 
	ASSERT(save_blk->magic == XFS_ATTR_LEAF_MAGIC);

	drop_leaf = drop_blk->bp->data;

	save_leaf = save_blk->bp->data;

	ASSERT(be16_to_cpu(drop_leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(be16_to_cpu(save_leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(drop_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	ASSERT(save_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	drop_hdr = &drop_leaf->hdr;

	save_hdr = &save_leaf->hdr;
@@ -1915,7 +1915,7 @@ xfs_attr_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args) 
	xfs_dahash_t hashval;



	leaf = bp->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	ASSERT(be16_to_cpu(leaf->hdr.count)

					< (XFS_LBSIZE(args->dp->i_mount)/8));
@@ -2019,7 +2019,7 @@ xfs_attr_leaf_getvalue(xfs_dabuf_t *bp, xfs_da_args_t *args) 
	xfs_attr_leaf_name_remote_t *name_rmt;



	leaf = bp->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	ASSERT(be16_to_cpu(leaf->hdr.count)

					< (XFS_LBSIZE(args->dp->i_mount)/8));

	ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
@@ -2087,8 +2087,8 @@ xfs_attr_leaf_moveents(xfs_attr_leafblock_t *leaf_s, int start_s, 
	/*

	 * Set up environment.

	 */

	ASSERT(be16_to_cpu(leaf_s->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(be16_to_cpu(leaf_d->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf_s->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	ASSERT(leaf_d->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	hdr_s = &leaf_s->hdr;

	hdr_d = &leaf_d->hdr;

	ASSERT((be16_to_cpu(hdr_s->count) > 0) &&
@@ -2222,8 +2222,8 @@ xfs_attr_leaf_order(xfs_dabuf_t *leaf1_bp, xfs_dabuf_t *leaf2_bp) 


	leaf1 = leaf1_bp->data;

	leaf2 = leaf2_bp->data;

	ASSERT((be16_to_cpu(leaf1->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC) &&

	       (be16_to_cpu(leaf2->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC));

	ASSERT((leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) &&

	       (leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)));

	if ((be16_to_cpu(leaf1->hdr.count) > 0) &&

	    (be16_to_cpu(leaf2->hdr.count) > 0) &&

	    ((be32_to_cpu(leaf2->entries[0].hashval) <
@@ -2246,7 +2246,7 @@ xfs_attr_leaf_lasthash(xfs_dabuf_t *bp, int *count) 
	xfs_attr_leafblock_t *leaf;



	leaf = bp->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	if (count)

		*count = be16_to_cpu(leaf->hdr.count);

	if (!leaf->hdr.count)
@@ -2265,7 +2265,7 @@ xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index) 
	xfs_attr_leaf_name_remote_t *name_rmt;

	int size;



	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	if (leaf->entries[index].flags & XFS_ATTR_LOCAL) {

		name_loc = xfs_attr_leaf_name_local(leaf, index);

		size = xfs_attr_leaf_entsize_local(name_loc->namelen,
@@ -2451,7 +2451,7 @@ xfs_attr_leaf_clearflag(xfs_da_args_t *args) 
	ASSERT(bp != NULL);



	leaf = bp->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	ASSERT(args->index < be16_to_cpu(leaf->hdr.count));

	ASSERT(args->index >= 0);

	entry = &leaf->entries[ args->index ];
@@ -2515,7 +2515,7 @@ xfs_attr_leaf_setflag(xfs_da_args_t *args) 
	ASSERT(bp != NULL);



	leaf = bp->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	ASSERT(args->index < be16_to_cpu(leaf->hdr.count));

	ASSERT(args->index >= 0);

	entry = &leaf->entries[ args->index ];
@@ -2585,13 +2585,13 @@ xfs_attr_leaf_flipflags(xfs_da_args_t *args) 
	}



	leaf1 = bp1->data;

	ASSERT(be16_to_cpu(leaf1->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	ASSERT(args->index < be16_to_cpu(leaf1->hdr.count));

	ASSERT(args->index >= 0);

	entry1 = &leaf1->entries[ args->index ];



	leaf2 = bp2->data;

	ASSERT(be16_to_cpu(leaf2->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));

	ASSERT(args->index2 < be16_to_cpu(leaf2->hdr.count));

	ASSERT(args->index2 >= 0);

	entry2 = &leaf2->entries[ args->index2 ];
@@ -2689,9 +2689,9 @@ xfs_attr_root_inactive(xfs_trans_t **trans, xfs_inode_t *dp) 
	 * This is a depth-first traversal!

	 */

	info = bp->data;

	if (be16_to_cpu(info->magic) == XFS_DA_NODE_MAGIC) {

	if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {

		error = xfs_attr_node_inactive(trans, dp, bp, 1);

	} else if (be16_to_cpu(info->magic) == XFS_ATTR_LEAF_MAGIC) {

	} else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {

		error = xfs_attr_leaf_inactive(trans, dp, bp);

	} else {

		error = XFS_ERROR(EIO);
@@ -2739,7 +2739,7 @@ xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp, 
	}



	node = bp->data;

	ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC);

	ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));

	parent_blkno = xfs_da_blkno(bp);	/* save for re-read later */

	count = be16_to_cpu(node->hdr.count);

	if (!count) {
@@ -2773,10 +2773,10 @@ xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp, 
			 * Invalidate the subtree, however we have to.

			 */

			info = child_bp->data;

			if (be16_to_cpu(info->magic) == XFS_DA_NODE_MAGIC) {

			if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {

				error = xfs_attr_node_inactive(trans, dp,

						child_bp, level+1);

			} else if (be16_to_cpu(info->magic) == XFS_ATTR_LEAF_MAGIC) {

			} else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {

				error = xfs_attr_leaf_inactive(trans, dp,

						child_bp);

			} else {
@@ -2836,7 +2836,7 @@ xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp) 
	int error, count, size, tmp, i;



	leaf = bp->data;

	ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC);

	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));



	/*

	 * Count the number of "remote" value extents.

fs/xfs/xfs_bmap.c

+1 −1
Original line number Diff line number Diff line
@@ -4083,7 +4083,7 @@ xfs_bmap_sanity_check( 
{

	struct xfs_btree_block  *block = XFS_BUF_TO_BLOCK(bp);



	if (be32_to_cpu(block->bb_magic) != XFS_BMAP_MAGIC ||

	if (block->bb_magic != cpu_to_be32(XFS_BMAP_MAGIC) ||

	    be16_to_cpu(block->bb_level) != level ||

	    be16_to_cpu(block->bb_numrecs) == 0 ||

	    be16_to_cpu(block->bb_numrecs) > mp->m_bmap_dmxr[level != 0])

fs/xfs/xfs_bmap_btree.c

+4 −4
Original line number Diff line number Diff line
@@ -425,10 +425,10 @@ xfs_bmbt_to_bmdr( 
	xfs_bmbt_key_t		*tkp;

	__be64			*tpp;



	ASSERT(be32_to_cpu(rblock->bb_magic) == XFS_BMAP_MAGIC);

	ASSERT(be64_to_cpu(rblock->bb_u.l.bb_leftsib) == NULLDFSBNO);

	ASSERT(be64_to_cpu(rblock->bb_u.l.bb_rightsib) == NULLDFSBNO);

	ASSERT(be16_to_cpu(rblock->bb_level) > 0);

	ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_MAGIC));

	ASSERT(rblock->bb_u.l.bb_leftsib == cpu_to_be64(NULLDFSBNO));

	ASSERT(rblock->bb_u.l.bb_rightsib == cpu_to_be64(NULLDFSBNO));

	ASSERT(rblock->bb_level != 0);

	dblock->bb_level = rblock->bb_level;

	dblock->bb_numrecs = rblock->bb_numrecs;

	dmxr = xfs_bmdr_maxrecs(mp, dblocklen, 0);