xfsprogs: Delay Ready Attributes
v17 cover xfsprogs: Delay Ready Attributes
Hi all,
This set applies the corresponding changes for delayed ready attributes to xfsprogs. I will pick up the reviews from the kernel side series and mirror them here. This set also includes some patches from the kernel side that have not yet been ported. This set also includes patches needed for the user space cli and log printing routines
This series can also be viewed on github here:
https://github.com/allisonhenderson/xfs_work/tree/delay_ready_attrs_xfsprogs_v17
And also the extended delayed attribute and parent pointer series:
https://github.com/allisonhenderson/xfs_work/tree/delay_ready_attrs_xfsprogs_v17_extended
Thanks all!
Allison
Allison Henderson (11):
xfsprogs: Reverse apply 72b97ea40d
xfsprogs: Add xfs_attr_node_remove_cleanup
xfsprogs: Hoist xfs_attr_set_shortform
xfsprogs: Add helper xfs_attr_set_fmt
xfsprogs: Separate xfs_attr_node_addname and
xfs_attr_node_addname_clear_incomplete
xfsprogs: Add helper xfs_attr_node_addname_find_attr
xfsprogs: Hoist xfs_attr_node_addname
xfsprogs: Hoist xfs_attr_leaf_addname
xfsprogs: Hoist node transaction handling
xfsprogs: Add delay ready attr remove routines
xfsprogs: Add delay ready attr set routines
Gao Xiang (1):
xfs: add error injection for per-AG resv failure
include/libxfs.h | 1 + include/xfs_trace.h | 2 - io/inject.c | 1 + libxfs/xfs_ag_resv.c | 6 +- libxfs/xfs_attr.c | 907 ++++++++++++++++++++++++++++------------------- libxfs/xfs_attr.h | 401 +++++++++++++++++++++ libxfs/xfs_attr_leaf.c | 2 +- libxfs/xfs_attr_remote.c | 126 ++++--- libxfs/xfs_attr_remote.h | 7 +- libxfs/xfs_errortag.h | 4 +- 10 files changed, 1047 insertions(+), 410 deletions(-)
Signature · 1 line
2.7.4
PATCH v17 1/12 xfs: add error injection for per-AG resv failure
From: Gao Xiang <[email protected]>
Source kernel commit: 2b92faed551173f065ee2a8cf087dc76cf40303b
per-AG resv failure after fixing up freespace is hard to test in an effective way, so directly add an error injection path to observe such error handling path works as expected.
--- io/inject.c | 1 + libxfs/xfs_ag_resv.c | 6 +++++- libxfs/xfs_errortag.h | 4 +++- 3 files changed, 9 insertions(+), 2 deletions(-)
io/inject.c +1 -0
@@ -57,6 +57,7 @@ error_tag(char *name) { XFS_ERRTAG_BUF_IOERROR, "buf_ioerror" }, { XFS_ERRTAG_REDUCE_MAX_IEXTENTS, "reduce_max_iextents" }, { XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT, "bmap_alloc_minlen_extent" }, + { XFS_ERRTAG_AG_RESV_FAIL, "ag_resv_fail"}, { XFS_ERRTAG_MAX, NULL } };int count;
libxfs/xfs_ag_resv.c +5 -1
@@ -210,7 +210,11 @@ __xfs_ag_resv_init(ASSERT (0 );return -EINVAL ; } - error =xfs_mod_fdblocks (mp, -(int64_t )hidden_space, true); + +if (XFS_TEST_ERROR (false, mp,XFS_ERRTAG_AG_RESV_FAIL )) + error = -ENOSPC ; +else + error =xfs_mod_fdblocks (mp, -(int64_t )hidden_space, true);if (error) {trace_xfs_ag_resv_init_error (pag->pag_mount, pag->pag_agno, error, _RET_IP_);
libxfs/xfs_errortag.h +3 -1
@@ -58,7 +58,8 @@#define XFS_ERRTAG_BUF_IOERROR 35#define XFS_ERRTAG_REDUCE_MAX_IEXTENTS 36#define XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT 37 -#define XFS_ERRTAG_MAX 38 +#define XFS_ERRTAG_AG_RESV_FAIL 38 +#define XFS_ERRTAG_MAX 39/* * Random factors for above tags, 1 means always, 2 means 1/2 time, etc.
@@ -101,5 +102,6 @@#define XFS_RANDOM_BUF_IOERROR XFS_RANDOM_DEFAULT#define XFS_RANDOM_REDUCE_MAX_IEXTENTS 1#define XFS_RANDOM_BMAP_ALLOC_MINLEN_EXTENT 1 +#define XFS_RANDOM_AG_RESV_FAIL 1#endif /* __XFS_ERRORTAG_H_ */
Signature · 1 line
2.7.4
PATCH v17 2/12 xfsprogs: Reverse apply 72b97ea40d
In reply to Allison HendersonOriginally we added this patch to help modularize the attr code in preparation for delayed attributes and the state machine it requires. However, later reviews found that this slightly alters the transaction handling as the helper function is ambiguous as to whether the transaction is diry or clean. This may cause a dirty transaction to be included in the next roll, where previously it had not. To preserve the existing code flow, we reverse apply this commit.
--- libxfs/xfs_attr.c | 28 +++++++++------------------- 1 file changed, 9 insertions(+), 19 deletions(-)
libxfs/xfs_attr.c +9 -19
@@ -1202,24 +1202,6 @@ int xfs_attr_node_removename_setup(return 0 ; } -STATIC int -xfs_attr_node_remove_rmt ( -struct xfs_da_args *args, -struct xfs_da_state *state) -{ -int error =0 ; - - error =xfs_attr_rmtval_remove (args); -if (error) -return error; - -/* -* Refill the state structure with buffers, the prior calls released our -* buffers. -*/ -return xfs_attr_refillstate (state); -} -/* * Remove a name from a B-tree attribute list. *
@@ -1248,7 +1230,15 @@ xfs_attr_node_removename(* overflow the maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - error =xfs_attr_node_remove_rmt (args, state); + error =xfs_attr_rmtval_remove (args); +if (error) + goto out; + +/* +* Refill the state structure with buffers, the prior calls +* released our buffers. +*/ + error =xfs_attr_refillstate (state);if (error) goto out; }
Signature · 1 line
2.7.4
PATCH v17 3/12 xfsprogs: Add xfs_attr_node_remove_cleanup
In reply to Allison HendersonSource kernel commit: 4078af18570ef0f89fce18e9ed9c1fa0c827f37b
This patch pulls a new helper function xfs_attr_node_remove_cleanup out of xfs_attr_node_remove_step. This helps to modularize xfs_attr_node_remove_step which will help make the delayed attribute code easier to follow
--- libxfs/xfs_attr.c | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-)
libxfs/xfs_attr.c +20 -9
@@ -1202,6 +1202,25 @@ int xfs_attr_node_removename_setup(return 0 ; } +STATIC int +xfs_attr_node_remove_cleanup ( +struct xfs_da_args *args, +struct xfs_da_state *state) +{ +struct xfs_da_state_blk *blk; +int retval; + +/* +* Remove the name and update the hashvals in the tree. +*/ + blk = &state->path.blk[state->path.active-1 ]; +ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); + retval =xfs_attr3_leaf_remove (blk->bp, args); +xfs_da3_fixhashpath (state, &state->path); + +return retval; +} +/* * Remove a name from a B-tree attribute list. *
@@ -1214,7 +1233,6 @@ xfs_attr_node_removename( struct xfs_da_args *args) {struct xfs_da_state *state; -struct xfs_da_state_blk *blk;int retval, error;struct xfs_inode *dp = args->dp;
@@ -1242,14 +1260,7 @@ xfs_attr_node_removename(if (error) goto out; } - -/* -* Remove the name and update the hashvals in the tree. -*/ - blk = &state->path.blk[ state->path.active-1 ]; -ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); - retval =xfs_attr3_leaf_remove (blk->bp, args); -xfs_da3_fixhashpath (state, &state->path); + retval =xfs_attr_node_remove_cleanup (args, state);/* * Check to see if the tree needs to be collapsed.
Signature · 1 line
2.7.4
PATCH v17 4/12 xfsprogs: Hoist xfs_attr_set_shortform
In reply to Allison HendersonThis patch hoists xfs_attr_set_shortform into the calling function. This will help keep all state management code in the same scope.
--- libxfs/xfs_attr.c | 81 +++++++++++++++++++------------------------------------ 1 file changed, 27 insertions(+), 54 deletions(-)
libxfs/xfs_attr.c +27 -54
@@ -217,53 +217,6 @@ xfs_attr_is_shortform( }/* -* Attempts to set an attr in shortform, or converts short form to leaf form if -* there is not enough room. If the attr is set, the transaction is committed -* and set to NULL. -*/ -STATIC int -xfs_attr_set_shortform ( -struct xfs_da_args *args, -struct xfs_buf **leaf_bp) -{ -struct xfs_inode *dp = args->dp; -int error, error2 =0 ; - -/* -* Try to add the attr to the attribute list in the inode. -*/ - error =xfs_attr_try_sf_addname (dp, args); -if (error != -ENOSPC ) { - error2 =xfs_trans_commit (args->trans); - args->trans =NULL ; -return error ? error : error2; - } -/* -* 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, leaf_bp); -if (error) -return error; - -/* -* Prevent the leaf buffer from being unlocked so that a concurrent AIL -* push cannot grab the half-baked leaf buffer and run into problems -* with the write verifier. Once we're done rolling the transaction we -* can release the hold and add the attr to the leaf. -*/ -xfs_trans_bhold (args->trans, *leaf_bp); - error =xfs_defer_finish (&args->trans); -xfs_trans_bhold_release (args->trans, *leaf_bp); -if (error) { -xfs_trans_brelse (args->trans, *leaf_bp); -return error; - } - -return 0 ; -} - -/* * Set the attribute specified in @args. */ int
@@ -272,7 +225,7 @@ xfs_attr_set_args( {struct xfs_inode *dp = args->dp;struct xfs_buf *leaf_bp =NULL ; -int error =0 ; +int error2, error =0 ;/* * If the attribute list is already in leaf format, jump straight to
@@ -281,16 +234,36 @@ xfs_attr_set_args(* again. */ if (xfs_attr_is_shortform (dp)) { +/* +* Try to add the attr to the attribute list in the inode. +*/ + error =xfs_attr_try_sf_addname (dp, args); +if (error != -ENOSPC ) { + error2 =xfs_trans_commit (args->trans); + args->trans =NULL ; +return error ? error : error2; + } + +/* +* 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, &leaf_bp); +if (error) +return error;/* -* If the attr was successfully set in shortform, the -* transaction is committed and set to NULL. Otherwise, is it -* converted from shortform to leaf, and the transaction is -* retained. +* Prevent the leaf buffer from being unlocked so that a +* concurrent AIL push cannot grab the half-baked leaf buffer +* and run into problems with the write verifier. */ - error =xfs_attr_set_shortform (args, &leaf_bp); -if (error || !args->trans) +xfs_trans_bhold (args->trans, leaf_bp); + error =xfs_defer_finish (&args->trans); +xfs_trans_bhold_release (args->trans, leaf_bp); +if (error) { +xfs_trans_brelse (args->trans, leaf_bp);return error; + } }if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) {
Signature · 1 line
2.7.4
PATCH v17 5/12 xfsprogs: Add helper xfs_attr_set_fmt
In reply to Allison HendersonSource kernel commit: 45b71a4f3fd8bc8d47adcbdfd859ed736a54e66b
This patch adds a helper function xfs_attr_set_fmt. This will help isolate the code that will require state management from the portions that do not. xfs_attr_set_fmt returns 0 when the attr has been set and no further action is needed. It returns -EAGAIN when shortform has been transformed to leaf, and the calling function should proceed the set the attr in leaf form.
--- libxfs/xfs_attr.c | 79 ++++++++++++++++++++++++++++++++----------------------- 1 file changed, 46 insertions(+), 33 deletions(-)
libxfs/xfs_attr.c +46 -33
@@ -216,6 +216,48 @@ xfs_attr_is_shortform( ip->i_afp->if_nextents == 0); } +STATIC int +xfs_attr_set_fmt ( +struct xfs_da_args *args) +{ +struct xfs_buf *leaf_bp =NULL ; +struct xfs_inode *dp = args->dp; +int error2, error =0 ; + +/* +* Try to add the attr to the attribute list in the inode. +*/ + error =xfs_attr_try_sf_addname (dp, args); +if (error != -ENOSPC ) { + error2 =xfs_trans_commit (args->trans); + args->trans =NULL ; +return error ? error : error2; + } + +/* +* 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, &leaf_bp); +if (error) +return error; + +/* +* Prevent the leaf buffer from being unlocked so that a +* concurrent AIL push cannot grab the half-baked leaf buffer +* and run into problems with the write verifier. +*/ +xfs_trans_bhold (args->trans, leaf_bp); + error =xfs_defer_finish (&args->trans); +xfs_trans_bhold_release (args->trans, leaf_bp); +if (error) { +xfs_trans_brelse (args->trans, leaf_bp); +return error; + } + +return -EAGAIN ; +} +/* * Set the attribute specified in @args. */
@@ -224,8 +266,7 @@ xfs_attr_set_args( struct xfs_da_args *args) {struct xfs_inode *dp = args->dp; -struct xfs_buf *leaf_bp =NULL ; -int error2, error =0 ; +int error;/* * If the attribute list is already in leaf format, jump straight to
@@ -234,36 +275,9 @@ xfs_attr_set_args(* again. */ if (xfs_attr_is_shortform (dp)) { -/* -* Try to add the attr to the attribute list in the inode. -*/ - error =xfs_attr_try_sf_addname (dp, args); -if (error != -ENOSPC ) { - error2 =xfs_trans_commit (args->trans); - args->trans =NULL ; -return error ? error : error2; - } - -/* -* 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, &leaf_bp); -if (error) -return error; - -/* -* Prevent the leaf buffer from being unlocked so that a -* concurrent AIL push cannot grab the half-baked leaf buffer -* and run into problems with the write verifier. -*/ -xfs_trans_bhold (args->trans, leaf_bp); - error =xfs_defer_finish (&args->trans); -xfs_trans_bhold_release (args->trans, leaf_bp); -if (error) { -xfs_trans_brelse (args->trans, leaf_bp); + error =xfs_attr_set_fmt (args); +if (error != -EAGAIN )return error; - } }if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) {
@@ -297,8 +311,7 @@ xfs_attr_set_args(return error; } - error =xfs_attr_node_addname (args); -return error; +return xfs_attr_node_addname (args); }/*
Signature · 1 line
2.7.4
PATCH v17 6/12 xfsprogs: Separate xfs_attr_node_addname and xfs_attr_node_addname_clear_incomplete
In reply to Allison HendersonSource kernel commit: 392a7ea8080e3753aa179d4daaa2ad413d0ff441
This patch separate xfs_attr_node_addname into two functions. This will help to make it easier to hoist parts of xfs_attr_node_addname that need state management
--- libxfs/xfs_attr.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+)
libxfs/xfs_attr.c +20 -0
@@ -54,6 +54,7 @@ STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp); 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_addname_clear_incomplete(struct xfs_da_args *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);
@@ -1061,6 +1062,25 @@ restart:return error; } + error =xfs_attr_node_addname_clear_incomplete (args); +out: +if (state) +xfs_da_state_free (state); +if (error) +return error; +return retval; +} + + +STATIC +int xfs_attr_node_addname_clear_incomplete( +struct xfs_da_args *args) +{ +struct xfs_da_state *state =NULL ; +struct xfs_da_state_blk *blk; +int retval =0 ; +int error =0 ; +/* * Re-find the "old" attribute entry after any split ops. The INCOMPLETE * flag means that we will find the "old" attr, not the "new" one.
Signature · 1 line
2.7.4
PATCH v17 7/12 xfsprogs: Add helper xfs_attr_node_addname_find_attr
In reply to Allison HendersonSource kernel commit: 1aeec98c3f70bff14cc0e65ef898e91c2c554d41
This patch separates the first half of xfs_attr_node_addname into a helper function xfs_attr_node_addname_find_attr. It also replaces the restart goto with an EAGAIN return code driven by a loop in the calling function. This looks odd now, but will clean up nicly once we introduce the state machine. It will also enable hoisting the last state out of xfs_attr_node_addname with out having to plumb in a "done" parameter to know if we need to move to the next state or not.
--- libxfs/xfs_attr.c | 86 ++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 54 insertions(+), 32 deletions(-)
libxfs/xfs_attr.c +54 -32
@@ -52,7 +52,10 @@ 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. */ 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_addname(struct xfs_da_args *args, +struct xfs_da_state *state); +STATIC int xfs_attr_node_addname_find_attr(struct xfs_da_args *args, +struct xfs_da_state **state); STATIC int xfs_attr_node_removename(xfs_da_args_t *args); STATIC int xfs_attr_node_addname_clear_incomplete(struct xfs_da_args *args); STATIC int xfs_attr_node_hasname(xfs_da_args_t *args,
@@ -267,6 +270,7 @@ xfs_attr_set_args( struct xfs_da_args *args) {struct xfs_inode *dp = args->dp; +struct xfs_da_state *state;int error;/*
@@ -312,7 +316,14 @@ xfs_attr_set_args(return error; } -return xfs_attr_node_addname (args); +do { + error =xfs_attr_node_addname_find_attr (args, &state); +if (error) +return error; + error =xfs_attr_node_addname (args, state); + }while (error == -EAGAIN ); + +return error; }/*
@@ -885,47 +896,26 @@ xfs_attr_node_hasname(* External routines when attribute list size > geo->blksize *========================================================================*/ -/* -* Add a name to a Btree-format attribute list. -* -* This will involve walking down the Btree, and may involve splitting -* leaf nodes and even splitting intermediate nodes up to and including -* the root node (a special case of an intermediate node). -* -* "Remote" attribute values confuse the issue and atomic rename operations -* add a whole extra layer of confusion on top of that. -*/ STATIC int -xfs_attr_node_addname ( -struct xfs_da_args *args) +xfs_attr_node_addname_find_attr ( +struct xfs_da_args *args, +struct xfs_da_state **state) { -struct xfs_da_state *state; -struct xfs_da_state_blk *blk; -struct xfs_inode *dp; -int retval, error; - -trace_xfs_attr_node_addname (args); +int retval;/* -* Fill in bucket of arguments/results/context to carry around. -*/ - dp = args->dp; -restart: -/* * Search to see if name already exists, and get back a pointer * to where it should go. */ - retval =xfs_attr_node_hasname (args, &state); + retval =xfs_attr_node_hasname (args, state);if (retval != -ENOATTR && retval != -EEXIST ) - goto out; + goto error; - blk = &state->path.blk[ state->path.active-1 ]; -ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (retval == -ENOATTR && (args->attr_flags &XATTR_REPLACE )) - goto out; + goto error;if (retval == -EEXIST ) {if (args->attr_flags &XATTR_CREATE ) - goto out; + goto error;trace_xfs_attr_node_replace (args);
@@ -943,6 +933,38 @@ restart: args->rmtvaluelen =0 ; } +return 0 ; +error: +if (*state) +xfs_da_state_free (*state); +return retval; +} + +/* +* Add a name to a Btree-format attribute list. +* +* This will involve walking down the Btree, and may involve splitting +* leaf nodes and even splitting intermediate nodes up to and including +* the root node (a special case of an intermediate node). +* +* "Remote" attribute values confuse the issue and atomic rename operations +* add a whole extra layer of confusion on top of that. +*/ +STATIC int +xfs_attr_node_addname ( +struct xfs_da_args *args, +struct xfs_da_state *state) +{ +struct xfs_da_state_blk *blk; +struct xfs_inode *dp; +int retval, error; + +trace_xfs_attr_node_addname (args); + + dp = args->dp; + blk = &state->path.blk[state->path.active-1 ]; +ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); + retval =xfs_attr3_leaf_add (blk->bp, state->args);if (retval == -ENOSPC ) {if (state->path.active ==1 ) {
@@ -968,7 +990,7 @@ restart:if (error) goto out; - goto restart; +return -EAGAIN ; }/*
Signature · 1 line
2.7.4
PATCH v17 8/12 xfsprogs: Hoist xfs_attr_node_addname
In reply to Allison HendersonSource kernel commit: 8e7db2a154cf8889319a4d6e5f987998ed21fa1b
This patch hoists the later half of xfs_attr_node_addname into the calling function. We do this because it is this area that will need the most state management, and we want to keep such code in the same scope as much as possible
--- libxfs/xfs_attr.c | 157 ++++++++++++++++++++++++++---------------------------- 1 file changed, 76 insertions(+), 81 deletions(-)
libxfs/xfs_attr.c +76 -81
@@ -52,6 +52,7 @@ 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. */ 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_da_args *args,struct xfs_da_state *state); STATIC int xfs_attr_node_addname_find_attr(struct xfs_da_args *args,
@@ -270,8 +271,8 @@ xfs_attr_set_args( struct xfs_da_args *args) {struct xfs_inode *dp = args->dp; -struct xfs_da_state *state; -int error; +struct xfs_da_state *state =NULL ; +int error =0 ;/* * If the attribute list is already in leaf format, jump straight to
@@ -322,8 +323,77 @@ xfs_attr_set_args(return error; error =xfs_attr_node_addname (args, state); }while (error == -EAGAIN ); +if (error) +return error; + +/* +* Commit the leaf addition or btree split and start the next +* trans in the chain. +*/ + error =xfs_trans_roll_inode (&args->trans, dp); +if (error) + goto out; + +/* +* If there was an out-of-line value, allocate the blocks we +* identified for its storage and copy the value. This is done +* after we create the attribute so that we don't overflow the +* maximum size of a transaction and/or hit a deadlock. +*/ +if (args->rmtblkno >0 ) { + error =xfs_attr_rmtval_set (args); +if (error) +return error; + } + +if (!(args->op_flags &XFS_DA_OP_RENAME )) { +/* +* Added a "remote" value, just clear the incomplete flag. +*/ +if (args->rmtblkno >0 ) + error =xfs_attr3_leaf_clearflag (args); + goto out; + } + +/* +* If this is an atomic rename operation, we must "flip" the incomplete +* flags on the "new" and "old" attribute/value pairs so that one +* disappears and one appears atomically. Then we must remove the "old" +* attribute/value pair. +* +* In a separate transaction, set the incomplete flag on the "old" attr +* and clear the incomplete flag on the "new" attr. +*/ + error =xfs_attr3_leaf_flipflags (args); +if (error) + goto out; +/* +* Commit the flag value change and start the next trans in series +*/ + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) + goto out; + +/* +* Dismantle the "old" attribute/value pair by removing a "remote" value +* (if it exists). +*/ +xfs_attr_restore_rmt_blk (args); + +if (args->rmtblkno) { + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error; + + error =xfs_attr_rmtval_remove (args); +if (error) +return error; + } + error =xfs_attr_node_addname_clear_incomplete (args); +out:return error; + }/*
@@ -957,7 +1027,7 @@ xfs_attr_node_addname( {struct xfs_da_state_blk *blk;struct xfs_inode *dp; -int retval, error; +int error;trace_xfs_attr_node_addname (args);
@@ -965,8 +1035,8 @@ xfs_attr_node_addname( blk = &state->path.blk[state->path.active-1 ];ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); - retval =xfs_attr3_leaf_add (blk->bp, state->args); -if (retval == -ENOSPC ) { + error =xfs_attr3_leaf_add (blk->bp, state->args); +if (error == -ENOSPC ) {if (state->path.active ==1 ) {/* * Its really a single leaf node, but it had
@@ -1012,85 +1082,10 @@ xfs_attr_node_addname(xfs_da3_fixhashpath (state, &state->path); } -/* -* Kill the state structure, we're done with it and need to -* allow the buffers to come back later. -*/ -xfs_da_state_free (state); - state =NULL ; - -/* -* Commit the leaf addition or btree split and start the next -* trans in the chain. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; - -/* -* If there was an out-of-line value, allocate the blocks we -* identified for its storage and copy the value. This is done -* after we create the attribute so that we don't overflow the -* maximum size of a transaction and/or hit a deadlock. -*/ -if (args->rmtblkno >0 ) { - error =xfs_attr_rmtval_set (args); -if (error) -return error; - } - -if (!(args->op_flags &XFS_DA_OP_RENAME )) { -/* -* Added a "remote" value, just clear the incomplete flag. -*/ -if (args->rmtblkno >0 ) - error =xfs_attr3_leaf_clearflag (args); - retval = error; - goto out; - } - -/* -* If this is an atomic rename operation, we must "flip" the incomplete -* flags on the "new" and "old" attribute/value pairs so that one -* disappears and one appears atomically. Then we must remove the "old" -* attribute/value pair. -* -* In a separate transaction, set the incomplete flag on the "old" attr -* and clear the incomplete flag on the "new" attr. -*/ - error =xfs_attr3_leaf_flipflags (args); -if (error) - goto out; -/* -* Commit the flag value change and start the next trans in series -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) - goto out; - -/* -* Dismantle the "old" attribute/value pair by removing a "remote" value -* (if it exists). -*/ -xfs_attr_restore_rmt_blk (args); - -if (args->rmtblkno) { - error =xfs_attr_rmtval_invalidate (args); -if (error) -return error; - - error =xfs_attr_rmtval_remove (args); -if (error) -return error; - } - - error =xfs_attr_node_addname_clear_incomplete (args); out:if (state)xfs_da_state_free (state); -if (error) -return error; -return retval; +return error; }
Signature · 1 line
2.7.4
PATCH v17 9/12 xfsprogs: Hoist xfs_attr_leaf_addname
In reply to Allison HendersonSource kernel commit: 45adc55591f5d91b9b6c7752fa4253bf3de33886
This patch hoists xfs_attr_leaf_addname into the calling function. The goal being to get all the code that will require state management into the same scope. This isn't particularly aesthetic right away, but it is a preliminary step to merging in the state machine code.
--- include/xfs_trace.h | 1 - libxfs/xfs_attr.c | 209 ++++++++++++++++++++++++---------------------------- 2 files changed, 96 insertions(+), 114 deletions(-)
include/xfs_trace.h +0 -1
@@ -148,7 +148,6 @@#define trace_xfs_attr_leaf_flipflags (a) ((void) 0)#define trace_xfs_attr_sf_addname (a) ((void) 0) -#define trace_xfs_attr_leaf_addname (a) ((void) 0)#define trace_xfs_attr_leaf_replace (a) ((void) 0)#define trace_xfs_attr_leaf_removename (a) ((void) 0)#define trace_xfs_attr_leaf_get (a) ((void) 0)
libxfs/xfs_attr.c +96 -113
238 lines not on this page · raw message
Signature · 1 line
2.7.4
PATCH v17 10/12 xfsprogs: Hoist node transaction handling
In reply to Allison HendersonSource kernel commit: cb9e8e1fb89d84c77c8035b2391359f9cbf209e6
This patch basically hoists the node transaction handling around the leaf code we just hoisted. This will helps setup this area for the state machine since the goto is easily replaced with a state since it ends with a transaction roll.
--- libxfs/xfs_attr.c | 55 +++++++++++++++++++++++++++++-------------------------- 1 file changed, 29 insertions(+), 26 deletions(-)
libxfs/xfs_attr.c +29 -26
@@ -289,10 +289,36 @@ xfs_attr_set_args(if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { error =xfs_attr_leaf_try_add (args, bp); -if (error == -ENOSPC ) +if (error == -ENOSPC ) { +/* +* Promote the attribute list to the Btree format. +*/ + error =xfs_attr3_leaf_to_node (args); +if (error) +return error; + +/* +* Finish any deferred work items and roll the transaction once +* more. The goal here is to call node_addname with the inode +* and transaction in the same state (inode locked and joined, +* transaction clean) no matter how we got to this step. +*/ + error =xfs_defer_finish (&args->trans); +if (error) +return error; + +/* +* Commit the current trans (including the inode) and +* start a new one. +*/ + error =xfs_trans_roll_inode (&args->trans, dp); +if (error) +return error; + goto node; -else if (error) + }else if (error) {return error; + }/* * Commit the transaction that added the attr name so that
@@ -382,32 +408,9 @@ xfs_attr_set_args(/* bp is gone due to xfs_da_shrink_inode */ return error; + } node: -/* -* Promote the attribute list to the Btree format. -*/ - error =xfs_attr3_leaf_to_node (args); -if (error) -return error; - -/* -* Finish any deferred work items and roll the transaction once -* more. The goal here is to call node_addname with the inode -* and transaction in the same state (inode locked and joined, -* transaction clean) no matter how we got to this step. -*/ - error =xfs_defer_finish (&args->trans); -if (error) -return error; -/* -* Commit the current trans (including the inode) and -* start a new one. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) -return error; - } do { error = xfs_attr_node_addname_find_attr(args, &state);
Signature · 1 line
2.7.4
PATCH v17 11/12 xfsprogs: Add delay ready attr remove routines
In reply to Allison HendersonThis patch modifies the attr remove routines to be delay ready. This means they no longer roll or commit transactions, but instead return -EAGAIN to have the calling routine roll and refresh the transaction. In this series, xfs_attr_remove_args is merged with xfs_attr_node_removename become a new function, xfs_attr_remove_iter. This new version uses a sort of state machine like switch to keep track of where it was when EAGAIN was returned. A new version of xfs_attr_remove_args consists of a simple loop to refresh the transaction until the operation is completed. A new XFS_DAC_DEFER_FINISH flag is used to finish the transaction where ever the existing code used to.
Calls to xfs_attr_rmtval_remove are replaced with the delay ready version __xfs_attr_rmtval_remove. We will rename __xfs_attr_rmtval_remove back to xfs_attr_rmtval_remove when we are done.
xfs_attr_rmtval_remove itself is still in use by the set routines (used during a rename). For reasons of preserving existing function, we modify xfs_attr_rmtval_remove to call xfs_defer_finish when the flag is set. Similar to how xfs_attr_remove_args does here. Once we transition the set routines to be delay ready, xfs_attr_rmtval_remove is no longer used and will be removed.
This patch also adds a new struct xfs_delattr_context, which we will use to keep track of the current state of an attribute operation. The new xfs_delattr_state enum is used to track various operations that are in progress so that we know not to repeat them, and resume where we left off before EAGAIN was returned to cycle out the transaction. Other members take the place of local variables that need to retain their values across multiple function recalls. See xfs_attr.h for a more detailed diagram of the states.
--- include/libxfs.h | 1 + libxfs/xfs_attr.c | 208 ++++++++++++++++++++++++++++++++--------------- libxfs/xfs_attr.h | 131 +++++++++++++++++++++++++++++ libxfs/xfs_attr_leaf.c | 2 +- libxfs/xfs_attr_remote.c | 48 ++++++----- libxfs/xfs_attr_remote.h | 2 +- 6 files changed, 305 insertions(+), 87 deletions(-)
include/libxfs.h +1 -0
@@ -168,6 +168,7 @@ enum ce { CE_DEBUG, CE_CONT, CE_NOTE, CE_WARN, CE_ALERT, CE_PANIC };#include "xfs_ialloc.h" #include "xfs_attr_leaf.h" +#include "xfs_attr.h" #include "xfs_attr_remote.h" #include "xfs_trans_space.h"
libxfs/xfs_attr.c +143 -65
271 lines not on this page · raw message
libxfs/xfs_attr.h +131 -0
143 lines not on this page · raw message
libxfs/xfs_attr_leaf.c +1 -1
@@ -19,8 +19,8 @@#include "xfs_bmap_btree.h" #include "xfs_bmap.h" #include "xfs_attr_sf.h" -#include "xfs_attr_remote.h" #include "xfs_attr.h" +#include "xfs_attr_remote.h" #include "xfs_attr_leaf.h" #include "xfs_trace.h" #include "xfs_dir2.h"
libxfs/xfs_attr_remote.c +28 -20
81 lines not on this page · raw message
libxfs/xfs_attr_remote.h +1 -1
@@ -14,5 +14,5 @@ int xfs_attr_rmtval_remove(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_da_args *args); +int __xfs_attr_rmtval_remove (struct xfs_delattr_context *dac);#endif /* __XFS_ATTR_REMOTE_H__ */
Signature · 1 line
2.7.4
PATCH v17 12/12 xfsprogs: Add delay ready attr set routines
In reply to Allison HendersonSource kernel commit: 45e46c998cd75749f6975ffdeeb9a59768e4fcd3
This patch modifies the attr set routines to be delay ready. This means they no longer roll or commit transactions, but instead return -EAGAIN to have the calling routine roll and refresh the transaction. In this series, xfs_attr_set_args has become xfs_attr_set_iter, which uses a state machine like switch to keep track of where it was when EAGAIN was returned. See xfs_attr.h for a more detailed diagram of the states.
Two new helper functions have been added: xfs_attr_rmtval_find_space and xfs_attr_rmtval_set_blk. They provide a subset of logic similar to xfs_attr_rmtval_set, but they store the current block in the delay attr context to allow the caller to roll the transaction between allocations. This helps to simplify and consolidate code used by xfs_attr_leaf_addname and xfs_attr_node_addname. xfs_attr_set_args has now become a simple loop to refresh the transaction until the operation is completed. Lastly, xfs_attr_rmtval_remove is no longer used, and is removed.
--- include/xfs_trace.h | 1 - libxfs/xfs_attr.c | 445 +++++++++++++++++++++++++++++------------------ libxfs/xfs_attr.h | 272 ++++++++++++++++++++++++++++- libxfs/xfs_attr_remote.c | 100 +++++++---- libxfs/xfs_attr_remote.h | 5 +- 5 files changed, 613 insertions(+), 210 deletions(-)
include/xfs_trace.h +0 -1
@@ -159,7 +159,6 @@#define trace_xfs_attr_node_get (a) ((void) 0)#define trace_xfs_attr_rmtval_get (a) ((void) 0)#define trace_xfs_attr_rmtval_set (a) ((void) 0) -#define trace_xfs_attr_rmtval_remove (a) ((void) 0)#define trace_xfs_bmap_pre_update (a,b,c,d) ((void) 0)#define trace_xfs_bmap_post_update (a,b,c,d) ((void) 0)
libxfs/xfs_attr.c +272 -173
612 lines not on this page · raw message
libxfs/xfs_attr.h +271 -1
302 lines not on this page · raw message
libxfs/xfs_attr_remote.c +66 -34
125 lines not on this page · raw message
libxfs/xfs_attr_remote.h +4 -1
@@ -10,9 +10,12 @@ int xfs_attr3_rmt_blocks(struct xfs_mount *mp, int attrlen);int xfs_attr_rmtval_get (struct xfs_da_args *args);int xfs_attr_rmtval_set (struct xfs_da_args *args); -int xfs_attr_rmtval_remove (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_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);#endif /* __XFS_ATTR_REMOTE_H__ */
Signature · 1 line
2.7.4