[v7,03/19] xfs: Add xfs_has_attr and subroutines
diff mbox series

Message ID 20200223020611.1802-4-allison.henderson@oracle.com
State Superseded
Headers show
Series
  • xfs: Delayed Ready Attrs
Related show

Commit Message

Allison Collins Feb. 23, 2020, 2:05 a.m. UTC
From: Allison Henderson <allison.henderson@oracle.com>

This patch adds a new functions to check for the existence of an attribute.
Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
Common code that appears in existing attr add and remove functions have been
factored out to help reduce the appearance of duplicated code.  We will need these
routines later for delayed attributes since delayed operations cannot return error
codes.

Signed-off-by: Allison Collins <allison.henderson@oracle.com>
---
 fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
 fs/xfs/libxfs/xfs_attr.h      |   1 +
 fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
 fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
 4 files changed, 188 insertions(+), 98 deletions(-)

Comments

Amir Goldstein Feb. 23, 2020, 12:20 p.m. UTC | #1
On Sun, Feb 23, 2020 at 4:07 AM Allison Collins
<allison.henderson@oracle.com> wrote:
>
> From: Allison Henderson <allison.henderson@oracle.com>
>
> This patch adds a new functions to check for the existence of an attribute.
> Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
> Common code that appears in existing attr add and remove functions have been
> factored out to help reduce the appearance of duplicated code.  We will need these
> routines later for delayed attributes since delayed operations cannot return error
> codes.
>
> Signed-off-by: Allison Collins <allison.henderson@oracle.com>
> ---
>  fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
>  fs/xfs/libxfs/xfs_attr.h      |   1 +
>  fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
>  fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
>  4 files changed, 188 insertions(+), 98 deletions(-)
>
> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> index 9acdb23..2255060 100644
> --- a/fs/xfs/libxfs/xfs_attr.c
> +++ b/fs/xfs/libxfs/xfs_attr.c
> @@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
>  STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
>  STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
>  STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> +STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
>
>  /*
>   * Internal routines when attribute list is more than one block.
> @@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
>  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_hasname(xfs_da_args_t *args,
> +                                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);
>
> @@ -310,6 +313,37 @@ xfs_attr_set_args(
>  }
>
>  /*
> + * Return EEXIST if attr is found, or ENOATTR if not

This is a very silly return value for a function named has_attr in my taste.
I realize you inherited this interface from xfs_attr3_leaf_lookup_int(), but
IMO this change looks like a very good opportunity to change that internal
API:

xfs_has_attr?

0: NO
1: YES (or stay with the syscall standard of -ENOATTR)
<0: error

> + */
> +int
> +xfs_has_attr(
> +       struct xfs_da_args      *args)
> +{
> +       struct xfs_inode        *dp = args->dp;
> +       struct xfs_buf          *bp = NULL;
> +       int                     error;
> +
> +       if (!xfs_inode_hasattr(dp))
> +               return -ENOATTR;
> +
> +       if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
> +               ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
> +               return xfs_attr_sf_findname(args, NULL, NULL);
> +       }
> +
> +       if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
> +               error = xfs_attr_leaf_hasname(args, &bp);
> +
> +               if (bp)
> +                       xfs_trans_brelse(args->trans, bp);
> +
> +               return error;
> +       }
> +
> +       return xfs_attr_node_hasname(args, NULL);
> +}
> +
> +/*
>   * Remove the attribute specified in @args.
>   */
>  int
> @@ -583,26 +617,20 @@ STATIC int
>  xfs_attr_leaf_addname(
>         struct xfs_da_args      *args)
>  {
> -       struct xfs_inode        *dp;
>         struct xfs_buf          *bp;
>         int                     retval, error, forkoff;
> +       struct xfs_inode        *dp = args->dp;
>
>         trace_xfs_attr_leaf_addname(args);
>
>         /*
> -        * Read the (only) block in the attribute list in.
> -        */
> -       dp = args->dp;
> -       args->blkno = 0;
> -       error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> -       if (error)
> -               return error;
> -
> -       /*
>          * Look up the given attribute in the leaf block.  Figure out if
>          * the given flags produce an error or call for an atomic rename.
>          */
> -       retval = xfs_attr3_leaf_lookup_int(bp, args);
> +       retval = xfs_attr_leaf_hasname(args, &bp);
> +       if (retval != -ENOATTR && retval != -EEXIST)
> +               return retval;
> +
>         if ((args->name.type & ATTR_REPLACE) && (retval == -ENOATTR)) {

Example of how sane code (in my taste) would look like:

       retval = xfs_attr_leaf_hasname(args, &bp);
       if (retval < 0)
               return retval;

        if ((args->name.type & ATTR_REPLACE) && !retval) {
                 xfs_trans_brelse(args->trans, bp);
                 return -ENOATTR;
        } else if (retval) {
                if (args->flags & ATTR_CREATE) {        /* pure create op */
                        xfs_trans_brelse(args->trans, bp);
                        return -EEXIST;
               }

Thanks,
Amir.
Allison Collins Feb. 23, 2020, 5:28 p.m. UTC | #2
On 2/23/20 5:20 AM, Amir Goldstein wrote:
> On Sun, Feb 23, 2020 at 4:07 AM Allison Collins
> <allison.henderson@oracle.com> wrote:
>>
>> From: Allison Henderson <allison.henderson@oracle.com>
>>
>> This patch adds a new functions to check for the existence of an attribute.
>> Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
>> Common code that appears in existing attr add and remove functions have been
>> factored out to help reduce the appearance of duplicated code.  We will need these
>> routines later for delayed attributes since delayed operations cannot return error
>> codes.
>>
>> Signed-off-by: Allison Collins <allison.henderson@oracle.com>
>> ---
>>   fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
>>   fs/xfs/libxfs/xfs_attr.h      |   1 +
>>   fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
>>   fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
>>   4 files changed, 188 insertions(+), 98 deletions(-)
>>
>> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
>> index 9acdb23..2255060 100644
>> --- a/fs/xfs/libxfs/xfs_attr.c
>> +++ b/fs/xfs/libxfs/xfs_attr.c
>> @@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
>>   STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
>>   STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
>>   STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
>> +STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
>>
>>   /*
>>    * Internal routines when attribute list is more than one block.
>> @@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
>>   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_hasname(xfs_da_args_t *args,
>> +                                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);
>>
>> @@ -310,6 +313,37 @@ xfs_attr_set_args(
>>   }
>>
>>   /*
>> + * Return EEXIST if attr is found, or ENOATTR if not
> 
> This is a very silly return value for a function named has_attr in my taste.
> I realize you inherited this interface from xfs_attr3_leaf_lookup_int(), but
> IMO this change looks like a very good opportunity to change that internal
> API:
> 
> xfs_has_attr?
> 
> 0: NO
> 1: YES (or stay with the syscall standard of -ENOATTR)
> <0: error
Darrick had mentioned something like that in the last revision, but I 
think people wanted to keep everything a straight hoist at this phase. 
At least as much as possible.  Maybe I can add another patch that does 
this at the end when we're doing clean ups.

Allison

> 
>> + */
>> +int
>> +xfs_has_attr(
>> +       struct xfs_da_args      *args)
>> +{
>> +       struct xfs_inode        *dp = args->dp;
>> +       struct xfs_buf          *bp = NULL;
>> +       int                     error;
>> +
>> +       if (!xfs_inode_hasattr(dp))
>> +               return -ENOATTR;
>> +
>> +       if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
>> +               ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
>> +               return xfs_attr_sf_findname(args, NULL, NULL);
>> +       }
>> +
>> +       if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
>> +               error = xfs_attr_leaf_hasname(args, &bp);
>> +
>> +               if (bp)
>> +                       xfs_trans_brelse(args->trans, bp);
>> +
>> +               return error;
>> +       }
>> +
>> +       return xfs_attr_node_hasname(args, NULL);
>> +}
>> +
>> +/*
>>    * Remove the attribute specified in @args.
>>    */
>>   int
>> @@ -583,26 +617,20 @@ STATIC int
>>   xfs_attr_leaf_addname(
>>          struct xfs_da_args      *args)
>>   {
>> -       struct xfs_inode        *dp;
>>          struct xfs_buf          *bp;
>>          int                     retval, error, forkoff;
>> +       struct xfs_inode        *dp = args->dp;
>>
>>          trace_xfs_attr_leaf_addname(args);
>>
>>          /*
>> -        * Read the (only) block in the attribute list in.
>> -        */
>> -       dp = args->dp;
>> -       args->blkno = 0;
>> -       error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>> -       if (error)
>> -               return error;
>> -
>> -       /*
>>           * Look up the given attribute in the leaf block.  Figure out if
>>           * the given flags produce an error or call for an atomic rename.
>>           */
>> -       retval = xfs_attr3_leaf_lookup_int(bp, args);
>> +       retval = xfs_attr_leaf_hasname(args, &bp);
>> +       if (retval != -ENOATTR && retval != -EEXIST)
>> +               return retval;
>> +
>>          if ((args->name.type & ATTR_REPLACE) && (retval == -ENOATTR)) {
> 
> Example of how sane code (in my taste) would look like:
> 
>         retval = xfs_attr_leaf_hasname(args, &bp);
>         if (retval < 0)
>                 return retval;
> 
>          if ((args->name.type & ATTR_REPLACE) && !retval) {
>                   xfs_trans_brelse(args->trans, bp);
>                   return -ENOATTR;
>          } else if (retval) {
>                  if (args->flags & ATTR_CREATE) {        /* pure create op */
>                          xfs_trans_brelse(args->trans, bp);
>                          return -EEXIST;
>                 }
> 
> Thanks,
> Amir.
>
Amir Goldstein Feb. 24, 2020, 6:58 a.m. UTC | #3
On Sun, Feb 23, 2020 at 7:28 PM Allison Collins
<allison.henderson@oracle.com> wrote:
>
>
>
> On 2/23/20 5:20 AM, Amir Goldstein wrote:
> > On Sun, Feb 23, 2020 at 4:07 AM Allison Collins
> > <allison.henderson@oracle.com> wrote:
> >>
> >> From: Allison Henderson <allison.henderson@oracle.com>
> >>
> >> This patch adds a new functions to check for the existence of an attribute.
> >> Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
> >> Common code that appears in existing attr add and remove functions have been
> >> factored out to help reduce the appearance of duplicated code.  We will need these
> >> routines later for delayed attributes since delayed operations cannot return error
> >> codes.
> >>
> >> Signed-off-by: Allison Collins <allison.henderson@oracle.com>
> >> ---
> >>   fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
> >>   fs/xfs/libxfs/xfs_attr.h      |   1 +
> >>   fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
> >>   fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
> >>   4 files changed, 188 insertions(+), 98 deletions(-)
> >>
> >> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> >> index 9acdb23..2255060 100644
> >> --- a/fs/xfs/libxfs/xfs_attr.c
> >> +++ b/fs/xfs/libxfs/xfs_attr.c
> >> @@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
> >>   STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
> >>   STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
> >>   STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> >> +STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
> >>
> >>   /*
> >>    * Internal routines when attribute list is more than one block.
> >> @@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> >>   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_hasname(xfs_da_args_t *args,
> >> +                                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);
> >>
> >> @@ -310,6 +313,37 @@ xfs_attr_set_args(
> >>   }
> >>
> >>   /*
> >> + * Return EEXIST if attr is found, or ENOATTR if not
> >
> > This is a very silly return value for a function named has_attr in my taste.
> > I realize you inherited this interface from xfs_attr3_leaf_lookup_int(), but
> > IMO this change looks like a very good opportunity to change that internal
> > API:
> >
> > xfs_has_attr?
> >
> > 0: NO
> > 1: YES (or stay with the syscall standard of -ENOATTR)
> > <0: error
> Darrick had mentioned something like that in the last revision, but I
> think people wanted to keep everything a straight hoist at this phase.
> At least as much as possible.  Maybe I can add another patch that does
> this at the end when we're doing clean ups.

In my opinion, this change is hard enough to follow as is.
Making the interface cleaner at this point is not going to make
following the change any harder if anything I thing a clean interface
that makes sense, will make things easier at this point.
But whether you do it now or later, the interface was very bad IMO before
and when attached to a helper named has_attr makes it much worse.

Thanks,
Amir.
Brian Foster Feb. 24, 2020, 1:08 p.m. UTC | #4
On Sat, Feb 22, 2020 at 07:05:55PM -0700, Allison Collins wrote:
> From: Allison Henderson <allison.henderson@oracle.com>
> 
> This patch adds a new functions to check for the existence of an attribute.
> Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
> Common code that appears in existing attr add and remove functions have been
> factored out to help reduce the appearance of duplicated code.  We will need these
> routines later for delayed attributes since delayed operations cannot return error
> codes.
> 
> Signed-off-by: Allison Collins <allison.henderson@oracle.com>
> ---
>  fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
>  fs/xfs/libxfs/xfs_attr.h      |   1 +
>  fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
>  fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
>  4 files changed, 188 insertions(+), 98 deletions(-)
> 
> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> index 9acdb23..2255060 100644
> --- a/fs/xfs/libxfs/xfs_attr.c
> +++ b/fs/xfs/libxfs/xfs_attr.c
...
> @@ -310,6 +313,37 @@ xfs_attr_set_args(
>  }
>  
>  /*
> + * Return EEXIST if attr is found, or ENOATTR if not
> + */
> +int
> +xfs_has_attr(
> +	struct xfs_da_args      *args)
> +{
> +	struct xfs_inode	*dp = args->dp;
> +	struct xfs_buf		*bp = NULL;
> +	int			error;
> +
> +	if (!xfs_inode_hasattr(dp))
> +		return -ENOATTR;
> +
> +	if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
> +		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
> +		return xfs_attr_sf_findname(args, NULL, NULL);

Nit: any reason we use "findname" here and "hasname" for the other two
variants?

Just a few other nit level things..

> +	}
> +
> +	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
> +		error = xfs_attr_leaf_hasname(args, &bp);
> +
> +		if (bp)
> +			xfs_trans_brelse(args->trans, bp);
> +
> +		return error;
> +	}
> +
> +	return xfs_attr_node_hasname(args, NULL);
> +}
> +
> +/*
>   * Remove the attribute specified in @args.
>   */
>  int
...
> @@ -773,12 +822,11 @@ xfs_attr_leaf_removename(
>  	 * Remove the attribute.
>  	 */
>  	dp = args->dp;
> -	args->blkno = 0;
> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> -	if (error)
> +
> +	error = xfs_attr_leaf_hasname(args, &bp);
> +	if (error != -ENOATTR && error != -EEXIST)
>  		return error;
>  
> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>  	if (error == -ENOATTR) {

It looks like some of these error checks could be cleaned up where the
helper function is used. I.e., something like the following here:

	if (error == -ENOATTR) {
		xfs_trans_brelse(...);
		return error;
	} else if (error != -EEXIST)
		return error;

>  		xfs_trans_brelse(args->trans, bp);
>  		return error;
> @@ -817,12 +865,10 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>  
>  	trace_xfs_attr_leaf_get(args);
>  
> -	args->blkno = 0;
> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> -	if (error)
> +	error = xfs_attr_leaf_hasname(args, &bp);
> +	if (error != -ENOATTR && error != -EEXIST)
>  		return error;
>  
> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>  	if (error != -EEXIST)  {
>  		xfs_trans_brelse(args->trans, bp);
>  		return error;

Similar thing here, just reordering the checks simplifies the logic.

> @@ -832,6 +878,41 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>  	return error;
>  }
>  
> +/*
> + * Return EEXIST if attr is found, or ENOATTR if not
> + * statep: If not null is set to point at the found state.  Caller will
> + *         be responsible for freeing the state in this case.
> + */
> +STATIC int
> +xfs_attr_node_hasname(
> +	struct xfs_da_args	*args,
> +	struct xfs_da_state	**statep)
> +{
> +	struct xfs_da_state	*state;
> +	int			retval, error;
> +
> +	state = xfs_da_state_alloc();
> +	state->args = args;
> +	state->mp = args->dp->i_mount;
> +
> +	if (statep != NULL)
> +		*statep = NULL;
> +
> +	/*
> +	 * Search to see if name exists, and get back a pointer to it.
> +	 */
> +	error = xfs_da3_node_lookup_int(state, &retval);
> +	if (error == 0) {
> +		if (statep != NULL)
> +			*statep = state;
> +		return retval;
> +	}
> +
> +	xfs_da_state_free(state);
> +
> +	return error;
> +}
> +
>  /*========================================================================
>   * External routines when attribute list size > geo->blksize
>   *========================================================================*/
...
> @@ -1316,31 +1381,23 @@ xfs_attr_node_get(xfs_da_args_t *args)
>  {
>  	xfs_da_state_t *state;
>  	xfs_da_state_blk_t *blk;
> -	int error, retval;
> +	int error;
>  	int i;
>  
>  	trace_xfs_attr_node_get(args);
>  
> -	state = xfs_da_state_alloc();
> -	state->args = args;
> -	state->mp = args->dp->i_mount;
> -
>  	/*
>  	 * Search to see if name exists, and get back a pointer to it.
>  	 */
> -	error = xfs_da3_node_lookup_int(state, &retval);
> -	if (error) {
> -		retval = error;
> -		goto out_release;
> -	}
> -	if (retval != -EEXIST)
> +	error = xfs_attr_node_hasname(args, &state);
> +	if (error != -EEXIST)
>  		goto out_release;
>  
>  	/*
>  	 * Get the value, local or "remote"
>  	 */
>  	blk = &state->path.blk[state->path.active - 1];
> -	retval = xfs_attr3_leaf_getvalue(blk->bp, args);
> +	error = xfs_attr3_leaf_getvalue(blk->bp, args);
>  
>  	/*
>  	 * If not in a transaction, we have to release all the buffers.
> @@ -1352,7 +1409,7 @@ xfs_attr_node_get(xfs_da_args_t *args)
>  	}
>  
>  	xfs_da_state_free(state);

Do we need an 'if (state)' check here like the other node funcs?

> -	return retval;
> +	return error;
>  }
>  
>  /* Returns true if the attribute entry name is valid. */
...
> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
> index cb5ef66..9d6b68c 100644
> --- a/fs/xfs/libxfs/xfs_attr_leaf.c
> +++ b/fs/xfs/libxfs/xfs_attr_leaf.c
> @@ -654,18 +654,66 @@ xfs_attr_shortform_create(xfs_da_args_t *args)
>  }
>  
>  /*
> + * Return -EEXIST if attr is found, or -ENOATTR if not
> + * args:  args containing attribute name and namelen
> + * sfep:  If not null, pointer will be set to the last attr entry found on
> +	  -EEXIST.  On -ENOATTR pointer is left at the last entry in the list
> + * basep: If not null, pointer is set to the byte offset of the entry in the
> + *	  list on -EEXIST.  On -ENOATTR, pointer is left at the byte offset of
> + *	  the last entry in the list
> + */
> +int
> +xfs_attr_sf_findname(
> +	struct xfs_da_args	 *args,
> +	struct xfs_attr_sf_entry **sfep,
> +	unsigned int		 *basep)
> +{
> +	struct xfs_attr_shortform *sf;
> +	struct xfs_attr_sf_entry *sfe;
> +	unsigned int		base = sizeof(struct xfs_attr_sf_hdr);
> +	int			size = 0;
> +	int			end;
> +	int			i;
> +
> +	sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data;
> +	sfe = &sf->list[0];
> +	end = sf->hdr.count;
> +	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
> +			base += size, i++) {

Slightly more readable to align indendation with the sfe assignment
above.

Brian

> +		size = XFS_ATTR_SF_ENTSIZE(sfe);
> +		if (sfe->namelen != args->name.len)
> +			continue;
> +		if (memcmp(sfe->nameval, args->name.name, args->name.len) != 0)
> +			continue;
> +		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
> +			continue;
> +		break;
> +	}
> +
> +	if (sfep != NULL)
> +		*sfep = sfe;
> +
> +	if (basep != NULL)
> +		*basep = base;
> +
> +	if (i == end)
> +		return -ENOATTR;
> +	return -EEXIST;
> +}
> +
> +/*
>   * Add a name/value pair to the shortform attribute list.
>   * Overflow from the inode has already been checked for.
>   */
>  void
> -xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
> +xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff)
>  {
> -	xfs_attr_shortform_t *sf;
> -	xfs_attr_sf_entry_t *sfe;
> -	int i, offset, size;
> -	xfs_mount_t *mp;
> -	xfs_inode_t *dp;
> -	struct xfs_ifork *ifp;
> +	struct xfs_attr_shortform	*sf;
> +	struct xfs_attr_sf_entry	*sfe;
> +	int				offset, size, error;
> +	struct xfs_mount		*mp;
> +	struct xfs_inode		*dp;
> +	struct xfs_ifork		*ifp;
>  
>  	trace_xfs_attr_sf_add(args);
>  
> @@ -676,18 +724,8 @@ xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
>  	ifp = dp->i_afp;
>  	ASSERT(ifp->if_flags & XFS_IFINLINE);
>  	sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
> -	sfe = &sf->list[0];
> -	for (i = 0; i < sf->hdr.count; sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
> -#ifdef DEBUG
> -		if (sfe->namelen != args->name.len)
> -			continue;
> -		if (memcmp(args->name.name, sfe->nameval, args->name.len) != 0)
> -			continue;
> -		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
> -			continue;
> -		ASSERT(0);
> -#endif
> -	}
> +	error = xfs_attr_sf_findname(args, &sfe, NULL);
> +	ASSERT(error != -EEXIST);
>  
>  	offset = (char *)sfe - (char *)sf;
>  	size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->name.len, args->valuelen);
> @@ -730,35 +768,26 @@ xfs_attr_fork_remove(
>   * Remove an attribute from the shortform attribute list structure.
>   */
>  int
> -xfs_attr_shortform_remove(xfs_da_args_t *args)
> +xfs_attr_shortform_remove(struct xfs_da_args *args)
>  {
> -	xfs_attr_shortform_t *sf;
> -	xfs_attr_sf_entry_t *sfe;
> -	int base, size=0, end, totsize, i;
> -	xfs_mount_t *mp;
> -	xfs_inode_t *dp;
> +	struct xfs_attr_shortform	*sf;
> +	struct xfs_attr_sf_entry	*sfe;
> +	int				size = 0, end, totsize;
> +	unsigned int			base;
> +	struct xfs_mount		*mp;
> +	struct xfs_inode		*dp;
> +	int				error;
>  
>  	trace_xfs_attr_sf_remove(args);
>  
>  	dp = args->dp;
>  	mp = dp->i_mount;
> -	base = sizeof(xfs_attr_sf_hdr_t);
>  	sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
> -	sfe = &sf->list[0];
> -	end = sf->hdr.count;
> -	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
> -					base += size, i++) {
> -		size = XFS_ATTR_SF_ENTSIZE(sfe);
> -		if (sfe->namelen != args->name.len)
> -			continue;
> -		if (memcmp(sfe->nameval, args->name.name, args->name.len) != 0)
> -			continue;
> -		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
> -			continue;
> -		break;
> -	}
> -	if (i == end)
> -		return -ENOATTR;
> +
> +	error = xfs_attr_sf_findname(args, &sfe, &base);
> +	if (error != -EEXIST)
> +		return error;
> +	size = XFS_ATTR_SF_ENTSIZE(sfe);
>  
>  	/*
>  	 * Fix up the attribute fork data, covering the hole
> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
> index 73615b1..0e9c87c 100644
> --- a/fs/xfs/libxfs/xfs_attr_leaf.h
> +++ b/fs/xfs/libxfs/xfs_attr_leaf.h
> @@ -53,6 +53,9 @@ int	xfs_attr_shortform_getvalue(struct xfs_da_args *args);
>  int	xfs_attr_shortform_to_leaf(struct xfs_da_args *args,
>  			struct xfs_buf **leaf_bp);
>  int	xfs_attr_shortform_remove(struct xfs_da_args *args);
> +int	xfs_attr_sf_findname(struct xfs_da_args *args,
> +			     struct xfs_attr_sf_entry **sfep,
> +			     unsigned int *basep);
>  int	xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);
>  int	xfs_attr_shortform_bytesfit(struct xfs_inode *dp, int bytes);
>  xfs_failaddr_t xfs_attr_shortform_verify(struct xfs_inode *ip);
> -- 
> 2.7.4
>
Allison Collins Feb. 24, 2020, 9:18 p.m. UTC | #5
On 2/24/20 6:08 AM, Brian Foster wrote:
> On Sat, Feb 22, 2020 at 07:05:55PM -0700, Allison Collins wrote:
>> From: Allison Henderson <allison.henderson@oracle.com>
>>
>> This patch adds a new functions to check for the existence of an attribute.
>> Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
>> Common code that appears in existing attr add and remove functions have been
>> factored out to help reduce the appearance of duplicated code.  We will need these
>> routines later for delayed attributes since delayed operations cannot return error
>> codes.
>>
>> Signed-off-by: Allison Collins <allison.henderson@oracle.com>
>> ---
>>   fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
>>   fs/xfs/libxfs/xfs_attr.h      |   1 +
>>   fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
>>   fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
>>   4 files changed, 188 insertions(+), 98 deletions(-)
>>
>> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
>> index 9acdb23..2255060 100644
>> --- a/fs/xfs/libxfs/xfs_attr.c
>> +++ b/fs/xfs/libxfs/xfs_attr.c
> ...
>> @@ -310,6 +313,37 @@ xfs_attr_set_args(
>>   }
>>   
>>   /*
>> + * Return EEXIST if attr is found, or ENOATTR if not
>> + */
>> +int
>> +xfs_has_attr(
>> +	struct xfs_da_args      *args)
>> +{
>> +	struct xfs_inode	*dp = args->dp;
>> +	struct xfs_buf		*bp = NULL;
>> +	int			error;
>> +
>> +	if (!xfs_inode_hasattr(dp))
>> +		return -ENOATTR;
>> +
>> +	if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
>> +		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
>> +		return xfs_attr_sf_findname(args, NULL, NULL);
> 
> Nit: any reason we use "findname" here and "hasname" for the other two
> variants?
It was asked for in the v4 review.  Reason being we also return the 
location of the sf entry and byte offset.

> 
> Just a few other nit level things..
> 
>> +	}
>> +
>> +	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
>> +		error = xfs_attr_leaf_hasname(args, &bp);
>> +
>> +		if (bp)
>> +			xfs_trans_brelse(args->trans, bp);
>> +
>> +		return error;
>> +	}
>> +
>> +	return xfs_attr_node_hasname(args, NULL);
>> +}
>> +
>> +/*
>>    * Remove the attribute specified in @args.
>>    */
>>   int
> ...
>> @@ -773,12 +822,11 @@ xfs_attr_leaf_removename(
>>   	 * Remove the attribute.
>>   	 */
>>   	dp = args->dp;
>> -	args->blkno = 0;
>> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>> -	if (error)
>> +
>> +	error = xfs_attr_leaf_hasname(args, &bp);
>> +	if (error != -ENOATTR && error != -EEXIST)
>>   		return error;
>>   
>> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>>   	if (error == -ENOATTR) {
> 
> It looks like some of these error checks could be cleaned up where the
> helper function is used. I.e., something like the following here:
> 
> 	if (error == -ENOATTR) {
> 		xfs_trans_brelse(...);
> 		return error;
> 	} else if (error != -EEXIST)
> 		return error;
Sure, I'm starting to get more pressure in other reviews to change this 
api to a boolean return type though (1: y, 0: no, <0: error).  I think 
we talked about this in v3, but decided to stick with this original api 
for now.  I'm thinking maybe adding a patch at the end to shift the api 
might be a good compromise?  Thoughts?

> 
>>   		xfs_trans_brelse(args->trans, bp);
>>   		return error;
>> @@ -817,12 +865,10 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>>   
>>   	trace_xfs_attr_leaf_get(args);
>>   
>> -	args->blkno = 0;
>> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>> -	if (error)
>> +	error = xfs_attr_leaf_hasname(args, &bp);
>> +	if (error != -ENOATTR && error != -EEXIST)
>>   		return error;
>>   
>> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>>   	if (error != -EEXIST)  {
>>   		xfs_trans_brelse(args->trans, bp);
>>   		return error;
> 
> Similar thing here, just reordering the checks simplifies the logic.
Sure, will do.

> 
>> @@ -832,6 +878,41 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>>   	return error;
>>   }
>>   
>> +/*
>> + * Return EEXIST if attr is found, or ENOATTR if not
>> + * statep: If not null is set to point at the found state.  Caller will
>> + *         be responsible for freeing the state in this case.
>> + */
>> +STATIC int
>> +xfs_attr_node_hasname(
>> +	struct xfs_da_args	*args,
>> +	struct xfs_da_state	**statep)
>> +{
>> +	struct xfs_da_state	*state;
>> +	int			retval, error;
>> +
>> +	state = xfs_da_state_alloc();
>> +	state->args = args;
>> +	state->mp = args->dp->i_mount;
>> +
>> +	if (statep != NULL)
>> +		*statep = NULL;
>> +
>> +	/*
>> +	 * Search to see if name exists, and get back a pointer to it.
>> +	 */
>> +	error = xfs_da3_node_lookup_int(state, &retval);
>> +	if (error == 0) {
>> +		if (statep != NULL)
>> +			*statep = state;
>> +		return retval;
>> +	}
>> +
>> +	xfs_da_state_free(state);
>> +
>> +	return error;
>> +}
>> +
>>   /*========================================================================
>>    * External routines when attribute list size > geo->blksize
>>    *========================================================================*/
> ...
>> @@ -1316,31 +1381,23 @@ xfs_attr_node_get(xfs_da_args_t *args)
>>   {
>>   	xfs_da_state_t *state;
>>   	xfs_da_state_blk_t *blk;
>> -	int error, retval;
>> +	int error;
>>   	int i;
>>   
>>   	trace_xfs_attr_node_get(args);
>>   
>> -	state = xfs_da_state_alloc();
>> -	state->args = args;
>> -	state->mp = args->dp->i_mount;
>> -
>>   	/*
>>   	 * Search to see if name exists, and get back a pointer to it.
>>   	 */
>> -	error = xfs_da3_node_lookup_int(state, &retval);
>> -	if (error) {
>> -		retval = error;
>> -		goto out_release;
>> -	}
>> -	if (retval != -EEXIST)
>> +	error = xfs_attr_node_hasname(args, &state);
>> +	if (error != -EEXIST)
>>   		goto out_release;
>>   
>>   	/*
>>   	 * Get the value, local or "remote"
>>   	 */
>>   	blk = &state->path.blk[state->path.active - 1];
>> -	retval = xfs_attr3_leaf_getvalue(blk->bp, args);
>> +	error = xfs_attr3_leaf_getvalue(blk->bp, args);
>>   
>>   	/*
>>   	 * If not in a transaction, we have to release all the buffers.
>> @@ -1352,7 +1409,7 @@ xfs_attr_node_get(xfs_da_args_t *args)
>>   	}
>>   
>>   	xfs_da_state_free(state);
> 
> Do we need an 'if (state)' check here like the other node funcs?
I think so, because if xfs_attr_node_hasname errors out it releases the 
state.  Will add.

> 
>> -	return retval;
>> +	return error;
>>   }
>>   
>>   /* Returns true if the attribute entry name is valid. */
> ...
>> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
>> index cb5ef66..9d6b68c 100644
>> --- a/fs/xfs/libxfs/xfs_attr_leaf.c
>> +++ b/fs/xfs/libxfs/xfs_attr_leaf.c
>> @@ -654,18 +654,66 @@ xfs_attr_shortform_create(xfs_da_args_t *args)
>>   }
>>   
>>   /*
>> + * Return -EEXIST if attr is found, or -ENOATTR if not
>> + * args:  args containing attribute name and namelen
>> + * sfep:  If not null, pointer will be set to the last attr entry found on
>> +	  -EEXIST.  On -ENOATTR pointer is left at the last entry in the list
>> + * basep: If not null, pointer is set to the byte offset of the entry in the
>> + *	  list on -EEXIST.  On -ENOATTR, pointer is left at the byte offset of
>> + *	  the last entry in the list
>> + */
>> +int
>> +xfs_attr_sf_findname(
>> +	struct xfs_da_args	 *args,
>> +	struct xfs_attr_sf_entry **sfep,
>> +	unsigned int		 *basep)
>> +{
>> +	struct xfs_attr_shortform *sf;
>> +	struct xfs_attr_sf_entry *sfe;
>> +	unsigned int		base = sizeof(struct xfs_attr_sf_hdr);
>> +	int			size = 0;
>> +	int			end;
>> +	int			i;
>> +
>> +	sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data;
>> +	sfe = &sf->list[0];
>> +	end = sf->hdr.count;
>> +	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
>> +			base += size, i++) {
> 
> Slightly more readable to align indendation with the sfe assignment
> above.
Sure, will fix.  Thanks!

Allison

> 
> Brian
> 
>> +		size = XFS_ATTR_SF_ENTSIZE(sfe);
>> +		if (sfe->namelen != args->name.len)
>> +			continue;
>> +		if (memcmp(sfe->nameval, args->name.name, args->name.len) != 0)
>> +			continue;
>> +		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
>> +			continue;
>> +		break;
>> +	}
>> +
>> +	if (sfep != NULL)
>> +		*sfep = sfe;
>> +
>> +	if (basep != NULL)
>> +		*basep = base;
>> +
>> +	if (i == end)
>> +		return -ENOATTR;
>> +	return -EEXIST;
>> +}
>> +
>> +/*
>>    * Add a name/value pair to the shortform attribute list.
>>    * Overflow from the inode has already been checked for.
>>    */
>>   void
>> -xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
>> +xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff)
>>   {
>> -	xfs_attr_shortform_t *sf;
>> -	xfs_attr_sf_entry_t *sfe;
>> -	int i, offset, size;
>> -	xfs_mount_t *mp;
>> -	xfs_inode_t *dp;
>> -	struct xfs_ifork *ifp;
>> +	struct xfs_attr_shortform	*sf;
>> +	struct xfs_attr_sf_entry	*sfe;
>> +	int				offset, size, error;
>> +	struct xfs_mount		*mp;
>> +	struct xfs_inode		*dp;
>> +	struct xfs_ifork		*ifp;
>>   
>>   	trace_xfs_attr_sf_add(args);
>>   
>> @@ -676,18 +724,8 @@ xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
>>   	ifp = dp->i_afp;
>>   	ASSERT(ifp->if_flags & XFS_IFINLINE);
>>   	sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
>> -	sfe = &sf->list[0];
>> -	for (i = 0; i < sf->hdr.count; sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
>> -#ifdef DEBUG
>> -		if (sfe->namelen != args->name.len)
>> -			continue;
>> -		if (memcmp(args->name.name, sfe->nameval, args->name.len) != 0)
>> -			continue;
>> -		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
>> -			continue;
>> -		ASSERT(0);
>> -#endif
>> -	}
>> +	error = xfs_attr_sf_findname(args, &sfe, NULL);
>> +	ASSERT(error != -EEXIST);
>>   
>>   	offset = (char *)sfe - (char *)sf;
>>   	size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->name.len, args->valuelen);
>> @@ -730,35 +768,26 @@ xfs_attr_fork_remove(
>>    * Remove an attribute from the shortform attribute list structure.
>>    */
>>   int
>> -xfs_attr_shortform_remove(xfs_da_args_t *args)
>> +xfs_attr_shortform_remove(struct xfs_da_args *args)
>>   {
>> -	xfs_attr_shortform_t *sf;
>> -	xfs_attr_sf_entry_t *sfe;
>> -	int base, size=0, end, totsize, i;
>> -	xfs_mount_t *mp;
>> -	xfs_inode_t *dp;
>> +	struct xfs_attr_shortform	*sf;
>> +	struct xfs_attr_sf_entry	*sfe;
>> +	int				size = 0, end, totsize;
>> +	unsigned int			base;
>> +	struct xfs_mount		*mp;
>> +	struct xfs_inode		*dp;
>> +	int				error;
>>   
>>   	trace_xfs_attr_sf_remove(args);
>>   
>>   	dp = args->dp;
>>   	mp = dp->i_mount;
>> -	base = sizeof(xfs_attr_sf_hdr_t);
>>   	sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
>> -	sfe = &sf->list[0];
>> -	end = sf->hdr.count;
>> -	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
>> -					base += size, i++) {
>> -		size = XFS_ATTR_SF_ENTSIZE(sfe);
>> -		if (sfe->namelen != args->name.len)
>> -			continue;
>> -		if (memcmp(sfe->nameval, args->name.name, args->name.len) != 0)
>> -			continue;
>> -		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
>> -			continue;
>> -		break;
>> -	}
>> -	if (i == end)
>> -		return -ENOATTR;
>> +
>> +	error = xfs_attr_sf_findname(args, &sfe, &base);
>> +	if (error != -EEXIST)
>> +		return error;
>> +	size = XFS_ATTR_SF_ENTSIZE(sfe);
>>   
>>   	/*
>>   	 * Fix up the attribute fork data, covering the hole
>> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
>> index 73615b1..0e9c87c 100644
>> --- a/fs/xfs/libxfs/xfs_attr_leaf.h
>> +++ b/fs/xfs/libxfs/xfs_attr_leaf.h
>> @@ -53,6 +53,9 @@ int	xfs_attr_shortform_getvalue(struct xfs_da_args *args);
>>   int	xfs_attr_shortform_to_leaf(struct xfs_da_args *args,
>>   			struct xfs_buf **leaf_bp);
>>   int	xfs_attr_shortform_remove(struct xfs_da_args *args);
>> +int	xfs_attr_sf_findname(struct xfs_da_args *args,
>> +			     struct xfs_attr_sf_entry **sfep,
>> +			     unsigned int *basep);
>>   int	xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);
>>   int	xfs_attr_shortform_bytesfit(struct xfs_inode *dp, int bytes);
>>   xfs_failaddr_t xfs_attr_shortform_verify(struct xfs_inode *ip);
>> -- 
>> 2.7.4
>>
>
Dave Chinner Feb. 25, 2020, 6:26 a.m. UTC | #6
On Sun, Feb 23, 2020 at 02:20:32PM +0200, Amir Goldstein wrote:
> On Sun, Feb 23, 2020 at 4:07 AM Allison Collins
> <allison.henderson@oracle.com> wrote:
> >
> > From: Allison Henderson <allison.henderson@oracle.com>
> >
> > This patch adds a new functions to check for the existence of an attribute.
> > Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
> > Common code that appears in existing attr add and remove functions have been
> > factored out to help reduce the appearance of duplicated code.  We will need these
> > routines later for delayed attributes since delayed operations cannot return error
> > codes.
> >
> > Signed-off-by: Allison Collins <allison.henderson@oracle.com>
> > ---
> >  fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
> >  fs/xfs/libxfs/xfs_attr.h      |   1 +
> >  fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
> >  fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
> >  4 files changed, 188 insertions(+), 98 deletions(-)
> >
> > diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> > index 9acdb23..2255060 100644
> > --- a/fs/xfs/libxfs/xfs_attr.c
> > +++ b/fs/xfs/libxfs/xfs_attr.c
> > @@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
> >  STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
> >  STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
> >  STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> > +STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
> >
> >  /*
> >   * Internal routines when attribute list is more than one block.
> > @@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> >  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_hasname(xfs_da_args_t *args,
> > +                                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);
> >
> > @@ -310,6 +313,37 @@ xfs_attr_set_args(
> >  }
> >
> >  /*
> > + * Return EEXIST if attr is found, or ENOATTR if not
> 
> This is a very silly return value for a function named has_attr in my taste.
> I realize you inherited this interface from xfs_attr3_leaf_lookup_int(), but
> IMO this change looks like a very good opportunity to change that internal
> API:

tl;dr Cleaning up this API is work for another patchset.

> 
> xfs_has_attr?
> 
> 0: NO
> 1: YES (or stay with the syscall standard of -ENOATTR)
> <0: error

While I agree with your sentiment, Amir, the API you suggest is an
anti-pattern. We've been removing ternary return value APIs like
this from XFS and replacing them with an explicit error return value
and an operational return parameter like so:

	error = xfs_has_attr(&exists)
	if (error)
		return error;

	if (!exists && REPLACE) {
		error = -ENOATTR;
		goto out_error_release;
	}
	if (exists && CREATE) {
		error = -EEXIST;
		goto out_error_release;
	}

	.....

out_error_release:
	xfs_trans_brelse(args->trans, bp);
	return error;

This allows us to separate out fatal metadata fetch and parsing
errors from the operational logic that is run on the status returned
from a successful function call.

IMO, this sort of API change needs to be driven right down into
the internal functions that generate ENOATTR/EEXIST in the first
place. Otherwise all we are doing here is forcing the new code to
translate ENOATTR/EEXIST to some intermediate error code that the
higher layer code then has to convert back to ENOATTR/EEXIST so that
it's callers function properly.

Hence I don't think chagning this API just for this new function
makes the code simpler or easier to maintain. And I don't really
think changing the entire API is in the scope of this work. Hence,
even though I don't like the API, I think it is fine to be retained
for this patchset.

Cheers,

Dave.
Amir Goldstein Feb. 25, 2020, 6:43 a.m. UTC | #7
On Tue, Feb 25, 2020 at 8:26 AM Dave Chinner <david@fromorbit.com> wrote:
>
> On Sun, Feb 23, 2020 at 02:20:32PM +0200, Amir Goldstein wrote:
> > On Sun, Feb 23, 2020 at 4:07 AM Allison Collins
> > <allison.henderson@oracle.com> wrote:
> > >
> > > From: Allison Henderson <allison.henderson@oracle.com>
> > >
> > > This patch adds a new functions to check for the existence of an attribute.
> > > Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
> > > Common code that appears in existing attr add and remove functions have been
> > > factored out to help reduce the appearance of duplicated code.  We will need these
> > > routines later for delayed attributes since delayed operations cannot return error
> > > codes.
> > >
> > > Signed-off-by: Allison Collins <allison.henderson@oracle.com>
> > > ---
> > >  fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
> > >  fs/xfs/libxfs/xfs_attr.h      |   1 +
> > >  fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
> > >  fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
> > >  4 files changed, 188 insertions(+), 98 deletions(-)
> > >
> > > diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> > > index 9acdb23..2255060 100644
> > > --- a/fs/xfs/libxfs/xfs_attr.c
> > > +++ b/fs/xfs/libxfs/xfs_attr.c
> > > @@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
> > >  STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
> > >  STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
> > >  STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> > > +STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
> > >
> > >  /*
> > >   * Internal routines when attribute list is more than one block.
> > > @@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> > >  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_hasname(xfs_da_args_t *args,
> > > +                                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);
> > >
> > > @@ -310,6 +313,37 @@ xfs_attr_set_args(
> > >  }
> > >
> > >  /*
> > > + * Return EEXIST if attr is found, or ENOATTR if not
> >
> > This is a very silly return value for a function named has_attr in my taste.
> > I realize you inherited this interface from xfs_attr3_leaf_lookup_int(), but
> > IMO this change looks like a very good opportunity to change that internal
> > API:
>
> tl;dr Cleaning up this API is work for another patchset.
>
> >
> > xfs_has_attr?
> >
> > 0: NO
> > 1: YES (or stay with the syscall standard of -ENOATTR)
> > <0: error
>
> While I agree with your sentiment, Amir, the API you suggest is an
> anti-pattern. We've been removing ternary return value APIs like
> this from XFS and replacing them with an explicit error return value
> and an operational return parameter like so:
>
>         error = xfs_has_attr(&exists)
>         if (error)
>                 return error;
>

That would be neat and tidy.

One of the outcomes of new reviewers is comments on code unrelated
to the changes... I have no problem of keeping API as is for Allison's
change, but I did want to point out that the API became worse to read
due to the helper name change from _lookup_attr to _has_attr, which
really asks for a yes or no answer.

Thanks,
Amir.
Chandan Rajendra Feb. 25, 2020, 9:49 a.m. UTC | #8
On Sunday, February 23, 2020 7:35 AM Allison Collins wrote: 
> From: Allison Henderson <allison.henderson@oracle.com>
> 
> This patch adds a new functions to check for the existence of an attribute.
> Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
> Common code that appears in existing attr add and remove functions have been
> factored out to help reduce the appearance of duplicated code.  We will need these
> routines later for delayed attributes since delayed operations cannot return error
> codes.
> 
> Signed-off-by: Allison Collins <allison.henderson@oracle.com>
> ---
>  fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
>  fs/xfs/libxfs/xfs_attr.h      |   1 +
>  fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
>  fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
>  4 files changed, 188 insertions(+), 98 deletions(-)
> 
> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> index 9acdb23..2255060 100644
> --- a/fs/xfs/libxfs/xfs_attr.c
> +++ b/fs/xfs/libxfs/xfs_attr.c
> @@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
>  STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
>  STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
>  STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> +STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
>  
>  /*
>   * Internal routines when attribute list is more than one block.
> @@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
>  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_hasname(xfs_da_args_t *args,
> +				 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);
>  
> @@ -310,6 +313,37 @@ xfs_attr_set_args(
>  }
>  
>  /*
> + * Return EEXIST if attr is found, or ENOATTR if not
> + */
> +int
> +xfs_has_attr(
> +	struct xfs_da_args      *args)
> +{
> +	struct xfs_inode	*dp = args->dp;
> +	struct xfs_buf		*bp = NULL;
> +	int			error;
> +
> +	if (!xfs_inode_hasattr(dp))
> +		return -ENOATTR;
> +
> +	if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
> +		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
> +		return xfs_attr_sf_findname(args, NULL, NULL);
> +	}
> +
> +	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
> +		error = xfs_attr_leaf_hasname(args, &bp);
> +
> +		if (bp)
> +			xfs_trans_brelse(args->trans, bp);
> +
> +		return error;
> +	}
> +
> +	return xfs_attr_node_hasname(args, NULL);
> +}
> +
> +/*
>   * Remove the attribute specified in @args.
>   */
>  int
> @@ -583,26 +617,20 @@ STATIC int
>  xfs_attr_leaf_addname(
>  	struct xfs_da_args	*args)
>  {
> -	struct xfs_inode	*dp;
>  	struct xfs_buf		*bp;
>  	int			retval, error, forkoff;
> +	struct xfs_inode	*dp = args->dp;
>  
>  	trace_xfs_attr_leaf_addname(args);
>  
>  	/*
> -	 * Read the (only) block in the attribute list in.
> -	 */
> -	dp = args->dp;
> -	args->blkno = 0;
> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> -	if (error)
> -		return error;
> -
> -	/*
>  	 * Look up the given attribute in the leaf block.  Figure out if
>  	 * the given flags produce an error or call for an atomic rename.
>  	 */
> -	retval = xfs_attr3_leaf_lookup_int(bp, args);
> +	retval = xfs_attr_leaf_hasname(args, &bp);
> +	if (retval != -ENOATTR && retval != -EEXIST)
> +		return retval;
> +
>  	if ((args->name.type & ATTR_REPLACE) && (retval == -ENOATTR)) {
>  		xfs_trans_brelse(args->trans, bp);
>  		return retval;
> @@ -754,6 +782,27 @@ xfs_attr_leaf_addname(
>  }
>  
>  /*
> + * Return EEXIST if attr is found, or ENOATTR if not
> + */
> +STATIC int
> +xfs_attr_leaf_hasname(
> +	struct xfs_da_args      *args,
> +	struct xfs_buf		**bp)
> +{
> +	int                     error = 0;
> +
> +	error = xfs_attr3_leaf_read(args->trans, args->dp, 0, bp);
> +	if (error)
> +		return error;
> +
> +	error = xfs_attr3_leaf_lookup_int(*bp, args);
> +	if (error != -ENOATTR && error != -EEXIST)
> +		xfs_trans_brelse(args->trans, *bp);
> +
> +	return error;
> +}
> +
> +/*
>   * Remove a name from the leaf attribute list structure
>   *
>   * This leaf block cannot have a "remote" value, we only call this routine
> @@ -773,12 +822,11 @@ xfs_attr_leaf_removename(
>  	 * Remove the attribute.
>  	 */
>  	dp = args->dp;
> -	args->blkno = 0;
> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> -	if (error)
> +
> +	error = xfs_attr_leaf_hasname(args, &bp);
> +	if (error != -ENOATTR && error != -EEXIST)
>  		return error;
>  
> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>  	if (error == -ENOATTR) {
>  		xfs_trans_brelse(args->trans, bp);
>  		return error;
> @@ -817,12 +865,10 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>  
>  	trace_xfs_attr_leaf_get(args);
>  
> -	args->blkno = 0;
> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> -	if (error)
> +	error = xfs_attr_leaf_hasname(args, &bp);
> +	if (error != -ENOATTR && error != -EEXIST)
>  		return error;
>  
> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>  	if (error != -EEXIST)  {
>  		xfs_trans_brelse(args->trans, bp);
>  		return error;
> @@ -832,6 +878,41 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>  	return error;
>  }
>  
> +/*
> + * Return EEXIST if attr is found, or ENOATTR if not
> + * statep: If not null is set to point at the found state.  Caller will
> + *         be responsible for freeing the state in this case.
> + */
> +STATIC int
> +xfs_attr_node_hasname(
> +	struct xfs_da_args	*args,
> +	struct xfs_da_state	**statep)
> +{
> +	struct xfs_da_state	*state;
> +	int			retval, error;
> +
> +	state = xfs_da_state_alloc();
> +	state->args = args;
> +	state->mp = args->dp->i_mount;
> +
> +	if (statep != NULL)
> +		*statep = NULL;
> +
> +	/*
> +	 * Search to see if name exists, and get back a pointer to it.
> +	 */
> +	error = xfs_da3_node_lookup_int(state, &retval);
> +	if (error == 0) {
> +		if (statep != NULL)
> +			*statep = state;
> +		return retval;
> +	}

If 'statep' were NULL, then this would leak the memory pointed to by 'state'
right?
Chandan Rajendra Feb. 25, 2020, 10:15 a.m. UTC | #9
On Tuesday, February 25, 2020 3:19 PM Chandan Rajendra wrote: 
> On Sunday, February 23, 2020 7:35 AM Allison Collins wrote: 
> > From: Allison Henderson <allison.henderson@oracle.com>
> > 
> > This patch adds a new functions to check for the existence of an attribute.
> > Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
> > Common code that appears in existing attr add and remove functions have been
> > factored out to help reduce the appearance of duplicated code.  We will need these
> > routines later for delayed attributes since delayed operations cannot return error
> > codes.
> > 
> > Signed-off-by: Allison Collins <allison.henderson@oracle.com>
> > ---
> >  fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
> >  fs/xfs/libxfs/xfs_attr.h      |   1 +
> >  fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
> >  fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
> >  4 files changed, 188 insertions(+), 98 deletions(-)
> > 
> > diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> > index 9acdb23..2255060 100644
> > --- a/fs/xfs/libxfs/xfs_attr.c
> > +++ b/fs/xfs/libxfs/xfs_attr.c
> > @@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
> >  STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
> >  STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
> >  STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> > +STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
> >  
> >  /*
> >   * Internal routines when attribute list is more than one block.
> > @@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> >  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_hasname(xfs_da_args_t *args,
> > +				 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);
> >  
> > @@ -310,6 +313,37 @@ xfs_attr_set_args(
> >  }
> >  
> >  /*
> > + * Return EEXIST if attr is found, or ENOATTR if not
> > + */
> > +int
> > +xfs_has_attr(
> > +	struct xfs_da_args      *args)
> > +{
> > +	struct xfs_inode	*dp = args->dp;
> > +	struct xfs_buf		*bp = NULL;
> > +	int			error;
> > +
> > +	if (!xfs_inode_hasattr(dp))
> > +		return -ENOATTR;
> > +
> > +	if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
> > +		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
> > +		return xfs_attr_sf_findname(args, NULL, NULL);
> > +	}
> > +
> > +	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
> > +		error = xfs_attr_leaf_hasname(args, &bp);
> > +
> > +		if (bp)
> > +			xfs_trans_brelse(args->trans, bp);
> > +
> > +		return error;
> > +	}
> > +
> > +	return xfs_attr_node_hasname(args, NULL);
> > +}
> > +
> > +/*
> >   * Remove the attribute specified in @args.
> >   */
> >  int
> > @@ -583,26 +617,20 @@ STATIC int
> >  xfs_attr_leaf_addname(
> >  	struct xfs_da_args	*args)
> >  {
> > -	struct xfs_inode	*dp;
> >  	struct xfs_buf		*bp;
> >  	int			retval, error, forkoff;
> > +	struct xfs_inode	*dp = args->dp;
> >  
> >  	trace_xfs_attr_leaf_addname(args);
> >  
> >  	/*
> > -	 * Read the (only) block in the attribute list in.
> > -	 */
> > -	dp = args->dp;
> > -	args->blkno = 0;
> > -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> > -	if (error)
> > -		return error;
> > -
> > -	/*
> >  	 * Look up the given attribute in the leaf block.  Figure out if
> >  	 * the given flags produce an error or call for an atomic rename.
> >  	 */
> > -	retval = xfs_attr3_leaf_lookup_int(bp, args);
> > +	retval = xfs_attr_leaf_hasname(args, &bp);
> > +	if (retval != -ENOATTR && retval != -EEXIST)
> > +		return retval;
> > +
> >  	if ((args->name.type & ATTR_REPLACE) && (retval == -ENOATTR)) {
> >  		xfs_trans_brelse(args->trans, bp);
> >  		return retval;
> > @@ -754,6 +782,27 @@ xfs_attr_leaf_addname(
> >  }
> >  
> >  /*
> > + * Return EEXIST if attr is found, or ENOATTR if not
> > + */
> > +STATIC int
> > +xfs_attr_leaf_hasname(
> > +	struct xfs_da_args      *args,
> > +	struct xfs_buf		**bp)
> > +{
> > +	int                     error = 0;
> > +
> > +	error = xfs_attr3_leaf_read(args->trans, args->dp, 0, bp);
> > +	if (error)
> > +		return error;
> > +
> > +	error = xfs_attr3_leaf_lookup_int(*bp, args);
> > +	if (error != -ENOATTR && error != -EEXIST)
> > +		xfs_trans_brelse(args->trans, *bp);
> > +
> > +	return error;
> > +}
> > +
> > +/*
> >   * Remove a name from the leaf attribute list structure
> >   *
> >   * This leaf block cannot have a "remote" value, we only call this routine
> > @@ -773,12 +822,11 @@ xfs_attr_leaf_removename(
> >  	 * Remove the attribute.
> >  	 */
> >  	dp = args->dp;
> > -	args->blkno = 0;
> > -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> > -	if (error)
> > +
> > +	error = xfs_attr_leaf_hasname(args, &bp);
> > +	if (error != -ENOATTR && error != -EEXIST)
> >  		return error;
> >  
> > -	error = xfs_attr3_leaf_lookup_int(bp, args);
> >  	if (error == -ENOATTR) {
> >  		xfs_trans_brelse(args->trans, bp);
> >  		return error;
> > @@ -817,12 +865,10 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
> >  
> >  	trace_xfs_attr_leaf_get(args);
> >  
> > -	args->blkno = 0;
> > -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> > -	if (error)
> > +	error = xfs_attr_leaf_hasname(args, &bp);
> > +	if (error != -ENOATTR && error != -EEXIST)
> >  		return error;
> >  
> > -	error = xfs_attr3_leaf_lookup_int(bp, args);
> >  	if (error != -EEXIST)  {
> >  		xfs_trans_brelse(args->trans, bp);
> >  		return error;
> > @@ -832,6 +878,41 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
> >  	return error;
> >  }
> >  
> > +/*
> > + * Return EEXIST if attr is found, or ENOATTR if not
> > + * statep: If not null is set to point at the found state.  Caller will
> > + *         be responsible for freeing the state in this case.
> > + */
> > +STATIC int
> > +xfs_attr_node_hasname(
> > +	struct xfs_da_args	*args,
> > +	struct xfs_da_state	**statep)
> > +{
> > +	struct xfs_da_state	*state;
> > +	int			retval, error;
> > +
> > +	state = xfs_da_state_alloc();
> > +	state->args = args;
> > +	state->mp = args->dp->i_mount;
> > +
> > +	if (statep != NULL)
> > +		*statep = NULL;
> > +
> > +	/*
> > +	 * Search to see if name exists, and get back a pointer to it.
> > +	 */
> > +	error = xfs_da3_node_lookup_int(state, &retval);
> > +	if (error == 0) {
> > +		if (statep != NULL)
> > +			*statep = state;
> > +		return retval;
> > +	}
> 
> If 'statep' were NULL, then this would leak the memory pointed to by 'state'
> right? 
> 
Apart from the above, the remaining changes look good to me.

Reviewed-by: Chandan Rajendra <chandanrlinux@gmail.com>
Brian Foster Feb. 25, 2020, 1:25 p.m. UTC | #10
On Mon, Feb 24, 2020 at 02:18:35PM -0700, Allison Collins wrote:
> 
> 
> On 2/24/20 6:08 AM, Brian Foster wrote:
> > On Sat, Feb 22, 2020 at 07:05:55PM -0700, Allison Collins wrote:
> > > From: Allison Henderson <allison.henderson@oracle.com>
> > > 
> > > This patch adds a new functions to check for the existence of an attribute.
> > > Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
> > > Common code that appears in existing attr add and remove functions have been
> > > factored out to help reduce the appearance of duplicated code.  We will need these
> > > routines later for delayed attributes since delayed operations cannot return error
> > > codes.
> > > 
> > > Signed-off-by: Allison Collins <allison.henderson@oracle.com>
> > > ---
> > >   fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
> > >   fs/xfs/libxfs/xfs_attr.h      |   1 +
> > >   fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
> > >   fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
> > >   4 files changed, 188 insertions(+), 98 deletions(-)
> > > 
> > > diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> > > index 9acdb23..2255060 100644
> > > --- a/fs/xfs/libxfs/xfs_attr.c
> > > +++ b/fs/xfs/libxfs/xfs_attr.c
> > ...
> > > @@ -310,6 +313,37 @@ xfs_attr_set_args(
> > >   }
> > >   /*
> > > + * Return EEXIST if attr is found, or ENOATTR if not
> > > + */
> > > +int
> > > +xfs_has_attr(
> > > +	struct xfs_da_args      *args)
> > > +{
> > > +	struct xfs_inode	*dp = args->dp;
> > > +	struct xfs_buf		*bp = NULL;
> > > +	int			error;
> > > +
> > > +	if (!xfs_inode_hasattr(dp))
> > > +		return -ENOATTR;
> > > +
> > > +	if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
> > > +		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
> > > +		return xfs_attr_sf_findname(args, NULL, NULL);
> > 
> > Nit: any reason we use "findname" here and "hasname" for the other two
> > variants?
> It was asked for in the v4 review.  Reason being we also return the location
> of the sf entry and byte offset.
> 

Ok.

> > 
> > Just a few other nit level things..
> > 
> > > +	}
> > > +
> > > +	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
> > > +		error = xfs_attr_leaf_hasname(args, &bp);
> > > +
> > > +		if (bp)
> > > +			xfs_trans_brelse(args->trans, bp);
> > > +
> > > +		return error;
> > > +	}
> > > +
> > > +	return xfs_attr_node_hasname(args, NULL);
> > > +}
> > > +
> > > +/*
> > >    * Remove the attribute specified in @args.
> > >    */
> > >   int
> > ...
> > > @@ -773,12 +822,11 @@ xfs_attr_leaf_removename(
> > >   	 * Remove the attribute.
> > >   	 */
> > >   	dp = args->dp;
> > > -	args->blkno = 0;
> > > -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> > > -	if (error)
> > > +
> > > +	error = xfs_attr_leaf_hasname(args, &bp);
> > > +	if (error != -ENOATTR && error != -EEXIST)
> > >   		return error;
> > > -	error = xfs_attr3_leaf_lookup_int(bp, args);
> > >   	if (error == -ENOATTR) {
> > 
> > It looks like some of these error checks could be cleaned up where the
> > helper function is used. I.e., something like the following here:
> > 
> > 	if (error == -ENOATTR) {
> > 		xfs_trans_brelse(...);
> > 		return error;
> > 	} else if (error != -EEXIST)
> > 		return error;
> Sure, I'm starting to get more pressure in other reviews to change this api
> to a boolean return type though (1: y, 0: no, <0: error).  I think we talked
> about this in v3, but decided to stick with this original api for now.  I'm
> thinking maybe adding a patch at the end to shift the api might be a good
> compromise?  Thoughts?
> 

I think Dave commented on this earlier with regard to some of these API
cleanups being orthogonal to this work. The big challenge with this
series is really taking apart this big tangle of xattr code such that it
has smaller components and is thus mostly reusable between dfops context
for parent pointers etc. and the traditional codepath. I can see the
appeal of such API cleanups (so it's good feedback overall), but I agree
that it's probably wiser to allow this series to work with the interface
style we have in the existing code and consider that type of thing as a
follow on cleanup when the subsystem itself is more stabilized.

Brian

> > 
> > >   		xfs_trans_brelse(args->trans, bp);
> > >   		return error;
> > > @@ -817,12 +865,10 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
> > >   	trace_xfs_attr_leaf_get(args);
> > > -	args->blkno = 0;
> > > -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
> > > -	if (error)
> > > +	error = xfs_attr_leaf_hasname(args, &bp);
> > > +	if (error != -ENOATTR && error != -EEXIST)
> > >   		return error;
> > > -	error = xfs_attr3_leaf_lookup_int(bp, args);
> > >   	if (error != -EEXIST)  {
> > >   		xfs_trans_brelse(args->trans, bp);
> > >   		return error;
> > 
> > Similar thing here, just reordering the checks simplifies the logic.
> Sure, will do.
> 
> > 
> > > @@ -832,6 +878,41 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
> > >   	return error;
> > >   }
> > > +/*
> > > + * Return EEXIST if attr is found, or ENOATTR if not
> > > + * statep: If not null is set to point at the found state.  Caller will
> > > + *         be responsible for freeing the state in this case.
> > > + */
> > > +STATIC int
> > > +xfs_attr_node_hasname(
> > > +	struct xfs_da_args	*args,
> > > +	struct xfs_da_state	**statep)
> > > +{
> > > +	struct xfs_da_state	*state;
> > > +	int			retval, error;
> > > +
> > > +	state = xfs_da_state_alloc();
> > > +	state->args = args;
> > > +	state->mp = args->dp->i_mount;
> > > +
> > > +	if (statep != NULL)
> > > +		*statep = NULL;
> > > +
> > > +	/*
> > > +	 * Search to see if name exists, and get back a pointer to it.
> > > +	 */
> > > +	error = xfs_da3_node_lookup_int(state, &retval);
> > > +	if (error == 0) {
> > > +		if (statep != NULL)
> > > +			*statep = state;
> > > +		return retval;
> > > +	}
> > > +
> > > +	xfs_da_state_free(state);
> > > +
> > > +	return error;
> > > +}
> > > +
> > >   /*========================================================================
> > >    * External routines when attribute list size > geo->blksize
> > >    *========================================================================*/
> > ...
> > > @@ -1316,31 +1381,23 @@ xfs_attr_node_get(xfs_da_args_t *args)
> > >   {
> > >   	xfs_da_state_t *state;
> > >   	xfs_da_state_blk_t *blk;
> > > -	int error, retval;
> > > +	int error;
> > >   	int i;
> > >   	trace_xfs_attr_node_get(args);
> > > -	state = xfs_da_state_alloc();
> > > -	state->args = args;
> > > -	state->mp = args->dp->i_mount;
> > > -
> > >   	/*
> > >   	 * Search to see if name exists, and get back a pointer to it.
> > >   	 */
> > > -	error = xfs_da3_node_lookup_int(state, &retval);
> > > -	if (error) {
> > > -		retval = error;
> > > -		goto out_release;
> > > -	}
> > > -	if (retval != -EEXIST)
> > > +	error = xfs_attr_node_hasname(args, &state);
> > > +	if (error != -EEXIST)
> > >   		goto out_release;
> > >   	/*
> > >   	 * Get the value, local or "remote"
> > >   	 */
> > >   	blk = &state->path.blk[state->path.active - 1];
> > > -	retval = xfs_attr3_leaf_getvalue(blk->bp, args);
> > > +	error = xfs_attr3_leaf_getvalue(blk->bp, args);
> > >   	/*
> > >   	 * If not in a transaction, we have to release all the buffers.
> > > @@ -1352,7 +1409,7 @@ xfs_attr_node_get(xfs_da_args_t *args)
> > >   	}
> > >   	xfs_da_state_free(state);
> > 
> > Do we need an 'if (state)' check here like the other node funcs?
> I think so, because if xfs_attr_node_hasname errors out it releases the
> state.  Will add.
> 
> > 
> > > -	return retval;
> > > +	return error;
> > >   }
> > >   /* Returns true if the attribute entry name is valid. */
> > ...
> > > diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
> > > index cb5ef66..9d6b68c 100644
> > > --- a/fs/xfs/libxfs/xfs_attr_leaf.c
> > > +++ b/fs/xfs/libxfs/xfs_attr_leaf.c
> > > @@ -654,18 +654,66 @@ xfs_attr_shortform_create(xfs_da_args_t *args)
> > >   }
> > >   /*
> > > + * Return -EEXIST if attr is found, or -ENOATTR if not
> > > + * args:  args containing attribute name and namelen
> > > + * sfep:  If not null, pointer will be set to the last attr entry found on
> > > +	  -EEXIST.  On -ENOATTR pointer is left at the last entry in the list
> > > + * basep: If not null, pointer is set to the byte offset of the entry in the
> > > + *	  list on -EEXIST.  On -ENOATTR, pointer is left at the byte offset of
> > > + *	  the last entry in the list
> > > + */
> > > +int
> > > +xfs_attr_sf_findname(
> > > +	struct xfs_da_args	 *args,
> > > +	struct xfs_attr_sf_entry **sfep,
> > > +	unsigned int		 *basep)
> > > +{
> > > +	struct xfs_attr_shortform *sf;
> > > +	struct xfs_attr_sf_entry *sfe;
> > > +	unsigned int		base = sizeof(struct xfs_attr_sf_hdr);
> > > +	int			size = 0;
> > > +	int			end;
> > > +	int			i;
> > > +
> > > +	sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data;
> > > +	sfe = &sf->list[0];
> > > +	end = sf->hdr.count;
> > > +	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
> > > +			base += size, i++) {
> > 
> > Slightly more readable to align indendation with the sfe assignment
> > above.
> Sure, will fix.  Thanks!
> 
> Allison
> 
> > 
> > Brian
> > 
> > > +		size = XFS_ATTR_SF_ENTSIZE(sfe);
> > > +		if (sfe->namelen != args->name.len)
> > > +			continue;
> > > +		if (memcmp(sfe->nameval, args->name.name, args->name.len) != 0)
> > > +			continue;
> > > +		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
> > > +			continue;
> > > +		break;
> > > +	}
> > > +
> > > +	if (sfep != NULL)
> > > +		*sfep = sfe;
> > > +
> > > +	if (basep != NULL)
> > > +		*basep = base;
> > > +
> > > +	if (i == end)
> > > +		return -ENOATTR;
> > > +	return -EEXIST;
> > > +}
> > > +
> > > +/*
> > >    * Add a name/value pair to the shortform attribute list.
> > >    * Overflow from the inode has already been checked for.
> > >    */
> > >   void
> > > -xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
> > > +xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff)
> > >   {
> > > -	xfs_attr_shortform_t *sf;
> > > -	xfs_attr_sf_entry_t *sfe;
> > > -	int i, offset, size;
> > > -	xfs_mount_t *mp;
> > > -	xfs_inode_t *dp;
> > > -	struct xfs_ifork *ifp;
> > > +	struct xfs_attr_shortform	*sf;
> > > +	struct xfs_attr_sf_entry	*sfe;
> > > +	int				offset, size, error;
> > > +	struct xfs_mount		*mp;
> > > +	struct xfs_inode		*dp;
> > > +	struct xfs_ifork		*ifp;
> > >   	trace_xfs_attr_sf_add(args);
> > > @@ -676,18 +724,8 @@ xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
> > >   	ifp = dp->i_afp;
> > >   	ASSERT(ifp->if_flags & XFS_IFINLINE);
> > >   	sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
> > > -	sfe = &sf->list[0];
> > > -	for (i = 0; i < sf->hdr.count; sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
> > > -#ifdef DEBUG
> > > -		if (sfe->namelen != args->name.len)
> > > -			continue;
> > > -		if (memcmp(args->name.name, sfe->nameval, args->name.len) != 0)
> > > -			continue;
> > > -		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
> > > -			continue;
> > > -		ASSERT(0);
> > > -#endif
> > > -	}
> > > +	error = xfs_attr_sf_findname(args, &sfe, NULL);
> > > +	ASSERT(error != -EEXIST);
> > >   	offset = (char *)sfe - (char *)sf;
> > >   	size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->name.len, args->valuelen);
> > > @@ -730,35 +768,26 @@ xfs_attr_fork_remove(
> > >    * Remove an attribute from the shortform attribute list structure.
> > >    */
> > >   int
> > > -xfs_attr_shortform_remove(xfs_da_args_t *args)
> > > +xfs_attr_shortform_remove(struct xfs_da_args *args)
> > >   {
> > > -	xfs_attr_shortform_t *sf;
> > > -	xfs_attr_sf_entry_t *sfe;
> > > -	int base, size=0, end, totsize, i;
> > > -	xfs_mount_t *mp;
> > > -	xfs_inode_t *dp;
> > > +	struct xfs_attr_shortform	*sf;
> > > +	struct xfs_attr_sf_entry	*sfe;
> > > +	int				size = 0, end, totsize;
> > > +	unsigned int			base;
> > > +	struct xfs_mount		*mp;
> > > +	struct xfs_inode		*dp;
> > > +	int				error;
> > >   	trace_xfs_attr_sf_remove(args);
> > >   	dp = args->dp;
> > >   	mp = dp->i_mount;
> > > -	base = sizeof(xfs_attr_sf_hdr_t);
> > >   	sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
> > > -	sfe = &sf->list[0];
> > > -	end = sf->hdr.count;
> > > -	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
> > > -					base += size, i++) {
> > > -		size = XFS_ATTR_SF_ENTSIZE(sfe);
> > > -		if (sfe->namelen != args->name.len)
> > > -			continue;
> > > -		if (memcmp(sfe->nameval, args->name.name, args->name.len) != 0)
> > > -			continue;
> > > -		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
> > > -			continue;
> > > -		break;
> > > -	}
> > > -	if (i == end)
> > > -		return -ENOATTR;
> > > +
> > > +	error = xfs_attr_sf_findname(args, &sfe, &base);
> > > +	if (error != -EEXIST)
> > > +		return error;
> > > +	size = XFS_ATTR_SF_ENTSIZE(sfe);
> > >   	/*
> > >   	 * Fix up the attribute fork data, covering the hole
> > > diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
> > > index 73615b1..0e9c87c 100644
> > > --- a/fs/xfs/libxfs/xfs_attr_leaf.h
> > > +++ b/fs/xfs/libxfs/xfs_attr_leaf.h
> > > @@ -53,6 +53,9 @@ int	xfs_attr_shortform_getvalue(struct xfs_da_args *args);
> > >   int	xfs_attr_shortform_to_leaf(struct xfs_da_args *args,
> > >   			struct xfs_buf **leaf_bp);
> > >   int	xfs_attr_shortform_remove(struct xfs_da_args *args);
> > > +int	xfs_attr_sf_findname(struct xfs_da_args *args,
> > > +			     struct xfs_attr_sf_entry **sfep,
> > > +			     unsigned int *basep);
> > >   int	xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);
> > >   int	xfs_attr_shortform_bytesfit(struct xfs_inode *dp, int bytes);
> > >   xfs_failaddr_t xfs_attr_shortform_verify(struct xfs_inode *ip);
> > > -- 
> > > 2.7.4
> > > 
> > 
>
Dave Chinner Feb. 25, 2020, 10:27 p.m. UTC | #11
On Tue, Feb 25, 2020 at 08:43:53AM +0200, Amir Goldstein wrote:
> On Tue, Feb 25, 2020 at 8:26 AM Dave Chinner <david@fromorbit.com> wrote:
> >
> > On Sun, Feb 23, 2020 at 02:20:32PM +0200, Amir Goldstein wrote:
> > > On Sun, Feb 23, 2020 at 4:07 AM Allison Collins
> > > <allison.henderson@oracle.com> wrote:
> > > >
> > > > From: Allison Henderson <allison.henderson@oracle.com>
> > > >
> > > > This patch adds a new functions to check for the existence of an attribute.
> > > > Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
> > > > Common code that appears in existing attr add and remove functions have been
> > > > factored out to help reduce the appearance of duplicated code.  We will need these
> > > > routines later for delayed attributes since delayed operations cannot return error
> > > > codes.
> > > >
> > > > Signed-off-by: Allison Collins <allison.henderson@oracle.com>
> > > > ---
> > > >  fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
> > > >  fs/xfs/libxfs/xfs_attr.h      |   1 +
> > > >  fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
> > > >  fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
> > > >  4 files changed, 188 insertions(+), 98 deletions(-)
> > > >
> > > > diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
> > > > index 9acdb23..2255060 100644
> > > > --- a/fs/xfs/libxfs/xfs_attr.c
> > > > +++ b/fs/xfs/libxfs/xfs_attr.c
> > > > @@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
> > > >  STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
> > > >  STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
> > > >  STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> > > > +STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
> > > >
> > > >  /*
> > > >   * Internal routines when attribute list is more than one block.
> > > > @@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
> > > >  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_hasname(xfs_da_args_t *args,
> > > > +                                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);
> > > >
> > > > @@ -310,6 +313,37 @@ xfs_attr_set_args(
> > > >  }
> > > >
> > > >  /*
> > > > + * Return EEXIST if attr is found, or ENOATTR if not
> > >
> > > This is a very silly return value for a function named has_attr in my taste.
> > > I realize you inherited this interface from xfs_attr3_leaf_lookup_int(), but
> > > IMO this change looks like a very good opportunity to change that internal
> > > API:
> >
> > tl;dr Cleaning up this API is work for another patchset.
> >
> > >
> > > xfs_has_attr?
> > >
> > > 0: NO
> > > 1: YES (or stay with the syscall standard of -ENOATTR)
> > > <0: error
> >
> > While I agree with your sentiment, Amir, the API you suggest is an
> > anti-pattern. We've been removing ternary return value APIs like
> > this from XFS and replacing them with an explicit error return value
> > and an operational return parameter like so:
> >
> >         error = xfs_has_attr(&exists)
> >         if (error)
> >                 return error;
> >
> 
> That would be neat and tidy.
> 
> One of the outcomes of new reviewers is comments on code unrelated
> to the changes... I have no problem of keeping API as is for Allison's
> change, but I did want to point out that the API became worse to read
> due to the helper name change from _lookup_attr to _has_attr, which
> really asks for a yes or no answer.

No argument from me on that. :P

But we really need to make progress on the new attribute features
rather than get bogged down in completely rewriting the attribute
code because it's a bit gross and smelly. The smell can be removed
later...

Cheers,

Dave.
Allison Collins Feb. 26, 2020, 2:18 a.m. UTC | #12
On 2/25/20 2:49 AM, Chandan Rajendra wrote:
> On Sunday, February 23, 2020 7:35 AM Allison Collins wrote:
>> From: Allison Henderson <allison.henderson@oracle.com>
>>
>> This patch adds a new functions to check for the existence of an attribute.
>> Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
>> Common code that appears in existing attr add and remove functions have been
>> factored out to help reduce the appearance of duplicated code.  We will need these
>> routines later for delayed attributes since delayed operations cannot return error
>> codes.
>>
>> Signed-off-by: Allison Collins <allison.henderson@oracle.com>
>> ---
>>   fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
>>   fs/xfs/libxfs/xfs_attr.h      |   1 +
>>   fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
>>   fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
>>   4 files changed, 188 insertions(+), 98 deletions(-)
>>
>> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
>> index 9acdb23..2255060 100644
>> --- a/fs/xfs/libxfs/xfs_attr.c
>> +++ b/fs/xfs/libxfs/xfs_attr.c
>> @@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
>>   STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
>>   STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
>>   STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
>> +STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
>>   
>>   /*
>>    * Internal routines when attribute list is more than one block.
>> @@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
>>   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_hasname(xfs_da_args_t *args,
>> +				 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);
>>   
>> @@ -310,6 +313,37 @@ xfs_attr_set_args(
>>   }
>>   
>>   /*
>> + * Return EEXIST if attr is found, or ENOATTR if not
>> + */
>> +int
>> +xfs_has_attr(
>> +	struct xfs_da_args      *args)
>> +{
>> +	struct xfs_inode	*dp = args->dp;
>> +	struct xfs_buf		*bp = NULL;
>> +	int			error;
>> +
>> +	if (!xfs_inode_hasattr(dp))
>> +		return -ENOATTR;
>> +
>> +	if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
>> +		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
>> +		return xfs_attr_sf_findname(args, NULL, NULL);
>> +	}
>> +
>> +	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
>> +		error = xfs_attr_leaf_hasname(args, &bp);
>> +
>> +		if (bp)
>> +			xfs_trans_brelse(args->trans, bp);
>> +
>> +		return error;
>> +	}
>> +
>> +	return xfs_attr_node_hasname(args, NULL);
>> +}
>> +
>> +/*
>>    * Remove the attribute specified in @args.
>>    */
>>   int
>> @@ -583,26 +617,20 @@ STATIC int
>>   xfs_attr_leaf_addname(
>>   	struct xfs_da_args	*args)
>>   {
>> -	struct xfs_inode	*dp;
>>   	struct xfs_buf		*bp;
>>   	int			retval, error, forkoff;
>> +	struct xfs_inode	*dp = args->dp;
>>   
>>   	trace_xfs_attr_leaf_addname(args);
>>   
>>   	/*
>> -	 * Read the (only) block in the attribute list in.
>> -	 */
>> -	dp = args->dp;
>> -	args->blkno = 0;
>> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>> -	if (error)
>> -		return error;
>> -
>> -	/*
>>   	 * Look up the given attribute in the leaf block.  Figure out if
>>   	 * the given flags produce an error or call for an atomic rename.
>>   	 */
>> -	retval = xfs_attr3_leaf_lookup_int(bp, args);
>> +	retval = xfs_attr_leaf_hasname(args, &bp);
>> +	if (retval != -ENOATTR && retval != -EEXIST)
>> +		return retval;
>> +
>>   	if ((args->name.type & ATTR_REPLACE) && (retval == -ENOATTR)) {
>>   		xfs_trans_brelse(args->trans, bp);
>>   		return retval;
>> @@ -754,6 +782,27 @@ xfs_attr_leaf_addname(
>>   }
>>   
>>   /*
>> + * Return EEXIST if attr is found, or ENOATTR if not
>> + */
>> +STATIC int
>> +xfs_attr_leaf_hasname(
>> +	struct xfs_da_args      *args,
>> +	struct xfs_buf		**bp)
>> +{
>> +	int                     error = 0;
>> +
>> +	error = xfs_attr3_leaf_read(args->trans, args->dp, 0, bp);
>> +	if (error)
>> +		return error;
>> +
>> +	error = xfs_attr3_leaf_lookup_int(*bp, args);
>> +	if (error != -ENOATTR && error != -EEXIST)
>> +		xfs_trans_brelse(args->trans, *bp);
>> +
>> +	return error;
>> +}
>> +
>> +/*
>>    * Remove a name from the leaf attribute list structure
>>    *
>>    * This leaf block cannot have a "remote" value, we only call this routine
>> @@ -773,12 +822,11 @@ xfs_attr_leaf_removename(
>>   	 * Remove the attribute.
>>   	 */
>>   	dp = args->dp;
>> -	args->blkno = 0;
>> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>> -	if (error)
>> +
>> +	error = xfs_attr_leaf_hasname(args, &bp);
>> +	if (error != -ENOATTR && error != -EEXIST)
>>   		return error;
>>   
>> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>>   	if (error == -ENOATTR) {
>>   		xfs_trans_brelse(args->trans, bp);
>>   		return error;
>> @@ -817,12 +865,10 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>>   
>>   	trace_xfs_attr_leaf_get(args);
>>   
>> -	args->blkno = 0;
>> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>> -	if (error)
>> +	error = xfs_attr_leaf_hasname(args, &bp);
>> +	if (error != -ENOATTR && error != -EEXIST)
>>   		return error;
>>   
>> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>>   	if (error != -EEXIST)  {
>>   		xfs_trans_brelse(args->trans, bp);
>>   		return error;
>> @@ -832,6 +878,41 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>>   	return error;
>>   }
>>   
>> +/*
>> + * Return EEXIST if attr is found, or ENOATTR if not
>> + * statep: If not null is set to point at the found state.  Caller will
>> + *         be responsible for freeing the state in this case.
>> + */
>> +STATIC int
>> +xfs_attr_node_hasname(
>> +	struct xfs_da_args	*args,
>> +	struct xfs_da_state	**statep)
>> +{
>> +	struct xfs_da_state	*state;
>> +	int			retval, error;
>> +
>> +	state = xfs_da_state_alloc();
>> +	state->args = args;
>> +	state->mp = args->dp->i_mount;
>> +
>> +	if (statep != NULL)
>> +		*statep = NULL;
>> +
>> +	/*
>> +	 * Search to see if name exists, and get back a pointer to it.
>> +	 */
>> +	error = xfs_da3_node_lookup_int(state, &retval);
>> +	if (error == 0) {
>> +		if (statep != NULL)
>> +			*statep = state;
>> +		return retval;
>> +	}
> 
> If 'statep' were NULL, then this would leak the memory pointed to by 'state'
> right?
> 
Another reviewer caught this too.  Will update!  :-)

Thanks!
Allison
Allison Collins Feb. 26, 2020, 2:19 a.m. UTC | #13
On 2/25/20 3:15 AM, Chandan Rajendra wrote:
> On Tuesday, February 25, 2020 3:19 PM Chandan Rajendra wrote:
>> On Sunday, February 23, 2020 7:35 AM Allison Collins wrote:
>>> From: Allison Henderson <allison.henderson@oracle.com>
>>>
>>> This patch adds a new functions to check for the existence of an attribute.
>>> Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
>>> Common code that appears in existing attr add and remove functions have been
>>> factored out to help reduce the appearance of duplicated code.  We will need these
>>> routines later for delayed attributes since delayed operations cannot return error
>>> codes.
>>>
>>> Signed-off-by: Allison Collins <allison.henderson@oracle.com>
>>> ---
>>>   fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
>>>   fs/xfs/libxfs/xfs_attr.h      |   1 +
>>>   fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
>>>   fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
>>>   4 files changed, 188 insertions(+), 98 deletions(-)
>>>
>>> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
>>> index 9acdb23..2255060 100644
>>> --- a/fs/xfs/libxfs/xfs_attr.c
>>> +++ b/fs/xfs/libxfs/xfs_attr.c
>>> @@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
>>>   STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
>>>   STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
>>>   STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
>>> +STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
>>>   
>>>   /*
>>>    * Internal routines when attribute list is more than one block.
>>> @@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
>>>   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_hasname(xfs_da_args_t *args,
>>> +				 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);
>>>   
>>> @@ -310,6 +313,37 @@ xfs_attr_set_args(
>>>   }
>>>   
>>>   /*
>>> + * Return EEXIST if attr is found, or ENOATTR if not
>>> + */
>>> +int
>>> +xfs_has_attr(
>>> +	struct xfs_da_args      *args)
>>> +{
>>> +	struct xfs_inode	*dp = args->dp;
>>> +	struct xfs_buf		*bp = NULL;
>>> +	int			error;
>>> +
>>> +	if (!xfs_inode_hasattr(dp))
>>> +		return -ENOATTR;
>>> +
>>> +	if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
>>> +		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
>>> +		return xfs_attr_sf_findname(args, NULL, NULL);
>>> +	}
>>> +
>>> +	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
>>> +		error = xfs_attr_leaf_hasname(args, &bp);
>>> +
>>> +		if (bp)
>>> +			xfs_trans_brelse(args->trans, bp);
>>> +
>>> +		return error;
>>> +	}
>>> +
>>> +	return xfs_attr_node_hasname(args, NULL);
>>> +}
>>> +
>>> +/*
>>>    * Remove the attribute specified in @args.
>>>    */
>>>   int
>>> @@ -583,26 +617,20 @@ STATIC int
>>>   xfs_attr_leaf_addname(
>>>   	struct xfs_da_args	*args)
>>>   {
>>> -	struct xfs_inode	*dp;
>>>   	struct xfs_buf		*bp;
>>>   	int			retval, error, forkoff;
>>> +	struct xfs_inode	*dp = args->dp;
>>>   
>>>   	trace_xfs_attr_leaf_addname(args);
>>>   
>>>   	/*
>>> -	 * Read the (only) block in the attribute list in.
>>> -	 */
>>> -	dp = args->dp;
>>> -	args->blkno = 0;
>>> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>>> -	if (error)
>>> -		return error;
>>> -
>>> -	/*
>>>   	 * Look up the given attribute in the leaf block.  Figure out if
>>>   	 * the given flags produce an error or call for an atomic rename.
>>>   	 */
>>> -	retval = xfs_attr3_leaf_lookup_int(bp, args);
>>> +	retval = xfs_attr_leaf_hasname(args, &bp);
>>> +	if (retval != -ENOATTR && retval != -EEXIST)
>>> +		return retval;
>>> +
>>>   	if ((args->name.type & ATTR_REPLACE) && (retval == -ENOATTR)) {
>>>   		xfs_trans_brelse(args->trans, bp);
>>>   		return retval;
>>> @@ -754,6 +782,27 @@ xfs_attr_leaf_addname(
>>>   }
>>>   
>>>   /*
>>> + * Return EEXIST if attr is found, or ENOATTR if not
>>> + */
>>> +STATIC int
>>> +xfs_attr_leaf_hasname(
>>> +	struct xfs_da_args      *args,
>>> +	struct xfs_buf		**bp)
>>> +{
>>> +	int                     error = 0;
>>> +
>>> +	error = xfs_attr3_leaf_read(args->trans, args->dp, 0, bp);
>>> +	if (error)
>>> +		return error;
>>> +
>>> +	error = xfs_attr3_leaf_lookup_int(*bp, args);
>>> +	if (error != -ENOATTR && error != -EEXIST)
>>> +		xfs_trans_brelse(args->trans, *bp);
>>> +
>>> +	return error;
>>> +}
>>> +
>>> +/*
>>>    * Remove a name from the leaf attribute list structure
>>>    *
>>>    * This leaf block cannot have a "remote" value, we only call this routine
>>> @@ -773,12 +822,11 @@ xfs_attr_leaf_removename(
>>>   	 * Remove the attribute.
>>>   	 */
>>>   	dp = args->dp;
>>> -	args->blkno = 0;
>>> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>>> -	if (error)
>>> +
>>> +	error = xfs_attr_leaf_hasname(args, &bp);
>>> +	if (error != -ENOATTR && error != -EEXIST)
>>>   		return error;
>>>   
>>> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>>>   	if (error == -ENOATTR) {
>>>   		xfs_trans_brelse(args->trans, bp);
>>>   		return error;
>>> @@ -817,12 +865,10 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>>>   
>>>   	trace_xfs_attr_leaf_get(args);
>>>   
>>> -	args->blkno = 0;
>>> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>>> -	if (error)
>>> +	error = xfs_attr_leaf_hasname(args, &bp);
>>> +	if (error != -ENOATTR && error != -EEXIST)
>>>   		return error;
>>>   
>>> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>>>   	if (error != -EEXIST)  {
>>>   		xfs_trans_brelse(args->trans, bp);
>>>   		return error;
>>> @@ -832,6 +878,41 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>>>   	return error;
>>>   }
>>>   
>>> +/*
>>> + * Return EEXIST if attr is found, or ENOATTR if not
>>> + * statep: If not null is set to point at the found state.  Caller will
>>> + *         be responsible for freeing the state in this case.
>>> + */
>>> +STATIC int
>>> +xfs_attr_node_hasname(
>>> +	struct xfs_da_args	*args,
>>> +	struct xfs_da_state	**statep)
>>> +{
>>> +	struct xfs_da_state	*state;
>>> +	int			retval, error;
>>> +
>>> +	state = xfs_da_state_alloc();
>>> +	state->args = args;
>>> +	state->mp = args->dp->i_mount;
>>> +
>>> +	if (statep != NULL)
>>> +		*statep = NULL;
>>> +
>>> +	/*
>>> +	 * Search to see if name exists, and get back a pointer to it.
>>> +	 */
>>> +	error = xfs_da3_node_lookup_int(state, &retval);
>>> +	if (error == 0) {
>>> +		if (statep != NULL)
>>> +			*statep = state;
>>> +		return retval;
>>> +	}
>>
>> If 'statep' were NULL, then this would leak the memory pointed to by 'state'
>> right?
>>
> Apart from the above, the remaining changes look good to me.
> 
> Reviewed-by: Chandan Rajendra <chandanrlinux@gmail.com>
> 
Alrighty, will fix.  Thanks!

Allison
Allison Collins Feb. 26, 2020, 2:31 a.m. UTC | #14
On 2/25/20 6:25 AM, Brian Foster wrote:
> On Mon, Feb 24, 2020 at 02:18:35PM -0700, Allison Collins wrote:
>>
>>
>> On 2/24/20 6:08 AM, Brian Foster wrote:
>>> On Sat, Feb 22, 2020 at 07:05:55PM -0700, Allison Collins wrote:
>>>> From: Allison Henderson <allison.henderson@oracle.com>
>>>>
>>>> This patch adds a new functions to check for the existence of an attribute.
>>>> Subroutines are also added to handle the cases of leaf blocks, nodes or shortform.
>>>> Common code that appears in existing attr add and remove functions have been
>>>> factored out to help reduce the appearance of duplicated code.  We will need these
>>>> routines later for delayed attributes since delayed operations cannot return error
>>>> codes.
>>>>
>>>> Signed-off-by: Allison Collins <allison.henderson@oracle.com>
>>>> ---
>>>>    fs/xfs/libxfs/xfs_attr.c      | 171 ++++++++++++++++++++++++++++--------------
>>>>    fs/xfs/libxfs/xfs_attr.h      |   1 +
>>>>    fs/xfs/libxfs/xfs_attr_leaf.c | 111 +++++++++++++++++----------
>>>>    fs/xfs/libxfs/xfs_attr_leaf.h |   3 +
>>>>    4 files changed, 188 insertions(+), 98 deletions(-)
>>>>
>>>> diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
>>>> index 9acdb23..2255060 100644
>>>> --- a/fs/xfs/libxfs/xfs_attr.c
>>>> +++ b/fs/xfs/libxfs/xfs_attr.c
>>> ...
>>>> @@ -310,6 +313,37 @@ xfs_attr_set_args(
>>>>    }
>>>>    /*
>>>> + * Return EEXIST if attr is found, or ENOATTR if not
>>>> + */
>>>> +int
>>>> +xfs_has_attr(
>>>> +	struct xfs_da_args      *args)
>>>> +{
>>>> +	struct xfs_inode	*dp = args->dp;
>>>> +	struct xfs_buf		*bp = NULL;
>>>> +	int			error;
>>>> +
>>>> +	if (!xfs_inode_hasattr(dp))
>>>> +		return -ENOATTR;
>>>> +
>>>> +	if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
>>>> +		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
>>>> +		return xfs_attr_sf_findname(args, NULL, NULL);
>>>
>>> Nit: any reason we use "findname" here and "hasname" for the other two
>>> variants?
>> It was asked for in the v4 review.  Reason being we also return the location
>> of the sf entry and byte offset.
>>
> 
> Ok.
> 
>>>
>>> Just a few other nit level things..
>>>
>>>> +	}
>>>> +
>>>> +	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
>>>> +		error = xfs_attr_leaf_hasname(args, &bp);
>>>> +
>>>> +		if (bp)
>>>> +			xfs_trans_brelse(args->trans, bp);
>>>> +
>>>> +		return error;
>>>> +	}
>>>> +
>>>> +	return xfs_attr_node_hasname(args, NULL);
>>>> +}
>>>> +
>>>> +/*
>>>>     * Remove the attribute specified in @args.
>>>>     */
>>>>    int
>>> ...
>>>> @@ -773,12 +822,11 @@ xfs_attr_leaf_removename(
>>>>    	 * Remove the attribute.
>>>>    	 */
>>>>    	dp = args->dp;
>>>> -	args->blkno = 0;
>>>> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>>>> -	if (error)
>>>> +
>>>> +	error = xfs_attr_leaf_hasname(args, &bp);
>>>> +	if (error != -ENOATTR && error != -EEXIST)
>>>>    		return error;
>>>> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>>>>    	if (error == -ENOATTR) {
>>>
>>> It looks like some of these error checks could be cleaned up where the
>>> helper function is used. I.e., something like the following here:
>>>
>>> 	if (error == -ENOATTR) {
>>> 		xfs_trans_brelse(...);
>>> 		return error;
>>> 	} else if (error != -EEXIST)
>>> 		return error;
>> Sure, I'm starting to get more pressure in other reviews to change this api
>> to a boolean return type though (1: y, 0: no, <0: error).  I think we talked
>> about this in v3, but decided to stick with this original api for now.  I'm
>> thinking maybe adding a patch at the end to shift the api might be a good
>> compromise?  Thoughts?
>>
> 
> I think Dave commented on this earlier with regard to some of these API
> cleanups being orthogonal to this work. The big challenge with this
> series is really taking apart this big tangle of xattr code such that it
> has smaller components and is thus mostly reusable between dfops context
> for parent pointers etc. and the traditional codepath. I can see the
> appeal of such API cleanups (so it's good feedback overall), but I agree
> that it's probably wiser to allow this series to work with the interface
> style we have in the existing code and consider that type of thing as a
> follow on cleanup when the subsystem itself is more stabilized.
> 
> Brian
Alrighty, sounds good for now. We'll come back and touch on it at a 
later time once we get through all the bigger stuff

Allison

> 
>>>
>>>>    		xfs_trans_brelse(args->trans, bp);
>>>>    		return error;
>>>> @@ -817,12 +865,10 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>>>>    	trace_xfs_attr_leaf_get(args);
>>>> -	args->blkno = 0;
>>>> -	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
>>>> -	if (error)
>>>> +	error = xfs_attr_leaf_hasname(args, &bp);
>>>> +	if (error != -ENOATTR && error != -EEXIST)
>>>>    		return error;
>>>> -	error = xfs_attr3_leaf_lookup_int(bp, args);
>>>>    	if (error != -EEXIST)  {
>>>>    		xfs_trans_brelse(args->trans, bp);
>>>>    		return error;
>>>
>>> Similar thing here, just reordering the checks simplifies the logic.
>> Sure, will do.
>>
>>>
>>>> @@ -832,6 +878,41 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
>>>>    	return error;
>>>>    }
>>>> +/*
>>>> + * Return EEXIST if attr is found, or ENOATTR if not
>>>> + * statep: If not null is set to point at the found state.  Caller will
>>>> + *         be responsible for freeing the state in this case.
>>>> + */
>>>> +STATIC int
>>>> +xfs_attr_node_hasname(
>>>> +	struct xfs_da_args	*args,
>>>> +	struct xfs_da_state	**statep)
>>>> +{
>>>> +	struct xfs_da_state	*state;
>>>> +	int			retval, error;
>>>> +
>>>> +	state = xfs_da_state_alloc();
>>>> +	state->args = args;
>>>> +	state->mp = args->dp->i_mount;
>>>> +
>>>> +	if (statep != NULL)
>>>> +		*statep = NULL;
>>>> +
>>>> +	/*
>>>> +	 * Search to see if name exists, and get back a pointer to it.
>>>> +	 */
>>>> +	error = xfs_da3_node_lookup_int(state, &retval);
>>>> +	if (error == 0) {
>>>> +		if (statep != NULL)
>>>> +			*statep = state;
>>>> +		return retval;
>>>> +	}
>>>> +
>>>> +	xfs_da_state_free(state);
>>>> +
>>>> +	return error;
>>>> +}
>>>> +
>>>>    /*========================================================================
>>>>     * External routines when attribute list size > geo->blksize
>>>>     *========================================================================*/
>>> ...
>>>> @@ -1316,31 +1381,23 @@ xfs_attr_node_get(xfs_da_args_t *args)
>>>>    {
>>>>    	xfs_da_state_t *state;
>>>>    	xfs_da_state_blk_t *blk;
>>>> -	int error, retval;
>>>> +	int error;
>>>>    	int i;
>>>>    	trace_xfs_attr_node_get(args);
>>>> -	state = xfs_da_state_alloc();
>>>> -	state->args = args;
>>>> -	state->mp = args->dp->i_mount;
>>>> -
>>>>    	/*
>>>>    	 * Search to see if name exists, and get back a pointer to it.
>>>>    	 */
>>>> -	error = xfs_da3_node_lookup_int(state, &retval);
>>>> -	if (error) {
>>>> -		retval = error;
>>>> -		goto out_release;
>>>> -	}
>>>> -	if (retval != -EEXIST)
>>>> +	error = xfs_attr_node_hasname(args, &state);
>>>> +	if (error != -EEXIST)
>>>>    		goto out_release;
>>>>    	/*
>>>>    	 * Get the value, local or "remote"
>>>>    	 */
>>>>    	blk = &state->path.blk[state->path.active - 1];
>>>> -	retval = xfs_attr3_leaf_getvalue(blk->bp, args);
>>>> +	error = xfs_attr3_leaf_getvalue(blk->bp, args);
>>>>    	/*
>>>>    	 * If not in a transaction, we have to release all the buffers.
>>>> @@ -1352,7 +1409,7 @@ xfs_attr_node_get(xfs_da_args_t *args)
>>>>    	}
>>>>    	xfs_da_state_free(state);
>>>
>>> Do we need an 'if (state)' check here like the other node funcs?
>> I think so, because if xfs_attr_node_hasname errors out it releases the
>> state.  Will add.
>>
>>>
>>>> -	return retval;
>>>> +	return error;
>>>>    }
>>>>    /* Returns true if the attribute entry name is valid. */
>>> ...
>>>> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
>>>> index cb5ef66..9d6b68c 100644
>>>> --- a/fs/xfs/libxfs/xfs_attr_leaf.c
>>>> +++ b/fs/xfs/libxfs/xfs_attr_leaf.c
>>>> @@ -654,18 +654,66 @@ xfs_attr_shortform_create(xfs_da_args_t *args)
>>>>    }
>>>>    /*
>>>> + * Return -EEXIST if attr is found, or -ENOATTR if not
>>>> + * args:  args containing attribute name and namelen
>>>> + * sfep:  If not null, pointer will be set to the last attr entry found on
>>>> +	  -EEXIST.  On -ENOATTR pointer is left at the last entry in the list
>>>> + * basep: If not null, pointer is set to the byte offset of the entry in the
>>>> + *	  list on -EEXIST.  On -ENOATTR, pointer is left at the byte offset of
>>>> + *	  the last entry in the list
>>>> + */
>>>> +int
>>>> +xfs_attr_sf_findname(
>>>> +	struct xfs_da_args	 *args,
>>>> +	struct xfs_attr_sf_entry **sfep,
>>>> +	unsigned int		 *basep)
>>>> +{
>>>> +	struct xfs_attr_shortform *sf;
>>>> +	struct xfs_attr_sf_entry *sfe;
>>>> +	unsigned int		base = sizeof(struct xfs_attr_sf_hdr);
>>>> +	int			size = 0;
>>>> +	int			end;
>>>> +	int			i;
>>>> +
>>>> +	sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data;
>>>> +	sfe = &sf->list[0];
>>>> +	end = sf->hdr.count;
>>>> +	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
>>>> +			base += size, i++) {
>>>
>>> Slightly more readable to align indendation with the sfe assignment
>>> above.
>> Sure, will fix.  Thanks!
>>
>> Allison
>>
>>>
>>> Brian
>>>
>>>> +		size = XFS_ATTR_SF_ENTSIZE(sfe);
>>>> +		if (sfe->namelen != args->name.len)
>>>> +			continue;
>>>> +		if (memcmp(sfe->nameval, args->name.name, args->name.len) != 0)
>>>> +			continue;
>>>> +		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
>>>> +			continue;
>>>> +		break;
>>>> +	}
>>>> +
>>>> +	if (sfep != NULL)
>>>> +		*sfep = sfe;
>>>> +
>>>> +	if (basep != NULL)
>>>> +		*basep = base;
>>>> +
>>>> +	if (i == end)
>>>> +		return -ENOATTR;
>>>> +	return -EEXIST;
>>>> +}
>>>> +
>>>> +/*
>>>>     * Add a name/value pair to the shortform attribute list.
>>>>     * Overflow from the inode has already been checked for.
>>>>     */
>>>>    void
>>>> -xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
>>>> +xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff)
>>>>    {
>>>> -	xfs_attr_shortform_t *sf;
>>>> -	xfs_attr_sf_entry_t *sfe;
>>>> -	int i, offset, size;
>>>> -	xfs_mount_t *mp;
>>>> -	xfs_inode_t *dp;
>>>> -	struct xfs_ifork *ifp;
>>>> +	struct xfs_attr_shortform	*sf;
>>>> +	struct xfs_attr_sf_entry	*sfe;
>>>> +	int				offset, size, error;
>>>> +	struct xfs_mount		*mp;
>>>> +	struct xfs_inode		*dp;
>>>> +	struct xfs_ifork		*ifp;
>>>>    	trace_xfs_attr_sf_add(args);
>>>> @@ -676,18 +724,8 @@ xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
>>>>    	ifp = dp->i_afp;
>>>>    	ASSERT(ifp->if_flags & XFS_IFINLINE);
>>>>    	sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
>>>> -	sfe = &sf->list[0];
>>>> -	for (i = 0; i < sf->hdr.count; sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
>>>> -#ifdef DEBUG
>>>> -		if (sfe->namelen != args->name.len)
>>>> -			continue;
>>>> -		if (memcmp(args->name.name, sfe->nameval, args->name.len) != 0)
>>>> -			continue;
>>>> -		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
>>>> -			continue;
>>>> -		ASSERT(0);
>>>> -#endif
>>>> -	}
>>>> +	error = xfs_attr_sf_findname(args, &sfe, NULL);
>>>> +	ASSERT(error != -EEXIST);
>>>>    	offset = (char *)sfe - (char *)sf;
>>>>    	size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->name.len, args->valuelen);
>>>> @@ -730,35 +768,26 @@ xfs_attr_fork_remove(
>>>>     * Remove an attribute from the shortform attribute list structure.
>>>>     */
>>>>    int
>>>> -xfs_attr_shortform_remove(xfs_da_args_t *args)
>>>> +xfs_attr_shortform_remove(struct xfs_da_args *args)
>>>>    {
>>>> -	xfs_attr_shortform_t *sf;
>>>> -	xfs_attr_sf_entry_t *sfe;
>>>> -	int base, size=0, end, totsize, i;
>>>> -	xfs_mount_t *mp;
>>>> -	xfs_inode_t *dp;
>>>> +	struct xfs_attr_shortform	*sf;
>>>> +	struct xfs_attr_sf_entry	*sfe;
>>>> +	int				size = 0, end, totsize;
>>>> +	unsigned int			base;
>>>> +	struct xfs_mount		*mp;
>>>> +	struct xfs_inode		*dp;
>>>> +	int				error;
>>>>    	trace_xfs_attr_sf_remove(args);
>>>>    	dp = args->dp;
>>>>    	mp = dp->i_mount;
>>>> -	base = sizeof(xfs_attr_sf_hdr_t);
>>>>    	sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
>>>> -	sfe = &sf->list[0];
>>>> -	end = sf->hdr.count;
>>>> -	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
>>>> -					base += size, i++) {
>>>> -		size = XFS_ATTR_SF_ENTSIZE(sfe);
>>>> -		if (sfe->namelen != args->name.len)
>>>> -			continue;
>>>> -		if (memcmp(sfe->nameval, args->name.name, args->name.len) != 0)
>>>> -			continue;
>>>> -		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
>>>> -			continue;
>>>> -		break;
>>>> -	}
>>>> -	if (i == end)
>>>> -		return -ENOATTR;
>>>> +
>>>> +	error = xfs_attr_sf_findname(args, &sfe, &base);
>>>> +	if (error != -EEXIST)
>>>> +		return error;
>>>> +	size = XFS_ATTR_SF_ENTSIZE(sfe);
>>>>    	/*
>>>>    	 * Fix up the attribute fork data, covering the hole
>>>> diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
>>>> index 73615b1..0e9c87c 100644
>>>> --- a/fs/xfs/libxfs/xfs_attr_leaf.h
>>>> +++ b/fs/xfs/libxfs/xfs_attr_leaf.h
>>>> @@ -53,6 +53,9 @@ int	xfs_attr_shortform_getvalue(struct xfs_da_args *args);
>>>>    int	xfs_attr_shortform_to_leaf(struct xfs_da_args *args,
>>>>    			struct xfs_buf **leaf_bp);
>>>>    int	xfs_attr_shortform_remove(struct xfs_da_args *args);
>>>> +int	xfs_attr_sf_findname(struct xfs_da_args *args,
>>>> +			     struct xfs_attr_sf_entry **sfep,
>>>> +			     unsigned int *basep);
>>>>    int	xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);
>>>>    int	xfs_attr_shortform_bytesfit(struct xfs_inode *dp, int bytes);
>>>>    xfs_failaddr_t xfs_attr_shortform_verify(struct xfs_inode *ip);
>>>> -- 
>>>> 2.7.4
>>>>
>>>
>>
>

Patch
diff mbox series

diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 9acdb23..2255060 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -46,6 +46,7 @@  STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);
 STATIC int xfs_attr_leaf_get(xfs_da_args_t *args);
 STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args);
 STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
+STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
 
 /*
  * Internal routines when attribute list is more than one block.
@@ -53,6 +54,8 @@  STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args);
 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_hasname(xfs_da_args_t *args,
+				 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);
 
@@ -310,6 +313,37 @@  xfs_attr_set_args(
 }
 
 /*
+ * Return EEXIST if attr is found, or ENOATTR if not
+ */
+int
+xfs_has_attr(
+	struct xfs_da_args      *args)
+{
+	struct xfs_inode	*dp = args->dp;
+	struct xfs_buf		*bp = NULL;
+	int			error;
+
+	if (!xfs_inode_hasattr(dp))
+		return -ENOATTR;
+
+	if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
+		ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
+		return xfs_attr_sf_findname(args, NULL, NULL);
+	}
+
+	if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
+		error = xfs_attr_leaf_hasname(args, &bp);
+
+		if (bp)
+			xfs_trans_brelse(args->trans, bp);
+
+		return error;
+	}
+
+	return xfs_attr_node_hasname(args, NULL);
+}
+
+/*
  * Remove the attribute specified in @args.
  */
 int
@@ -583,26 +617,20 @@  STATIC int
 xfs_attr_leaf_addname(
 	struct xfs_da_args	*args)
 {
-	struct xfs_inode	*dp;
 	struct xfs_buf		*bp;
 	int			retval, error, forkoff;
+	struct xfs_inode	*dp = args->dp;
 
 	trace_xfs_attr_leaf_addname(args);
 
 	/*
-	 * Read the (only) block in the attribute list in.
-	 */
-	dp = args->dp;
-	args->blkno = 0;
-	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
-	if (error)
-		return error;
-
-	/*
 	 * Look up the given attribute in the leaf block.  Figure out if
 	 * the given flags produce an error or call for an atomic rename.
 	 */
-	retval = xfs_attr3_leaf_lookup_int(bp, args);
+	retval = xfs_attr_leaf_hasname(args, &bp);
+	if (retval != -ENOATTR && retval != -EEXIST)
+		return retval;
+
 	if ((args->name.type & ATTR_REPLACE) && (retval == -ENOATTR)) {
 		xfs_trans_brelse(args->trans, bp);
 		return retval;
@@ -754,6 +782,27 @@  xfs_attr_leaf_addname(
 }
 
 /*
+ * Return EEXIST if attr is found, or ENOATTR if not
+ */
+STATIC int
+xfs_attr_leaf_hasname(
+	struct xfs_da_args      *args,
+	struct xfs_buf		**bp)
+{
+	int                     error = 0;
+
+	error = xfs_attr3_leaf_read(args->trans, args->dp, 0, bp);
+	if (error)
+		return error;
+
+	error = xfs_attr3_leaf_lookup_int(*bp, args);
+	if (error != -ENOATTR && error != -EEXIST)
+		xfs_trans_brelse(args->trans, *bp);
+
+	return error;
+}
+
+/*
  * Remove a name from the leaf attribute list structure
  *
  * This leaf block cannot have a "remote" value, we only call this routine
@@ -773,12 +822,11 @@  xfs_attr_leaf_removename(
 	 * Remove the attribute.
 	 */
 	dp = args->dp;
-	args->blkno = 0;
-	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
-	if (error)
+
+	error = xfs_attr_leaf_hasname(args, &bp);
+	if (error != -ENOATTR && error != -EEXIST)
 		return error;
 
-	error = xfs_attr3_leaf_lookup_int(bp, args);
 	if (error == -ENOATTR) {
 		xfs_trans_brelse(args->trans, bp);
 		return error;
@@ -817,12 +865,10 @@  xfs_attr_leaf_get(xfs_da_args_t *args)
 
 	trace_xfs_attr_leaf_get(args);
 
-	args->blkno = 0;
-	error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, &bp);
-	if (error)
+	error = xfs_attr_leaf_hasname(args, &bp);
+	if (error != -ENOATTR && error != -EEXIST)
 		return error;
 
-	error = xfs_attr3_leaf_lookup_int(bp, args);
 	if (error != -EEXIST)  {
 		xfs_trans_brelse(args->trans, bp);
 		return error;
@@ -832,6 +878,41 @@  xfs_attr_leaf_get(xfs_da_args_t *args)
 	return error;
 }
 
+/*
+ * Return EEXIST if attr is found, or ENOATTR if not
+ * statep: If not null is set to point at the found state.  Caller will
+ *         be responsible for freeing the state in this case.
+ */
+STATIC int
+xfs_attr_node_hasname(
+	struct xfs_da_args	*args,
+	struct xfs_da_state	**statep)
+{
+	struct xfs_da_state	*state;
+	int			retval, error;
+
+	state = xfs_da_state_alloc();
+	state->args = args;
+	state->mp = args->dp->i_mount;
+
+	if (statep != NULL)
+		*statep = NULL;
+
+	/*
+	 * Search to see if name exists, and get back a pointer to it.
+	 */
+	error = xfs_da3_node_lookup_int(state, &retval);
+	if (error == 0) {
+		if (statep != NULL)
+			*statep = state;
+		return retval;
+	}
+
+	xfs_da_state_free(state);
+
+	return error;
+}
+
 /*========================================================================
  * External routines when attribute list size > geo->blksize
  *========================================================================*/
@@ -864,20 +945,17 @@  xfs_attr_node_addname(
 	dp = args->dp;
 	mp = dp->i_mount;
 restart:
-	state = xfs_da_state_alloc();
-	state->args = args;
-	state->mp = mp;
-
 	/*
 	 * Search to see if name already exists, and get back a pointer
 	 * to where it should go.
 	 */
-	error = xfs_da3_node_lookup_int(state, &retval);
-	if (error)
+	retval = xfs_attr_node_hasname(args, &state);
+	if (retval != -ENOATTR && retval != -EEXIST)
 		goto out;
+
 	blk = &state->path.blk[ state->path.active-1 ];
 	ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
-	if ((args->name.type & ATTR_REPLACE) && (retval == -ENOATTR)) {
+	if (retval == -ENOATTR && args->name.type & ATTR_REPLACE) {
 		goto out;
 	} else if (retval == -EEXIST) {
 		if (args->name.type & ATTR_CREATE)
@@ -1079,29 +1157,15 @@  xfs_attr_node_removename(
 {
 	struct xfs_da_state	*state;
 	struct xfs_da_state_blk	*blk;
-	struct xfs_inode	*dp;
 	struct xfs_buf		*bp;
 	int			retval, error, forkoff;
+	struct xfs_inode	*dp = args->dp;
 
 	trace_xfs_attr_node_removename(args);
 
-	/*
-	 * Tie a string around our finger to remind us where we are.
-	 */
-	dp = args->dp;
-	state = xfs_da_state_alloc();
-	state->args = args;
-	state->mp = dp->i_mount;
-
-	/*
-	 * Search to see if name exists, and get back a pointer to it.
-	 */
-	error = xfs_da3_node_lookup_int(state, &retval);
-	if (error || (retval != -EEXIST)) {
-		if (error == 0)
-			error = retval;
+	error = xfs_attr_node_hasname(args, &state);
+	if (error != -EEXIST)
 		goto out;
-	}
 
 	/*
 	 * If there is an out-of-line value, de-allocate the blocks.
@@ -1196,7 +1260,8 @@  xfs_attr_node_removename(
 	error = 0;
 
 out:
-	xfs_da_state_free(state);
+	if (state)
+		xfs_da_state_free(state);
 	return error;
 }
 
@@ -1316,31 +1381,23 @@  xfs_attr_node_get(xfs_da_args_t *args)
 {
 	xfs_da_state_t *state;
 	xfs_da_state_blk_t *blk;
-	int error, retval;
+	int error;
 	int i;
 
 	trace_xfs_attr_node_get(args);
 
-	state = xfs_da_state_alloc();
-	state->args = args;
-	state->mp = args->dp->i_mount;
-
 	/*
 	 * Search to see if name exists, and get back a pointer to it.
 	 */
-	error = xfs_da3_node_lookup_int(state, &retval);
-	if (error) {
-		retval = error;
-		goto out_release;
-	}
-	if (retval != -EEXIST)
+	error = xfs_attr_node_hasname(args, &state);
+	if (error != -EEXIST)
 		goto out_release;
 
 	/*
 	 * Get the value, local or "remote"
 	 */
 	blk = &state->path.blk[state->path.active - 1];
-	retval = xfs_attr3_leaf_getvalue(blk->bp, args);
+	error = xfs_attr3_leaf_getvalue(blk->bp, args);
 
 	/*
 	 * If not in a transaction, we have to release all the buffers.
@@ -1352,7 +1409,7 @@  xfs_attr_node_get(xfs_da_args_t *args)
 	}
 
 	xfs_da_state_free(state);
-	return retval;
+	return error;
 }
 
 /* Returns true if the attribute entry name is valid. */
diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index 35043db..ce7b039 100644
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -153,6 +153,7 @@  int xfs_attr_set(struct xfs_inode *dp, struct xfs_name *name,
 		 unsigned char *value, int valuelen, int flags);
 int xfs_attr_set_args(struct xfs_da_args *args);
 int xfs_attr_remove(struct xfs_inode *dp, struct xfs_name *name, int flags);
+int xfs_has_attr(struct xfs_da_args *args);
 int xfs_attr_remove_args(struct xfs_da_args *args);
 int xfs_attr_list(struct xfs_inode *dp, char *buffer, int bufsize,
 		  int flags, struct attrlist_cursor_kern *cursor);
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index cb5ef66..9d6b68c 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -654,18 +654,66 @@  xfs_attr_shortform_create(xfs_da_args_t *args)
 }
 
 /*
+ * Return -EEXIST if attr is found, or -ENOATTR if not
+ * args:  args containing attribute name and namelen
+ * sfep:  If not null, pointer will be set to the last attr entry found on
+	  -EEXIST.  On -ENOATTR pointer is left at the last entry in the list
+ * basep: If not null, pointer is set to the byte offset of the entry in the
+ *	  list on -EEXIST.  On -ENOATTR, pointer is left at the byte offset of
+ *	  the last entry in the list
+ */
+int
+xfs_attr_sf_findname(
+	struct xfs_da_args	 *args,
+	struct xfs_attr_sf_entry **sfep,
+	unsigned int		 *basep)
+{
+	struct xfs_attr_shortform *sf;
+	struct xfs_attr_sf_entry *sfe;
+	unsigned int		base = sizeof(struct xfs_attr_sf_hdr);
+	int			size = 0;
+	int			end;
+	int			i;
+
+	sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data;
+	sfe = &sf->list[0];
+	end = sf->hdr.count;
+	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
+			base += size, i++) {
+		size = XFS_ATTR_SF_ENTSIZE(sfe);
+		if (sfe->namelen != args->name.len)
+			continue;
+		if (memcmp(sfe->nameval, args->name.name, args->name.len) != 0)
+			continue;
+		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
+			continue;
+		break;
+	}
+
+	if (sfep != NULL)
+		*sfep = sfe;
+
+	if (basep != NULL)
+		*basep = base;
+
+	if (i == end)
+		return -ENOATTR;
+	return -EEXIST;
+}
+
+/*
  * Add a name/value pair to the shortform attribute list.
  * Overflow from the inode has already been checked for.
  */
 void
-xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
+xfs_attr_shortform_add(struct xfs_da_args *args, int forkoff)
 {
-	xfs_attr_shortform_t *sf;
-	xfs_attr_sf_entry_t *sfe;
-	int i, offset, size;
-	xfs_mount_t *mp;
-	xfs_inode_t *dp;
-	struct xfs_ifork *ifp;
+	struct xfs_attr_shortform	*sf;
+	struct xfs_attr_sf_entry	*sfe;
+	int				offset, size, error;
+	struct xfs_mount		*mp;
+	struct xfs_inode		*dp;
+	struct xfs_ifork		*ifp;
 
 	trace_xfs_attr_sf_add(args);
 
@@ -676,18 +724,8 @@  xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
 	ifp = dp->i_afp;
 	ASSERT(ifp->if_flags & XFS_IFINLINE);
 	sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
-	sfe = &sf->list[0];
-	for (i = 0; i < sf->hdr.count; sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
-#ifdef DEBUG
-		if (sfe->namelen != args->name.len)
-			continue;
-		if (memcmp(args->name.name, sfe->nameval, args->name.len) != 0)
-			continue;
-		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
-			continue;
-		ASSERT(0);
-#endif
-	}
+	error = xfs_attr_sf_findname(args, &sfe, NULL);
+	ASSERT(error != -EEXIST);
 
 	offset = (char *)sfe - (char *)sf;
 	size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->name.len, args->valuelen);
@@ -730,35 +768,26 @@  xfs_attr_fork_remove(
  * Remove an attribute from the shortform attribute list structure.
  */
 int
-xfs_attr_shortform_remove(xfs_da_args_t *args)
+xfs_attr_shortform_remove(struct xfs_da_args *args)
 {
-	xfs_attr_shortform_t *sf;
-	xfs_attr_sf_entry_t *sfe;
-	int base, size=0, end, totsize, i;
-	xfs_mount_t *mp;
-	xfs_inode_t *dp;
+	struct xfs_attr_shortform	*sf;
+	struct xfs_attr_sf_entry	*sfe;
+	int				size = 0, end, totsize;
+	unsigned int			base;
+	struct xfs_mount		*mp;
+	struct xfs_inode		*dp;
+	int				error;
 
 	trace_xfs_attr_sf_remove(args);
 
 	dp = args->dp;
 	mp = dp->i_mount;
-	base = sizeof(xfs_attr_sf_hdr_t);
 	sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
-	sfe = &sf->list[0];
-	end = sf->hdr.count;
-	for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
-					base += size, i++) {
-		size = XFS_ATTR_SF_ENTSIZE(sfe);
-		if (sfe->namelen != args->name.len)
-			continue;
-		if (memcmp(sfe->nameval, args->name.name, args->name.len) != 0)
-			continue;
-		if (!xfs_attr_namesp_match(args->name.type, sfe->flags))
-			continue;
-		break;
-	}
-	if (i == end)
-		return -ENOATTR;
+
+	error = xfs_attr_sf_findname(args, &sfe, &base);
+	if (error != -EEXIST)
+		return error;
+	size = XFS_ATTR_SF_ENTSIZE(sfe);
 
 	/*
 	 * Fix up the attribute fork data, covering the hole
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.h b/fs/xfs/libxfs/xfs_attr_leaf.h
index 73615b1..0e9c87c 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.h
+++ b/fs/xfs/libxfs/xfs_attr_leaf.h
@@ -53,6 +53,9 @@  int	xfs_attr_shortform_getvalue(struct xfs_da_args *args);
 int	xfs_attr_shortform_to_leaf(struct xfs_da_args *args,
 			struct xfs_buf **leaf_bp);
 int	xfs_attr_shortform_remove(struct xfs_da_args *args);
+int	xfs_attr_sf_findname(struct xfs_da_args *args,
+			     struct xfs_attr_sf_entry **sfep,
+			     unsigned int *basep);
 int	xfs_attr_shortform_allfit(struct xfs_buf *bp, struct xfs_inode *dp);
 int	xfs_attr_shortform_bytesfit(struct xfs_inode *dp, int bytes);
 xfs_failaddr_t xfs_attr_shortform_verify(struct xfs_inode *ip);