xfs: remove xfs_attri_remove_iter (59782a23) · Commits · EulixOS / Software / Kernel

fs/xfs/libxfs/xfs_attr.c

+139 −279

Original line number	Original line	Diff line number	Diff line
	@@ -63,10 +63,6 @@ STATIC int xfs_attr_node_addname_find_attr(struct xfs_attr_item *attr);
	STATIC int xfs_attr_node_remove_attr(struct xfs_attr_item *attr);		STATIC int xfs_attr_node_remove_attr(struct xfs_attr_item *attr);
	STATIC int xfs_attr_node_hasname(xfs_da_args_t *args,		STATIC int xfs_attr_node_hasname(xfs_da_args_t *args,
	struct xfs_da_state **state);		struct xfs_da_state **state);
	STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
	STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
	STATIC int xfs_attr_node_removename(struct xfs_da_args *args,
	struct xfs_da_state *state);

	int		int
	xfs_inode_hasattr(		xfs_inode_hasattr(
	@@ -99,6 +95,123 @@ xfs_attr_is_leaf(
	return imap.br_startoff == 0 && imap.br_blockcount == 1;		return imap.br_startoff == 0 && imap.br_blockcount == 1;
	}		}

			/*
			* XXX (dchinner): name path state saving and refilling is an optimisation to
			* avoid needing to look up name entries after rolling transactions removing
			* remote xattr blocks between the name entry lookup and name entry removal.
			* This optimisation got sidelined when combining the set and remove state
			* machines, but the code has been left in place because it is worthwhile to
			* restore the optimisation once the combined state machine paths have settled.
			*
			* This comment is a public service announcement to remind Future Dave that he
			* still needs to restore this code to working order.
			*/
			#if 0
			/*
			* Fill in the disk block numbers in the state structure for the buffers
			* that are attached to the state structure.
			* This is done so that we can quickly reattach ourselves to those buffers
			* after some set of transaction commits have released these buffers.
			*/
			static int
			xfs_attr_fillstate(xfs_da_state_t *state)
			{
			xfs_da_state_path_t *path;
			xfs_da_state_blk_t *blk;
			int level;

			trace_xfs_attr_fillstate(state->args);

			/*
			* Roll down the "path" in the state structure, storing the on-disk
			* block number for those buffers in the "path".
			*/
			path = &state->path;
			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_buf_daddr(blk->bp);
			blk->bp = NULL;
			} else {
			blk->disk_blkno = 0;
			}
			}

			/*
			* Roll down the "altpath" in the state structure, storing the on-disk
			* block number for those buffers in the "altpath".
			*/
			path = &state->altpath;
			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_buf_daddr(blk->bp);
			blk->bp = NULL;
			} else {
			blk->disk_blkno = 0;
			}
			}

			return 0;
			}

			/*
			* Reattach the buffers to the state structure based on the disk block
			* numbers stored in the state structure.
			* This is done after some set of transaction commits have released those
			* buffers from our grip.
			*/
			static int
			xfs_attr_refillstate(xfs_da_state_t *state)
			{
			xfs_da_state_path_t *path;
			xfs_da_state_blk_t *blk;
			int level, error;

			trace_xfs_attr_refillstate(state->args);

			/*
			* Roll down the "path" in the state structure, storing the on-disk
			* block number for those buffers in the "path".
			*/
			path = &state->path;
			ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
			for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
			if (blk->disk_blkno) {
			error = xfs_da3_node_read_mapped(state->args->trans,
			state->args->dp, blk->disk_blkno,
			&blk->bp, XFS_ATTR_FORK);
			if (error)
			return error;
			} else {
			blk->bp = NULL;
			}
			}

			/*
			* Roll down the "altpath" in the state structure, storing the on-disk
			* block number for those buffers in the "altpath".
			*/
			path = &state->altpath;
			ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
			for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
			if (blk->disk_blkno) {
			error = xfs_da3_node_read_mapped(state->args->trans,
			state->args->dp, blk->disk_blkno,
			&blk->bp, XFS_ATTR_FORK);
			if (error)
			return error;
			} else {
			blk->bp = NULL;
			}
			}

			return 0;
			}
			#else
			static int xfs_attr_fillstate(xfs_da_state_t *state) { return 0; }
			#endif

	/*========================================================================		/*========================================================================
	* Overall external interface routines.		* Overall external interface routines.
	========================================================================/		========================================================================/
	@@ -547,25 +660,16 @@ xfs_attr_leaf_remove_attr(
	*/		*/
	static int		static int
	xfs_attr_leaf_shrink(		xfs_attr_leaf_shrink(
	struct xfs_da_args *args,		struct xfs_da_args *args)
	struct xfs_da_state *state)
	{		{
	struct xfs_inode *dp = args->dp;		struct xfs_inode *dp = args->dp;
	int error, forkoff;
	struct xfs_buf *bp;		struct xfs_buf *bp;
			int forkoff;
			int error;

	if (!xfs_attr_is_leaf(dp))		if (!xfs_attr_is_leaf(dp))
	return 0;		return 0;

	/*
	* Have to get rid of the copy of this dabuf in the state.
	*/
	if (state) {
	ASSERT(state->path.active == 1);
	ASSERT(state->path.blk[0].bp);
	state->path.blk[0].bp = NULL;
	}

	error = xfs_attr3_leaf_read(args->trans, args->dp, 0, &bp);		error = xfs_attr3_leaf_read(args->trans, args->dp, 0, &bp);
	if (error)		if (error)
	return error;		return error;
	@@ -708,7 +812,7 @@ xfs_attr_set_iter(
	case XFS_DAS_NODE_REMOVE_ATTR:		case XFS_DAS_NODE_REMOVE_ATTR:
	error = xfs_attr_node_remove_attr(attr);		error = xfs_attr_node_remove_attr(attr);
	if (!error)		if (!error)
	error = xfs_attr_leaf_shrink(args, NULL);		error = xfs_attr_leaf_shrink(args);
	attr->xattri_dela_state = XFS_DAS_DONE;		attr->xattri_dela_state = XFS_DAS_DONE;
	break;		break;
	default:		default:
	@@ -1379,50 +1483,7 @@ xfs_attr_node_try_addname(
	return error;		return error;
	}		}


	static int		static int
	xfs_attr_node_remove_attr(
	struct xfs_attr_item *attr)
	{
	struct xfs_da_args *args = attr->xattri_da_args;
	struct xfs_da_state *state = NULL;
	int retval = 0;
	int error = 0;

	/*
	* The attr we are removing has already been marked incomplete, so
	* we need to set the filter appropriately to re-find the "old"
	* attribute entry after any split ops.
	*/
	args->attr_filter \|= XFS_ATTR_INCOMPLETE;
	state = xfs_da_state_alloc(args);
	state->inleaf = 0;
	error = xfs_da3_node_lookup_int(state, &retval);
	if (error)
	goto out;

	error = xfs_attr_node_removename(args, state);

	/*
	* Check to see if the tree needs to be collapsed.
	*/
	if (retval && (state->path.active > 1)) {
	error = xfs_da3_join(state);
	if (error)
	goto out;
	}
	retval = error = 0;

	out:
	if (state)
	xfs_da_state_free(state);
	if (error)
	return error;
	return retval;
	}


	STATIC int
	xfs_attr_node_removename(		xfs_attr_node_removename(
	struct xfs_da_args *args,		struct xfs_da_args *args,
	struct xfs_da_state *state)		struct xfs_da_state *state)
	@@ -1441,246 +1502,45 @@ xfs_attr_node_removename(
	return retval;		return retval;
	}		}

	/*		static int
	* Remove the attribute specified in @args.		xfs_attr_node_remove_attr(
	*
	* This will involve walking down the Btree, and may involve joining
	* leaf nodes and even joining intermediate nodes up to and including
	* the root node (a special case of an intermediate node).
	*
	* This routine is meant to function as either an in-line or delayed operation,
	* and may return -EAGAIN when the transaction needs to be rolled. Calling
	* functions will need to handle this, and call the function until a
	* successful error code is returned.
	*/
	int
	xfs_attr_remove_iter(
	struct xfs_attr_item *attr)		struct xfs_attr_item *attr)
	{		{
	struct xfs_da_args *args = attr->xattri_da_args;		struct xfs_da_args *args = attr->xattri_da_args;
	struct xfs_da_state *state = attr->xattri_da_state;		struct xfs_da_state *state = NULL;
	int retval, error = 0;		int retval = 0;
	struct xfs_inode *dp = args->dp;		int error = 0;

	trace_xfs_attr_node_removename(args);

	switch (attr->xattri_dela_state) {
	case XFS_DAS_UNINIT:
	if (!xfs_inode_hasattr(dp))
	return -ENOATTR;

	/*
	* Shortform or leaf formats don't require transaction rolls and
	* thus state transitions. Call the right helper and return.
	*/
	if (dp->i_afp->if_format == XFS_DINODE_FMT_LOCAL)
	return xfs_attr_sf_removename(args);

	if (xfs_attr_is_leaf(dp))
	return xfs_attr_leaf_removename(args);

	/*
	* Node format may require transaction rolls. Set up the
	* state context and fall into the state machine.
	*/
	if (!attr->xattri_da_state) {
	error = xfs_attr_node_removename_setup(attr);
	if (error)
	return error;
	state = attr->xattri_da_state;
	}

	fallthrough;
	case XFS_DAS_RMTBLK:
	attr->xattri_dela_state = XFS_DAS_RMTBLK;

	/*
	* If there is an out-of-line value, de-allocate the blocks.
	* This is done before we remove the attribute so that we don't
	* overflow the maximum size of a transaction and/or hit a
	* deadlock.
	*/
	if (args->rmtblkno > 0) {
	/*
	* May return -EAGAIN. Roll and repeat until all remote
	* blocks are removed.
	*/
	error = xfs_attr_rmtval_remove(attr);
	if (error == -EAGAIN) {
	trace_xfs_attr_remove_iter_return(
	attr->xattri_dela_state, args->dp);
	return error;
	} else if (error) {
	goto out;
	}

	/*
	* Refill the state structure with buffers (the prior
	* calls released our buffers) and close out this
	* transaction before proceeding.
	*/
	ASSERT(args->rmtblkno == 0);
	error = xfs_attr_refillstate(state);
	if (error)
	goto out;

	attr->xattri_dela_state = XFS_DAS_RM_NAME;
	trace_xfs_attr_remove_iter_return(
	attr->xattri_dela_state, args->dp);
	return -EAGAIN;
	}

	fallthrough;
	case XFS_DAS_RM_NAME:
	/*		/*
	* If we came here fresh from a transaction roll, reattach all		* The attr we are removing has already been marked incomplete, so
	* the buffers to the current transaction.		* we need to set the filter appropriately to re-find the "old"
			* attribute entry after any split ops.
	*/		*/
	if (attr->xattri_dela_state == XFS_DAS_RM_NAME) {		args->attr_filter \|= XFS_ATTR_INCOMPLETE;
	error = xfs_attr_refillstate(state);		state = xfs_da_state_alloc(args);
			state->inleaf = 0;
			error = xfs_da3_node_lookup_int(state, &retval);
	if (error)		if (error)
	goto out;		goto out;
	}

	retval = xfs_attr_node_removename(args, state);		error = xfs_attr_node_removename(args, state);

	/*		/*
	* Check to see if the tree needs to be collapsed. If so, roll		* Check to see if the tree needs to be collapsed.
	* the transacton and fall into the shrink state.
	*/		*/
	if (retval && (state->path.active > 1)) {		if (retval && (state->path.active > 1)) {
	error = xfs_da3_join(state);		error = xfs_da3_join(state);
	if (error)		if (error)
	goto out;		goto out;

	attr->xattri_dela_state = XFS_DAS_RM_SHRINK;
	trace_xfs_attr_remove_iter_return(
	attr->xattri_dela_state, args->dp);
	return -EAGAIN;
	}		}
			retval = error = 0;

	fallthrough;
	case XFS_DAS_RM_SHRINK:
	/*
	* If the result is small enough, push it all into the inode.
	* This is our final state so it's safe to return a dirty
	* transaction.
	*/
	if (xfs_attr_is_leaf(dp))
	error = xfs_attr_leaf_shrink(args, state);
	ASSERT(error != -EAGAIN);
	break;
	default:
	ASSERT(0);
	error = -EINVAL;
	goto out;
	}
	out:		out:
	if (state)		if (state)
	xfs_da_state_free(state);		xfs_da_state_free(state);
	return error;
	}

	/*
	* Fill in the disk block numbers in the state structure for the buffers
	* that are attached to the state structure.
	* This is done so that we can quickly reattach ourselves to those buffers
	* after some set of transaction commits have released these buffers.
	*/
	STATIC int
	xfs_attr_fillstate(xfs_da_state_t *state)
	{
	xfs_da_state_path_t *path;
	xfs_da_state_blk_t *blk;
	int level;

	trace_xfs_attr_fillstate(state->args);

	/*
	* Roll down the "path" in the state structure, storing the on-disk
	* block number for those buffers in the "path".
	*/
	path = &state->path;
	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_buf_daddr(blk->bp);
	blk->bp = NULL;
	} else {
	blk->disk_blkno = 0;
	}
	}

	/*
	* Roll down the "altpath" in the state structure, storing the on-disk
	* block number for those buffers in the "altpath".
	*/
	path = &state->altpath;
	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_buf_daddr(blk->bp);
	blk->bp = NULL;
	} else {
	blk->disk_blkno = 0;
	}
	}

	return 0;
	}

	/*
	* Reattach the buffers to the state structure based on the disk block
	* numbers stored in the state structure.
	* This is done after some set of transaction commits have released those
	* buffers from our grip.
	*/
	STATIC int
	xfs_attr_refillstate(xfs_da_state_t *state)
	{
	xfs_da_state_path_t *path;
	xfs_da_state_blk_t *blk;
	int level, error;

	trace_xfs_attr_refillstate(state->args);

	/*
	* Roll down the "path" in the state structure, storing the on-disk
	* block number for those buffers in the "path".
	*/
	path = &state->path;
	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
	if (blk->disk_blkno) {
	error = xfs_da3_node_read_mapped(state->args->trans,
	state->args->dp, blk->disk_blkno,
	&blk->bp, XFS_ATTR_FORK);
	if (error)		if (error)
	return error;		return error;
	} else {		return retval;
	blk->bp = NULL;
	}
	}

	/*
	* Roll down the "altpath" in the state structure, storing the on-disk
	* block number for those buffers in the "altpath".
	*/
	path = &state->altpath;
	ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
	for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
	if (blk->disk_blkno) {
	error = xfs_da3_node_read_mapped(state->args->trans,
	state->args->dp, blk->disk_blkno,
	&blk->bp, XFS_ATTR_FORK);
	if (error)
	return error;
	} else {
	blk->bp = NULL;
	}
	}

	return 0;
	}		}

	/*		/*