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

Commit 1d9025e5 authored by Dave Chinner's avatar Dave Chinner Committed by Ben Myers
Browse files

xfs: remove struct xfs_dabuf and infrastructure 



The struct xfs_dabuf now only tracks a single xfs_buf and all the
information it holds can be gained directly from the xfs_buf. Hence
we can remove the struct dabuf and pass the xfs_buf around
everywhere.

Kill the struct dabuf and the associated infrastructure.

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 3605431f

fs/xfs/xfs_attr.c

+36 −42
Original line number Diff line number Diff line
@@ -893,7 +893,7 @@ STATIC int 
xfs_attr_leaf_addname(xfs_da_args_t *args)

{

	xfs_inode_t *dp;

	xfs_dabuf_t *bp;

	struct xfs_buf *bp;

	int retval, error, committed, forkoff;



	trace_xfs_attr_leaf_addname(args);
@@ -915,11 +915,11 @@ xfs_attr_leaf_addname(xfs_da_args_t *args) 
	 */

	retval = xfs_attr_leaf_lookup_int(bp, args);

	if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {

		xfs_da_brelse(args->trans, bp);

		xfs_trans_brelse(args->trans, bp);

		return(retval);

	} else if (retval == EEXIST) {

		if (args->flags & ATTR_CREATE) {	/* pure create op */

			xfs_da_brelse(args->trans, bp);

			xfs_trans_brelse(args->trans, bp);

			return(retval);

		}
@@ -937,7 +937,6 @@ xfs_attr_leaf_addname(xfs_da_args_t *args) 
	 * if required.

	 */

	retval = xfs_attr_leaf_add(bp, args);

	xfs_da_buf_done(bp);

	if (retval == ENOSPC) {

		/*

		 * Promote the attribute list to the Btree format, then
@@ -1065,8 +1064,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args) 
			 */

			if (committed)

				xfs_trans_ijoin(args->trans, dp, 0);

		} else

			xfs_da_buf_done(bp);

		}



		/*

		 * Commit the remove and start the next trans in series.
@@ -1092,7 +1090,7 @@ STATIC int 
xfs_attr_leaf_removename(xfs_da_args_t *args)

{

	xfs_inode_t *dp;

	xfs_dabuf_t *bp;

	struct xfs_buf *bp;

	int error, committed, forkoff;



	trace_xfs_attr_leaf_removename(args);
@@ -1111,7 +1109,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args) 
	ASSERT(bp != NULL);

	error = xfs_attr_leaf_lookup_int(bp, args);

	if (error == ENOATTR) {

		xfs_da_brelse(args->trans, bp);

		xfs_trans_brelse(args->trans, bp);

		return(error);

	}
@@ -1141,8 +1139,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args) 
		 */

		if (committed)

			xfs_trans_ijoin(args->trans, dp, 0);

	} else

		xfs_da_buf_done(bp);

	}

	return(0);

}
@@ -1155,7 +1152,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args) 
STATIC int

xfs_attr_leaf_get(xfs_da_args_t *args)

