Commit 0e5ab8dd authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'xfs-5.19-for-linus-2' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux 

Pull more xfs updates from Dave Chinner:
 "This update is largely bug fixes and cleanups for all the code merged
  in the first pull request. The majority of them are to the new logged
  attribute code, but there are also a couple of fixes for other log
  recovery and memory leaks that have recently been found.

  Summary:

   - fix refcount leak in xfs_ifree()

   - fix xfs_buf_cancel structure leaks in log recovery

   - fix dquot leak after failed quota check

   - fix a couple of problematic ASSERTS

   - fix small aim7 perf regression in from new btree sibling validation

   - clean up log incompat feature marking for new logged attribute
     feature

   - disallow logged attributes on legacy V4 filesystem formats.

   - fix da state leak when freeing attr intents

   - improve validation of the attr log items in recovery

   - use slab caches for commonly used attr structures

   - fix leaks of attr name/value buffer and reduce copying overhead
     during intent logging

   - remove some dead debug code from log recovery"

* tag 'xfs-5.19-for-linus-2' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux: (33 commits)
  xfs: fix xfs_ifree() error handling to not leak perag ref
  xfs: move xfs_attr_use_log_assist usage out of libxfs
  xfs: move xfs_attr_use_log_assist out of xfs_log.c
  xfs: warn about LARP once per mount
  xfs: implement per-mount warnings for scrub and shrink usage
  xfs: don't log every time we clear the log incompat flags
  xfs: convert buf_cancel_table allocation to kmalloc_array
  xfs: don't leak xfs_buf_cancel structures when recovery fails
  xfs: refactor buffer cancellation table allocation
  xfs: don't leak btree cursor when insrec fails after a split
  xfs: purge dquots after inode walk fails during quotacheck
  xfs: assert in xfs_btree_del_cursor should take into account error
  xfs: don't assert fail on perag references on teardown
  xfs: avoid unnecessary runtime sibling pointer endian conversions
  xfs: share xattr name and value buffers when logging xattr updates
  xfs: do not use logged xattr updates on V4 filesystems
  xfs: Remove duplicate include
  xfs: reduce IOCB_NOWAIT judgment for retry exclusive unaligned DIO
  xfs: Remove dead code
  xfs: fix typo in comment
  ...
parents 54eb8462 7146bda7

fs/xfs/libxfs/xfs_ag.c

