xfs: remove struct xfs_dabuf and infrastructure (1d9025e5) · Commits · 戴 / test

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__ */

Admin message