{

	xfs_dabuf_t *bp;

	struct xfs_buf *bp;

	int error;



	args->blkno = 0;
@@ -1167,11 +1164,11 @@ xfs_attr_leaf_get(xfs_da_args_t *args) 


	error = xfs_attr_leaf_lookup_int(bp, args);

	if (error != EEXIST)  {

		xfs_da_brelse(args->trans, bp);

		xfs_trans_brelse(args->trans, bp);

		return(error);

	}

	error = xfs_attr_leaf_getvalue(bp, args);

	xfs_da_brelse(args->trans, bp);

	xfs_trans_brelse(args->trans, bp);

	if (!error && (args->rmtblkno > 0) && !(args->flags & ATTR_KERNOVAL)) {

		error = xfs_attr_rmtval_get(args);

	}
@@ -1186,23 +1183,23 @@ xfs_attr_leaf_list(xfs_attr_list_context_t *context) 
{

	xfs_attr_leafblock_t *leaf;

	int error;

	xfs_dabuf_t *bp;

	struct xfs_buf *bp;



	context->cursor->blkno = 0;

	error = xfs_da_read_buf(NULL, context->dp, 0, -1, &bp, XFS_ATTR_FORK);

	if (error)

		return XFS_ERROR(error);

	ASSERT(bp != NULL);

	leaf = bp->data;

	leaf = bp->b_addr;

	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);

		xfs_trans_brelse(NULL, bp);

		return XFS_ERROR(EFSCORRUPTED);

	}



	error = xfs_attr_leaf_list_int(bp, context);

	xfs_da_brelse(NULL, bp);

	xfs_trans_brelse(NULL, bp);

	return XFS_ERROR(error);

}
@@ -1489,7 +1486,7 @@ xfs_attr_node_removename(xfs_da_args_t *args) 
	xfs_da_state_t *state;

	xfs_da_state_blk_t *blk;

	xfs_inode_t *dp;

	xfs_dabuf_t *bp;

	struct xfs_buf *bp;

	int retval, error, committed, forkoff;



	trace_xfs_attr_node_removename(args);
@@ -1601,14 +1598,13 @@ xfs_attr_node_removename(xfs_da_args_t *args) 
		 */

		ASSERT(state->path.active == 1);

		ASSERT(state->path.blk[0].bp);

		xfs_da_buf_done(state->path.blk[0].bp);

		state->path.blk[0].bp = NULL;



		error = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp,

						     XFS_ATTR_FORK);

		if (error)

			goto out;

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

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

		       cpu_to_be16(XFS_ATTR_LEAF_MAGIC));



		if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
@@ -1635,7 +1631,7 @@ xfs_attr_node_removename(xfs_da_args_t *args) 
			if (committed)

				xfs_trans_ijoin(args->trans, dp, 0);

		} else

			xfs_da_brelse(args->trans, bp);

			xfs_trans_brelse(args->trans, bp);

	}

	error = 0;
@@ -1665,8 +1661,7 @@ xfs_attr_fillstate(xfs_da_state_t *state) 
	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));

	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {

		if (blk->bp) {

			blk->disk_blkno = xfs_da_blkno(blk->bp);

			xfs_da_buf_done(blk->bp);

			blk->disk_blkno = XFS_BUF_ADDR(blk->bp);

			blk->bp = NULL;

		} else {

			blk->disk_blkno = 0;
@@ -1681,8 +1676,7 @@ xfs_attr_fillstate(xfs_da_state_t *state) 
	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));

	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {

		if (blk->bp) {

			blk->disk_blkno = xfs_da_blkno(blk->bp);

			xfs_da_buf_done(blk->bp);

			blk->disk_blkno = XFS_BUF_ADDR(blk->bp);

			blk->bp = NULL;

		} else {

			blk->disk_blkno = 0;
@@ -1792,7 +1786,7 @@ xfs_attr_node_get(xfs_da_args_t *args) 
	 * If not in a transaction, we have to release all the buffers.

	 */

	for (i = 0; i < state->path.active; i++) {

		xfs_da_brelse(args->trans, state->path.blk[i].bp);

		xfs_trans_brelse(args->trans, state->path.blk[i].bp);

		state->path.blk[i].bp = NULL;

	}
@@ -1808,7 +1802,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context) 
	xfs_da_intnode_t *node;

	xfs_da_node_entry_t *btree;

	int error, i;

	xfs_dabuf_t *bp;

	struct xfs_buf *bp;



	cursor = context->cursor;

	cursor->initted = 1;
@@ -1825,30 +1819,30 @@ xfs_attr_node_list(xfs_attr_list_context_t *context) 
		if ((error != 0) && (error != EFSCORRUPTED))

			return(error);

		if (bp) {

			node = bp->data;

			node = bp->b_addr;

			switch (be16_to_cpu(node->hdr.info.magic)) {

			case XFS_DA_NODE_MAGIC:

				trace_xfs_attr_list_wrong_blk(context);

				xfs_da_brelse(NULL, bp);

				xfs_trans_brelse(NULL, bp);

				bp = NULL;

				break;

			case XFS_ATTR_LEAF_MAGIC:

				leaf = bp->data;

				leaf = bp->b_addr;

				if (cursor->hashval > be32_to_cpu(leaf->entries[

				    be16_to_cpu(leaf->hdr.count)-1].hashval)) {

					trace_xfs_attr_list_wrong_blk(context);

					xfs_da_brelse(NULL, bp);

					xfs_trans_brelse(NULL, bp);

					bp = NULL;

				} else if (cursor->hashval <=

					     be32_to_cpu(leaf->entries[0].hashval)) {

					trace_xfs_attr_list_wrong_blk(context);

					xfs_da_brelse(NULL, bp);

					xfs_trans_brelse(NULL, bp);

					bp = NULL;

				}

				break;

			default:

				trace_xfs_attr_list_wrong_blk(context);

				xfs_da_brelse(NULL, bp);

				xfs_trans_brelse(NULL, bp);

				bp = NULL;

			}

		}
@@ -1873,7 +1867,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context) 
						 context->dp->i_mount);

				return(XFS_ERROR(EFSCORRUPTED));

			}

			node = bp->data;

			node = bp->b_addr;

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

			    cpu_to_be16(XFS_ATTR_LEAF_MAGIC))

				break;
