Re: [PATCH v13 02/10] xfs: Add delay ready attr remove routines

Allison Henderson
2020-10-29T01:32:31Z

On 10/28/20 5:04 AM, Chandan Babu R wrote:
> On Tuesday 27 October 2020 9:02:05 PM IST Allison Henderson wrote:
>>
>> On 10/27/20 2:59 AM, Chandan Babu R wrote:
>>> On Friday 23 October 2020 12:04:27 PM IST Allison Henderson wrote:
>>>> This patch modifies the attr remove routines to be delay ready. This
>>>> means they no longer roll or commit transactions, but instead return
>>>> -EAGAIN to have the calling routine roll and refresh the transaction. In
>>>> this series, xfs_attr_remove_args has become xfs_attr_remove_iter, which
>>>> uses a sort of state machine like switch to keep track of where it was
>>>> when EAGAIN was returned. xfs_attr_node_removename has also been
>>>> modified to use the switch, and a new version of xfs_attr_remove_args
>>>> consists of a simple loop to refresh the transaction until the operation
>>>> is completed. A new XFS_DAC_DEFER_FINISH flag is used to finish the
>>>> transaction where ever the existing code used to.
>>>>
>>>> Calls to xfs_attr_rmtval_remove are replaced with the delay ready
>>>> version __xfs_attr_rmtval_remove. We will rename
>>>> __xfs_attr_rmtval_remove back to xfs_attr_rmtval_remove when we are
>>>> done.
>>>>
>>>> xfs_attr_rmtval_remove itself is still in use by the set routines (used
>>>> during a rename). For reasons of preserving existing function, we
>>>> modify xfs_attr_rmtval_remove to call xfs_defer_finish when the flag is
>>>> set. Similar to how xfs_attr_remove_args does here. Once we transition
>>>> the set routines to be delay ready, xfs_attr_rmtval_remove is no longer
>>>> used and will be removed.
>>>>
>>>> This patch also adds a new struct xfs_delattr_context, which we will use
>>>> to keep track of the current state of an attribute operation. The new
>>>> xfs_delattr_state enum is used to track various operations that are in
>>>> progress so that we know not to repeat them, and resume where we left
>>>> off before EAGAIN was returned to cycle out the transaction. Other
>>>> members take the place of local variables that need to retain their
>>>> values across multiple function recalls. See xfs_attr.h for a more
>>>> detailed diagram of the states.
>>>>
>>>> Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
>>>> ---
>>>> fs/xfs/libxfs/xfs_attr.c | 200 +++++++++++++++++++++++++++++-----------
>>>> fs/xfs/libxfs/xfs_attr.h | 72 +++++++++++++++
>>>> fs/xfs/libxfs/xfs_attr_leaf.c | 2 +-
>>>> fs/xfs/libxfs/xfs_attr_remote.c | 37 ++++----
>>>> fs/xfs/libxfs/xfs_attr_remote.h | 2 +-
>>>> fs/xfs/xfs_attr_inactive.c | 2 +-
>>>> 6 files changed, 241 insertions(+), 74 deletions(-)
>>>>
>>>> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
>>>> index f4d39bf..6ca94cb 100644
>>>> --- a/fs/xfs/libxfs/xfs_attr.c
>>>> +++ b/fs/xfs/libxfs/xfs_attr.c
>>>> @@ -53,7 +53,7 @@ STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
>>>> */
>>>> STATIC int xfs_attr_node_get(xfs_da_args_t *args);
>>>> STATIC int xfs_attr_node_addname(xfs_da_args_t *args);
>>>> -STATIC int xfs_attr_node_removename(xfs_da_args_t *args);
>>>> +STATIC int xfs_attr_node_removename_iter(struct xfs_delattr_context *dac);
>>>> STATIC int xfs_attr_node_hasname(xfs_da_args_t *args,
>>>> struct xfs_da_state **state);
>>>> STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
>>>> @@ -264,6 +264,33 @@ xfs_attr_set_shortform(
>>>> }
>>>>
>>>> /*
>>>> + * Checks to see if a delayed attribute transaction should be rolled. If so,
>>>> + * also checks for a defer finish. Transaction is finished and rolled as
>>>> + * needed, and returns true of false if the delayed operation should continue.
>>>> + */
>>>> +int
>>>> +xfs_attr_trans_roll(
>>>> + struct xfs_delattr_context *dac)
>>>> +{
>>>> + struct xfs_da_args *args = dac->da_args;
>>>> + int error = 0;
>>>> +
>>>> + if (dac->flags & XFS_DAC_DEFER_FINISH) {
>>>> + /*
>>>> + * The caller wants us to finish all the deferred ops so that we
>>>> + * avoid pinning the log tail with a large number of deferred
>>>> + * ops.
>>>> + */
>>>> + dac->flags &= ~XFS_DAC_DEFER_FINISH;
>>>> + error = xfs_defer_finish(&args->trans);
>>>> + if (error)
>>>> + return error;
>>>> + }
>>>> +
>>>> + return xfs_trans_roll_inode(&args->trans, args->dp);
>>>> +}
>>>> +
>>>> +/*
>>>> * Set the attribute specified in @args.
>>>> */
>>>> int
>>>> @@ -364,23 +391,54 @@ xfs_has_attr(
>>>> */
>>>> int
>>>> xfs_attr_remove_args(
>>>> - struct xfs_da_args *args)
>>>> + struct xfs_da_args *args)
>>>> {
>>>> - struct xfs_inode *dp = args->dp;
>>>> - int error;
>>>> + int error = 0;
>>>
>>> I guess the explicit initialization of "error" can be removed since the
>>> value returned by the call to xfs_attr_remove_iter() will overwrite it.
>> Sure, will fix
>>>
>>>> + struct xfs_delattr_context dac = {
>>>> + .da_args = args,
>>>> + };
>>>> +
>>>> + do {
>>>> + error = xfs_attr_remove_iter(&dac);
>>>> + if (error != -EAGAIN)
>>>> + break;
>>>> +
>>>> + error = xfs_attr_trans_roll(&dac);
>>>> + if (error)
>>>> + return error;
>>>> +
>>>> + } while (true);
>>>> +
>>>> + return error;
>>>> +}
>>>> +
>>>> +/*
>>>> + * Remove the attribute specified in @args.
>>>> + *
>>>> + * This function may return -EAGAIN to signal that the transaction needs to be
>>>> + * rolled. Callers should continue calling this function until they receive a
>>>> + * return value other than -EAGAIN.
>>>> + */
>>>> +int
>>>> +xfs_attr_remove_iter(
>>>> + struct xfs_delattr_context *dac)
>>>> +{
>>>> + struct xfs_da_args *args = dac->da_args;
>>>> + struct xfs_inode *dp = args->dp;
>>>> +
>>>> + if (dac->dela_state == XFS_DAS_RM_SHRINK)
>>>> + goto node;
>>>>
>>>> if (!xfs_inode_hasattr(dp)) {
>>>> - error = -ENOATTR;
>>>> + return -ENOATTR;
>>>> } else if (dp->i_afp->if_format == XFS_DINODE_FMT_LOCAL) {
>>>> ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
>>>> - error = xfs_attr_shortform_remove(args);
>>>> + return xfs_attr_shortform_remove(args);
>>>> } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
>>>> - error = xfs_attr_leaf_removename(args);
>>>> - } else {
>>>> - error = xfs_attr_node_removename(args);
>>>> + return xfs_attr_leaf_removename(args);
>>>> }
>>>> -
>>>> - return error;
>>>> +node:
>>>> + return xfs_attr_node_removename_iter(dac);
>>>> }
>>>>
>>>> /*
>>>> @@ -1178,10 +1236,11 @@ xfs_attr_leaf_mark_incomplete(
>>>> */
>>>> STATIC
>>>> int xfs_attr_node_removename_setup(
>>>> - struct xfs_da_args *args,
>>>> - struct xfs_da_state **state)
>>>> + struct xfs_delattr_context *dac,
>>>> + struct xfs_da_state **state)
>>>> {
>>>> - int error;
>>>> + struct xfs_da_args *args = dac->da_args;
>>>> + int error;
>>>>
>>>> error = xfs_attr_node_hasname(args, state);
>>>> if (error != -EEXIST)
>>>> @@ -1191,6 +1250,12 @@ int xfs_attr_node_removename_setup(
>>>> ASSERT((*state)->path.blk[(*state)->path.active - 1].magic ==
>>>> XFS_ATTR_LEAF_MAGIC);
>>>>
>>>> + /*
>>>> + * Store state in the context incase we need to cycle out the
>>>> + * transaction
>>>> + */
>>>> + dac->da_state = *state;
>>>> +
>>>> if (args->rmtblkno > 0) {
>>>> error = xfs_attr_leaf_mark_incomplete(args, *state);
>>>> if (error)
>>>> @@ -1203,13 +1268,16 @@ int xfs_attr_node_removename_setup(
>>>> }
>>>>
>>>> STATIC int
>>>> -xfs_attr_node_remove_rmt(
>>>> - struct xfs_da_args *args,
>>>> - struct xfs_da_state *state)
>>>> +xfs_attr_node_remove_rmt (
>>>> + struct xfs_delattr_context *dac,
>>>> + struct xfs_da_state *state)
>>>> {
>>>> - int error = 0;
>>>> + int error = 0;
>>>>
>>>> - error = xfs_attr_rmtval_remove(args);
>>>> + /*
>>>> + * May return -EAGAIN to request that the caller recall this function
>>>> + */
>>>> + error = __xfs_attr_rmtval_remove(dac);
>>>> if (error)
>>>> return error;
>>>>
>>>> @@ -1221,21 +1289,27 @@ xfs_attr_node_remove_rmt(
>>>> }
>>>>
>>>> /*
>>>> - * Remove a name from a B-tree attribute list.
>>>> + * Step through removeing a name from a B-tree attribute list.
>>>> *
>>>> * 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 inline or delayed operation,
>>>> + * and may return -EAGAIN when the transaction needs to be rolled. Calling
>>>> + * functions will need to handle this, and recall the function until a
>>>> + * successful error code is returned.
>>>> */
>>>> STATIC int
>>>> xfs_attr_node_remove_step(
>>>> - struct xfs_da_args *args,
>>>> - struct xfs_da_state *state)
>>>> + struct xfs_delattr_context *dac)
>>>> {
>>>> - struct xfs_da_state_blk *blk;
>>>> - int retval, error;
>>>> - struct xfs_inode *dp = args->dp;
>>>> + struct xfs_da_args *args = dac->da_args;
>>>> + struct xfs_da_state *state;
>>>> + struct xfs_da_state_blk *blk;
>>>> + int retval, error = 0;
>>>>
>>>> + state = dac->da_state;
>>>>
>>>> /*
>>>> * If there is an out-of-line value, de-allocate the blocks.
>>>> @@ -1243,7 +1317,10 @@ xfs_attr_node_remove_step(
>>>> * overflow the maximum size of a transaction and/or hit a deadlock.
>>>> */
>>>> if (args->rmtblkno > 0) {
>>>> - error = xfs_attr_node_remove_rmt(args, state);
>>>> + /*
>>>> + * May return -EAGAIN. Remove blocks until args->rmtblkno == 0
>>>> + */
>>>> + error = xfs_attr_node_remove_rmt(dac, state);
>>>> if (error)
>>>> return error;
>>>> }
>>>> @@ -1257,21 +1334,18 @@ xfs_attr_node_remove_step(
>>>> xfs_da3_fixhashpath(state, &state->path);
>>>>
>>>> /*
>>>> - * Check to see if the tree needs to be collapsed.
>>>> + * Check to see if the tree needs to be collapsed. Set the flag to
>>>> + * indicate that the calling function needs to move the to shrink
>>>> + * operation
>>>> */
>>>> if (retval && (state->path.active > 1)) {
>>>> error = xfs_da3_join(state);
>>>> if (error)
>>>> return error;
>>>> - error = xfs_defer_finish(&args->trans);
>>>> - if (error)
>>>> - return error;
>>>> - /*
>>>> - * Commit the Btree join operation and start a new trans.
>>>> - */
>>>> - error = xfs_trans_roll_inode(&args->trans, dp);
>>>> - if (error)
>>>> - return error;
>>>> +
>>>> + dac->flags |= XFS_DAC_DEFER_FINISH;
>>>> + dac->dela_state = XFS_DAS_RM_SHRINK;
>>>> + return -EAGAIN;
>>>> }
>>>>
>>>> return error;
>>>> @@ -1282,31 +1356,53 @@ xfs_attr_node_remove_step(
>>>> *
>>>> * This routine will find the blocks of the name to remove, remove them and
>>>> * shirnk the tree if needed.
>>>> + *
>>>> + * This routine is meant to function as either an inline or delayed operation,
>>>> + * and may return -EAGAIN when the transaction needs to be rolled. Calling
>>>> + * functions will need to handle this, and recall the function until a
>>>> + * successful error code is returned.
>>>> */
>>>> STATIC int
>>>> -xfs_attr_node_removename(
>>>> - struct xfs_da_args *args)
>>>> +xfs_attr_node_removename_iter(
>>>> + struct xfs_delattr_context *dac)
>>>> {
>>>> - struct xfs_da_state *state;
>>>> - int error;
>>>> - struct xfs_inode *dp = args->dp;
>>>> + struct xfs_da_args *args = dac->da_args;
>>>> + struct xfs_da_state *state;
>>>> + int error;
>>>> + struct xfs_inode *dp = args->dp;
>>>>
>>>> trace_xfs_attr_node_removename(args);
>>>> + state = dac->da_state;
>>>>
>>>> - error = xfs_attr_node_removename_setup(args, &state);
>>>> - if (error)
>>>> - goto out;
>>>> + if ((dac->flags & XFS_DAC_NODE_RMVNAME_INIT) == 0) {
>>>> + dac->flags |= XFS_DAC_NODE_RMVNAME_INIT;
>>>> + error = xfs_attr_node_removename_setup(dac, &state);
>>>> + if (error)
>>>> + goto out;
>>>> + }
>>>>
>>>> - error = xfs_attr_node_remove_step(args, state);
>>>> - if (error)
>>>> - goto out;
>>>> + switch (dac->dela_state) {
>>>> + case XFS_DAS_UNINIT:
>>>> + error = xfs_attr_node_remove_step(dac);
>>>> + if (error)
>>>> + break;
>>>>
>>>> - /*
>>>> - * If the result is small enough, push it all into the inode.
>>>> - */
>>>> - if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
>>>> - error = xfs_attr_node_shrink(args, state);
>>>> + /* do not break, proceed to shrink if needed */
>>>> + case XFS_DAS_RM_SHRINK:
>>>> + /*
>>>> + * If the result is small enough, push it all into the inode.
>>>> + */
>>>> + if (xfs_bmap_one_block(dp, XFS_ATTR_FORK))
>>>> + error = xfs_attr_node_shrink(args, state);
>>>>
>>>> + break;
>>>> + default:
>>>> + ASSERT(0);
>>>> + return -EINVAL;
>>>
>>> I don't think it is possible in a real world scenario, but if "state" were
>>> pointing to allocated memory then the above return value might leak the
>>> corresponding memory.
>> Hmm, trying to follow you here.... I'm assuming you meant dela_state
>> instead of state since that's what controls the switch. The dac
>> structure is zeroed when allocated to avoid this. Most of the time when
>> this switch executes, dela_state is zero. I did have to add the
>> XFS_DAS_UNINIT from the previous suggestion in the last revision though
>> or it generates warnings.
>>>
>
> Sorry, I should have clarified that I was referring to the allocated
> memory pointed to by dac->da_state. If dac->da_state was pointing to a valid
> memory location and dac->dela_state's value is not equal to either
> XFS_DAS_UNINIT nor XFS_DAS_RM_SHRINK then the code under the "default" clause
> will execute causing -EINVAL to be returned. This could leak the memory
> pointed to by dac->da_state.

Oooh, ok I see it. We should set error to -EINVAL and goto out.
Ideally it should never happen, but that should be the proper error
handling if it did. Thanks for the catch :-)

Allison
>
>
>>> Apart from the above nit, the remaining changes look good to me.
>> Ok, thanks for the review!
>> Allison
>>
>>>
>>> Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
>>>
>>>> + }
>>>> +
>>>> + if (error == -EAGAIN)
>>>> + return error;
>>>> out:
>>>> if (state)
>>>> xfs_da_state_free(state);
>>>> diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
>>>> index 3e97a93..64dcf0f 100644
>>>> --- a/fs/xfs/libxfs/xfs_attr.h
>>>> +++ b/fs/xfs/libxfs/xfs_attr.h
>>>> @@ -74,6 +74,74 @@ struct xfs_attr_list_context {
>>>> };
>>>>
>>>>
>>>> +/*
>>>> + * ========================================================================
>>>> + * Structure used to pass context around among the delayed routines.
>>>> + * ========================================================================
>>>> + */
>>>> +
>>>> +/*
>>>> + * Below is a state machine diagram for attr remove operations. The XFS_DAS_*
>>>> + * states indicate places where the function would return -EAGAIN, and then
>>>> + * immediately resume from after being recalled by the calling function. States
>>>> + * marked as a "subroutine state" indicate that they belong to a subroutine, and
>>>> + * so the calling function needs to pass them back to that subroutine to allow
>>>> + * it to finish where it left off. But they otherwise do not have a role in the
>>>> + * calling function other than just passing through.
>>>> + *
>>>> + * xfs_attr_remove_iter()
>>>> + * XFS_DAS_RM_SHRINK ─┐
>>>> + * (subroutine state) │
>>>> + * └─>xfs_attr_node_removename()
>>>> + * │
>>>> + * v
>>>> + * need to
>>>> + * shrink tree? ─n─┐
>>>> + * │ │
>>>> + * y │
>>>> + * │ │
>>>> + * v │
>>>> + * XFS_DAS_RM_SHRINK │
>>>> + * │ │
>>>> + * v │
>>>> + * done <─────┘
>>>> + *
>>>> + */
>>>> +
>>>> +/*
>>>> + * Enum values for xfs_delattr_context.da_state
>>>> + *
>>>> + * These values are used by delayed attribute operations to keep track of where
>>>> + * they were before they returned -EAGAIN. A return code of -EAGAIN signals the
>>>> + * calling function to roll the transaction, and then recall the subroutine to
>>>> + * finish the operation. The enum is then used by the subroutine to jump back
>>>> + * to where it was and resume executing where it left off.
>>>> + */
>>>> +enum xfs_delattr_state {
>>>> + XFS_DAS_UNINIT = 0, /* No state has been set yet */
>>>> + XFS_DAS_RM_SHRINK, /* We are shrinking the tree */
>>>> +};
>>>> +
>>>> +/*
>>>> + * Defines for xfs_delattr_context.flags
>>>> + */
>>>> +#define XFS_DAC_DEFER_FINISH 0x01 /* finish the transaction */
>>>> +#define XFS_DAC_NODE_RMVNAME_INIT 0x02 /* xfs_attr_node_removename init */
>>>> +
>>>> +/*
>>>> + * Context used for keeping track of delayed attribute operations
>>>> + */
>>>> +struct xfs_delattr_context {
>>>> + struct xfs_da_args *da_args;
>>>> +
>>>> + /* Used in xfs_attr_node_removename to roll through removing blocks */
>>>> + struct xfs_da_state *da_state;
>>>> +
>>>> + /* Used to keep track of current state of delayed operation */
>>>> + unsigned int flags;
>>>> + enum xfs_delattr_state dela_state;
>>>> +};
>>>> +
>>>> /*========================================================================
>>>> * Function prototypes for the kernel.
>>>> *========================================================================*/
>>>> @@ -91,6 +159,10 @@ int xfs_attr_set(struct xfs_da_args *args);
>>>> int xfs_attr_set_args(struct xfs_da_args *args);
>>>> int xfs_has_attr(struct xfs_da_args *args);
>>>> int xfs_attr_remove_args(struct xfs_da_args *args);
>>>> +int xfs_attr_remove_iter(struct xfs_delattr_context *dac);
>>>> +int xfs_attr_trans_roll(struct xfs_delattr_context *dac);
>>>> bool xfs_attr_namecheck(const void *name, size_t length);
>>>> +void xfs_delattr_context_init(struct xfs_delattr_context *dac,
>>>> + struct xfs_da_args *args);
>>>>
>>>> #endif /* __XFS_ATTR_H__ */
>>>> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
>>>> index bb128db..338377e 100644
>>>> --- a/fs/xfs/libxfs/xfs_attr_leaf.c
>>>> +++ b/fs/xfs/libxfs/xfs_attr_leaf.c
>>>> @@ -19,8 +19,8 @@
>>>> #include "xfs_bmap_btree.h"
>>>> #include "xfs_bmap.h"
>>>> #include "xfs_attr_sf.h"
>>>> -#include "xfs_attr_remote.h"
>>>> #include "xfs_attr.h"
>>>> +#include "xfs_attr_remote.h"
>>>> #include "xfs_attr_leaf.h"
>>>> #include "xfs_error.h"
>>>> #include "xfs_trace.h"
>>>> diff --git a/fs/xfs/libxfs/xfs_attr_remote.c b/fs/xfs/libxfs/xfs_attr_remote.c
>>>> index 48d8e9c..1426c15 100644
>>>> --- a/fs/xfs/libxfs/xfs_attr_remote.c
>>>> +++ b/fs/xfs/libxfs/xfs_attr_remote.c
>>>> @@ -674,10 +674,12 @@ xfs_attr_rmtval_invalidate(
>>>> */
>>>> int
>>>> xfs_attr_rmtval_remove(
>>>> - struct xfs_da_args *args)
>>>> + struct xfs_da_args *args)
>>>> {
>>>> - int error;
>>>> - int retval;
>>>> + int error;
>>>> + struct xfs_delattr_context dac = {
>>>> + .da_args = args,
>>>> + };
>>>>
>>>> trace_xfs_attr_rmtval_remove(args);
>>>>
>>>> @@ -685,19 +687,17 @@ xfs_attr_rmtval_remove(
>>>> * Keep de-allocating extents until the remote-value region is gone.
>>>> */
>>>> do {
>>>> - retval = __xfs_attr_rmtval_remove(args);
>>>> - if (retval && retval != -EAGAIN)
>>>> - return retval;
>>>> + error = __xfs_attr_rmtval_remove(&dac);
>>>> + if (error != -EAGAIN)
>>>> + break;
>>>>
>>>> - /*
>>>> - * Close out trans and start the next one in the chain.
>>>> - */
>>>> - error = xfs_trans_roll_inode(&args->trans, args->dp);
>>>> + error = xfs_attr_trans_roll(&dac);
>>>> if (error)
>>>> return error;
>>>> - } while (retval == -EAGAIN);
>>>>
>>>> - return 0;
>>>> + } while (true);
>>>> +
>>>> + return error;
>>>> }
>>>>
>>>> /*
>>>> @@ -707,9 +707,10 @@ xfs_attr_rmtval_remove(
>>>> */
>>>> int
>>>> __xfs_attr_rmtval_remove(
>>>> - struct xfs_da_args *args)
>>>> + struct xfs_delattr_context *dac)
>>>> {
>>>> - int error, done;
>>>> + struct xfs_da_args *args = dac->da_args;
>>>> + int error, done;
>>>>
>>>> /*
>>>> * Unmap value blocks for this attr.
>>>> @@ -719,12 +720,10 @@ __xfs_attr_rmtval_remove(
>>>> if (error)
>>>> return error;
>>>>
>>>> - error = xfs_defer_finish(&args->trans);
>>>> - if (error)
>>>> - return error;
>>>> -
>>>> - if (!done)
>>>> + if (!done) {
>>>> + dac->flags |= XFS_DAC_DEFER_FINISH;
>>>> return -EAGAIN;
>>>> + }
>>>>
>>>> return error;
>>>> }
>>>> diff --git a/fs/xfs/libxfs/xfs_attr_remote.h b/fs/xfs/libxfs/xfs_attr_remote.h
>>>> index 9eee615..002fd30 100644
>>>> --- a/fs/xfs/libxfs/xfs_attr_remote.h
>>>> +++ b/fs/xfs/libxfs/xfs_attr_remote.h
>>>> @@ -14,5 +14,5 @@ int xfs_attr_rmtval_remove(struct xfs_da_args *args);
>>>> int xfs_attr_rmtval_stale(struct xfs_inode *ip, struct xfs_bmbt_irec *map,
>>>> xfs_buf_flags_t incore_flags);
>>>> int xfs_attr_rmtval_invalidate(struct xfs_da_args *args);
>>>> -int __xfs_attr_rmtval_remove(struct xfs_da_args *args);
>>>> +int __xfs_attr_rmtval_remove(struct xfs_delattr_context *dac);
>>>> #endif /* __XFS_ATTR_REMOTE_H__ */
>>>> diff --git a/fs/xfs/xfs_attr_inactive.c b/fs/xfs/xfs_attr_inactive.c
>>>> index bfad669..aaa7e66 100644
>>>> --- a/fs/xfs/xfs_attr_inactive.c
>>>> +++ b/fs/xfs/xfs_attr_inactive.c
>>>> @@ -15,10 +15,10 @@
>>>> #include "xfs_da_format.h"
>>>> #include "xfs_da_btree.h"
>>>> #include "xfs_inode.h"
>>>> +#include "xfs_attr.h"
>>>> #include "xfs_attr_remote.h"
>>>> #include "xfs_trans.h"
>>>> #include "xfs_bmap.h"
>>>> -#include "xfs_attr.h"
>>>> #include "xfs_attr_leaf.h"
>>>> #include "xfs_quota.h"
>>>> #include "xfs_dir2.h"
>>>>
>>>
>>>
>>
>
>