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: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Chandan Rajendra <chandanrlinux@gmail.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>

diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index f887d62e0956aaedffabae6aab90e03d0b956f85..eea6d90af27646c09789ab70b38c053fe6032163 100644 (file)
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -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;
 }
 

diff --git a/fs/xfs/libxfs/xfs_attr.h b/fs/xfs/libxfs/xfs_attr.h
index db58a6c7dea5a766e7c25bffdb9affcbb9da20bc..07ca543db831f14fc8c82ea4c21209cffffcf34a 100644 (file)
--- a/fs/xfs/libxfs/xfs_attr.h
+++ b/fs/xfs/libxfs/xfs_attr.h
@@ -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,

diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 2a135fbc980780e12e28c304ad1429322ae0bf7a..39a53d5afc478ed8ea19657ba0427d825bac00fd 100644 (file)
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -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>
 
@@ -170,41 +172,42 @@ xfs_get_acl(struct inode *inode, int type)
 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;
-       int error;
+       struct xfs_inode        *ip = XFS_I(inode);
+       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.

diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index d42be87ca143d16959dc84944c0f6e8b5d58e9e2..d4aa60a6f761ba2e199cef93c972df67dd82f7ac 100644 (file)
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -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;
 }
 

diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index a5b7c3100a2f187dbe007894200770c8f99f4591..5f6613dc0617b860138113c2461526dcfa668085 100644 (file)
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -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;
        }

diff --git a/fs/xfs/xfs_xattr.c b/fs/xfs/xfs_xattr.c
index 1670bfbc9ad26225e845ca83fb59ad130a6f8324..bd770094b95a008bc26ed52ae17024792fe15d28 100644 (file)
--- a/fs/xfs/xfs_xattr.c
+++ b/fs/xfs/xfs_xattr.c
@@ -12,6 +12,8 @@
 #include "xfs_inode.h"
 #include "xfs_attr.h"
 #include "xfs_acl.h"
+#include "xfs_da_format.h"
+#include "xfs_da_btree.h"
 
 #include <linux/posix_acl_xattr.h>
 #include <linux/xattr.h>
@@ -66,20 +68,25 @@ xfs_xattr_set(const struct xattr_handler *handler, struct dentry *unused,
                struct inode *inode, const char *name, const void *value,
                size_t size, int flags)
 {
-       int                     xflags = handler->flags;
-       struct xfs_inode        *ip = XFS_I(inode);
+       struct xfs_da_args      args = {
+               .dp             = XFS_I(inode),
+               .flags          = handler->flags,
+               .name           = name,
+               .namelen        = strlen(name),
+               .value          = (void *)value,
+               .valuelen       = size,
+       };
        int                     error;
 
        /* Convert Linux syscall to XFS internal ATTR flags */
        if (flags & XATTR_CREATE)
-               xflags |= ATTR_CREATE;
+               args.flags |= ATTR_CREATE;
        if (flags & XATTR_REPLACE)
-               xflags |= ATTR_REPLACE;
+               args.flags |= ATTR_REPLACE;
 
-       error = xfs_attr_set(ip, (unsigned char *)name, strlen(name),
-                               (void *)value, size, xflags);
+       error = xfs_attr_set(&args);
        if (!error)
-               xfs_forget_acl(inode, name, xflags);
+               xfs_forget_acl(inode, name, args.flags);
        return error;
 }