@@ -1883,7 +1877,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context) 
						     XFS_ERRLEVEL_LOW,

						     context->dp->i_mount,

						     node);

				xfs_da_brelse(NULL, bp);

				xfs_trans_brelse(NULL, bp);

				return(XFS_ERROR(EFSCORRUPTED));

			}

			btree = node->btree;
@@ -1898,10 +1892,10 @@ xfs_attr_node_list(xfs_attr_list_context_t *context) 
				}

			}

			if (i == be16_to_cpu(node->hdr.count)) {

				xfs_da_brelse(NULL, bp);

				xfs_trans_brelse(NULL, bp);

				return(0);

			}

			xfs_da_brelse(NULL, bp);

			xfs_trans_brelse(NULL, bp);

		}

	}

	ASSERT(bp != NULL);
@@ -1912,24 +1906,24 @@ xfs_attr_node_list(xfs_attr_list_context_t *context) 
	 * adding the information.

	 */

	for (;;) {

		leaf = bp->data;

		leaf = bp->b_addr;

		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);

			xfs_da_brelse(NULL, bp);

			xfs_trans_brelse(NULL, bp);

			return(XFS_ERROR(EFSCORRUPTED));

		}

		error = xfs_attr_leaf_list_int(bp, context);

		if (error) {

			xfs_da_brelse(NULL, bp);

			xfs_trans_brelse(NULL, bp);

			return error;

		}

		if (context->seen_enough || leaf->hdr.info.forw == 0)

			break;

		cursor->blkno = be32_to_cpu(leaf->hdr.info.forw);

		xfs_da_brelse(NULL, bp);

		xfs_trans_brelse(NULL, bp);

		error = xfs_da_read_buf(NULL, context->dp, cursor->blkno, -1,

					      &bp, XFS_ATTR_FORK);

		if (error)
@@ -1941,7 +1935,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context) 
			return(XFS_ERROR(EFSCORRUPTED));

		}

	}

	xfs_da_brelse(NULL, bp);

	xfs_trans_brelse(NULL, bp);

	return(0);

}

fs/xfs/xfs_attr_leaf.c

+138 −117

File changed.

Preview size limit exceeded, changes collapsed.

fs/xfs/xfs_attr_leaf.h

+10 −11
Original line number Diff line number Diff line
@@ -31,7 +31,6 @@ 
struct attrlist;

