Commit a2544622 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Darrick J. Wong
Browse files

xfs: pass an initialized xfs_da_args structure to xfs_attr_set 



Instead of converting from one style of arguments to another in
xfs_attr_set, pass the structure from higher up in the call chain.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarChandan Rajendra <chandanrlinux@gmail.com>
Reviewed-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: default avatarDarrick J. Wong <darrick.wong@oracle.com>
parent ead189ad

fs/xfs/libxfs/xfs_attr.c

+31 −38
Original line number Diff line number Diff line
@@ -330,22 +330,17 @@ xfs_attr_remove_args( 
}



/*

 * Note: If value is NULL the attribute will be removed, just like the

 * Note: If args->value is NULL the attribute will be removed, just like the

 * Linux ->setattr API.

 */

int

xfs_attr_set(

	struct xfs_inode	*dp,

	const unsigned char	*name,

	size_t			namelen,

	unsigned char		*value,

	int			valuelen,

	int			flags)

	struct xfs_da_args	*args)

{

	struct xfs_inode	*dp = args->dp;

	struct xfs_mount	*mp = dp->i_mount;

	struct xfs_da_args	args;

	struct xfs_trans_res	tres;

	int			rsvd = (flags & ATTR_ROOT) != 0;

	int			rsvd = (args->flags & ATTR_ROOT) != 0;

	int			error, local;