+1 −2
Original line number Diff line number Diff line
@@ -173,7 +173,6 @@ __xfs_free_perag( 
	struct xfs_perag *pag = container_of(head, struct xfs_perag, rcu_head);



	ASSERT(!delayed_work_pending(&pag->pag_blockgc_work));

	ASSERT(atomic_read(&pag->pag_ref) == 0);

	kmem_free(pag);

}
@@ -192,7 +191,7 @@ xfs_free_perag( 
		pag = radix_tree_delete(&mp->m_perag_tree, agno);

		spin_unlock(&mp->m_perag_lock);

		ASSERT(pag);

		ASSERT(atomic_read(&pag->pag_ref) == 0);

		XFS_IS_CORRUPT(pag->pag_mount, atomic_read(&pag->pag_ref) != 0);



		cancel_delayed_work_sync(&pag->pag_blockgc_work);

		xfs_iunlink_destroy(pag);

fs/xfs/libxfs/xfs_attr.c

+90 −108
Original line number Diff line number Diff line
@@ -25,10 +25,9 @@ 
#include "xfs_trans_space.h"

#include "xfs_trace.h"

#include "xfs_attr_item.h"

#include "xfs_log.h"

#include "xfs_xattr.h"



struct kmem_cache		*xfs_attri_cache;

struct kmem_cache		*xfs_attrd_cache;

struct kmem_cache		*xfs_attr_intent_cache;



/*

 * xfs_attr.c
@@ -58,11 +57,11 @@ STATIC int xfs_attr_leaf_try_add(struct xfs_da_args *args, struct xfs_buf *bp); 
 */

STATIC int xfs_attr_node_get(xfs_da_args_t *args);

STATIC void xfs_attr_restore_rmt_blk(struct xfs_da_args *args);

static int xfs_attr_node_try_addname(struct xfs_attr_item *attr);

STATIC int xfs_attr_node_addname_find_attr(struct xfs_attr_item *attr);

STATIC int xfs_attr_node_remove_attr(struct xfs_attr_item *attr);

STATIC int xfs_attr_node_hasname(xfs_da_args_t *args,

				 struct xfs_da_state **state);

static int xfs_attr_node_try_addname(struct xfs_attr_intent *attr);

STATIC int xfs_attr_node_addname_find_attr(struct xfs_attr_intent *attr);

STATIC int xfs_attr_node_remove_attr(struct xfs_attr_intent *attr);

STATIC int xfs_attr_node_lookup(struct xfs_da_args *args,

		struct xfs_da_state *state);



int

xfs_inode_hasattr(
@@ -377,7 +376,7 @@ xfs_attr_try_sf_addname( 


static int

xfs_attr_sf_addname(

	struct xfs_attr_item		*attr)

	struct xfs_attr_intent		*attr)

{

	struct xfs_da_args		*args = attr->xattri_da_args;

	struct xfs_inode		*dp = args->dp;
@@ -423,7 +422,7 @@ xfs_attr_sf_addname( 
 */

static enum xfs_delattr_state

xfs_attr_complete_op(

	struct xfs_attr_item	*attr,

	struct xfs_attr_intent	*attr,

	enum xfs_delattr_state	replace_state)

{

	struct xfs_da_args	*args = attr->xattri_da_args;
@@ -439,7 +438,7 @@ xfs_attr_complete_op( 


static int

xfs_attr_leaf_addname(

	struct xfs_attr_item	*attr)

	struct xfs_attr_intent	*attr)

{

	struct xfs_da_args	*args = attr->xattri_da_args;

	int			error;
@@ -493,7 +492,7 @@ xfs_attr_leaf_addname( 
 */

static int

xfs_attr_node_addname(

	struct xfs_attr_item	*attr)

	struct xfs_attr_intent	*attr)

{

	struct xfs_da_args	*args = attr->xattri_da_args;

	int			error;
@@ -530,7 +529,7 @@ xfs_attr_node_addname( 


static int

xfs_attr_rmtval_alloc(

	struct xfs_attr_item		*attr)

	struct xfs_attr_intent		*attr)

{

	struct xfs_da_args              *args = attr->xattri_da_args;

	int				error = 0;
@@ -594,6 +593,19 @@ xfs_attr_leaf_mark_incomplete( 
	return xfs_attr3_leaf_setflag(args);

}



/* Ensure the da state of an xattr deferred work item is ready to go. */

static inline void

xfs_attr_item_init_da_state(

	struct xfs_attr_intent	*attr)

{

	struct xfs_da_args	*args = attr->xattri_da_args;



	if (!attr->xattri_da_state)

		attr->xattri_da_state = xfs_da_state_alloc(args);

	else

		xfs_da_state_reset(attr->xattri_da_state, args);

}



/*

 * Initial setup for xfs_attr_node_removename.  Make sure the attr is there and

 * the blocks are valid.  Attr keys with remote blocks will be marked
@@ -601,29 +613,33 @@ xfs_attr_leaf_mark_incomplete( 
 */

static

int xfs_attr_node_removename_setup(

	struct xfs_attr_item		*attr)

	struct xfs_attr_intent		*attr)

{

	struct xfs_da_args		*args = attr->xattri_da_args;

	struct xfs_da_state		**state = &attr->xattri_da_state;

	struct xfs_da_state		*state;

	int				error;



	error = xfs_attr_node_hasname(args, state);

	xfs_attr_item_init_da_state(attr);

	error = xfs_attr_node_lookup(args, attr->xattri_da_state);

	if (error != -EEXIST)

		goto out;

	error = 0;



	ASSERT((*state)->path.blk[(*state)->path.active - 1].bp != NULL);

	ASSERT((*state)->path.blk[(*state)->path.active - 1].magic ==

	state = attr->xattri_da_state;

	ASSERT(state->path.blk[state->path.active - 1].bp != NULL);

	ASSERT(state->path.blk[state->path.active - 1].magic ==

		XFS_ATTR_LEAF_MAGIC);



	error = xfs_attr_leaf_mark_incomplete(args, *state);

	error = xfs_attr_leaf_mark_incomplete(args, state);

	if (error)

		goto out;

	if (args->rmtblkno > 0)

		error = xfs_attr_rmtval_invalidate(args);

out:

	if (error)

		xfs_da_state_free(*state);

	if (error) {

		xfs_da_state_free(attr->xattri_da_state);

		attr->xattri_da_state = NULL;

	}



	return error;

}
@@ -635,7 +651,7 @@ int xfs_attr_node_removename_setup( 
 */

static int

xfs_attr_leaf_remove_attr(

	struct xfs_attr_item		*attr)

	struct xfs_attr_intent		*attr)

{

	struct xfs_da_args              *args = attr->xattri_da_args;

	struct xfs_inode		*dp = args->dp;
@@ -700,7 +716,7 @@ xfs_attr_leaf_shrink( 
 */

int

xfs_attr_set_iter(

	struct xfs_attr_item		*attr)

	struct xfs_attr_intent		*attr)

{

	struct xfs_da_args              *args = attr->xattri_da_args;

	int				error = 0;
@@ -852,6 +868,7 @@ xfs_attr_lookup( 
{

	struct xfs_inode	*dp = args->dp;

	struct xfs_buf		*bp = NULL;

	struct xfs_da_state	*state;

	int			error;



	if (!xfs_inode_hasattr(dp))
@@ -869,19 +886,22 @@ xfs_attr_lookup( 
		return error;

	}



	return xfs_attr_node_hasname(args, NULL);

	state = xfs_da_state_alloc(args);

	error = xfs_attr_node_lookup(args, state);

	xfs_da_state_free(state);

	return error;

}



static int

xfs_attr_item_init(

xfs_attr_intent_init(

	struct xfs_da_args	*args,

	unsigned int		op_flags,	/* op flag (set or remove) */

	struct xfs_attr_item	**attr)		/* new xfs_attr_item */

	struct xfs_attr_intent	**attr)		/* new xfs_attr_intent */

{



	struct xfs_attr_item	*new;

	struct xfs_attr_intent	*new;



	new = kmem_zalloc(sizeof(struct xfs_attr_item), KM_NOFS);

	new = kmem_cache_zalloc(xfs_attr_intent_cache, GFP_NOFS | __GFP_NOFAIL);

	new->xattri_op_flags = op_flags;

	new->xattri_da_args = args;
@@ -894,10 +914,10 @@ static int 
xfs_attr_defer_add(

	struct xfs_da_args	*args)

{

	struct xfs_attr_item	*new;

	struct xfs_attr_intent	*new;

	int			error = 0;



	error = xfs_attr_item_init(args, XFS_ATTR_OP_FLAGS_SET, &new);

	error = xfs_attr_intent_init(args, XFS_ATTRI_OP_FLAGS_SET, &new);

	if (error)

		return error;
@@ -913,10 +933,10 @@ static int 
xfs_attr_defer_replace(

	struct xfs_da_args	*args)

{

	struct xfs_attr_item	*new;

	struct xfs_attr_intent	*new;

	int			error = 0;



	error = xfs_attr_item_init(args, XFS_ATTR_OP_FLAGS_REPLACE, &new);

	error = xfs_attr_intent_init(args, XFS_ATTRI_OP_FLAGS_REPLACE, &new);

	if (error)

		return error;
@@ -933,10 +953,10 @@ xfs_attr_defer_remove( 
	struct xfs_da_args	*args)

{



	struct xfs_attr_item	*new;

	struct xfs_attr_intent	*new;

	int			error;



	error  = xfs_attr_item_init(args, XFS_ATTR_OP_FLAGS_REMOVE, &new);

	error  = xfs_attr_intent_init(args, XFS_ATTRI_OP_FLAGS_REMOVE, &new);

	if (error)

		return error;
@@ -962,7 +982,6 @@ xfs_attr_set( 
	int			error, local;

	int			rmt_blks = 0;

	unsigned int		total;

	int			delayed = xfs_has_larp(mp);



	if (xfs_is_shutdown(dp->i_mount))

		return -EIO;
@@ -1007,12 +1026,6 @@ xfs_attr_set( 
		rmt_blks = xfs_attr3_rmt_blocks(mp, XFS_XATTR_SIZE_MAX);

	}



	if (delayed) {

		error = xfs_attr_use_log_assist(mp);

		if (error)

			return error;

	}



	/*

	 * Root fork attributes can use reserved data blocks for this

	 * operation if necessary
@@ -1020,7 +1033,7 @@ xfs_attr_set( 
	xfs_init_attr_trans(args, &tres, &total);

	error = xfs_trans_alloc_inode(dp, &tres, total, 0, rsvd, &args->trans);

	if (error)

		goto drop_incompat;

		return error;



	if (args->value || xfs_inode_hasattr(dp)) {

		error = xfs_iext_count_may_overflow(dp, XFS_ATTR_FORK,
@@ -1080,9 +1093,6 @@ xfs_attr_set( 
	error = xfs_trans_commit(args->trans);

out_unlock:

	xfs_iunlock(dp, XFS_ILOCK_EXCL);

drop_incompat:

	if (delayed)

		xlog_drop_incompat_feat(mp->m_log);

	return error;



out_trans_cancel:
@@ -1091,40 +1101,6 @@ xfs_attr_set( 
	goto out_unlock;

}



int __init

xfs_attri_init_cache(void)

{

	xfs_attri_cache = kmem_cache_create("xfs_attri",

					    sizeof(struct xfs_attri_log_item),

					    0, 0, NULL);



	return xfs_attri_cache != NULL ? 0 : -ENOMEM;

}



void

xfs_attri_destroy_cache(void)

{

	kmem_cache_destroy(xfs_attri_cache);

	xfs_attri_cache = NULL;

}



int __init

xfs_attrd_init_cache(void)

{

	xfs_attrd_cache = kmem_cache_create("xfs_attrd",

					    sizeof(struct xfs_attrd_log_item),

					    0, 0, NULL);



	return xfs_attrd_cache != NULL ? 0 : -ENOMEM;

}



void

xfs_attrd_destroy_cache(void)

{

	kmem_cache_destroy(xfs_attrd_cache);

	xfs_attrd_cache = NULL;

}



/*========================================================================

 * External routines when attribute list is inside the inode

 *========================================================================*/
@@ -1384,32 +1360,20 @@ 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.

 */

/* Return EEXIST if attr is found, or ENOATTR if not. */

STATIC int

xfs_attr_node_hasname(

xfs_attr_node_lookup(

	struct xfs_da_args	*args,

	struct xfs_da_state	**statep)

	struct xfs_da_state	*state)

{

	struct xfs_da_state	*state;

	int			retval, error;



	state = xfs_da_state_alloc(args);

	if (statep != NULL)

		*statep = state;



	/*

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



	if (!statep)

		xfs_da_state_free(state);

		return error;



	return retval;

}
@@ -1420,7 +1384,7 @@ xfs_attr_node_hasname( 


STATIC int

xfs_attr_node_addname_find_attr(

	 struct xfs_attr_item	*attr)

	 struct xfs_attr_intent	*attr)

{

	struct xfs_da_args	*args = attr->xattri_da_args;

	int			error;
@@ -1429,7 +1393,8 @@ xfs_attr_node_addname_find_attr( 
	 * Search to see if name already exists, and get back a pointer

	 * to where it should go.

	 */

	error = xfs_attr_node_hasname(args, &attr->xattri_da_state);

	xfs_attr_item_init_da_state(attr);

	error = xfs_attr_node_lookup(args, attr->xattri_da_state);

	switch (error) {

	case -ENOATTR:

		if (args->op_flags & XFS_DA_OP_REPLACE)
@@ -1456,8 +1421,10 @@ xfs_attr_node_addname_find_attr( 


	return 0;

error:

	if (attr->xattri_da_state)

	if (attr->xattri_da_state) {

		xfs_da_state_free(attr->xattri_da_state);

		attr->xattri_da_state = NULL;

	}

	return error;

}
@@ -1470,7 +1437,7 @@ xfs_attr_node_addname_find_attr( 
 */

static int

xfs_attr_node_try_addname(

	struct xfs_attr_item		*attr)

	struct xfs_attr_intent		*attr)

{

	struct xfs_da_args		*args = attr->xattri_da_args;

	struct xfs_da_state		*state = attr->xattri_da_state;
@@ -1511,6 +1478,7 @@ xfs_attr_node_try_addname( 


out:

	xfs_da_state_free(state);

	attr->xattri_da_state = NULL;

	return error;

}
@@ -1535,10 +1503,10 @@ xfs_attr_node_removename( 


static int

xfs_attr_node_remove_attr(

	struct xfs_attr_item		*attr)

	struct xfs_attr_intent		*attr)

{

	struct xfs_da_args		*args = attr->xattri_da_args;

	struct xfs_da_state		*state = NULL;

	struct xfs_da_state		*state = xfs_da_state_alloc(args);

	int				retval = 0;

	int				error = 0;
@@ -1548,8 +1516,6 @@ xfs_attr_node_remove_attr( 
	 * attribute entry after any split ops.

	 */

	args->attr_filter |= XFS_ATTR_INCOMPLETE;

	state = xfs_da_state_alloc(args);

	state->inleaf = 0;

	error = xfs_da3_node_lookup_int(state, &retval);

	if (error)

		goto out;
@@ -1567,7 +1533,6 @@ xfs_attr_node_remove_attr( 
	retval = error = 0;



out:

	if (state)

	xfs_da_state_free(state);

	if (error)

		return error;
@@ -1597,7 +1562,8 @@ xfs_attr_node_get( 
	/*

	 * Search to see if name exists, and get back a pointer to it.

	 */

	error = xfs_attr_node_hasname(args, &state);

	state = xfs_da_state_alloc(args);

	error = xfs_attr_node_lookup(args, state);

	if (error != -EEXIST)

		goto out_release;
@@ -1616,7 +1582,6 @@ xfs_attr_node_get( 
		state->path.blk[i].bp = NULL;

	}



	if (state)

	xfs_da_state_free(state);

	return error;

}
@@ -1637,3 +1602,20 @@ xfs_attr_namecheck( 
	/* There shouldn't be any nulls here */

	return !memchr(name, 0, length);

}



int __init

xfs_attr_intent_init_cache(void)

{

	xfs_attr_intent_cache = kmem_cache_create("xfs_attr_intent",

			sizeof(struct xfs_attr_intent),

			0, 0, NULL);



	return xfs_attr_intent_cache != NULL ? 0 : -ENOMEM;

}



void

xfs_attr_intent_destroy_cache(void)

{

	kmem_cache_destroy(xfs_attr_intent_cache);

	xfs_attr_intent_cache = NULL;

}

fs/xfs/libxfs/xfs_attr.h

+31 −32
Original line number Diff line number Diff line
@@ -31,7 +31,8 @@ struct xfs_attr_list_context; 
static inline bool xfs_has_larp(struct xfs_mount *mp)

{

#ifdef DEBUG

	return xfs_globals.larp;

	/* Logged xattrs require a V5 super for log_incompat */

	return xfs_has_crc(mp) && xfs_globals.larp;

#else

	return false;

#endif
@@ -434,7 +435,7 @@ struct xfs_attr_list_context { 
 */



/*

 * Enum values for xfs_attr_item.xattri_da_state

 * Enum values for xfs_attr_intent.xattri_da_state

 *

 * These values are used by delayed attribute operations to keep track  of where

 * they were before they returned -EAGAIN.  A return code of -EAGAIN signals the
@@ -501,44 +502,46 @@ enum xfs_delattr_state { 
	{ XFS_DAS_NODE_REMOVE_ATTR,	"XFS_DAS_NODE_REMOVE_ATTR" }, \

	{ XFS_DAS_DONE,			"XFS_DAS_DONE" }



/*

 * Defines for xfs_attr_item.xattri_flags

 */

#define XFS_DAC_LEAF_ADDNAME_INIT	0x01 /* xfs_attr_leaf_addname init*/

struct xfs_attri_log_nameval;



/*

 * Context used for keeping track of delayed attribute operations

 */

struct xfs_attr_item {

struct xfs_attr_intent {

	/*

	 * used to log this item to an intent containing a list of attrs to

	 * commit later

	 */

	struct list_head		xattri_list;



	/* Used in xfs_attr_node_removename to roll through removing blocks */

	struct xfs_da_state		*xattri_da_state;



	struct xfs_da_args		*xattri_da_args;



	/*

	 * Shared buffer containing the attr name and value so that the logging

	 * code can share large memory buffers between log items.

	 */

	struct xfs_attri_log_nameval	*xattri_nameval;



	/*

	 * Used by xfs_attr_set to hold a leaf buffer across a transaction roll

	 */

	struct xfs_buf			*xattri_leaf_bp;



	/* Used in xfs_attr_rmtval_set_blk to roll through allocating blocks */

	struct xfs_bmbt_irec		xattri_map;

	xfs_dablk_t			xattri_lblkno;

	int				xattri_blkcnt;



	/* Used in xfs_attr_node_removename to roll through removing blocks */

	struct xfs_da_state		*xattri_da_state;



	/* Used to keep track of current state of delayed operation */

	unsigned int			xattri_flags;

	enum xfs_delattr_state		xattri_dela_state;



	/*

	 * Attr operation being performed - XFS_ATTR_OP_FLAGS_*

	 * Attr operation being performed - XFS_ATTRI_OP_FLAGS_*

	 */

	unsigned int			xattri_op_flags;



	/*

	 * used to log this item to an intent containing a list of attrs to

	 * commit later

	 */

	struct list_head		xattri_list;

	/* Used in xfs_attr_rmtval_set_blk to roll through allocating blocks */

	xfs_dablk_t			xattri_lblkno;

	int				xattri_blkcnt;

	struct xfs_bmbt_irec		xattri_map;

};
@@ -557,21 +560,13 @@ bool xfs_attr_is_leaf(struct xfs_inode *ip); 
int xfs_attr_get_ilocked(struct xfs_da_args *args);

int xfs_attr_get(struct xfs_da_args *args);

int xfs_attr_set(struct xfs_da_args *args);

int xfs_attr_set_iter(struct xfs_attr_item *attr);

int xfs_attr_remove_iter(struct xfs_attr_item *attr);

int xfs_attr_set_iter(struct xfs_attr_intent *attr);

int xfs_attr_remove_iter(struct xfs_attr_intent *attr);

bool xfs_attr_namecheck(const void *name, size_t length);

int xfs_attr_calc_size(struct xfs_da_args *args, int *local);

void xfs_init_attr_trans(struct xfs_da_args *args, struct xfs_trans_res *tres,

			 unsigned int *total);



extern struct kmem_cache	*xfs_attri_cache;

extern struct kmem_cache	*xfs_attrd_cache;



int __init xfs_attri_init_cache(void);

void xfs_attri_destroy_cache(void);

int __init xfs_attrd_init_cache(void);

void xfs_attrd_destroy_cache(void);



/*

 * Check to see if the attr should be upgraded from non-existent or shortform to

 * single-leaf-block attribute list.
@@ -634,4 +629,8 @@ xfs_attr_init_replace_state(struct xfs_da_args *args) 
	return xfs_attr_init_add_state(args);

}



extern struct kmem_cache *xfs_attr_intent_cache;

int __init xfs_attr_intent_init_cache(void);

void xfs_attr_intent_destroy_cache(void);



#endif	/* __XFS_ATTR_H__ */

fs/xfs/libxfs/xfs_attr_remote.c

+3 −3
Original line number Diff line number Diff line
@@ -568,7 +568,7 @@ xfs_attr_rmtval_stale( 
 */

int

xfs_attr_rmtval_find_space(

	struct xfs_attr_item		*attr)

	struct xfs_attr_intent		*attr)

{

	struct xfs_da_args		*args = attr->xattri_da_args;

	struct xfs_bmbt_irec		*map = &attr->xattri_map;
@@ -598,7 +598,7 @@ xfs_attr_rmtval_find_space( 
 */

int

xfs_attr_rmtval_set_blk(

	struct xfs_attr_item		*attr)

	struct xfs_attr_intent		*attr)

{

	struct xfs_da_args		*args = attr->xattri_da_args;

	struct xfs_inode		*dp = args->dp;
@@ -674,7 +674,7 @@ xfs_attr_rmtval_invalidate( 
 */

int

xfs_attr_rmtval_remove(

	struct xfs_attr_item		*attr)

	struct xfs_attr_intent		*attr)

{

	struct xfs_da_args		*args = attr->xattri_da_args;

	int				error, done;

fs/xfs/libxfs/xfs_attr_remote.h

+3 −3
Original line number Diff line number Diff line
@@ -12,9 +12,9 @@ int xfs_attr_rmtval_get(struct xfs_da_args *args); 
int xfs_attr_rmtval_stale(struct xfs_inode *ip, struct xfs_bmbt_irec *map,

		xfs_buf_flags_t incore_flags);

int xfs_attr_rmtval_invalidate(struct xfs_da_args *args);

int xfs_attr_rmtval_remove(struct xfs_attr_item *attr);

int xfs_attr_rmtval_remove(struct xfs_attr_intent *attr);

int xfs_attr_rmt_find_hole(struct xfs_da_args *args);

int xfs_attr_rmtval_set_value(struct xfs_da_args *args);

int xfs_attr_rmtval_set_blk(struct xfs_attr_item *attr);

int xfs_attr_rmtval_find_space(struct xfs_attr_item *attr);

int xfs_attr_rmtval_set_blk(struct xfs_attr_intent *attr);

int xfs_attr_rmtval_find_space(struct xfs_attr_intent *attr);

#endif /* __XFS_ATTR_REMOTE_H__ */