struct attrlist_cursor_kern;

struct xfs_attr_list_context;

struct xfs_dabuf;

struct xfs_da_args;

struct xfs_da_state;

struct xfs_da_state_blk;
@@ -215,7 +214,7 @@ int xfs_attr_shortform_getvalue(struct xfs_da_args *args); 
int	xfs_attr_shortform_to_leaf(struct xfs_da_args *args);

int	xfs_attr_shortform_remove(struct xfs_da_args *args);

int	xfs_attr_shortform_list(struct xfs_attr_list_context *context);

int	xfs_attr_shortform_allfit(struct xfs_dabuf *bp, struct xfs_inode *dp);

int	xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);

int	xfs_attr_shortform_bytesfit(xfs_inode_t *dp, int bytes);
@@ -223,7 +222,7 @@ int xfs_attr_shortform_bytesfit(xfs_inode_t *dp, int bytes); 
 * Internal routines when attribute fork size == XFS_LBSIZE(mp).

 */

int	xfs_attr_leaf_to_node(struct xfs_da_args *args);

int	xfs_attr_leaf_to_shortform(struct xfs_dabuf *bp,

int	xfs_attr_leaf_to_shortform(struct xfs_buf *bp,

				   struct xfs_da_args *args, int forkoff);

int	xfs_attr_leaf_clearflag(struct xfs_da_args *args);

int	xfs_attr_leaf_setflag(struct xfs_da_args *args);
@@ -235,14 +234,14 @@ int xfs_attr_leaf_flipflags(xfs_da_args_t *args); 
int	xfs_attr_leaf_split(struct xfs_da_state *state,

				   struct xfs_da_state_blk *oldblk,

				   struct xfs_da_state_blk *newblk);

int	xfs_attr_leaf_lookup_int(struct xfs_dabuf *leaf,

int	xfs_attr_leaf_lookup_int(struct xfs_buf *leaf,

					struct xfs_da_args *args);

int	xfs_attr_leaf_getvalue(struct xfs_dabuf *bp, struct xfs_da_args *args);

int	xfs_attr_leaf_add(struct xfs_dabuf *leaf_buffer,

int	xfs_attr_leaf_getvalue(struct xfs_buf *bp, struct xfs_da_args *args);

int	xfs_attr_leaf_add(struct xfs_buf *leaf_buffer,

				 struct xfs_da_args *args);

int	xfs_attr_leaf_remove(struct xfs_dabuf *leaf_buffer,

int	xfs_attr_leaf_remove(struct xfs_buf *leaf_buffer,

				    struct xfs_da_args *args);

int	xfs_attr_leaf_list_int(struct xfs_dabuf *bp,

int	xfs_attr_leaf_list_int(struct xfs_buf *bp,

				      struct xfs_attr_list_context *context);



/*
@@ -257,9 +256,9 @@ int xfs_attr_root_inactive(struct xfs_trans **trans, struct xfs_inode *dp); 
/*

 * Utility routines.

 */

xfs_dahash_t	xfs_attr_leaf_lasthash(struct xfs_dabuf *bp, int *count);

int	xfs_attr_leaf_order(struct xfs_dabuf *leaf1_bp,

				   struct xfs_dabuf *leaf2_bp);

xfs_dahash_t	xfs_attr_leaf_lasthash(struct xfs_buf *bp, int *count);

int	xfs_attr_leaf_order(struct xfs_buf *leaf1_bp,

				   struct xfs_buf *leaf2_bp);

int	xfs_attr_leaf_newentsize(int namelen, int valuelen, int blocksize,

					int *local);

#endif	/* __XFS_ATTR_LEAF_H__ */

fs/xfs/xfs_da_btree.c

+118 −219

File changed.

Preview size limit exceeded, changes collapsed.

fs/xfs/xfs_da_btree.h

+5 −27
Original line number Diff line number Diff line
@@ -132,20 +132,6 @@ typedef struct xfs_da_args { 
	{ XFS_DA_OP_OKNOENT,	"OKNOENT" }, \

	{ XFS_DA_OP_CILOOKUP,	"CILOOKUP" }



/*

 * Structure to describe buffer(s) for a block.

 * This is needed in the directory version 2 format case, when

 * multiple non-contiguous fsblocks might be needed to cover one

 * logical directory block.

 * If the buffer count is 1 then the data pointer points to the

 * same place as the b_addr field for the buffer, else to kmem_alloced memory.

 */

typedef struct xfs_dabuf {

	short		bbcount;	/* how large is data in bbs */

	void		*data;		/* pointer for buffers' data */

	struct xfs_buf	*bp;		/* actually nbuf of these */

} xfs_dabuf_t;



/*

 * Storage for holding state during Btree searches and split/join ops.

 *
@@ -154,7 +140,7 @@ typedef struct xfs_dabuf { 
 * which is slightly more than enough.

 */

typedef struct xfs_da_state_blk {

	xfs_dabuf_t	*bp;		/* buffer containing block */

	struct xfs_buf	*bp;		/* buffer containing block */

	xfs_dablk_t	blkno;		/* filesystem blkno of buffer */

	xfs_daddr_t	disk_blkno;	/* on-disk blkno (in BBs) of buffer */

	int		index;		/* relevant index into block */
@@ -207,7 +193,7 @@ struct xfs_nameops { 
 * Routines used for growing the Btree.

 */

int	xfs_da_node_create(xfs_da_args_t *args, xfs_dablk_t blkno, int level,

					 xfs_dabuf_t **bpp, int whichfork);

					 struct xfs_buf **bpp, int whichfork);

int	xfs_da_split(xfs_da_state_t *state);



/*
@@ -237,14 +223,14 @@ int xfs_da_grow_inode_int(struct xfs_da_args *args, xfs_fileoff_t *bno, 
			      int count);

int	xfs_da_get_buf(struct xfs_trans *trans, struct xfs_inode *dp,

			      xfs_dablk_t bno, xfs_daddr_t mappedbno,

			      xfs_dabuf_t **bp, int whichfork);

			      struct xfs_buf **bp, int whichfork);

int	xfs_da_read_buf(struct xfs_trans *trans, struct xfs_inode *dp,

			       xfs_dablk_t bno, xfs_daddr_t mappedbno,

			       xfs_dabuf_t **bpp, int whichfork);

			       struct xfs_buf **bpp, int whichfork);

xfs_daddr_t	xfs_da_reada_buf(struct xfs_trans *trans, struct xfs_inode *dp,

			xfs_dablk_t bno, int whichfork);

int	xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,

					  xfs_dabuf_t *dead_buf);

					  struct xfs_buf *dead_buf);



uint xfs_da_hashname(const __uint8_t *name_string, int name_length);

enum xfs_dacmp xfs_da_compname(struct xfs_da_args *args,
@@ -254,15 +240,7 @@ enum xfs_dacmp xfs_da_compname(struct xfs_da_args *args, 
xfs_da_state_t *xfs_da_state_alloc(void);

void xfs_da_state_free(xfs_da_state_t *state);



void xfs_da_buf_done(xfs_dabuf_t *dabuf);

void xfs_da_log_buf(struct xfs_trans *tp, xfs_dabuf_t *dabuf, uint first,

			   uint last);

void xfs_da_brelse(struct xfs_trans *tp, xfs_dabuf_t *dabuf);

void xfs_da_binval(struct xfs_trans *tp, xfs_dabuf_t *dabuf);

xfs_daddr_t xfs_da_blkno(xfs_dabuf_t *dabuf);



extern struct kmem_zone *xfs_da_state_zone;

extern struct kmem_zone *xfs_dabuf_zone;

extern const struct xfs_nameops xfs_default_nameops;



#endif	/* __XFS_DA_BTREE_H__ */