xfs: Merge xfs_delattr_context into xfs_attr_item

Source kernel commit: d68c51e9a4095b57f06bf5dd15ab8fae6dab5d8b

This is a clean up patch that merges xfs_delattr_context into
xfs_attr_item.  Now that the refactoring is complete and the delayed
operation infrastructure is in place, we can combine these to eliminate
the extra struct

Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
Signed-off-by: Eric Sandeen <sandeen@sandeen.net>

diff --git a/libxfs/defer_item.c b/libxfs/defer_item.c
index 65afdb21afa0de1376b48387ead8bc588154036f..8030b8344c22d6f67ee2c623a60ce8aac74d00f8 100644 (file)
--- a/libxfs/defer_item.c
+++ b/libxfs/defer_item.c
@@ -495,13 +495,11 @@ xfs_attr_finish_item(
 {
        struct xfs_attr_item    *attr;
        int                     error;
-       struct xfs_delattr_context *dac;
        struct xfs_da_args      *args;
        unsigned int            op;
 
        attr = container_of(item, struct xfs_attr_item, xattri_list);
-       dac = &attr->xattri_dac;
-       args = dac->da_args;
+       args = attr->xattri_da_args;
        op = attr->xattri_op_flags & XFS_ATTR_OP_FLAGS_TYPE_MASK;
 
        /*
@@ -517,11 +515,11 @@ xfs_attr_finish_item(
 
        switch (op) {
        case XFS_ATTR_OP_FLAGS_SET:
-               error = xfs_attr_set_iter(dac);
+               error = xfs_attr_set_iter(attr);
                break;
        case XFS_ATTR_OP_FLAGS_REMOVE:
                ASSERT(XFS_IFORK_Q(args->dp));
-               error = xfs_attr_remove_iter(dac);
+               error = xfs_attr_remove_iter(attr);
                break;
        default:
                error = -EFSCORRUPTED;

diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index 7631f880c3e4c156126594c616a0c2b9067ed992..85141dfafaa5bb84e25438b2610639e914ee6caf 100644 (file)
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -56,10 +56,9 @@ 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_addname(struct xfs_delattr_context *dac);
-STATIC int xfs_attr_node_addname_find_attr(struct xfs_delattr_context *dac);
-STATIC int xfs_attr_node_addname_clear_incomplete(
-                               struct xfs_delattr_context *dac);
+STATIC int xfs_attr_node_addname(struct xfs_attr_item *attr);
+STATIC int xfs_attr_node_addname_find_attr(struct xfs_attr_item *attr);
+STATIC int xfs_attr_node_addname_clear_incomplete(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_fillstate(xfs_da_state_t *state);
@@ -246,9 +245,9 @@ xfs_attr_is_shortform(
 
 STATIC int
 xfs_attr_sf_addname(
-       struct xfs_delattr_context      *dac)
+       struct xfs_attr_item            *attr)
 {
-       struct xfs_da_args              *args = dac->da_args;
+       struct xfs_da_args              *args = attr->xattri_da_args;
        struct xfs_inode                *dp = args->dp;
        int                             error = 0;
 
@@ -265,7 +264,7 @@ xfs_attr_sf_addname(
         * It won't fit in the shortform, transform to a leaf block.  GROT:
         * another possible req'mt for a double-split btree op.
         */
-       error = xfs_attr_shortform_to_leaf(args, &dac->leaf_bp);
+       error = xfs_attr_shortform_to_leaf(args, &attr->xattri_leaf_bp);
        if (error)
                return error;
 
@@ -274,7 +273,7 @@ xfs_attr_sf_addname(
         * push cannot grab the half-baked leaf buffer and run into problems
         * with the write verifier.
         */
-       xfs_trans_bhold(args->trans, dac->leaf_bp);
+       xfs_trans_bhold(args->trans, attr->xattri_leaf_bp);
 
        /*
         * We're still in XFS_DAS_UNINIT state here.  We've converted
@@ -294,16 +293,16 @@ xfs_attr_sf_addname(
  */
 int
 xfs_attr_set_iter(
-       struct xfs_delattr_context      *dac)
+       struct xfs_attr_item            *attr)
 {
-       struct xfs_da_args              *args = dac->da_args;
+       struct xfs_da_args              *args = attr->xattri_da_args;
        struct xfs_inode                *dp = args->dp;
        struct xfs_buf                  *bp = NULL;
        int                             forkoff, error = 0;
        struct xfs_mount                *mp = args->dp->i_mount;
 
        /* State machine switch */
-       switch (dac->dela_state) {
+       switch (attr->xattri_dela_state) {
        case XFS_DAS_UNINIT:
                /*
                 * If the fork is shortform, attempt to add the attr. If there
@@ -313,14 +312,16 @@ xfs_attr_set_iter(
                 * release the hold once we return with a clean transaction.
                 */
                if (xfs_attr_is_shortform(dp))
-                       return xfs_attr_sf_addname(dac);
-               if (dac->leaf_bp != NULL) {
-                       xfs_trans_bhold_release(args->trans, dac->leaf_bp);
-                       dac->leaf_bp = NULL;
+                       return xfs_attr_sf_addname(attr);
+               if (attr->xattri_leaf_bp != NULL) {
+                       xfs_trans_bhold_release(args->trans,
+                                               attr->xattri_leaf_bp);
+                       attr->xattri_leaf_bp = NULL;
                }
 
                if (xfs_attr_is_leaf(dp)) {
-                       error = xfs_attr_leaf_try_add(args, dac->leaf_bp);
+                       error = xfs_attr_leaf_try_add(args,
+                                                     attr->xattri_leaf_bp);
                        if (error == -ENOSPC) {
                                error = xfs_attr3_leaf_to_node(args);
                                if (error)
@@ -340,19 +341,19 @@ xfs_attr_set_iter(
                                 * handling code below
                                 */
                                trace_xfs_attr_set_iter_return(
-                                       dac->dela_state, args->dp);
+                                       attr->xattri_dela_state, args->dp);
                                return -EAGAIN;
                        } else if (error) {
                                return error;
                        }
 
-                       dac->dela_state = XFS_DAS_FOUND_LBLK;
+                       attr->xattri_dela_state = XFS_DAS_FOUND_LBLK;
                } else {
-                       error = xfs_attr_node_addname_find_attr(dac);
+                       error = xfs_attr_node_addname_find_attr(attr);
                        if (error)
                                return error;
 
-                       error = xfs_attr_node_addname(dac);
+                       error = xfs_attr_node_addname(attr);
                        if (error)
                                return error;
 
@@ -364,9 +365,10 @@ xfs_attr_set_iter(
                            !(args->op_flags & XFS_DA_OP_RENAME))
                                return 0;
 
-                       dac->dela_state = XFS_DAS_FOUND_NBLK;
+                       attr->xattri_dela_state = XFS_DAS_FOUND_NBLK;
                }
-               trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
+               trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
+                                              args->dp);
                return -EAGAIN;
        case XFS_DAS_FOUND_LBLK:
                /*
@@ -377,10 +379,10 @@ xfs_attr_set_iter(
                 */
 
                /* Open coded xfs_attr_rmtval_set without trans handling */
-               if ((dac->flags & XFS_DAC_LEAF_ADDNAME_INIT) == 0) {
-                       dac->flags |= XFS_DAC_LEAF_ADDNAME_INIT;
+               if ((attr->xattri_flags & XFS_DAC_LEAF_ADDNAME_INIT) == 0) {
+                       attr->xattri_flags |= XFS_DAC_LEAF_ADDNAME_INIT;
                        if (args->rmtblkno > 0) {
-                               error = xfs_attr_rmtval_find_space(dac);
+                               error = xfs_attr_rmtval_find_space(attr);
                                if (error)
                                        return error;
                        }
@@ -390,11 +392,11 @@ xfs_attr_set_iter(
                 * Repeat allocating remote blocks for the attr value until
                 * blkcnt drops to zero.
                 */
-               if (dac->blkcnt > 0) {
-                       error = xfs_attr_rmtval_set_blk(dac);
+               if (attr->xattri_blkcnt > 0) {
+                       error = xfs_attr_rmtval_set_blk(attr);
                        if (error)
                                return error;
-                       trace_xfs_attr_set_iter_return(dac->dela_state,
+                       trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
                                                       args->dp);
                        return -EAGAIN;
                }
@@ -430,8 +432,8 @@ xfs_attr_set_iter(
                         * Commit the flag value change and start the next trans
                         * in series.
                         */
-                       dac->dela_state = XFS_DAS_FLIP_LFLAG;
-                       trace_xfs_attr_set_iter_return(dac->dela_state,
+                       attr->xattri_dela_state = XFS_DAS_FLIP_LFLAG;
+                       trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
                                                       args->dp);
                        return -EAGAIN;
                }
@@ -450,17 +452,18 @@ xfs_attr_set_iter(
                fallthrough;
        case XFS_DAS_RM_LBLK:
                /* Set state in case xfs_attr_rmtval_remove returns -EAGAIN */
-               dac->dela_state = XFS_DAS_RM_LBLK;
+               attr->xattri_dela_state = XFS_DAS_RM_LBLK;
                if (args->rmtblkno) {
-                       error = xfs_attr_rmtval_remove(dac);
+                       error = xfs_attr_rmtval_remove(attr);
                        if (error == -EAGAIN)
                                trace_xfs_attr_set_iter_return(
-                                       dac->dela_state, args->dp);
+                                       attr->xattri_dela_state, args->dp);
                        if (error)
                                return error;
 
-                       dac->dela_state = XFS_DAS_RD_LEAF;
-                       trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
+                       attr->xattri_dela_state = XFS_DAS_RD_LEAF;
+                       trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
+                                                      args->dp);
                        return -EAGAIN;
                }
 
@@ -491,7 +494,7 @@ xfs_attr_set_iter(
                 * state.
                 */
                if (args->rmtblkno > 0) {
-                       error = xfs_attr_rmtval_find_space(dac);
+                       error = xfs_attr_rmtval_find_space(attr);
                        if (error)
                                return error;
                }
@@ -504,14 +507,14 @@ xfs_attr_set_iter(
                 * after we create the attribute so that we don't overflow the
                 * maximum size of a transaction and/or hit a deadlock.
                 */
-               dac->dela_state = XFS_DAS_ALLOC_NODE;
+               attr->xattri_dela_state = XFS_DAS_ALLOC_NODE;
                if (args->rmtblkno > 0) {
-                       if (dac->blkcnt > 0) {
-                               error = xfs_attr_rmtval_set_blk(dac);
+                       if (attr->xattri_blkcnt > 0) {
+                               error = xfs_attr_rmtval_set_blk(attr);
                                if (error)
                                        return error;
                                trace_xfs_attr_set_iter_return(
-                                       dac->dela_state, args->dp);
+                                       attr->xattri_dela_state, args->dp);
                                return -EAGAIN;
                        }
 
@@ -547,8 +550,8 @@ xfs_attr_set_iter(
                         * Commit the flag value change and start the next trans
                         * in series
                         */
-                       dac->dela_state = XFS_DAS_FLIP_NFLAG;
-                       trace_xfs_attr_set_iter_return(dac->dela_state,
+                       attr->xattri_dela_state = XFS_DAS_FLIP_NFLAG;
+                       trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
                                                       args->dp);
                        return -EAGAIN;
                }
@@ -568,18 +571,19 @@ xfs_attr_set_iter(
                fallthrough;
        case XFS_DAS_RM_NBLK:
                /* Set state in case xfs_attr_rmtval_remove returns -EAGAIN */
-               dac->dela_state = XFS_DAS_RM_NBLK;
+               attr->xattri_dela_state = XFS_DAS_RM_NBLK;
                if (args->rmtblkno) {
-                       error = xfs_attr_rmtval_remove(dac);
+                       error = xfs_attr_rmtval_remove(attr);
                        if (error == -EAGAIN)
                                trace_xfs_attr_set_iter_return(
-                                       dac->dela_state, args->dp);
+                                       attr->xattri_dela_state, args->dp);
 
                        if (error)
                                return error;
 
-                       dac->dela_state = XFS_DAS_CLR_FLAG;
-                       trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
+                       attr->xattri_dela_state = XFS_DAS_CLR_FLAG;
+                       trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
+                                                      args->dp);
                        return -EAGAIN;
                }
 
@@ -589,7 +593,7 @@ xfs_attr_set_iter(
                 * The last state for node format. Look up the old attr and
                 * remove it.
                 */
-               error = xfs_attr_node_addname_clear_incomplete(dac);
+               error = xfs_attr_node_addname_clear_incomplete(attr);
                break;
        default:
                ASSERT(0);
@@ -823,7 +827,7 @@ xfs_attr_item_init(
 
        new = kmem_zalloc(sizeof(struct xfs_attr_item), KM_NOFS);
        new->xattri_op_flags = op_flags;
-       new->xattri_dac.da_args = args;
+       new->xattri_da_args = args;
 
        *attr = new;
        return 0;
@@ -1133,16 +1137,16 @@ xfs_attr_node_hasname(
 
 STATIC int
 xfs_attr_node_addname_find_attr(
-       struct xfs_delattr_context      *dac)
+        struct xfs_attr_item           *attr)
 {
-       struct xfs_da_args              *args = dac->da_args;
+       struct xfs_da_args              *args = attr->xattri_da_args;
        int                             retval;
 
        /*
         * Search to see if name already exists, and get back a pointer
         * to where it should go.
         */
-       retval = xfs_attr_node_hasname(args, &dac->da_state);
+       retval = xfs_attr_node_hasname(args, &attr->xattri_da_state);
        if (retval != -ENOATTR && retval != -EEXIST)
                goto error;
 
@@ -1170,8 +1174,8 @@ xfs_attr_node_addname_find_attr(
 
        return 0;
 error:
-       if (dac->da_state)
-               xfs_da_state_free(dac->da_state);
+       if (attr->xattri_da_state)
+               xfs_da_state_free(attr->xattri_da_state);
        return retval;
 }
 
@@ -1192,10 +1196,10 @@ error:
  */
 STATIC int
 xfs_attr_node_addname(
-       struct xfs_delattr_context      *dac)
+       struct xfs_attr_item            *attr)
 {
-       struct xfs_da_args              *args = dac->da_args;
-       struct xfs_da_state             *state = dac->da_state;
+       struct xfs_da_args              *args = attr->xattri_da_args;
+       struct xfs_da_state             *state = attr->xattri_da_state;
        struct xfs_da_state_blk         *blk;
        int                             error;
 
@@ -1226,7 +1230,7 @@ xfs_attr_node_addname(
                         * this point.
                         */
                        trace_xfs_attr_node_addname_return(
-                                       dac->dela_state, args->dp);
+                                       attr->xattri_dela_state, args->dp);
                        return -EAGAIN;
                }
 
@@ -1255,9 +1259,9 @@ out:
 
 STATIC int
 xfs_attr_node_addname_clear_incomplete(
-       struct xfs_delattr_context      *dac)
+       struct xfs_attr_item            *attr)
 {
-       struct xfs_da_args              *args = dac->da_args;
+       struct xfs_da_args              *args = attr->xattri_da_args;
        struct xfs_da_state             *state = NULL;
        struct xfs_mount                *mp = args->dp->i_mount;
        int                             retval = 0;
@@ -1361,10 +1365,10 @@ xfs_attr_leaf_mark_incomplete(
  */
 STATIC
 int xfs_attr_node_removename_setup(
-       struct xfs_delattr_context      *dac)
+       struct xfs_attr_item            *attr)
 {
-       struct xfs_da_args              *args = dac->da_args;
-       struct xfs_da_state             **state = &dac->da_state;
+       struct xfs_da_args              *args = attr->xattri_da_args;
+       struct xfs_da_state             **state = &attr->xattri_da_state;
        int                             error;
 
        error = xfs_attr_node_hasname(args, state);
@@ -1423,16 +1427,16 @@ xfs_attr_node_removename(
  */
 int
 xfs_attr_remove_iter(
-       struct xfs_delattr_context      *dac)
+       struct xfs_attr_item            *attr)
 {
-       struct xfs_da_args              *args = dac->da_args;
-       struct xfs_da_state             *state = dac->da_state;
+       struct xfs_da_args              *args = attr->xattri_da_args;
+       struct xfs_da_state             *state = attr->xattri_da_state;
        int                             retval, error = 0;
        struct xfs_inode                *dp = args->dp;
 
        trace_xfs_attr_node_removename(args);
 
-       switch (dac->dela_state) {
+       switch (attr->xattri_dela_state) {
        case XFS_DAS_UNINIT:
                if (!xfs_inode_hasattr(dp))
                        return -ENOATTR;
@@ -1451,16 +1455,16 @@ xfs_attr_remove_iter(
                 * Node format may require transaction rolls. Set up the
                 * state context and fall into the state machine.
                 */
-               if (!dac->da_state) {
-                       error = xfs_attr_node_removename_setup(dac);
+               if (!attr->xattri_da_state) {
+                       error = xfs_attr_node_removename_setup(attr);
                        if (error)
                                return error;
-                       state = dac->da_state;
+                       state = attr->xattri_da_state;
                }
 
                fallthrough;
        case XFS_DAS_RMTBLK:
-               dac->dela_state = XFS_DAS_RMTBLK;
+               attr->xattri_dela_state = XFS_DAS_RMTBLK;
 
                /*
                 * If there is an out-of-line value, de-allocate the blocks.
@@ -1473,10 +1477,10 @@ xfs_attr_remove_iter(
                         * May return -EAGAIN. Roll and repeat until all remote
                         * blocks are removed.
                         */
-                       error = xfs_attr_rmtval_remove(dac);
+                       error = xfs_attr_rmtval_remove(attr);
                        if (error == -EAGAIN) {
                                trace_xfs_attr_remove_iter_return(
-                                               dac->dela_state, args->dp);
+                                       attr->xattri_dela_state, args->dp);
                                return error;
                        } else if (error) {
                                goto out;
@@ -1491,8 +1495,10 @@ xfs_attr_remove_iter(
                        error = xfs_attr_refillstate(state);
                        if (error)
                                goto out;
-                       dac->dela_state = XFS_DAS_RM_NAME;
-                       trace_xfs_attr_remove_iter_return(dac->dela_state, args->dp);
+
+                       attr->xattri_dela_state = XFS_DAS_RM_NAME;
+                       trace_xfs_attr_remove_iter_return(
+                                       attr->xattri_dela_state, args->dp);
                        return -EAGAIN;
                }
 
@@ -1502,7 +1508,7 @@ xfs_attr_remove_iter(
                 * If we came here fresh from a transaction roll, reattach all
                 * the buffers to the current transaction.
                 */
-               if (dac->dela_state == XFS_DAS_RM_NAME) {
+               if (attr->xattri_dela_state == XFS_DAS_RM_NAME) {
                        error = xfs_attr_refillstate(state);
                        if (error)
                                goto out;
@@ -1519,9 +1525,9 @@ xfs_attr_remove_iter(
                        if (error)
                                goto out;
 
-                       dac->dela_state = XFS_DAS_RM_SHRINK;
+                       attr->xattri_dela_state = XFS_DAS_RM_SHRINK;
                        trace_xfs_attr_remove_iter_return(
-                                       dac->dela_state, args->dp);
+                                       attr->xattri_dela_state, args->dp);
                        return -EAGAIN;
                }
 

diff --git a/libxfs/xfs_attr.h b/libxfs/xfs_attr.h
index 78884e826ca4707e9d61da5b9ddbc3094250e72a..1ef58d34eb5926916aae9c33ecbce189bee3cb42 100644 (file)
--- a/libxfs/xfs_attr.h
+++ b/libxfs/xfs_attr.h
@@ -434,7 +434,7 @@ struct xfs_attr_list_context {
  */
 
 /*
- * Enum values for xfs_delattr_context.da_state
+ * Enum values for xfs_attr_item.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
@@ -459,39 +459,32 @@ enum xfs_delattr_state {
 };
 
 /*
- * Defines for xfs_delattr_context.flags
+ * Defines for xfs_attr_item.xattri_flags
  */
 #define XFS_DAC_LEAF_ADDNAME_INIT      0x01 /* xfs_attr_leaf_addname init*/
 
 /*
  * Context used for keeping track of delayed attribute operations
  */
-struct xfs_delattr_context {
-       struct xfs_da_args      *da_args;
+struct xfs_attr_item {
+       struct xfs_da_args              *xattri_da_args;
 
        /*
         * Used by xfs_attr_set to hold a leaf buffer across a transaction roll
         */
-       struct xfs_buf          *leaf_bp;
+       struct xfs_buf                  *xattri_leaf_bp;
 
        /* Used in xfs_attr_rmtval_set_blk to roll through allocating blocks */
-       struct xfs_bmbt_irec    map;
-       xfs_dablk_t             lblkno;
-       int                     blkcnt;
+       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     *da_state;
+       struct xfs_da_state             *xattri_da_state;
 
        /* Used to keep track of current state of delayed operation */
-       unsigned int            flags;
-       enum xfs_delattr_state  dela_state;
-};
-
-/*
- * List of attrs to commit later.
- */
-struct xfs_attr_item {
-       struct xfs_delattr_context      xattri_dac;
+       unsigned int                    xattri_flags;
+       enum xfs_delattr_state          xattri_dela_state;
 
        /*
         * Indicates if the attr operation is a set or a remove
@@ -499,7 +492,10 @@ struct xfs_attr_item {
         */
        unsigned int                    xattri_op_flags;
 
-       /* used to log this item to an intent */
+       /*
+        * used to log this item to an intent containing a list of attrs to
+        * commit later
+        */
        struct list_head                xattri_list;
 };
 
@@ -519,11 +515,9 @@ 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_delattr_context *dac);
-int xfs_attr_remove_iter(struct xfs_delattr_context *dac);
+int xfs_attr_set_iter(struct xfs_attr_item *attr);
+int xfs_attr_remove_iter(struct xfs_attr_item *attr);
 bool xfs_attr_namecheck(const void *name, size_t length);
-void xfs_delattr_context_init(struct xfs_delattr_context *dac,
-                             struct xfs_da_args *args);
 int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
 int xfs_attr_set_deferred(struct xfs_da_args *args);
 int xfs_attr_remove_deferred(struct xfs_da_args *args);

diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
index 5dc93c3b26d4be971cf0812dc34f609abe8c83f6..40215a4dba5d27ad426afdf9f347eb31a65c58ca 100644 (file)
--- a/libxfs/xfs_attr_remote.c
+++ b/libxfs/xfs_attr_remote.c
@@ -567,14 +567,14 @@ xfs_attr_rmtval_stale(
  */
 int
 xfs_attr_rmtval_find_space(
-       struct xfs_delattr_context      *dac)
+       struct xfs_attr_item            *attr)
 {
-       struct xfs_da_args              *args = dac->da_args;
-       struct xfs_bmbt_irec            *map = &dac->map;
+       struct xfs_da_args              *args = attr->xattri_da_args;
+       struct xfs_bmbt_irec            *map = &attr->xattri_map;
        int                             error;
 
-       dac->lblkno = 0;
-       dac->blkcnt = 0;
+       attr->xattri_lblkno = 0;
+       attr->xattri_blkcnt = 0;
        args->rmtblkcnt = 0;
        args->rmtblkno = 0;
        memset(map, 0, sizeof(struct xfs_bmbt_irec));
@@ -583,8 +583,8 @@ xfs_attr_rmtval_find_space(
        if (error)
                return error;
 
-       dac->blkcnt = args->rmtblkcnt;
-       dac->lblkno = args->rmtblkno;
+       attr->xattri_blkcnt = args->rmtblkcnt;
+       attr->xattri_lblkno = args->rmtblkno;
 
        return 0;
 }
@@ -597,17 +597,18 @@ xfs_attr_rmtval_find_space(
  */
 int
 xfs_attr_rmtval_set_blk(
-       struct xfs_delattr_context      *dac)
+       struct xfs_attr_item            *attr)
 {
-       struct xfs_da_args              *args = dac->da_args;
+       struct xfs_da_args              *args = attr->xattri_da_args;
        struct xfs_inode                *dp = args->dp;
-       struct xfs_bmbt_irec            *map = &dac->map;
+       struct xfs_bmbt_irec            *map = &attr->xattri_map;
        int nmap;
        int error;
 
        nmap = 1;
-       error = xfs_bmapi_write(args->trans, dp, (xfs_fileoff_t)dac->lblkno,
-                       dac->blkcnt, XFS_BMAPI_ATTRFORK, args->total,
+       error = xfs_bmapi_write(args->trans, dp,
+                       (xfs_fileoff_t)attr->xattri_lblkno,
+                       attr->xattri_blkcnt, XFS_BMAPI_ATTRFORK, args->total,
                        map, &nmap);
        if (error)
                return error;
@@ -617,8 +618,8 @@ xfs_attr_rmtval_set_blk(
               (map->br_startblock != HOLESTARTBLOCK));
 
        /* roll attribute extent map forwards */
-       dac->lblkno += map->br_blockcount;
-       dac->blkcnt -= map->br_blockcount;
+       attr->xattri_lblkno += map->br_blockcount;
+       attr->xattri_blkcnt -= map->br_blockcount;
 
        return 0;
 }
@@ -672,9 +673,9 @@ xfs_attr_rmtval_invalidate(
  */
 int
 xfs_attr_rmtval_remove(
-       struct xfs_delattr_context      *dac)
+       struct xfs_attr_item            *attr)
 {
-       struct xfs_da_args              *args = dac->da_args;
+       struct xfs_da_args              *args = attr->xattri_da_args;
        int                             error, done;
 
        /*
@@ -694,7 +695,8 @@ xfs_attr_rmtval_remove(
         * the parent
         */
        if (!done) {
-               trace_xfs_attr_rmtval_remove_return(dac->dela_state, args->dp);
+               trace_xfs_attr_rmtval_remove_return(attr->xattri_dela_state,
+                                                   args->dp);
                return -EAGAIN;
        }
 

diff --git a/libxfs/xfs_attr_remote.h b/libxfs/xfs_attr_remote.h
index d72eff30ca1833dd639e4695f9ffb01229a54bd2..62b398edec3f3e595188bcda7b7bf81ce9f6a2fe 100644 (file)
--- a/libxfs/xfs_attr_remote.h
+++ b/libxfs/xfs_attr_remote.h
@@ -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_delattr_context *dac);
+int xfs_attr_rmtval_remove(struct xfs_attr_item *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_delattr_context *dac);
-int xfs_attr_rmtval_find_space(struct xfs_delattr_context *dac);
+int xfs_attr_rmtval_set_blk(struct xfs_attr_item *attr);
+int xfs_attr_rmtval_find_space(struct xfs_attr_item *attr);
 #endif /* __XFS_ATTR_REMOTE_H__ */