	unsigned int		total;
@@ -356,25 +351,22 @@ xfs_attr_set( 
	if (error)

		return error;



	error = xfs_attr_args_init(&args, dp, name, namelen, flags);

	if (error)

		return error;



	args.value = value;

	args.valuelen = valuelen;

	args->geo = mp->m_attr_geo;

	args->whichfork = XFS_ATTR_FORK;

	args->hashval = xfs_da_hashname(args->name, args->namelen);



	/*

	 * We have no control over the attribute names that userspace passes us

	 * to remove, so we have to allow the name lookup prior to attribute

	 * removal to fail as well.

	 */

	args.op_flags = XFS_DA_OP_OKNOENT;

	args->op_flags = XFS_DA_OP_OKNOENT;



	if (value) {

	if (args->value) {

		XFS_STATS_INC(mp, xs_attr_set);



		args.op_flags |= XFS_DA_OP_ADDNAME;

		args.total = xfs_attr_calc_size(&args, &local);

		args->op_flags |= XFS_DA_OP_ADDNAME;

		args->total = xfs_attr_calc_size(args, &local);



		/*

		 * If the inode doesn't have an attribute fork, add one.
@@ -382,8 +374,8 @@ xfs_attr_set( 
		 */

		if (XFS_IFORK_Q(dp) == 0) {

			int sf_size = sizeof(struct xfs_attr_sf_hdr) +

				XFS_ATTR_SF_ENTSIZE_BYNAME(args.namelen,

						valuelen);

				XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen,

						args->valuelen);



			error = xfs_bmap_add_attrfork(dp, sf_size, rsvd);

			if (error)
@@ -391,10 +383,11 @@ xfs_attr_set( 
		}



		tres.tr_logres = M_RES(mp)->tr_attrsetm.tr_logres +

				 M_RES(mp)->tr_attrsetrt.tr_logres * args.total;

				 M_RES(mp)->tr_attrsetrt.tr_logres *

					args->total;

		tres.tr_logcount = XFS_ATTRSET_LOG_COUNT;

		tres.tr_logflags = XFS_TRANS_PERM_LOG_RES;

		total = args.total;

		total = args->total;

	} else {

		XFS_STATS_INC(mp, xs_attr_remove);
@@ -407,29 +400,29 @@ xfs_attr_set( 
	 * operation if necessary

	 */

	error = xfs_trans_alloc(mp, &tres, total, 0,

			rsvd ? XFS_TRANS_RESERVE : 0, &args.trans);

			rsvd ? XFS_TRANS_RESERVE : 0, &args->trans);

	if (error)

		return error;



	xfs_ilock(dp, XFS_ILOCK_EXCL);

	xfs_trans_ijoin(args.trans, dp, 0);

	if (value) {

	xfs_trans_ijoin(args->trans, dp, 0);

	if (args->value) {

		unsigned int	quota_flags = XFS_QMOPT_RES_REGBLKS;



		if (rsvd)

			quota_flags |= XFS_QMOPT_FORCE_RES;

		error = xfs_trans_reserve_quota_nblks(args.trans, dp,

				args.total, 0, quota_flags);

		error = xfs_trans_reserve_quota_nblks(args->trans, dp,

				args->total, 0, quota_flags);

		if (error)

			goto out_trans_cancel;

		error = xfs_attr_set_args(&args);

		error = xfs_attr_set_args(args);

		if (error)

			goto out_trans_cancel;

		/* shortform attribute has already been committed */

		if (!args.trans)

		if (!args->trans)

			goto out_unlock;

	} else {

		error = xfs_attr_remove_args(&args);

		error = xfs_attr_remove_args(args);

		if (error)

			goto out_trans_cancel;

	}
@@ -439,23 +432,23 @@ xfs_attr_set( 
	 * transaction goes to disk before returning to the user.

	 */

	if (mp->m_flags & XFS_MOUNT_WSYNC)

		xfs_trans_set_sync(args.trans);

		xfs_trans_set_sync(args->trans);



	if ((flags & ATTR_KERNOTIME) == 0)

		xfs_trans_ichgtime(args.trans, dp, XFS_ICHGTIME_CHG);

	if ((args->flags & ATTR_KERNOTIME) == 0)

		xfs_trans_ichgtime(args->trans, dp, XFS_ICHGTIME_CHG);



	/*

	 * Commit the last in the sequence of transactions.

	 */

	xfs_trans_log_inode(args.trans, dp, XFS_ILOG_CORE);

	error = xfs_trans_commit(args.trans);

	xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE);

	error = xfs_trans_commit(args->trans);

out_unlock:

	xfs_iunlock(dp, XFS_ILOCK_EXCL);

	return error;



out_trans_cancel:

	if (args.trans)

		xfs_trans_cancel(args.trans);

	if (args->trans)

		xfs_trans_cancel(args->trans);

	goto out_unlock;

}

fs/xfs/libxfs/xfs_attr.h

+1 −2
Original line number Diff line number Diff line
@@ -149,8 +149,7 @@ int xfs_attr_get_ilocked(struct xfs_inode *ip, struct xfs_da_args *args); 
int xfs_attr_get(struct xfs_inode *ip, const unsigned char *name,

		 size_t namelen, unsigned char **value, int *valuelenp,

		 int flags);

int xfs_attr_set(struct xfs_inode *dp, const unsigned char *name,

		 size_t namelen, unsigned char *value, int valuelen, int flags);

int xfs_attr_set(struct xfs_da_args *args);

int xfs_attr_set_args(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,

fs/xfs/xfs_acl.c

+18 −15
Original line number Diff line number Diff line
@@ -14,6 +14,8 @@ 
#include "xfs_trace.h"

#include "xfs_error.h"

#include "xfs_acl.h"

#include "xfs_da_format.h"

#include "xfs_da_btree.h"



#include <linux/posix_acl_xattr.h>
@@ -171,40 +173,41 @@ int 
__xfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)

{

	struct xfs_inode	*ip = XFS_I(inode);

	unsigned char *ea_name;

	struct xfs_acl *xfs_acl = NULL;

	int len = 0;

	struct xfs_da_args	args = {

		.dp		= ip,

		.flags		= ATTR_ROOT,

	};

	int			error;



	switch (type) {

	case ACL_TYPE_ACCESS:

		ea_name = SGI_ACL_FILE;

		args.name = SGI_ACL_FILE;

		break;

	case ACL_TYPE_DEFAULT:

		if (!S_ISDIR(inode->i_mode))

			return acl ? -EACCES : 0;

		ea_name = SGI_ACL_DEFAULT;

		args.name = SGI_ACL_DEFAULT;

		break;

	default:

		return -EINVAL;

	}

	args.namelen = strlen(args.name);



	if (acl) {

		len = XFS_ACL_MAX_SIZE(ip->i_mount);

		xfs_acl = kmem_zalloc_large(len, 0);

		if (!xfs_acl)

		args.valuelen = XFS_ACL_MAX_SIZE(ip->i_mount);

		args.value = kmem_zalloc_large(args.valuelen, 0);

		if (!args.value)

			return -ENOMEM;



		xfs_acl_to_disk(xfs_acl, acl);

		xfs_acl_to_disk(args.value, acl);



		/* subtract away the unused acl entries */

		len -= sizeof(struct xfs_acl_entry) *

		args.valuelen -= sizeof(struct xfs_acl_entry) *

			 (XFS_ACL_MAX_ENTRIES(ip->i_mount) - acl->a_count);

	}



	error = xfs_attr_set(ip, ea_name, strlen(ea_name),

			(unsigned char *)xfs_acl, len, ATTR_ROOT);

	kmem_free(xfs_acl);

	error = xfs_attr_set(&args);

	kmem_free(args.value);



	/*

	 * If the attribute didn't exist to start with that's fine.

fs/xfs/xfs_ioctl.c

+14 −8
Original line number Diff line number Diff line
@@ -35,6 +35,8 @@ 
#include "xfs_health.h"

#include "xfs_reflink.h"

#include "xfs_ioctl.h"

#include "xfs_da_format.h"

#include "xfs_da_btree.h"



#include <linux/mount.h>

#include <linux/namei.h>
@@ -389,9 +391,13 @@ xfs_attrmulti_attr_set( 
	uint32_t		len,

	uint32_t		flags)

{

	unsigned char		*kbuf = NULL;

	struct xfs_da_args	args = {

		.dp		= XFS_I(inode),

		.flags		= flags,

		.name		= name,

		.namelen	= strlen(name),

	};

	int			error;

	size_t			namelen;



	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))

		return -EPERM;
@@ -399,16 +405,16 @@ xfs_attrmulti_attr_set( 
	if (ubuf) {

		if (len > XFS_XATTR_SIZE_MAX)

			return -EINVAL;

		kbuf = memdup_user(ubuf, len);

		if (IS_ERR(kbuf))

			return PTR_ERR(kbuf);

		args.value = memdup_user(ubuf, len);

		if (IS_ERR(args.value))

			return PTR_ERR(args.value);

		args.valuelen = len;

	}



	namelen = strlen(name);

	error = xfs_attr_set(XFS_I(inode), name, namelen, kbuf, len, flags);

	error = xfs_attr_set(&args);

	if (!error)

		xfs_forget_acl(inode, name, flags);

	kfree(kbuf);

	kfree(args.value);

	return error;

}

fs/xfs/xfs_iops.c

+9 −4
Original line number Diff line number Diff line
@@ -50,10 +50,15 @@ xfs_initxattrs( 
	int			error = 0;



	for (xattr = xattr_array; xattr->name != NULL; xattr++) {

		error = xfs_attr_set(ip, xattr->name,

				     strlen(xattr->name),

				     xattr->value, xattr->value_len,

				     ATTR_SECURE);

		struct xfs_da_args	args = {

			.dp		= ip,

			.flags		= ATTR_SECURE,

			.name		= xattr->name,

			.namelen	= strlen(xattr->name),

			.value		= xattr->value,

			.valuelen	= xattr->value_len,

		};

		error = xfs_attr_set(&args);

		if (error < 0)

			break;

	}