xfs: Delay Ready Attributes
v8 cover xfs: Delay Ready Attributes
Hi all,
This set is a subset of a larger series for delayed attributes. Which is a subset of an even larger series, parent pointers. Delayed attributes allow attribute operations (set and remove) to be logged and committed in the same way that other delayed operations do. This allows more complex operations (like parent pointers) to be broken up into multiple smaller transactions. To do this, the existing attr operations must be modified to operate as either a delayed operation or a inline operation since older filesystems will not be able to use the new log entries. This means that they cannot roll, commit, or finish transactions. Instead, they return -EAGAIN to allow the calling function to handle the transaction. In this series, we focus on only the clean up and refactoring needed to accomplish this. We will introduce delayed attrs and parent pointers in a later set.
At the moment, I would like people to focus their review efforts on just this "delay ready" subseries, as I think that is a more conservative use of peoples review time. I also think the set is a bit much to manage all at once, and we need to get the infrastructure ironed out before we focus too much anything that depends on it. But I do have the extended series for folks that want to see the bigger picture of where this is going.
To help organize the set, I've arranged the patches to make sort of mini sets. I thought it would help reviewers break down the reviewing some. For reviewing purposes, the set could be broken up into 4 different phases:
Error code filtering (patches 1-2):
These two patches are all about finding and catching error codes that need to be sent back up to user space before starting delayed operations. Errors that happen during a delayed operation are treated like internal errors that cause a shutdown. But we wouldnt want that for example: when the user tries to rename a non existent attr. So the idea is that we need to find all such conditions, and take care of them before starting a delayed operation.
xfs: Add xfs_has_attr and subroutines
xfs: Check for -ENOATTR or -EEXIST
Move transactions upwards (patches 3-10):
The goal of this subset is to try and move all the transaction specific code up the call stack much as possible. The idea being that once we get them to the top, we can introduce the statemachine to handle the -EAGAIN logic where ever the transactions used to be.
xfs: Factor out new helper functions xfs_attr_rmtval_set
xfs: Pull up trans handling in xfs_attr3_leaf_flipflags
xfs: Split apart xfs_attr_leaf_addname
xfs: Refactor xfs_attr_try_sf_addname
xfs: Pull up trans roll from xfs_attr3_leaf_setflag
xfs: Factor out xfs_attr_rmtval_invalidate
xfs: Pull up trans roll in xfs_attr3_leaf_clearflag
xfs: Add helper function __xfs_attr_rmtval_remove
Modularizing and cleanups (patches 11-18):
Now that we have pulled the transactions up to where we need them, it's time to start breaking down the top level functions into new subfunctions. The goal being to work towards a top level function that deals mostly with the statemachine, and helpers for those states
xfs: Add helper function xfs_attr_node_shrink
xfs: Removed unneeded xfs_trans_roll_inode calls
xfs: Add helpers xfs_attr_is_shortform and xfs_attr_set_shortform
xfs: Add helper function xfs_attr_leaf_mark_incomplete
xfs: Add remote block helper functions
xfs: Add helper function xfs_attr_node_removename_setup
xfs: Add helper function xfs_attr_node_removename_rmt
Introduce statemachine (patches 18-20):
Now that we have re-arranged the code such that we can remove the transaction handling, we proceed to do so. The behavior of the attr set/remove routines are now also compatible as a .finish_item callback
xfs: Add delay ready attr remove routines
xfs: Add delay ready attr set routines
xfs: Rename __xfs_attr_rmtval_remove
Changes since v7:
Theres a lot of activity that goes around with each set, so to help people recall the discussion I've outlined the changes for each patch, which are new, and which are unchanged:
xfs: Add xfs_has_attr and subroutines
Added extra free in the case of statep == NULL
Minor error handling syntax nits
Rebase adjustments
xfs: Check for -ENOATTR or -EEXIST
Extra error handling in the case of (error != -ENOATTR && error != -EEXIST) Rebase adjustments
xfs: Factor out new helper functions xfs_attr_rmtval_set
No change
xfs: Pull up trans handling in xfs_attr3_leaf_flipflags
Commit message amended based on review commentary
xfs: Split apart xfs_attr_leaf_addname
Commit message amended based on review commentary brealse on error moved into xfs_attr_leaf_addname helper line wrap adjust
Investigated error handling logic suggestion:
let go for reasons of later statemachine impacts
xfs: Refactor xfs_attr_try_sf_addname
Commit message typo
xfs: Pull up out trans roll from xfs_attr3_leaf_setflag
Commit message amended based on review nits
xfs: Factor out xfs_attr_rmtval_invalidate
no change
xfs: Pull up trans roll in xfs_attr3_leaf_clearflag
Commit message amended based on review commentary
xfs: Add helper function __xfs_attr_rmtval_remove
renamed xfs_attr_rmtval_unmap to __xfs_attr_rmtval_remove remove stale comment
xfs: Add helper function xfs_attr_node_shrink
rebase to lower position in the set
xfs: Removed unneeded xfs_trans_roll_inode calls
new
xfs: Add helpers xfs_attr_is_shortform and xfs_attr_set_shortform
new
xfs: Add helper function xfs_attr_leaf_mark_incomplete
rebased to lower position in the set
xfs: Add remote block helper functions
rename xfs_attr_store_rmt_blk to xfs_attr_save_rmt_blk rebase adjustments
xfs: Add helper function xfs_attr_node_removename_setup
new
xfs: Add helper function xfs_attr_node_removename_rmt
rename xfs_attr_rmtval_unmap to _xfs_attr_rmtval_remove
xfs: Add delay ready attr remove routines
Simplify xfs_attr_remove_args loop now that trailing transaction rolls are gone
(removed in patch 12)
Subroutines adjusted to accept a struct xfs_delattr_context containing an xfs_da_args
instead of an xfs_da_args containing a struct xfs_delattr_context
Extra transaction conversion logic added for helpers added in the new patches gotos associated with state logic amended to have the das_* prefix XFS_DAC_DEFER_FINISH renamed to XFS_DAC_DEFER_FINISH
enum xfs_delattr_state ammended to start at 1 instead of 0
extra includes removed due to xfs_delattr_context and an xfs_da_args flip rebase adjustments
xfs: Add delay ready attr set routines
Simplify xfs_attr_remove_args loop now that trailing transaction rolls are gone
(removed in patch 12)
Subroutines adjusted to accept a struct xfs_delattr_context containing an xfs_da_args
instead of an xfs_da_args containing a struct xfs_delattr_context
Extra transaction conversion logic added for helpers added in the new patches gotos associated with state logic amended to have the das_* prefix XFS_DAC_DEFER_FINISH renamed to XFS_DAC_DEFER_FINISH
Extra XFS_DAS_RM_LBLK state added in the case of attr rename
Remove now unused xfs_attr_rmtval_remove added to this patch instead of next patch rebase adjustments
xfs: Rename __xfs_attr_rmtval_remove
New
This series can be viewed on github here:
https://github.com/allisonhenderson/xfs_work/tree/delay_ready_attrs_v8
As well as the extended delayed attribute and parent pointer series:
https://github.com/allisonhenderson/xfs_work/tree/delay_ready_attrs_v8_extended
And the test cases:
https://github.com/allisonhenderson/xfs_work/tree/pptr_xfstests
In order to run the test cases, you will need have the corresponding xfsprogs changes as well. Which can be found here:
https://github.com/allisonhenderson/xfs_work/tree/delay_ready_attrs_xfsprogs_v8
https://github.com/allisonhenderson/xfs_work/tree/delay_ready_attrs_xfsprogs_v8_extended
To run the xfs attributes tests run:
check -g attr
To run as delayed attributes run:
export MKFS_OPTIONS="-n delattr"
check -g attr
To run parent pointer tests:
check -g parent
I've also made the corresponding updates to the user space side as well, and ported anything they need to seat correctly.
Questions, comment and feedback appreciated!
Thanks all!
Allison
Allison Collins (20):
xfs: Add xfs_has_attr and subroutines
xfs: Check for -ENOATTR or -EEXIST
xfs: Factor out new helper functions xfs_attr_rmtval_set
xfs: Pull up trans handling in xfs_attr3_leaf_flipflags
xfs: Split apart xfs_attr_leaf_addname
xfs: Refactor xfs_attr_try_sf_addname
xfs: Pull up trans roll from xfs_attr3_leaf_setflag
xfs: Factor out xfs_attr_rmtval_invalidate
xfs: Pull up trans roll in xfs_attr3_leaf_clearflag
xfs: Add helper function __xfs_attr_rmtval_remove
xfs: Add helper function xfs_attr_node_shrink
xfs: Removed unneeded xfs_trans_roll_inode calls
xfs: Add helpers xfs_attr_is_shortform and xfs_attr_set_shortform
xfs: Add helper function xfs_attr_leaf_mark_incomplete
xfs: Add remote block helper functions
xfs: Add helper function xfs_attr_node_removename_setup
xfs: Add helper function xfs_attr_node_removename_rmt
xfs: Add delay ready attr remove routines
xfs: Add delay ready attr set routines
xfs: Rename __xfs_attr_rmtval_remove
fs/xfs/libxfs/xfs_attr.c | 1052 ++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_attr.h | 55 ++ fs/xfs/libxfs/xfs_attr_leaf.c | 115 +++-- fs/xfs/libxfs/xfs_attr_leaf.h | 3 + fs/xfs/libxfs/xfs_attr_remote.c | 257 +++++++--- fs/xfs/libxfs/xfs_attr_remote.h | 7 +- fs/xfs/xfs_attr_inactive.c | 1 + fs/xfs/xfs_trace.h | 1 - 8 files changed, 1067 insertions(+), 424 deletions(-)
Signature · 1 line
2.7.4
PATCH v8 1/20 xfs: Add xfs_has_attr and subroutines
This patch adds a new functions to check for the existence of an attribute. Subroutines are also added to handle the cases of leaf blocks, nodes or shortform. Common code that appears in existing attr add and remove functions have been factored out to help reduce the appearance of duplicated code. We will need these routines later for delayed attributes since delayed operations cannot return error codes.
--- fs/xfs/libxfs/xfs_attr.c | 181 ++++++++++++++++++++++++++++-------------- fs/xfs/libxfs/xfs_attr.h | 1 + fs/xfs/libxfs/xfs_attr_leaf.c | 97 +++++++++++++++------- fs/xfs/libxfs/xfs_attr_leaf.h | 3 + 4 files changed, 191 insertions(+), 91 deletions(-)
fs/xfs/libxfs/xfs_attr.c +120 -61
@@ -46,6 +46,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args); STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); +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.
@@ -53,6 +54,8 @@ STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); 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_hasname(xfs_da_args_t *args, +struct xfs_da_state **state); STATIC int xfs_attr_fillstate(xfs_da_state_t *state); STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
@@ -261,6 +264,37 @@ xfs_attr_set_args( }/* +* Return EEXIST if attr is found, or ENOATTR if not +*/ +int +xfs_has_attr ( +struct xfs_da_args *args) +{ +struct xfs_inode *dp = args->dp; +struct xfs_buf *bp =NULL ; +int error; + +if (!xfs_inode_hasattr (dp)) +return -ENOATTR ; + +if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL ) { +ASSERT (dp->i_afp->if_flags &XFS_IFINLINE ); +return xfs_attr_sf_findname (args,NULL ,NULL ); + } + +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { + error =xfs_attr_leaf_hasname (args, &bp); + +if (bp) +xfs_trans_brelse (args->trans, bp); + +return error; + } + +return xfs_attr_node_hasname (args,NULL ); +} + +/* * Remove the attribute specified in @args. */ int
@@ -469,26 +503,19 @@ STATIC intxfs_attr_leaf_addname ( struct xfs_da_args *args) { -struct xfs_inode *dp;struct xfs_buf *bp;int retval, error, forkoff; +struct xfs_inode *dp = args->dp;trace_xfs_attr_leaf_addname (args);/* -* Read the (only) block in the attribute list in. -*/ - dp = args->dp; - args->blkno =0 ; - error =xfs_attr3_leaf_read (args->trans, args->dp, args->blkno, &bp); -if (error) -return error; - -/* * Look up the given attribute in the leaf block. Figure out if * the given flags produce an error or call for an atomic rename. */ - retval =xfs_attr3_leaf_lookup_int (bp, args); + retval =xfs_attr_leaf_hasname (args, &bp); +if (retval != -ENOATTR && retval != -EEXIST ) +return retval;if (retval == -ENOATTR && (args->attr_flags &XATTR_REPLACE )) goto out_brelse;if (retval == -EEXIST ) {
@@ -640,6 +667,27 @@ xfs_attr_leaf_addname( }/* +* Return EEXIST if attr is found, or ENOATTR if not +*/ +STATIC int +xfs_attr_leaf_hasname ( +struct xfs_da_args *args, +struct xfs_buf **bp) +{ +int error =0 ; + + error =xfs_attr3_leaf_read (args->trans, args->dp,0 , bp); +if (error) +return error; + + error =xfs_attr3_leaf_lookup_int (*bp, args); +if (error != -ENOATTR && error != -EEXIST ) +xfs_trans_brelse (args->trans, *bp); + +return error; +} + +/* * Remove a name from the leaf attribute list structure * * This leaf block cannot have a "remote" value, we only call this routine
@@ -659,16 +707,14 @@ xfs_attr_leaf_removename(* Remove the attribute. */ dp = args->dp; - args->blkno =0 ; - error =xfs_attr3_leaf_read (args->trans, args->dp, args->blkno, &bp); -if (error) -return error; - error =xfs_attr3_leaf_lookup_int (bp, args); + error =xfs_attr_leaf_hasname (args, &bp); +if (error == -ENOATTR ) {xfs_trans_brelse (args->trans, bp);return error; - } + }else if (error != -EEXIST ) +return error;xfs_attr3_leaf_remove (bp, args);
@@ -703,21 +749,57 @@ xfs_attr_leaf_get(xfs_da_args_t *args)trace_xfs_attr_leaf_get (args); - args->blkno =0 ; - error =xfs_attr3_leaf_read (args->trans, args->dp, args->blkno, &bp); -if (error) -return error; + error =xfs_attr_leaf_hasname (args, &bp); - error =xfs_attr3_leaf_lookup_int (bp, args);if (error != -EEXIST ) {xfs_trans_brelse (args->trans, bp);return error; - } + }else if (error != -EEXIST ) +return error; + + error =xfs_attr3_leaf_getvalue (bp, args);xfs_trans_brelse (args->trans, bp);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. +*/ +STATIC int +xfs_attr_node_hasname ( +struct xfs_da_args *args, +struct xfs_da_state **statep) +{ +struct xfs_da_state *state; +int retval, error; + + state =xfs_da_state_alloc (); + state->args = args; + state->mp = args->dp->i_mount; + +if (statep !=NULL ) + *statep =NULL ; + +/* +* Search to see if name exists, and get back a pointer to it. +*/ + error =xfs_da3_node_lookup_int (state, &retval); +if (error ==0 ) { +if (statep !=NULL ) + *statep = state; +else +xfs_da_state_free (state); +return retval; + } + +xfs_da_state_free (state); + +return error; +} +/*======================================================================== * External routines when attribute list size > geo->blksize *========================================================================*/
@@ -750,17 +832,14 @@ xfs_attr_node_addname( dp = args->dp; mp = dp->i_mount; restart: - state =xfs_da_state_alloc (); - state->args = args; - state->mp = mp; -/* * Search to see if name already exists, and get back a pointer * to where it should go. */ - error =xfs_da3_node_lookup_int (state, &retval); -if (error) + retval =xfs_attr_node_hasname (args, &state); +if (retval != -ENOATTR && retval != -EEXIST ) goto out; + blk = &state->path.blk[ state->path.active-1 ];ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (retval == -ENOATTR && (args->attr_flags &XATTR_REPLACE ))
@@ -965,29 +1044,15 @@ xfs_attr_node_removename( {struct xfs_da_state *state;struct xfs_da_state_blk *blk; -struct xfs_inode *dp;struct xfs_buf *bp;int retval, error, forkoff; +struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); -/* -* Tie a string around our finger to remind us where we are. -*/ - dp = args->dp; - state =xfs_da_state_alloc (); - state->args = args; - state->mp = dp->i_mount; - -/* -* Search to see if name exists, and get back a pointer to it. -*/ - error =xfs_da3_node_lookup_int (state, &retval); -if (error || (retval != -EEXIST )) { -if (error ==0 ) - error = retval; + error =xfs_attr_node_hasname (args, &state); +if (error != -EEXIST ) goto out; - }/* * If there is an out-of-line value, de-allocate the blocks.
@@ -1082,7 +1147,8 @@ xfs_attr_node_removename( error =0 ; out: -xfs_da_state_free (state); +if (state) +xfs_da_state_free (state);return error; }
@@ -1202,31 +1268,23 @@ xfs_attr_node_get(xfs_da_args_t *args) {xfs_da_state_t *state;xfs_da_state_blk_t *blk; -int error, retval; +int error;int i;trace_xfs_attr_node_get (args); - state =xfs_da_state_alloc (); - state->args = args; - state->mp = args->dp->i_mount; -/* * 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; - goto out_release; - } -if (retval != -EEXIST ) + error =xfs_attr_node_hasname (args, &state); +if (error != -EEXIST ) goto out_release;/* * Get the value, local or "remote" */ blk = &state->path.blk[state->path.active -1 ]; - retval =xfs_attr3_leaf_getvalue (blk->bp, args); + error =xfs_attr3_leaf_getvalue (blk->bp, args);/* * If not in a transaction, we have to release all the buffers.
@@ -1237,8 +1295,9 @@ xfs_attr_node_get(xfs_da_args_t *args) state->path.blk[i].bp =NULL ; } -xfs_da_state_free (state); -return retval; +if (state) +xfs_da_state_free (state); +return error; }/* Returns true if the attribute entry name is valid. */
fs/xfs/libxfs/xfs_attr.h +1 -0
@@ -89,6 +89,7 @@ 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_args (struct xfs_da_args *args); +int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args);bool xfs_attr_namecheck (const void *name,size_t length);
fs/xfs/libxfs/xfs_attr_leaf.c +67 -30
127 lines not on this page · raw message
fs/xfs/libxfs/xfs_attr_leaf.h +3 -0
@@ -52,6 +52,9 @@ int xfs_attr_shortform_getvalue(struct xfs_da_args *args);int xfs_attr_shortform_to_leaf (struct xfs_da_args *args,struct xfs_buf **leaf_bp);int xfs_attr_shortform_remove (struct xfs_da_args *args); +int xfs_attr_sf_findname (struct xfs_da_args *args, +struct xfs_attr_sf_entry **sfep, +unsigned int *basep);int xfs_attr_shortform_allfit (struct xfs_buf *bp,struct xfs_inode *dp);int xfs_attr_shortform_bytesfit (struct xfs_inode *dp,int bytes);xfs_failaddr_t xfs_attr_shortform_verify (struct xfs_inode *ip);
Signature · 1 line
2.7.4
Re: [PATCH v8 01/20] xfs: Add xfs_has_attr and subroutines
Quoted 20 lines · Allison Collins
This patch adds a new functions to check for the existence of an attribute. Subroutines are also added to handle the cases of leaf blocks, nodes or shortform. Common code that appears in existing attr add and remove functions have been factored out to help reduce the appearance of duplicated code. We will need these routines later for delayed attributes since delayed operations cannot return error codes.
Signed-off-by Allison Collins <[email protected]>Reviewed-by Chandan Rajendra <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 181 ++++++++++++++++++++++++++++-------------- fs/xfs/libxfs/xfs_attr.h | 1 + fs/xfs/libxfs/xfs_attr_leaf.c | 97 +++++++++++++++------- fs/xfs/libxfs/xfs_attr_leaf.h | 3 + 4 files changed, 191 insertions(+), 91 deletions(-)fs/xfs/libxfs/xfs_attr.c +0
-0
...
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c +0
-4@@ -703,21 +749,57 @@ xfs_attr_leaf_get(xfs_da_args_t *args)trace_xfs_attr_leaf_get (args); - args->blkno =0 ; - error =xfs_attr3_leaf_read (args->trans, args->dp, args->blkno, &bp); -if (error) -return error;
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_get(xfs_da_args_t *args) · line 759
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +4
-2+ error =xfs_attr_leaf_hasname (args, &bp); - error =xfs_attr3_leaf_lookup_int (bp, args);if (error != -EEXIST ) {xfs_trans_brelse (args->trans, bp);return error; - } + }else if (error != -EEXIST ) +return error; +
The if/else above looks busted (the same check for both branches).
Quoted 30 lines
fs/xfs/libxfs/xfs_attr.c +25
-0+ error =xfs_attr3_leaf_getvalue (bp, args);xfs_trans_brelse (args->trans, bp);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. +*/ +STATIC int +xfs_attr_node_hasname ( +struct xfs_da_args *args, +struct xfs_da_state **statep) +{ +struct xfs_da_state *state; +int retval, error; + + state =xfs_da_state_alloc (); + state->args = args; + state->mp = args->dp->i_mount; + +if (statep !=NULL ) + *statep =NULL ; + +/* +* Search to see if name exists, and get back a pointer to it. +*/ + error =xfs_da3_node_lookup_int (state, &retval);
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_get(xfs_da_args_t *args) · line 799
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+if (error ==0 ) { +if (statep !=NULL ) + *statep = state; +else +xfs_da_state_free (state); +return retval; + } + +xfs_da_state_free (state); +
Inverting the logic is a bit more clear IMO:
...
error = xfs_da3_node_lookup_int(state, &retval);
if (error) {
...
return error;
}
if (statep)
...
else
...
return retval;
}With those things addressed:
Quoted 281 lines
fs/xfs/libxfs/xfs_attr.c +18
-38+return error; +} +/*======================================================================== * External routines when attribute list size > geo->blksize *========================================================================*/ @@ -750,17 +832,14 @@ xfs_attr_node_addname( dp = args->dp; mp = dp->i_mount; restart: - state =xfs_da_state_alloc (); - state->args = args; - state->mp = mp; -/* * Search to see if name already exists, and get back a pointer * to where it should go. */ - error =xfs_da3_node_lookup_int (state, &retval); -if (error) + retval =xfs_attr_node_hasname (args, &state); +if (retval != -ENOATTR && retval != -EEXIST ) goto out; + blk = &state->path.blk[ state->path.active-1 ];ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (retval == -ENOATTR && (args->attr_flags &XATTR_REPLACE ))@@ -965,29 +1044,15 @@ xfs_attr_node_removename( {struct xfs_da_state *state;struct xfs_da_state_blk *blk; -struct xfs_inode *dp;struct xfs_buf *bp;int retval, error, forkoff; +struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); -/* -* Tie a string around our finger to remind us where we are. -*/ - dp = args->dp; - state =xfs_da_state_alloc (); - state->args = args; - state->mp = dp->i_mount; - -/* -* Search to see if name exists, and get back a pointer to it. -*/ - error =xfs_da3_node_lookup_int (state, &retval); -if (error || (retval != -EEXIST )) { -if (error ==0 ) - error = retval; + error =xfs_attr_node_hasname (args, &state); +if (error != -EEXIST ) goto out; - }/* * If there is an out-of-line value, de-allocate the blocks. @@ -1082,7 +1147,8 @@ xfs_attr_node_removename( error =0 ; out: -xfs_da_state_free (state); +if (state) +xfs_da_state_free (state);return error; }@@ -1202,31 +1268,23 @@ xfs_attr_node_get(xfs_da_args_t *args) {xfs_da_state_t *state;xfs_da_state_blk_t *blk; -int error, retval; +int error;int i;trace_xfs_attr_node_get (args); - state =xfs_da_state_alloc (); - state->args = args; - state->mp = args->dp->i_mount; -/* * 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; - goto out_release; - } -if (retval != -EEXIST ) + error =xfs_attr_node_hasname (args, &state); +if (error != -EEXIST ) goto out_release;/* * Get the value, local or "remote" */ blk = &state->path.blk[state->path.active -1 ]; - retval =xfs_attr3_leaf_getvalue (blk->bp, args); + error =xfs_attr3_leaf_getvalue (blk->bp, args);/* * If not in a transaction, we have to release all the buffers. @@ -1237,8 +1295,9 @@ xfs_attr_node_get(xfs_da_args_t *args) state->path.blk[i].bp =NULL ; } -xfs_da_state_free (state); -return retval; +if (state) +xfs_da_state_free (state); +return error; }/* Returns true if the attribute entry name is valid. */ fs/xfs/libxfs/xfs_attr.h +1
-0@@ -89,6 +89,7 @@ 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_args (struct xfs_da_args *args); +int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args);bool xfs_attr_namecheck (const void *name,size_t length);fs/xfs/libxfs/xfs_attr_leaf.c +67
-30@@ -664,18 +664,63 @@ xfs_attr_shortform_create(xfs_da_args_t *args) }/* +* Return -EEXIST if attr is found, or -ENOATTR if not +* args: args containing attribute name and namelen +* sfep: If not null, pointer will be set to the last attr entry found on +-EEXIST. On -ENOATTR pointer is left at the last entry in the list +* basep: If not null, pointer is set to the byte offset of the entry in the +* list on -EEXIST. On -ENOATTR, pointer is left at the byte offset of +* the last entry in the list +*/ +int +xfs_attr_sf_findname ( +struct xfs_da_args *args, +struct xfs_attr_sf_entry **sfep, +unsigned int *basep) +{ +struct xfs_attr_shortform *sf; +struct xfs_attr_sf_entry *sfe; +unsigned int base =sizeof (struct xfs_attr_sf_hdr ); +int size =0 ; +int end; +int i; + + sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data; + sfe = &sf->list[0 ]; + end = sf->hdr.count; +for (i =0 ; i < end; sfe =XFS_ATTR_SF_NEXTENTRY (sfe), + base += size, i++) { + size =XFS_ATTR_SF_ENTSIZE (sfe); +if (!xfs_attr_match (args, sfe->namelen, sfe->nameval, + sfe->flags)) +continue ; +break ; + } + +if (sfep !=NULL ) + *sfep = sfe; + +if (basep !=NULL ) + *basep = base; + +if (i == end) +return -ENOATTR ; +return -EEXIST ; +} + +/* * Add a name/value pair to the shortform attribute list. * Overflow from the inode has already been checked for. */ void -xfs_attr_shortform_add (xfs_da_args_t *args,int forkoff) +xfs_attr_shortform_add (struct xfs_da_args *args,int forkoff) { -xfs_attr_shortform_t *sf; -xfs_attr_sf_entry_t *sfe; -int i, offset, size; -xfs_mount_t *mp; -xfs_inode_t *dp; -struct xfs_ifork *ifp; +struct xfs_attr_shortform *sf; +struct xfs_attr_sf_entry *sfe; +int offset, size, error; +struct xfs_mount *mp; +struct xfs_inode *dp; +struct xfs_ifork *ifp;trace_xfs_attr_sf_add (args);@@ -686,11 +731,8 @@ xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff) ifp = dp->i_afp;ASSERT (ifp->if_flags &XFS_IFINLINE ); sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data; - sfe = &sf->list[0 ]; -for (i =0 ; i < sf->hdr.count; sfe =XFS_ATTR_SF_NEXTENTRY (sfe), i++) { -ASSERT (!xfs_attr_match (args, sfe->namelen, sfe->nameval, - sfe->flags)); - } + error =xfs_attr_sf_findname (args, &sfe,NULL ); +ASSERT (error != -EEXIST ); offset = (char *)sfe - (char *)sf; size =XFS_ATTR_SF_ENTSIZE_BYNAME (args->namelen, args->valuelen);@@ -733,31 +775,26 @@ xfs_attr_fork_remove(* Remove an attribute from the shortform attribute list structure. */ int -xfs_attr_shortform_remove (xfs_da_args_t *args) +xfs_attr_shortform_remove (struct xfs_da_args *args) { -xfs_attr_shortform_t *sf; -xfs_attr_sf_entry_t *sfe; -int base, size=0 , end, totsize, i; -xfs_mount_t *mp; -xfs_inode_t *dp; +struct xfs_attr_shortform *sf; +struct xfs_attr_sf_entry *sfe; +int size =0 , end, totsize; +unsigned int base; +struct xfs_mount *mp; +struct xfs_inode *dp; +int error;trace_xfs_attr_sf_remove (args); dp = args->dp; mp = dp->i_mount; - base =sizeof (xfs_attr_sf_hdr_t); sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data; - sfe = &sf->list[0 ]; - end = sf->hdr.count; -for (i =0 ; i < end; sfe =XFS_ATTR_SF_NEXTENTRY (sfe), - base += size, i++) { - size =XFS_ATTR_SF_ENTSIZE (sfe); -if (xfs_attr_match (args, sfe->namelen, sfe->nameval, - sfe->flags)) -break ; - } -if (i == end) -return -ENOATTR ; + + error =xfs_attr_sf_findname (args, &sfe, &base); +if (error != -EEXIST ) +return error; + size =XFS_ATTR_SF_ENTSIZE (sfe);/* * Fix up the attribute fork data, covering the hole fs/xfs/libxfs/xfs_attr_leaf.h +3
-0@@ -52,6 +52,9 @@ int xfs_attr_shortform_getvalue(struct xfs_da_args *args);int xfs_attr_shortform_to_leaf (struct xfs_da_args *args,struct xfs_buf **leaf_bp);int xfs_attr_shortform_remove (struct xfs_da_args *args); +int xfs_attr_sf_findname (struct xfs_da_args *args, +struct xfs_attr_sf_entry **sfep, +unsigned int *basep);int xfs_attr_shortform_allfit (struct xfs_buf *bp,struct xfs_inode *dp);int xfs_attr_shortform_bytesfit (struct xfs_inode *dp,int bytes);xfs_failaddr_t xfs_attr_shortform_verify (struct xfs_inode *ip);Signature · 1 line
2.7.4
Re: [PATCH v8 01/20] xfs: Add xfs_has_attr and subroutines
Quoted 32 lines · Brian Foster
Quoted 20 lines · Allison Collins
This patch adds a new functions to check for the existence of an attribute. Subroutines are also added to handle the cases of leaf blocks, nodes or shortform. Common code that appears in existing attr add and remove functions have been factored out to help reduce the appearance of duplicated code. We will need these routines later for delayed attributes since delayed operations cannot return error codes.
Signed-off-by Allison Collins <[email protected]>Reviewed-by Chandan Rajendra <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 181 ++++++++++++++++++++++++++++-------------- fs/xfs/libxfs/xfs_attr.h | 1 + fs/xfs/libxfs/xfs_attr_leaf.c | 97 +++++++++++++++------- fs/xfs/libxfs/xfs_attr_leaf.h | 3 + 4 files changed, 191 insertions(+), 91 deletions(-)fs/xfs/libxfs/xfs_attr.c +0
-0...
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +1
-4@@ -703,21 +749,57 @@ xfs_attr_leaf_get(xfs_da_args_t *args)trace_xfs_attr_leaf_get (args); - args->blkno =0 ; - error =xfs_attr3_leaf_read (args->trans, args->dp, args->blkno, &bp); -if (error) -return error; + error =xfs_attr_leaf_hasname (args, &bp);
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_get(xfs_da_args_t *args) · line 759
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c +3
-2- error =xfs_attr3_leaf_lookup_int (bp, args);if (error != -EEXIST ) {xfs_trans_brelse (args->trans, bp);return error; - } + }else if (error != -EEXIST ) +return error; +The if/else above looks busted (the same check for both branches).
Sorry, that one should have been ENOATTR for this branch. Will fix.
Quoted 44 lines
Quoted 31 lines
fs/xfs/libxfs/xfs_attr.c +25
-0+ error =xfs_attr3_leaf_getvalue (bp, args);xfs_trans_brelse (args->trans, bp);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. +*/ +STATIC int +xfs_attr_node_hasname ( +struct xfs_da_args *args, +struct xfs_da_state **statep) +{ +struct xfs_da_state *state; +int retval, error; + + state =xfs_da_state_alloc (); + state->args = args; + state->mp = args->dp->i_mount; + +if (statep !=NULL ) + *statep =NULL ; + +/* +* Search to see if name exists, and get back a pointer to it. +*/ + error =xfs_da3_node_lookup_int (state, &retval);fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_get(xfs_da_args_t *args) · line 799
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+if (error ==0 ) { +if (statep !=NULL ) + *statep = state; +else +xfs_da_state_free (state); +return retval; + } + +xfs_da_state_free (state); +Inverting the logic is a bit more clear IMO:
Quoted 14 lines
...
error = xfs_da3_node_lookup_int(state, &retval);
if (error) {
...
return error;
}
if (statep)
...
else
...
return retval;
}Sure, will flip. Thanks for the reviews!
Allison
Quoted 286 lines
With those things addressed:
Reviewed-by Brian Foster <[email protected]>Quoted 281 lines
fs/xfs/libxfs/xfs_attr.c +18
-38+return error; +} +/*======================================================================== * External routines when attribute list size > geo->blksize *========================================================================*/ @@ -750,17 +832,14 @@ xfs_attr_node_addname( dp = args->dp; mp = dp->i_mount; restart: - state =xfs_da_state_alloc (); - state->args = args; - state->mp = mp; -/* * Search to see if name already exists, and get back a pointer * to where it should go. */ - error =xfs_da3_node_lookup_int (state, &retval); -if (error) + retval =xfs_attr_node_hasname (args, &state); +if (retval != -ENOATTR && retval != -EEXIST ) goto out; + blk = &state->path.blk[ state->path.active-1 ];ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (retval == -ENOATTR && (args->attr_flags &XATTR_REPLACE ))@@ -965,29 +1044,15 @@ xfs_attr_node_removename( {struct xfs_da_state *state;struct xfs_da_state_blk *blk; -struct xfs_inode *dp;struct xfs_buf *bp;int retval, error, forkoff; +struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); -/* -* Tie a string around our finger to remind us where we are. -*/ - dp = args->dp; - state =xfs_da_state_alloc (); - state->args = args; - state->mp = dp->i_mount; - -/* -* Search to see if name exists, and get back a pointer to it. -*/ - error =xfs_da3_node_lookup_int (state, &retval); -if (error || (retval != -EEXIST )) { -if (error ==0 ) - error = retval; + error =xfs_attr_node_hasname (args, &state); +if (error != -EEXIST ) goto out; - }/* * If there is an out-of-line value, de-allocate the blocks. @@ -1082,7 +1147,8 @@ xfs_attr_node_removename( error =0 ; out: -xfs_da_state_free (state); +if (state) +xfs_da_state_free (state);return error; }@@ -1202,31 +1268,23 @@ xfs_attr_node_get(xfs_da_args_t *args) {xfs_da_state_t *state;xfs_da_state_blk_t *blk; -int error, retval; +int error;int i;trace_xfs_attr_node_get (args); - state =xfs_da_state_alloc (); - state->args = args; - state->mp = args->dp->i_mount; -/* * 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; - goto out_release; - } -if (retval != -EEXIST ) + error =xfs_attr_node_hasname (args, &state); +if (error != -EEXIST ) goto out_release;/* * Get the value, local or "remote" */ blk = &state->path.blk[state->path.active -1 ]; - retval =xfs_attr3_leaf_getvalue (blk->bp, args); + error =xfs_attr3_leaf_getvalue (blk->bp, args);/* * If not in a transaction, we have to release all the buffers. @@ -1237,8 +1295,9 @@ xfs_attr_node_get(xfs_da_args_t *args) state->path.blk[i].bp =NULL ; } -xfs_da_state_free (state); -return retval; +if (state) +xfs_da_state_free (state); +return error; }/* Returns true if the attribute entry name is valid. */ fs/xfs/libxfs/xfs_attr.h +1
-0@@ -89,6 +89,7 @@ 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_args (struct xfs_da_args *args); +int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args);bool xfs_attr_namecheck (const void *name,size_t length);fs/xfs/libxfs/xfs_attr_leaf.c +67
-30@@ -664,18 +664,63 @@ xfs_attr_shortform_create(xfs_da_args_t *args) }/* +* Return -EEXIST if attr is found, or -ENOATTR if not +* args: args containing attribute name and namelen +* sfep: If not null, pointer will be set to the last attr entry found on +-EEXIST. On -ENOATTR pointer is left at the last entry in the list +* basep: If not null, pointer is set to the byte offset of the entry in the +* list on -EEXIST. On -ENOATTR, pointer is left at the byte offset of +* the last entry in the list +*/ +int +xfs_attr_sf_findname ( +struct xfs_da_args *args, +struct xfs_attr_sf_entry **sfep, +unsigned int *basep) +{ +struct xfs_attr_shortform *sf; +struct xfs_attr_sf_entry *sfe; +unsigned int base =sizeof (struct xfs_attr_sf_hdr ); +int size =0 ; +int end; +int i; + + sf = (struct xfs_attr_shortform *)args->dp->i_afp->if_u1.if_data; + sfe = &sf->list[0 ]; + end = sf->hdr.count; +for (i =0 ; i < end; sfe =XFS_ATTR_SF_NEXTENTRY (sfe), + base += size, i++) { + size =XFS_ATTR_SF_ENTSIZE (sfe); +if (!xfs_attr_match (args, sfe->namelen, sfe->nameval, + sfe->flags)) +continue ; +break ; + } + +if (sfep !=NULL ) + *sfep = sfe; + +if (basep !=NULL ) + *basep = base; + +if (i == end) +return -ENOATTR ; +return -EEXIST ; +} + +/* * Add a name/value pair to the shortform attribute list. * Overflow from the inode has already been checked for. */ void -xfs_attr_shortform_add (xfs_da_args_t *args,int forkoff) +xfs_attr_shortform_add (struct xfs_da_args *args,int forkoff) { -xfs_attr_shortform_t *sf; -xfs_attr_sf_entry_t *sfe; -int i, offset, size; -xfs_mount_t *mp; -xfs_inode_t *dp; -struct xfs_ifork *ifp; +struct xfs_attr_shortform *sf; +struct xfs_attr_sf_entry *sfe; +int offset, size, error; +struct xfs_mount *mp; +struct xfs_inode *dp; +struct xfs_ifork *ifp;trace_xfs_attr_sf_add (args);@@ -686,11 +731,8 @@ xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff) ifp = dp->i_afp;ASSERT (ifp->if_flags &XFS_IFINLINE ); sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data; - sfe = &sf->list[0 ]; -for (i =0 ; i < sf->hdr.count; sfe =XFS_ATTR_SF_NEXTENTRY (sfe), i++) { -ASSERT (!xfs_attr_match (args, sfe->namelen, sfe->nameval, - sfe->flags)); - } + error =xfs_attr_sf_findname (args, &sfe,NULL ); +ASSERT (error != -EEXIST ); offset = (char *)sfe - (char *)sf; size =XFS_ATTR_SF_ENTSIZE_BYNAME (args->namelen, args->valuelen);@@ -733,31 +775,26 @@ xfs_attr_fork_remove(* Remove an attribute from the shortform attribute list structure. */ int -xfs_attr_shortform_remove (xfs_da_args_t *args) +xfs_attr_shortform_remove (struct xfs_da_args *args) { -xfs_attr_shortform_t *sf; -xfs_attr_sf_entry_t *sfe; -int base, size=0 , end, totsize, i; -xfs_mount_t *mp; -xfs_inode_t *dp; +struct xfs_attr_shortform *sf; +struct xfs_attr_sf_entry *sfe; +int size =0 , end, totsize; +unsigned int base; +struct xfs_mount *mp; +struct xfs_inode *dp; +int error;trace_xfs_attr_sf_remove (args); dp = args->dp; mp = dp->i_mount; - base =sizeof (xfs_attr_sf_hdr_t); sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data; - sfe = &sf->list[0 ]; - end = sf->hdr.count; -for (i =0 ; i < end; sfe =XFS_ATTR_SF_NEXTENTRY (sfe), - base += size, i++) { - size =XFS_ATTR_SF_ENTSIZE (sfe); -if (xfs_attr_match (args, sfe->namelen, sfe->nameval, - sfe->flags)) -break ; - } -if (i == end) -return -ENOATTR ; + + error =xfs_attr_sf_findname (args, &sfe, &base); +if (error != -EEXIST ) +return error; + size =XFS_ATTR_SF_ENTSIZE (sfe);/* * Fix up the attribute fork data, covering the hole fs/xfs/libxfs/xfs_attr_leaf.h +3
-0@@ -52,6 +52,9 @@ int xfs_attr_shortform_getvalue(struct xfs_da_args *args);int xfs_attr_shortform_to_leaf (struct xfs_da_args *args,struct xfs_buf **leaf_bp);int xfs_attr_shortform_remove (struct xfs_da_args *args); +int xfs_attr_sf_findname (struct xfs_da_args *args, +struct xfs_attr_sf_entry **sfep, +unsigned int *basep);int xfs_attr_shortform_allfit (struct xfs_buf *bp,struct xfs_inode *dp);int xfs_attr_shortform_bytesfit (struct xfs_inode *dp,int bytes);xfs_failaddr_t xfs_attr_shortform_verify (struct xfs_inode *ip);Signature · 1 line
2.7.4
PATCH v8 2/20 xfs: Check for -ENOATTR or -EEXIST
In reply to Allison CollinsDelayed operations cannot return error codes. So we must check for these conditions first before starting set or remove operations
--- fs/xfs/libxfs/xfs_attr.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
fs/xfs/libxfs/xfs_attr.c +15 -0
@@ -404,6 +404,17 @@ xfs_attr_set( args->total, 0, quota_flags);if (error) goto out_trans_cancel; + + error =xfs_has_attr (args); +if (error == -EEXIST && (args->attr_flags &XATTR_CREATE )) + goto out_trans_cancel; + +if (error == -ENOATTR && (args->attr_flags &XATTR_REPLACE )) + goto out_trans_cancel; + +if (error != -ENOATTR && error != -EEXIST ) + goto out_trans_cancel; + error =xfs_attr_set_args (args);if (error) goto out_trans_cancel;
@@ -411,6 +422,10 @@ xfs_attr_set(if (!args->trans) goto out_unlock; }else { + error =xfs_has_attr (args); +if (error != -EEXIST ) + goto out_trans_cancel; + error =xfs_attr_remove_args (args);if (error) goto out_trans_cancel;
Signature · 1 line
2.7.4
Re: [PATCH v8 02/20] xfs: Check for -ENOATTR or -EEXIST
Quoted 17 lines · Allison Collins
Delayed operations cannot return error codes. So we must check for these conditions first before starting set or remove operations
Signed-off-by Allison Collins <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)fs/xfs/libxfs/xfs_attr.c +0
-0@@ -404,6 +404,17 @@ xfs_attr_set( args->total, 0, quota_flags);if (error) goto out_trans_cancel;
fs/xfs/libxfs/xfs_attr.c xfs_attr_set( · line 416
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+ + error =xfs_has_attr (args); +if (error == -EEXIST && (args->attr_flags &XATTR_CREATE )) + goto out_trans_cancel; + +if (error == -ENOATTR && (args->attr_flags &XATTR_REPLACE )) + goto out_trans_cancel; + +if (error != -ENOATTR && error != -EEXIST ) + goto out_trans_cancel;
I'd kill off the whitespace between the above error checks. Otherwise looks good to me:
Quoted 18 lines
fs/xfs/libxfs/xfs_attr.c +5
-0+ error =xfs_attr_set_args (args);if (error) goto out_trans_cancel;@@ -411,6 +422,10 @@ xfs_attr_set(if (!args->trans) goto out_unlock; }else { + error =xfs_has_attr (args); +if (error != -EEXIST ) + goto out_trans_cancel; + error =xfs_attr_remove_args (args);if (error) goto out_trans_cancel;Signature · 1 line
2.7.4
Re: [PATCH v8 02/20] xfs: Check for -ENOATTR or -EEXIST
Quoted 32 lines · Brian Foster
Quoted 17 lines · Allison Collins
Delayed operations cannot return error codes. So we must check for these conditions first before starting set or remove operations
Signed-off-by Allison Collins <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)fs/xfs/libxfs/xfs_attr.c +0
-0@@ -404,6 +404,17 @@ xfs_attr_set( args->total, 0, quota_flags);if (error) goto out_trans_cancel;fs/xfs/libxfs/xfs_attr.c xfs_attr_set( · line 416
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+ + error =xfs_has_attr (args); +if (error == -EEXIST && (args->attr_flags &XATTR_CREATE )) + goto out_trans_cancel; + +if (error == -ENOATTR && (args->attr_flags &XATTR_REPLACE )) + goto out_trans_cancel; + +if (error != -ENOATTR && error != -EEXIST ) + goto out_trans_cancel;I'd kill off the whitespace between the above error checks. Otherwise looks good to me:
Quoted 1 line
Reviewed-by Brian Foster <[email protected]>
Alrighty, will do. Thanks!
Allison
Quoted 20 lines
Quoted 19 lines
fs/xfs/libxfs/xfs_attr.c +5
-0+ error =xfs_attr_set_args (args);if (error) goto out_trans_cancel;@@ -411,6 +422,10 @@ xfs_attr_set(if (!args->trans) goto out_unlock; }else { + error =xfs_has_attr (args); +if (error != -EEXIST ) + goto out_trans_cancel; + error =xfs_attr_remove_args (args);if (error) goto out_trans_cancel;Signature · 1 line
2.7.4
Re: [PATCH v8 02/20] xfs: Check for -ENOATTR or -EEXIST
In reply to Allison CollinsQuoted 3 lines · Allison Collins
Delayed operations cannot return error codes. So we must check for these conditions first before starting set or remove operations
The changes are logically correct.
Quoted 40 lines
Signed-off-by Allison Collins <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)fs/xfs/libxfs/xfs_attr.c +15
-0@@ -404,6 +404,17 @@ xfs_attr_set( args->total, 0, quota_flags);if (error) goto out_trans_cancel; + + error =xfs_has_attr (args); +if (error == -EEXIST && (args->attr_flags &XATTR_CREATE )) + goto out_trans_cancel; + +if (error == -ENOATTR && (args->attr_flags &XATTR_REPLACE )) + goto out_trans_cancel; + +if (error != -ENOATTR && error != -EEXIST ) + goto out_trans_cancel; + error =xfs_attr_set_args (args);if (error) goto out_trans_cancel;@@ -411,6 +422,10 @@ xfs_attr_set(if (!args->trans) goto out_unlock; }else { + error =xfs_has_attr (args); +if (error != -EEXIST ) + goto out_trans_cancel; + error =xfs_attr_remove_args (args);if (error) goto out_trans_cancel;
Signature · 1 line
chandan
PATCH v8 3/20 xfs: Factor out new helper functions xfs_attr_rmtval_set
In reply to Allison CollinsBreak xfs_attr_rmtval_set into two helper functions xfs_attr_rmt_find_hole and xfs_attr_rmtval_set_value. xfs_attr_rmtval_set rolls the transaction between the helpers, but delayed operations cannot. We will use the helpers later when constructing new delayed attribute routines.
--- fs/xfs/libxfs/xfs_attr_remote.c | 149 +++++++++++++++++++++++++--------------- 1 file changed, 92 insertions(+), 57 deletions(-)
fs/xfs/libxfs/xfs_attr_remote.c +92 -57
@@ -440,32 +440,23 @@ xfs_attr_rmtval_get( }/* -* Write the value associated with an attribute into the out-of-line buffer -* that we have defined for it. +* Find a "hole" in the attribute address space large enough for us to drop the +* new attribute's value into */ -int -xfs_attr_rmtval_set ( +STATIC int +xfs_attr_rmt_find_hole (struct xfs_da_args *args) {struct xfs_inode *dp = args->dp;struct xfs_mount *mp = dp->i_mount; -struct xfs_bmbt_irec map; -xfs_dablk_t lblkno; -xfs_fileoff_t lfileoff =0 ; -uint8_t *src = args->value; -int blkcnt; -int valuelen; -int nmap;int error; -int offset =0 ; - -trace_xfs_attr_rmtval_set (args); +int blkcnt; +xfs_fileoff_t lfileoff =0 ;/* -* Find a "hole" in the attribute address space large enough for -* us to drop the new attribute's value into. Because CRC enable -* attributes have headers, we can't just do a straight byte to FSB -* conversion and have to take the header space into account. +* Because CRC enable attributes have headers, we can't just do a +* straight byte to FSB conversion and have to take the header space +* into account. */ blkcnt =xfs_attr3_rmt_blocks (mp, args->rmtvaluelen); error = xfs_bmap_first_unused(args->trans, args->dp, blkcnt, &lfileoff,
@@ -473,48 +464,26 @@ xfs_attr_rmtval_set(if (error)return error; - args->rmtblkno = lblkno = (xfs_dablk_t )lfileoff; + args->rmtblkno = (xfs_dablk_t )lfileoff; args->rmtblkcnt = blkcnt; -/* -* Roll through the "value", allocating blocks on disk as required. -*/ -while (blkcnt >0 ) { -/* -* Allocate a single extent, up to the size of the value. -* -* Note that we have to consider this a data allocation as we -* write the remote attribute without logging the contents. -* Hence we must ensure that we aren't using blocks that are on -* the busy list so that we don't overwrite blocks which have -* recently been freed but their transactions are not yet -* committed to disk. If we overwrite the contents of a busy -* extent and then crash then the block may not contain the -* correct metadata after log recovery occurs. -*/ - nmap =1 ; - error =xfs_bmapi_write (args->trans, dp, (xfs_fileoff_t )lblkno, - blkcnt,XFS_BMAPI_ATTRFORK , args->total, &map, - &nmap); -if (error) -return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; - -ASSERT (nmap ==1 ); -ASSERT ((map.br_startblock !=DELAYSTARTBLOCK ) && - (map.br_startblock !=HOLESTARTBLOCK )); - lblkno += map.br_blockcount; - blkcnt -= map.br_blockcount; +return 0 ; +} -/* -* Start the next trans in the chain. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) -return error; - } +STATIC int +xfs_attr_rmtval_set_value ( +struct xfs_da_args *args) +{ +struct xfs_inode *dp = args->dp; +struct xfs_mount *mp = dp->i_mount; +struct xfs_bmbt_irec map; +xfs_dablk_t lblkno; +uint8_t *src = args->value; +int blkcnt; +int valuelen; +int nmap; +int error; +int offset =0 ;/* * Roll through the "value", copying the attribute value to the
@@ -595,6 +564,72 @@ xfs_attr_rmtval_stale( }/* +* Write the value associated with an attribute into the out-of-line buffer +* that we have defined for it. +*/ +int +xfs_attr_rmtval_set ( +struct xfs_da_args *args) +{ +struct xfs_inode *dp = args->dp; +struct xfs_bmbt_irec map; +xfs_dablk_t lblkno; +int blkcnt; +int nmap; +int error; + +trace_xfs_attr_rmtval_set (args); + + error =xfs_attr_rmt_find_hole (args); +if (error) +return error; + + blkcnt = args->rmtblkcnt; + lblkno = (xfs_dablk_t )args->rmtblkno; +/* +* Roll through the "value", allocating blocks on disk as required. +*/ +while (blkcnt >0 ) { +/* +* Allocate a single extent, up to the size of the value. +* +* Note that we have to consider this a data allocation as we +* write the remote attribute without logging the contents. +* Hence we must ensure that we aren't using blocks that are on +* the busy list so that we don't overwrite blocks which have +* recently been freed but their transactions are not yet +* committed to disk. If we overwrite the contents of a busy +* extent and then crash then the block may not contain the +* correct metadata after log recovery occurs. +*/ + nmap =1 ; + error =xfs_bmapi_write (args->trans, dp, (xfs_fileoff_t )lblkno, + blkcnt,XFS_BMAPI_ATTRFORK , args->total, &map, + &nmap); +if (error) +return error; + error =xfs_defer_finish (&args->trans); +if (error) +return error; + +ASSERT (nmap ==1 ); +ASSERT ((map.br_startblock !=DELAYSTARTBLOCK ) && + (map.br_startblock !=HOLESTARTBLOCK )); + lblkno += map.br_blockcount; + blkcnt -= map.br_blockcount; + +/* +* Start the next trans in the chain. +*/ + error =xfs_trans_roll_inode (&args->trans, dp); +if (error) +return error; + } + +return xfs_attr_rmtval_set_value (args); +} + +/* * Remove the value associated with an attribute by deleting the * out-of-line buffer that it is stored on. */
Signature · 1 line
2.7.4
PATCH v8 4/20 xfs: Pull up trans handling in xfs_attr3_leaf_flipflags
In reply to Allison CollinsSince delayed operations cannot roll transactions, pull up the transaction handling into the calling function
--- fs/xfs/libxfs/xfs_attr.c | 14 ++++++++++++++ fs/xfs/libxfs/xfs_attr_leaf.c | 7 +------ 2 files changed, 15 insertions(+), 6 deletions(-)
fs/xfs/libxfs/xfs_attr.c +14 -0
@@ -624,6 +624,13 @@ xfs_attr_leaf_addname( error =xfs_attr3_leaf_flipflags (args);if (error)return error; +/* +* Commit the flag value change and start the next trans in +* series. +*/ + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +return error;/* * Dismantle the "old" attribute/value pair by removing
@@ -971,6 +978,13 @@ xfs_attr_node_addname( 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
fs/xfs/libxfs/xfs_attr_leaf.c +1 -6
@@ -2953,10 +2953,5 @@ xfs_attr3_leaf_flipflags( XFS_DA_LOGRANGE(leaf2, name_rmt, sizeof(*name_rmt))); } -/* -* Commit the flag value change and start the next trans in series. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); - -return error; +return 0 ; }
Signature · 1 line
2.7.4
PATCH v8 5/20 xfs: Split apart xfs_attr_leaf_addname
In reply to Allison CollinsSplit out new helper function xfs_attr_leaf_try_add from xfs_attr_leaf_addname. Because new delayed attribute routines cannot roll transactions, we split off the parts of xfs_attr_leaf_addname that we can use, and move the commit into the calling function.
--- fs/xfs/libxfs/xfs_attr.c | 94 ++++++++++++++++++++++++++++++------------------ 1 file changed, 60 insertions(+), 34 deletions(-)
fs/xfs/libxfs/xfs_attr.c +60 -34
@@ -256,10 +256,30 @@ xfs_attr_set_args( } } -if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { error =xfs_attr_leaf_addname (args); -else - error =xfs_attr_node_addname (args); +if (error != -ENOSPC ) +return error; + +/* +* Commit that transaction so that the node_addname() +* call can manage its own transactions. +*/ + 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; + + } + + error =xfs_attr_node_addname (args);return error; }
@@ -509,20 +529,21 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)*========================================================================*/ /* -* Add a name to the leaf attribute list structure +* Tries to add an attribute to an inode in leaf form * -* This leaf block cannot have a "remote" value, we only call this routine -* if bmap_one_block() says there is only one block (ie: no remote blks). +* This function is meant to execute as part of a delayed operation and leaves +* the transaction handling to the caller. On success the attribute is added +* and the inode and transaction are left dirty. If there is not enough space, +* the attr data is converted to node format and -ENOSPC is returned. Caller is +* responsible for handling the dirty inode and transaction or adding the attr +* in node format. */ STATIC int -xfs_attr_leaf_addname ( -struct xfs_da_args *args) +xfs_attr_leaf_try_add ( +struct xfs_da_args *args, +struct xfs_buf *bp) { -struct xfs_buf *bp; -int retval, error, forkoff; -struct xfs_inode *dp = args->dp; - -trace_xfs_attr_leaf_addname (args); +int retval, error;/* * Look up the given attribute in the leaf block. Figure out if
@@ -564,31 +585,39 @@ xfs_attr_leaf_addname( retval =xfs_attr3_leaf_add (bp, args);if (retval == -ENOSPC ) {/* -* Promote the attribute list to the Btree format, then -* Commit that transaction so that the node_addname() call -* can manage its own transactions. +* Promote the attribute list to the Btree format. Unless an +* error occurs, retain the -ENOSPC retval */ error =xfs_attr3_leaf_to_node (args);if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + } +return retval; +out_brelse: +xfs_trans_brelse (args->trans, bp); +return retval; +} -/* -* Commit the current trans (including the inode) and start -* a new one. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) -return error; -/* -* Fob the whole rest of the problem off on the Btree code. -*/ - error =xfs_attr_node_addname (args); +/* +* Add a name to the leaf attribute list structure +* +* This leaf block cannot have a "remote" value, we only call this routine +* if bmap_one_block() says there is only one block (ie: no remote blks). +*/ +STATIC int +xfs_attr_leaf_addname ( +struct xfs_da_args *args) +{ +int error, forkoff; +struct xfs_buf *bp =NULL ; +struct xfs_inode *dp = args->dp; + +trace_xfs_attr_leaf_addname (args); + + error =xfs_attr_leaf_try_add (args, bp); +if (error)return error; - }/* * Commit the transaction that added the attr name so that
@@ -683,9 +712,6 @@ xfs_attr_leaf_addname( error =xfs_attr3_leaf_clearflag (args); }return error; -out_brelse: -xfs_trans_brelse (args->trans, bp); -return retval; }/*
Signature · 1 line
2.7.4
PATCH v8 6/20 xfs: Refactor xfs_attr_try_sf_addname
In reply to Allison CollinsTo help pre-simplify xfs_attr_set_args, we need to hoist transaction handling up, while modularizing the adjacent code down into helpers. In this patch, hoist the commit in xfs_attr_try_sf_addname up into the calling function, and also pull the attr list creation down.
--- fs/xfs/libxfs/xfs_attr.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-)
fs/xfs/libxfs/xfs_attr.c +15 -15
@@ -178,8 +178,13 @@ xfs_attr_try_sf_addname( struct xfs_da_args *args) { -struct xfs_mount *mp = dp->i_mount; -int error, error2; +int error; + +/* +* Build initial attribute list (if required). +*/ +if (dp->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS ) +xfs_attr_shortform_create (args); error =xfs_attr_shortform_addname (args);if (error == -ENOSPC )
@@ -192,12 +197,10 @@ xfs_attr_try_sf_addname(if (!error && !(args->op_flags &XFS_DA_OP_NOTIME ))xfs_trans_ichgtime (args->trans, dp,XFS_ICHGTIME_CHG ); -if (mp->m_flags &XFS_MOUNT_WSYNC ) +if (dp->i_mount->m_flags &XFS_MOUNT_WSYNC )xfs_trans_set_sync (args->trans); - error2 =xfs_trans_commit (args->trans); - args->trans =NULL ; -return error ? error : error2; +return error; }/*
@@ -209,7 +212,7 @@ xfs_attr_set_args( {struct xfs_inode *dp = args->dp;struct xfs_buf *leaf_bp =NULL ; -int error; +int error, error2 =0 ;/* * If the attribute list is non-existent or a shortform list,
@@ -220,17 +223,14 @@ xfs_attr_set_args( dp->i_d.di_anextents == 0)) {/* -* Build initial attribute list (if required). -*/ -if (dp->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS ) -xfs_attr_shortform_create (args); - -/* * Try to add the attr to the attribute list in the inode. */ error =xfs_attr_try_sf_addname (dp, args); -if (error != -ENOSPC ) -return error; +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.
Signature · 1 line
2.7.4
PATCH v8 7/20 xfs: Pull up trans roll from xfs_attr3_leaf_setflag
In reply to Allison CollinsNew delayed allocation routines cannot be handling transactions so pull them up into the calling functions
--- fs/xfs/libxfs/xfs_attr.c | 5 +++++ fs/xfs/libxfs/xfs_attr_leaf.c | 5 +---- 2 files changed, 6 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_attr.c +5 -0
@@ -1134,6 +1134,11 @@ xfs_attr_node_removename( error =xfs_attr3_leaf_setflag (args);if (error) goto out; + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) + goto out; + error =xfs_attr_rmtval_remove (args);if (error) goto out;
fs/xfs/libxfs/xfs_attr_leaf.c +1 -4
@@ -2835,10 +2835,7 @@ xfs_attr3_leaf_setflag( XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt))); } -/* -* Commit the flag value change and start the next trans in series. -*/ -return xfs_trans_roll_inode (&args->trans, args->dp); +return 0 ; }/*
Signature · 1 line
2.7.4
PATCH v8 8/20 xfs: Factor out xfs_attr_rmtval_invalidate
In reply to Allison CollinsBecause new delayed attribute routines cannot roll transactions, we carve off the parts of xfs_attr_rmtval_remove that we can use. This will help to reduce repetitive code later when we introduce delayed attributes.
--- fs/xfs/libxfs/xfs_attr_remote.c | 26 +++++++++++++++++++++----- fs/xfs/libxfs/xfs_attr_remote.h | 2 +- 2 files changed, 22 insertions(+), 6 deletions(-)
fs/xfs/libxfs/xfs_attr_remote.c +21 -5
@@ -634,15 +634,12 @@ xfs_attr_rmtval_set(* out-of-line buffer that it is stored on. */ int -xfs_attr_rmtval_remove ( +xfs_attr_rmtval_invalidate (struct xfs_da_args *args) {xfs_dablk_t lblkno;int blkcnt;int error; -int done; - -trace_xfs_attr_rmtval_remove (args);/* * Roll through the "value", invalidating the attribute value's blocks.
@@ -670,13 +667,32 @@ xfs_attr_rmtval_remove( lblkno += map.br_blockcount; blkcnt -= map.br_blockcount; } +return 0 ; +} +/* +* Remove the value associated with an attribute by deleting the +* out-of-line buffer that it is stored on. +*/ +int +xfs_attr_rmtval_remove ( +struct xfs_da_args *args) +{ +xfs_dablk_t lblkno; +int blkcnt; +int error =0 ; +int done =0 ; + +trace_xfs_attr_rmtval_remove (args); + + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error;/* * Keep de-allocating extents until the remote-value region is gone. */ lblkno = args->rmtblkno; blkcnt = args->rmtblkcnt; - done =0 ;while (!done) { error =xfs_bunmapi (args->trans, args->dp, lblkno, blkcnt,XFS_BMAPI_ATTRFORK ,1 , &done);
fs/xfs/libxfs/xfs_attr_remote.h +1 -1
@@ -13,5 +13,5 @@ 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);#endif /* __XFS_ATTR_REMOTE_H__ */
Signature · 1 line
2.7.4
PATCH v8 9/20 xfs: Pull up trans roll in xfs_attr3_leaf_clearflag
In reply to Allison CollinsNew delayed allocation routines cannot be handling transactions so pull them out into the calling functions
--- fs/xfs/libxfs/xfs_attr.c | 16 ++++++++++++++++ fs/xfs/libxfs/xfs_attr_leaf.c | 5 +---- 2 files changed, 17 insertions(+), 4 deletions(-)
fs/xfs/libxfs/xfs_attr.c +16 -0
@@ -710,6 +710,14 @@ xfs_attr_leaf_addname(* Added a "remote" value, just clear the incomplete flag. */ error =xfs_attr3_leaf_clearflag (args); +if (error) +return error; + +/* +* Commit the flag value change and start the next trans in +* series. +*/ + error =xfs_trans_roll_inode (&args->trans, args->dp); }return error; }
@@ -1075,6 +1083,14 @@ xfs_attr_node_addname( error =xfs_attr3_leaf_clearflag (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; } retval = error =0 ;
fs/xfs/libxfs/xfs_attr_leaf.c +1 -4
@@ -2784,10 +2784,7 @@ xfs_attr3_leaf_clearflag( XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt))); } -/* -* Commit the flag value change and start the next trans in series. -*/ -return xfs_trans_roll_inode (&args->trans, args->dp); +return 0 ; }/*
Signature · 1 line
2.7.4
PATCH v8 10/20 xfs: Add helper function __xfs_attr_rmtval_remove
In reply to Allison CollinsThis function is similar to xfs_attr_rmtval_remove, but adapted to return EAGAIN for new transactions. We will use this later when we introduce delayed attributes. This function will eventually replace xfs_attr_rmtval_remove
--- fs/xfs/libxfs/xfs_attr_remote.c | 25 +++++++++++++++++++++++++ fs/xfs/libxfs/xfs_attr_remote.h | 1 + 2 files changed, 26 insertions(+)
fs/xfs/libxfs/xfs_attr_remote.c +25 -0
@@ -711,3 +711,28 @@ xfs_attr_rmtval_remove( }return 0 ; } + +/* +* Remove the value associated with an attribute by deleting the out-of-line +* buffer that it is stored on. Returns EAGAIN for the caller to refresh the +* transaction and recall the function +*/ +int +__xfs_attr_rmtval_remove ( +struct xfs_da_args *args) +{ +int error, done; + +/* +* Unmap value blocks for this attr. +*/ + error =xfs_bunmapi (args->trans, args->dp, args->rmtblkno, + args->rmtblkcnt,XFS_BMAPI_ATTRFORK ,1 , &done); +if (error) +return error; + +if (!done) +return -EAGAIN ; + +return 0 ; +}
fs/xfs/libxfs/xfs_attr_remote.h +1 -0
@@ -14,4 +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);#endif /* __XFS_ATTR_REMOTE_H__ */
Signature · 1 line
2.7.4
Re: [PATCH v8 10/20] xfs: Add helper function __xfs_attr_rmtval_remove
Quoted 35 lines · Allison Collins
This function is similar to
xfs_attr_rmtval_remove, but adapted to return EAGAIN for new transactions. We will use this later when we introduce delayed attributes. This function will eventually replacexfs_attr_rmtval_removeSigned-off-by Allison Collins <[email protected]>Reviewed-by Chandan Rajendra <[email protected]>--- fs/xfs/libxfs/xfs_attr_remote.c | 25 +++++++++++++++++++++++++ fs/xfs/libxfs/xfs_attr_remote.h | 1 + 2 files changed, 26 insertions(+)fs/xfs/libxfs/xfs_attr_remote.c +15
-0@@ -711,3 +711,28 @@ xfs_attr_rmtval_remove( }return 0 ; } + +/* +* Remove the value associated with an attribute by deleting the out-of-line +* buffer that it is stored on. Returns EAGAIN for the caller to refresh the +* transaction and recall the function +*/ +int +__xfs_attr_rmtval_remove ( +struct xfs_da_args *args) +{ +int error, done; + +/* +* Unmap value blocks for this attr. +*/
fs/xfs/libxfs/xfs_attr_remote.c xfs_attr_rmtval_remove( · line 738
Quoted 10 lines
fs/xfs/libxfs/xfs_attr_remote.c +10
-0+ error =xfs_bunmapi (args->trans, args->dp, args->rmtblkno, + args->rmtblkcnt,XFS_BMAPI_ATTRFORK ,1 , &done); +if (error) +return error; + +if (!done) +return -EAGAIN ; + +return 0 ; +}
We should let xfs_attr_rmtval_remove() call this function and do the roll based on -EAGAIN, then eliminate the higher level function later if it becomes unused.
Brian
Quoted 13 lines
fs/xfs/libxfs/xfs_attr_remote.h +1
-0@@ -14,4 +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);#endif /* __XFS_ATTR_REMOTE_H__ */ Signature · 1 line
2.7.4
Re: [PATCH v8 10/20] xfs: Add helper function __xfs_attr_rmtval_remove
Quoted 51 lines · Brian Foster
Quoted 35 lines · Allison Collins
This function is similar to
xfs_attr_rmtval_remove, but adapted to return EAGAIN for new transactions. We will use this later when we introduce delayed attributes. This function will eventually replacexfs_attr_rmtval_removeSigned-off-by Allison Collins <[email protected]>Reviewed-by Chandan Rajendra <[email protected]>--- fs/xfs/libxfs/xfs_attr_remote.c | 25 +++++++++++++++++++++++++ fs/xfs/libxfs/xfs_attr_remote.h | 1 + 2 files changed, 26 insertions(+)fs/xfs/libxfs/xfs_attr_remote.c +15
-0@@ -711,3 +711,28 @@ xfs_attr_rmtval_remove( }return 0 ; } + +/* +* Remove the value associated with an attribute by deleting the out-of-line +* buffer that it is stored on. Returns EAGAIN for the caller to refresh the +* transaction and recall the function +*/ +int +__xfs_attr_rmtval_remove ( +struct xfs_da_args *args) +{ +int error, done; + +/* +* Unmap value blocks for this attr. +*/ fs/xfs/libxfs/xfs_attr_remote.c xfs_attr_rmtval_remove( · line 738
Quoted 10 lines
fs/xfs/libxfs/xfs_attr_remote.c +10
-0+ error =xfs_bunmapi (args->trans, args->dp, args->rmtblkno, + args->rmtblkcnt,XFS_BMAPI_ATTRFORK ,1 , &done); +if (error) +return error; + +if (!done) +return -EAGAIN ; + +return 0 ; +}We should let
xfs_attr_rmtval_remove()call this function and do the roll based on-EAGAIN, then eliminate the higher level function later if it becomes unused.
Quoted 1 line
Brian
Sure, that should work. Will update. Thanks!
Allison
Quoted 15 lines
Quoted 14 lines
fs/xfs/libxfs/xfs_attr_remote.h +1
-0@@ -14,4 +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);#endif /* __XFS_ATTR_REMOTE_H__ */ Signature · 1 line
2.7.4
Re: [PATCH v8 10/20] xfs: Add helper function __xfs_attr_rmtval_remove
In reply to Allison CollinsQuoted 7 lines · Allison Collins
This function is similar to
xfs_attr_rmtval_remove, but adapted to return EAGAIN for new transactions. We will use this later when we introduce delayed attributes. This function will eventually replacexfs_attr_rmtval_removeSigned-off-by Allison Collins <[email protected]>Reviewed-by Chandan Rajendra <[email protected]>
Seems reasonable, but oh my the transaction roll hoisting is complex...
--D
Quoted 51 lines
--- fs/xfs/libxfs/xfs_attr_remote.c | 25 +++++++++++++++++++++++++ fs/xfs/libxfs/xfs_attr_remote.h | 1 + 2 files changed, 26 insertions(+)fs/xfs/libxfs/xfs_attr_remote.c +25
-0@@ -711,3 +711,28 @@ xfs_attr_rmtval_remove( }return 0 ; } + +/* +* Remove the value associated with an attribute by deleting the out-of-line +* buffer that it is stored on. Returns EAGAIN for the caller to refresh the +* transaction and recall the function +*/ +int +__xfs_attr_rmtval_remove ( +struct xfs_da_args *args) +{ +int error, done; + +/* +* Unmap value blocks for this attr. +*/ + error =xfs_bunmapi (args->trans, args->dp, args->rmtblkno, + args->rmtblkcnt,XFS_BMAPI_ATTRFORK ,1 , &done); +if (error) +return error; + +if (!done) +return -EAGAIN ; + +return 0 ; +}fs/xfs/libxfs/xfs_attr_remote.h +1
-0@@ -14,4 +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);#endif /* __XFS_ATTR_REMOTE_H__ */ Signature · 1 line
2.7.4
Re: [PATCH v8 10/20] xfs: Add helper function __xfs_attr_rmtval_remove
Quoted 6 lines · Darrick J. Wong
Quoted 5 lines · Allison Collins
This function is similar to
xfs_attr_rmtval_remove, but adapted to return EAGAIN for new transactions. We will use this later when we introduce delayed attributes. This function will eventually replacexfs_attr_rmtval_remove
Quoted 6 lines
Quoted 2 lines
Signed-off-by Allison Collins <[email protected]>Reviewed-by Chandan Rajendra <[email protected]>Seems reasonable, but oh my the transaction roll hoisting is complex...
Reviewed-by Darrick J. Wong <[email protected]>
Err... whooops. I meant to send this for patch 13. Maybe I should just wait for v9 to appear on the list...
--D
Quoted 53 lines
--D
Quoted 51 lines
--- fs/xfs/libxfs/xfs_attr_remote.c | 25 +++++++++++++++++++++++++ fs/xfs/libxfs/xfs_attr_remote.h | 1 + 2 files changed, 26 insertions(+)fs/xfs/libxfs/xfs_attr_remote.c +25
-0@@ -711,3 +711,28 @@ xfs_attr_rmtval_remove( }return 0 ; } + +/* +* Remove the value associated with an attribute by deleting the out-of-line +* buffer that it is stored on. Returns EAGAIN for the caller to refresh the +* transaction and recall the function +*/ +int +__xfs_attr_rmtval_remove ( +struct xfs_da_args *args) +{ +int error, done; + +/* +* Unmap value blocks for this attr. +*/ + error =xfs_bunmapi (args->trans, args->dp, args->rmtblkno, + args->rmtblkcnt,XFS_BMAPI_ATTRFORK ,1 , &done); +if (error) +return error; + +if (!done) +return -EAGAIN ; + +return 0 ; +}fs/xfs/libxfs/xfs_attr_remote.h +1
-0@@ -14,4 +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);#endif /* __XFS_ATTR_REMOTE_H__ */ Signature · 1 line
2.7.4
PATCH v8 11/20 xfs: Add helper function xfs_attr_node_shrink
In reply to Allison CollinsThis patch adds a new helper function xfs_attr_node_shrink used to shrink an attr name into an inode if it is small enough. This helps to modularize the greater calling function xfs_attr_node_removename.
--- fs/xfs/libxfs/xfs_attr.c | 67 ++++++++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 25 deletions(-)
fs/xfs/libxfs/xfs_attr.c +42 -25
@@ -1103,6 +1103,45 @@ xfs_attr_node_addname( }/* +* Shrink an attribute from leaf to shortform +*/ +STATIC int +xfs_attr_node_shrink ( +struct xfs_da_args *args, +struct xfs_da_state *state) +{ +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp; + +/* +* Have to get rid of the copy of this dabuf in the state. +*/ +ASSERT (state->path.active ==1 ); +ASSERT (state->path.blk[0 ].bp); + state->path.blk[0 ].bp =NULL ; + + error =xfs_attr3_leaf_read (args->trans, args->dp,0 , &bp); +if (error) +return error; + + forkoff =xfs_attr_shortform_allfit (bp, dp); +if (forkoff) { + error =xfs_attr3_leaf_to_shortform (bp, args, forkoff); +/* bp is gone due to xfs_da_shrink_inode */ +if (error) +return error; + + error =xfs_defer_finish (&args->trans); +if (error) +return error; + }else +xfs_trans_brelse (args->trans, bp); + +return 0 ; +} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining
@@ -1115,8 +1154,7 @@ xfs_attr_node_removename( {struct xfs_da_state *state;struct xfs_da_state_blk *blk; -struct xfs_buf *bp; -int retval, error, forkoff; +int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args);
@@ -1197,31 +1235,10 @@ xfs_attr_node_removename(/* * If the result is small enough, push it all into the inode. */ -if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { -/* -* Have to get rid of the copy of this dabuf in the state. -*/ -ASSERT (state->path.active ==1 ); -ASSERT (state->path.blk[0 ].bp); - state->path.blk[0 ].bp =NULL ; - - error =xfs_attr3_leaf_read (args->trans, args->dp,0 , &bp); -if (error) - goto out; +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) + error =xfs_attr_node_shrink (args, state); -if ((forkoff =xfs_attr_shortform_allfit (bp, dp))) { - error =xfs_attr3_leaf_to_shortform (bp, args, forkoff); -/* bp is gone due to xfs_da_shrink_inode */ -if (error) - goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; - }else -xfs_trans_brelse (args->trans, bp); - } error =0 ; - out:if (state)xfs_da_state_free (state);
Signature · 1 line
2.7.4
Re: [PATCH v8 11/20] xfs: Add helper function xfs_attr_node_shrink
Quoted 13 lines · Allison Collins
This patch adds a new helper function
xfs_attr_node_shrinkused to shrink an attr name into an inode if it is small enough. This helps to modularize the greater calling functionxfs_attr_node_removename.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 67 ++++++++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 25 deletions(-)fs/xfs/libxfs/xfs_attr.c +0
-0
...
Quoted 20 lines
fs/xfs/libxfs/xfs_attr.c +2
-13@@ -1197,31 +1235,10 @@ xfs_attr_node_removename(/* * If the result is small enough, push it all into the inode. */ -if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { -/* -* Have to get rid of the copy of this dabuf in the state. -*/ -ASSERT (state->path.active ==1 ); -ASSERT (state->path.blk[0 ].bp); - state->path.blk[0 ].bp =NULL ; - - error =xfs_attr3_leaf_read (args->trans, args->dp,0 , &bp); -if (error) - goto out; +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) + error =xfs_attr_node_shrink (args, state); -if ((forkoff =xfs_attr_shortform_allfit (bp, dp))) { - error =xfs_attr3_leaf_to_shortform (bp, args, forkoff);
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1241
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +0
-9-/* bp is gone due to xfs_da_shrink_inode */ -if (error) - goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; - }else -xfs_trans_brelse (args->trans, bp); - } error =0 ;
Looks like the error handling is busted here..? We used to goto out, now we always reset error to 0.
Brian
Quoted 7 lines
fs/xfs/libxfs/xfs_attr.c +0
-1- out:if (state)xfs_da_state_free (state);Signature · 1 line
2.7.4
Re: [PATCH v8 11/20] xfs: Add helper function xfs_attr_node_shrink
Quoted 49 lines · Brian Foster
Quoted 13 lines · Allison Collins
This patch adds a new helper function
xfs_attr_node_shrinkused to shrink an attr name into an inode if it is small enough. This helps to modularize the greater calling functionxfs_attr_node_removename.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 67 ++++++++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 25 deletions(-)fs/xfs/libxfs/xfs_attr.c +0
-0...
Quoted 20 lines
fs/xfs/libxfs/xfs_attr.c +2
-13@@ -1197,31 +1235,10 @@ xfs_attr_node_removename(/* * If the result is small enough, push it all into the inode. */ -if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { -/* -* Have to get rid of the copy of this dabuf in the state. -*/ -ASSERT (state->path.active ==1 ); -ASSERT (state->path.blk[0 ].bp); - state->path.blk[0 ].bp =NULL ; - - error =xfs_attr3_leaf_read (args->trans, args->dp,0 , &bp); -if (error) - goto out; +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) + error =xfs_attr_node_shrink (args, state); -if ((forkoff =xfs_attr_shortform_allfit (bp, dp))) { - error =xfs_attr3_leaf_to_shortform (bp, args, forkoff);fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1241
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +0
-9-/* bp is gone due to xfs_da_shrink_inode */ -if (error) - goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; - }else -xfs_trans_brelse (args->trans, bp); - } error =0 ;Looks like the error handling is busted here..? We used to goto out, now we always reset error to 0.
Quoted 1 line
Brian
Ah, yes the error = 0; should have been removed along with the rest of it. Will remove. Thanks!
Allison
Quoted 9 lines
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c +0
-1- out:if (state)xfs_da_state_free (state);Signature · 1 line
2.7.4
Re: [PATCH v8 11/20] xfs: Add helper function xfs_attr_node_shrink
In reply to Allison CollinsQuoted 76 lines · Allison Collins
This patch adds a new helper function
xfs_attr_node_shrinkused to shrink an attr name into an inode if it is small enough. This helps to modularize the greater calling functionxfs_attr_node_removename.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 67 ++++++++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 25 deletions(-)fs/xfs/libxfs/xfs_attr.c +40
-5@@ -1103,6 +1103,45 @@ xfs_attr_node_addname( }/* +* Shrink an attribute from leaf to shortform +*/ +STATIC int +xfs_attr_node_shrink ( +struct xfs_da_args *args, +struct xfs_da_state *state) +{ +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp; + +/* +* Have to get rid of the copy of this dabuf in the state. +*/ +ASSERT (state->path.active ==1 ); +ASSERT (state->path.blk[0 ].bp); + state->path.blk[0 ].bp =NULL ; + + error =xfs_attr3_leaf_read (args->trans, args->dp,0 , &bp); +if (error) +return error; + + forkoff =xfs_attr_shortform_allfit (bp, dp); +if (forkoff) { + error =xfs_attr3_leaf_to_shortform (bp, args, forkoff); +/* bp is gone due to xfs_da_shrink_inode */ +if (error) +return error; + + error =xfs_defer_finish (&args->trans); +if (error) +return error; + }else +xfs_trans_brelse (args->trans, bp); + +return 0 ; +} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining @@ -1115,8 +1154,7 @@ xfs_attr_node_removename( {struct xfs_da_state *state;struct xfs_da_state_blk *blk; -struct xfs_buf *bp; -int retval, error, forkoff; +int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args);@@ -1197,31 +1235,10 @@ xfs_attr_node_removename(/* * If the result is small enough, push it all into the inode. */ -if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { -/* -* Have to get rid of the copy of this dabuf in the state.
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1239
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +2
-8-*/ -ASSERT (state->path.active ==1 ); -ASSERT (state->path.blk[0 ].bp); - state->path.blk[0 ].bp =NULL ; - - error =xfs_attr3_leaf_read (args->trans, args->dp,0 , &bp); -if (error) - goto out; +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) + error =xfs_attr_node_shrink (args, state);
If a non-zero error value is returned by the above statement, the following statement i.e. "error = 0" will overwrite it.
Apart from that everything else looks fine.
Quoted 18 lines
fs/xfs/libxfs/xfs_attr.c +0
-12-if ((forkoff =xfs_attr_shortform_allfit (bp, dp))) { - error =xfs_attr3_leaf_to_shortform (bp, args, forkoff); -/* bp is gone due to xfs_da_shrink_inode */ -if (error) - goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; - }else -xfs_trans_brelse (args->trans, bp); - } error =0 ; - out:if (state)xfs_da_state_free (state);
Signature · 1 line
chandan
Re: [PATCH v8 11/20] xfs: Add helper function xfs_attr_node_shrink
Quoted 92 lines · Chandan Rajendra
Quoted 76 lines · Allison Collins
This patch adds a new helper function
xfs_attr_node_shrinkused to shrink an attr name into an inode if it is small enough. This helps to modularize the greater calling functionxfs_attr_node_removename.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 67 ++++++++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 25 deletions(-)fs/xfs/libxfs/xfs_attr.c +40
-5@@ -1103,6 +1103,45 @@ xfs_attr_node_addname( }/* +* Shrink an attribute from leaf to shortform +*/ +STATIC int +xfs_attr_node_shrink ( +struct xfs_da_args *args, +struct xfs_da_state *state) +{ +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp; + +/* +* Have to get rid of the copy of this dabuf in the state. +*/ +ASSERT (state->path.active ==1 ); +ASSERT (state->path.blk[0 ].bp); + state->path.blk[0 ].bp =NULL ; + + error =xfs_attr3_leaf_read (args->trans, args->dp,0 , &bp); +if (error) +return error; + + forkoff =xfs_attr_shortform_allfit (bp, dp); +if (forkoff) { + error =xfs_attr3_leaf_to_shortform (bp, args, forkoff); +/* bp is gone due to xfs_da_shrink_inode */ +if (error) +return error; + + error =xfs_defer_finish (&args->trans); +if (error) +return error; + }else +xfs_trans_brelse (args->trans, bp); + +return 0 ; +} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining @@ -1115,8 +1154,7 @@ xfs_attr_node_removename( {struct xfs_da_state *state;struct xfs_da_state_blk *blk; -struct xfs_buf *bp; -int retval, error, forkoff; +int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args);@@ -1197,31 +1235,10 @@ xfs_attr_node_removename(/* * If the result is small enough, push it all into the inode. */ -if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { -/* -* Have to get rid of the copy of this dabuf in the state. fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1239
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +2
-8-*/ -ASSERT (state->path.active ==1 ); -ASSERT (state->path.blk[0 ].bp); - state->path.blk[0 ].bp =NULL ; - - error =xfs_attr3_leaf_read (args->trans, args->dp,0 , &bp); -if (error) - goto out; +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) + error =xfs_attr_node_shrink (args, state);If a non-zero error value is returned by the above statement, the following statement i.e. "error = 0" will overwrite it.
Apart from that everything else looks fine.
Quoted 1 line
Reviewed-by Chandan Rajendra <[email protected]>
Yep, I've removed the trailing error = 0; in the new v9. Thanks for the review!
Allison
Quoted 21 lines
Quoted 19 lines
fs/xfs/libxfs/xfs_attr.c +0
-12-if ((forkoff =xfs_attr_shortform_allfit (bp, dp))) { - error =xfs_attr3_leaf_to_shortform (bp, args, forkoff); -/* bp is gone due to xfs_da_shrink_inode */ -if (error) - goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; - }else -xfs_trans_brelse (args->trans, bp); - } error =0 ; - out:if (state)xfs_da_state_free (state);
PATCH v8 12/20 xfs: Removed unneeded xfs_trans_roll_inode calls
In reply to Allison CollinsSome calls to xfs_trans_roll_inode in the *_addname routines are not needed. If they are the last operations executed in these functions, and no further changes are made, then higher level routines will roll or commit the tranactions. The xfs_trans_roll in _removename is also not needed because invalidating blocks is not an incore change.
--- fs/xfs/libxfs/xfs_attr.c | 30 ------------------------------ 1 file changed, 30 deletions(-)
fs/xfs/libxfs/xfs_attr.c +0 -30
@@ -700,11 +700,6 @@ xfs_attr_leaf_addname(return error; } -/* -* Commit the remove and start the next trans in series. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); - }else if (args->rmtblkno >0 ) {/* * Added a "remote" value, just clear the incomplete flag.
@@ -712,12 +707,6 @@ xfs_attr_leaf_addname( error =xfs_attr3_leaf_clearflag (args);if (error)return error; - -/* -* Commit the flag value change and start the next trans in -* series. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); }return error; }
@@ -1069,13 +1058,6 @@ xfs_attr_node_addname( goto out; } -/* -* Commit and start the next trans in the chain. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; - }else if (args->rmtblkno >0 ) {/* * Added a "remote" value, just clear the incomplete flag.
@@ -1083,14 +1065,6 @@ xfs_attr_node_addname( error =xfs_attr3_leaf_clearflag (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; } retval = error =0 ;
@@ -1189,10 +1163,6 @@ xfs_attr_node_removename(if (error) goto out; - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) - goto out; - error =xfs_attr_rmtval_remove (args);if (error) goto out;
Signature · 1 line
2.7.4
Re: [PATCH v8 12/20] xfs: Removed unneeded xfs_trans_roll_inode calls
Quoted 16 lines · Allison Collins
Some calls to
xfs_trans_roll_inodein the*_addnameroutines are not needed. If they are the last operations executed in these functions, and no further changes are made, then higher level routines will roll or commit the tranactions. Thexfs_trans_rollin_removenameis also not needed because invalidating blocks is not an incore change.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 30 ------------------------------ 1 file changed, 30 deletions(-)fs/xfs/libxfs/xfs_attr.c +0
-0
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_addname( · line 707
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c +0
-5@@ -700,11 +700,6 @@ xfs_attr_leaf_addname(return error; } -/* -* Commit the remove and start the next trans in series. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -
Ok, so it looks like the only caller immediately rolls again.
Quoted 4 lines
fs/xfs/libxfs/xfs_attr.c +0
-0}else if (args->rmtblkno >0 ) {/* * Added a "remote" value, just clear the incomplete flag.
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_addname( · line 710
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +0
-6@@ -712,12 +707,6 @@ xfs_attr_leaf_addname( error =xfs_attr3_leaf_clearflag (args);if (error)return error; - -/* -* Commit the flag value change and start the next trans in -* series. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); }
Same logic applies here. Makes sense.
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_addname( · line 1078
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c +0
-7return error; }@@ -1069,13 +1058,6 @@ xfs_attr_node_addname( goto out; } -/* -* Commit and start the next trans in the chain. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; -
From here, we log the inode and commit, so that seems safe.
BTW, doesn't that mean the defer_finish() just above (after the da3_join()) is unnecessary as well?
Quoted 19 lines
fs/xfs/libxfs/xfs_attr.c +0
-8}else if (args->rmtblkno >0 ) {/* * Added a "remote" value, just clear the incomplete flag. @@ -1083,14 +1065,6 @@ xfs_attr_node_addname( error =xfs_attr3_leaf_clearflag (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; } retval = error =0 ;
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1195
Quoted 7 lines
fs/xfs/libxfs/xfs_attr.c +0
-4@@ -1189,10 +1163,6 @@ xfs_attr_node_removename(if (error) goto out; - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) - goto out; -
Hmm, not sure I follow this one. Don't we want to commit the incomplete flag before proceeding? Or are we just saying it can be combined with the first bunmap since that's going to roll anyways..?
BTW, the commit log refers to the invalidation as "not incore," which I think is opposite. :P xfs_attr_rmtval_invalidate() is incore-only in the sense that it doesn't seem to use the transaction. Is that what you mean?
Brian
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +0
-0error =xfs_attr_rmtval_remove (args);if (error) goto out;Signature · 1 line
2.7.4
Re: [PATCH v8 12/20] xfs: Removed unneeded xfs_trans_roll_inode calls
Quoted 61 lines · Brian Foster
Quoted 16 lines · Allison Collins
Some calls to
xfs_trans_roll_inodein the*_addnameroutines are not needed. If they are the last operations executed in these functions, and no further changes are made, then higher level routines will roll or commit the tranactions. Thexfs_trans_rollin_removenameis also not needed because invalidating blocks is not an incore change.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 30 ------------------------------ 1 file changed, 30 deletions(-)fs/xfs/libxfs/xfs_attr.c +0
-0fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_addname( · line 707
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c +0
-5@@ -700,11 +700,6 @@ xfs_attr_leaf_addname(return error; } -/* -* Commit the remove and start the next trans in series. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -Ok, so it looks like the only caller immediately rolls again.
Quoted 4 lines
fs/xfs/libxfs/xfs_attr.c +0
-0}else if (args->rmtblkno >0 ) {/* * Added a "remote" value, just clear the incomplete flag. fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_addname( · line 710
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +0
-6@@ -712,12 +707,6 @@ xfs_attr_leaf_addname( error =xfs_attr3_leaf_clearflag (args);if (error)return error; - -/* -* Commit the flag value change and start the next trans in -* series. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); }Same logic applies here. Makes sense.
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_addname( · line 1078
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c +0
-7return error; }@@ -1069,13 +1058,6 @@ xfs_attr_node_addname( goto out; } -/* -* Commit and start the next trans in the chain. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; -From here, we log the inode and commit, so that seems safe.
Quoted 2 lines
BTW, doesn't that mean the
defer_finish()just above (after theda3_join()) is unnecessary as well?
Hmm, I think you're right. Will clean out here too.
Quoted 32 lines
Quoted 20 lines
fs/xfs/libxfs/xfs_attr.c +0
-8}else if (args->rmtblkno >0 ) {/* * Added a "remote" value, just clear the incomplete flag. @@ -1083,14 +1065,6 @@ xfs_attr_node_addname( error =xfs_attr3_leaf_clearflag (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; } retval = error =0 ;fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1195
Quoted 7 lines
fs/xfs/libxfs/xfs_attr.c +0
-4@@ -1189,10 +1163,6 @@ xfs_attr_node_removename(if (error) goto out; - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) - goto out; -Hmm, not sure I follow this one. Don't we want to commit the incomplete flag before proceeding? Or are we just saying it can be combined with the first bunmap since that's going to roll anyways..?
Quoted 4 lines
BTW, the commit log refers to the invalidation as "not incore," which I think is opposite. :P
xfs_attr_rmtval_invalidate()is incore-only in the sense that it doesn't seem to use the transaction. Is that what you mean?
Yes, sorry, the commit should say in-core only. We pulled this one out in v5 for that reason. It used to belong to the later "Add delay ready attr remove routines" patch in v6 and v7. Then when we decided to clean out these extra transaction rolls, because it simplifies the top level transaction rolling. So I decided to do the removename clean out in this patch because it seemed appropriate. In any case, will amend the commit message. Discussion thread just for brain refresh:
https://lore.kernel.org/linux-xfs/[email protected]/
Thanks for the reviews! Will update!
Allison
Quoted 10 lines
Brian
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +0
-0error =xfs_attr_rmtval_remove (args);if (error) goto out;Signature · 1 line
2.7.4
PATCH v8 13/20 xfs: Add helpers xfs_attr_is_shortform and xfs_attr_set_shortform
In reply to Allison CollinsIn this patch, we hoist code from xfs_attr_set_args into two new helpers xfs_attr_is_shortform and xfs_attr_set_shortform. These two will help to simplify xfs_attr_set_args when we get into delayed attrs later.
--- fs/xfs/libxfs/xfs_attr.c | 107 +++++++++++++++++++++++++++++++---------------- 1 file changed, 72 insertions(+), 35 deletions(-)
fs/xfs/libxfs/xfs_attr.c +72 -35
@@ -204,6 +204,66 @@ xfs_attr_try_sf_addname( }/* +* Check to see if the attr should be upgraded from non-existent or shortform to +* single-leaf-block attribute list. +*/ +static inline bool +xfs_attr_is_shortform ( +struct xfs_inode *ip) +{ +return ip->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL || + (ip->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS && + ip->i_d.di_anextents ==0 ); +} + +/* +* Attempts to set an attr in shortform, or converts the tree 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
@@ -212,48 +272,25 @@ xfs_attr_set_args( {struct xfs_inode *dp = args->dp;struct xfs_buf *leaf_bp =NULL ; -int error, error2 =0 ; +int error =0 ;/* -* If the attribute list is non-existent or a shortform list, -* upgrade it to a single-leaf-block attribute list. +* If the attribute list is already in leaf format, jump straight to +* leaf handling. Otherwise, try to add the attribute to the shortform +* list; if there's no room then convert the list to leaf format and try +* again. */ -if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL || - (dp->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS && - dp->i_d.di_anextents ==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; +if (xfs_attr_is_shortform (dp)) {/* -* 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. +* 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. */ -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_shortform (args, &leaf_bp); +if (error || !args->trans)return error; - } }if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) {
Signature · 1 line
2.7.4
Re: [PATCH v8 13/20] xfs: Add helpers xfs_attr_is_shortform and xfs_attr_set_shortform
Quoted 17 lines · Allison Collins
In this patch, we hoist code from
xfs_attr_set_argsinto two new helpersxfs_attr_is_shortformandxfs_attr_set_shortform. These two will help to simplifyxfs_attr_set_argswhen we get into delayed attrs later.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 107 +++++++++++++++++++++++++++++++---------------- 1 file changed, 72 insertions(+), 35 deletions(-)fs/xfs/libxfs/xfs_attr.c +0
-0@@ -204,6 +204,66 @@ xfs_attr_try_sf_addname( }/*
fs/xfs/libxfs/xfs_attr.c xfs_attr_try_sf_addname( · line 216
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+* Check to see if the attr should be upgraded from non-existent or shortform to +* single-leaf-block attribute list. +*/ +static inline bool +xfs_attr_is_shortform ( +struct xfs_inode *ip) +{ +return ip->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL || + (ip->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS && + ip->i_d.di_anextents ==0 );
Logic should be indented similar to the original:
return ip->i_d.di_aformat == XFS_DINODE_FMT_LOCAL || (ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS && ip->i_d.di_anextents == 0);
Otherwise looks good:
Quoted 117 lines
fs/xfs/libxfs/xfs_attr.c +62
-35+} + +/* +* Attempts to set an attr in shortform, or converts the tree 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 @@ -212,48 +272,25 @@ xfs_attr_set_args( {struct xfs_inode *dp = args->dp;struct xfs_buf *leaf_bp =NULL ; -int error, error2 =0 ; +int error =0 ;/* -* If the attribute list is non-existent or a shortform list, -* upgrade it to a single-leaf-block attribute list. +* If the attribute list is already in leaf format, jump straight to +* leaf handling. Otherwise, try to add the attribute to the shortform +* list; if there's no room then convert the list to leaf format and try +* again. */ -if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL || - (dp->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS && - dp->i_d.di_anextents ==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; +if (xfs_attr_is_shortform (dp)) {/* -* 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. +* 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. */ -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_shortform (args, &leaf_bp); +if (error || !args->trans)return error; - } }if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) {Signature · 1 line
2.7.4
Re: [PATCH v8 13/20] xfs: Add helpers xfs_attr_is_shortform and xfs_attr_set_shortform
Quoted 31 lines · Brian Foster
Quoted 17 lines · Allison Collins
In this patch, we hoist code from
xfs_attr_set_argsinto two new helpersxfs_attr_is_shortformandxfs_attr_set_shortform. These two will help to simplifyxfs_attr_set_argswhen we get into delayed attrs later.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 107 +++++++++++++++++++++++++++++++---------------- 1 file changed, 72 insertions(+), 35 deletions(-)fs/xfs/libxfs/xfs_attr.c +0
-0@@ -204,6 +204,66 @@ xfs_attr_try_sf_addname( }/* fs/xfs/libxfs/xfs_attr.c xfs_attr_try_sf_addname( · line 216
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+* Check to see if the attr should be upgraded from non-existent or shortform to +* single-leaf-block attribute list. +*/ +static inline bool +xfs_attr_is_shortform ( +struct xfs_inode *ip) +{ +return ip->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL || + (ip->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS && + ip->i_d.di_anextents ==0 );Logic should be indented similar to the original:
Quoted 7 lines
return ip->i_d.di_aformat == XFS_DINODE_FMT_LOCAL || (ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS && ip->i_d.di_anextents == 0);Otherwise looks good:
Reviewed-by Brian Foster <[email protected]>
Alrighty, will fix. Thanks!
Allison
Quoted 119 lines
Quoted 118 lines
fs/xfs/libxfs/xfs_attr.c +62
-35+} + +/* +* Attempts to set an attr in shortform, or converts the tree 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 @@ -212,48 +272,25 @@ xfs_attr_set_args( {struct xfs_inode *dp = args->dp;struct xfs_buf *leaf_bp =NULL ; -int error, error2 =0 ; +int error =0 ;/* -* If the attribute list is non-existent or a shortform list, -* upgrade it to a single-leaf-block attribute list. +* If the attribute list is already in leaf format, jump straight to +* leaf handling. Otherwise, try to add the attribute to the shortform +* list; if there's no room then convert the list to leaf format and try +* again. */ -if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL || - (dp->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS && - dp->i_d.di_anextents ==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; +if (xfs_attr_is_shortform (dp)) {/* -* 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. +* 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. */ -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_shortform (args, &leaf_bp); +if (error || !args->trans)return error; - } }if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) {Signature · 1 line
2.7.4
Re: [PATCH v8 13/20] xfs: Add helpers xfs_attr_is_shortform and xfs_attr_set_shortform
Quoted 35 lines · Allison Collins
Quoted 32 lines · Brian Foster
Quoted 21 lines · Allison Collins
In this patch, we hoist code from
xfs_attr_set_argsinto two new helpersxfs_attr_is_shortformand xfs_attr_set_shortform. These two will help to simplifyxfs_attr_set_argswhen we get into delayed attrs later.Signed-off-by Allison Collins <[email protected]>---
fs/xfs/libxfs/xfs_attr.c| 107
+++++++++++++++++++++++++++++++----------------1 file changed, 72 insertions(+), 35 deletions(-)fs/xfs/libxfs/xfs_attr.c +1
-0@@ -204,6 +204,66 @@ xfs_attr_try_sf_addname( } /* +* Check to see if the attr should be upgraded from non-existent or shortform to
+ * single-leaf-block attribute list.
+ */fs/xfs/libxfs/xfs_attr.c xfs_attr_try_sf_addname( · line 216
Quoted 7 lines
fs/xfs/libxfs/xfs_attr.c +7
-0+static inline bool +xfs_attr_is_shortform ( + struct xfs_inode *ip) +{ + return ip->i_d.di_aformat == XFS_DINODE_FMT_LOCAL || + (ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS && + ip->i_d.di_anextents == 0);Logic should be indented similar to the original:
Quoted 3 lines
Quoted 3 lines
return
ip->i_d.di_aformat==XFS_DINODE_FMT_LOCAL|| (ip->i_d.di_aformat==XFS_DINODE_FMT_EXTENTS&&ip->i_d.di_anextents== 0);
Did you really mean to have the last line offset like this? On second pass, it doesnt look similar to the original, and looks more like it may have been a typo in the review. Just trying to avoid more cycles on spacing goofs. Thx!
Allison
Quoted 132 lines
Quoted 4 lines
Otherwise looks good:
Reviewed-by Brian Foster <[email protected]>Alrighty, will fix. Thanks!
Allison
Quoted 124 lines
Quoted 123 lines
fs/xfs/libxfs/xfs_attr.c +4
-0+} + +/* +* Attempts to set an attr in shortform, or converts the tree to leaf form if
+ * there is not enough room. If the attr is set, the transaction is committed
+ * and set to NULL.
+ */fs/xfs/libxfs/xfs_attr.c +27
-0+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;
+ }fs/xfs/libxfs/xfs_attr.c +5
-0+ + return 0; +} + +/* * Set the attribute specified in @args.
*/
intfs/xfs/libxfs/xfs_attr.c +2
-3@@ -212,48 +272,25 @@ xfs_attr_set_args( { struct xfs_inode *dp = args->dp; struct xfs_buf *leaf_bp = NULL; - int error, error2 = 0; + int error = 0; /* -* If the attribute list is non-existent or a shortform list, -* upgrade it to a single-leaf-block attribute list. +* If the attribute list is already in leaf format, jump straight to
+ * leaf handling. Otherwise, try to add the attribute to the shortform
+ * list; if there's no room then convert the list to leaf format and try
+ * again.
*/
- if (dp->i_d.di_aformat==XFS_DINODE_FMT_LOCAL||
- (dp->i_d.di_aformat==XFS_DINODE_FMT_EXTENTS&& -dp->i_d.di_anextents== 0)) {fs/xfs/libxfs/xfs_attr.c +1
-18- - /* - * 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 (xfs_attr_is_shortform(dp)) {/*
- * 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.
+ * 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.
*/
-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_shortform(args, &leaf_bp);
+ if (error || !args->trans)
return error;
- }
}
if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {Signature · 1 line
2.7.4
Re: [PATCH v8 13/20] xfs: Add helpers xfs_attr_is_shortform and xfs_attr_set_shortform
Quoted 38 lines · Allison Collins
Quoted 35 lines · Allison Collins
Quoted 32 lines · Brian Foster
Quoted 21 lines · Allison Collins
In this patch, we hoist code from
xfs_attr_set_argsinto two new helpersxfs_attr_is_shortformand xfs_attr_set_shortform. These two will help to simplifyxfs_attr_set_argswhen we get into delayed attrs later.Signed-off-by Allison Collins <[email protected]>---
fs/xfs/libxfs/xfs_attr.c| 107
+++++++++++++++++++++++++++++++----------------1 file changed, 72 insertions(+), 35 deletions(-)fs/xfs/libxfs/xfs_attr.c +1
-0@@ -204,6 +204,66 @@ xfs_attr_try_sf_addname( } /* +* Check to see if the attr should be upgraded from non-existent or shortform to
+ * single-leaf-block attribute list.
+ */fs/xfs/libxfs/xfs_attr.c xfs_attr_try_sf_addname( · line 216
Quoted 7 lines
fs/xfs/libxfs/xfs_attr.c +7
-0+static inline bool +xfs_attr_is_shortform ( + struct xfs_inode *ip) +{ + return ip->i_d.di_aformat == XFS_DINODE_FMT_LOCAL || + (ip->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS && + ip->i_d.di_anextents == 0);Logic should be indented similar to the original:
Quoted 8 lines
Quoted 3 lines
Quoted 3 lines
return
ip->i_d.di_aformat==XFS_DINODE_FMT_LOCAL|| (ip->i_d.di_aformat==XFS_DINODE_FMT_EXTENTS&&ip->i_d.di_anextents== 0);Did you really mean to have the last line offset like this? On second pass, it doesnt look similar to the original, and looks more like it may have been a typo in the review. Just trying to avoid more cycles on spacing goofs. Thx!
Nope. What is quoted here is not how my reply appears in my mailer. :/ Anyways, the last line is supposed to be aligned to the first character inside the opening brace of the previous line.
Brian
Quoted 135 lines
Allison
Quoted 132 lines
Quoted 4 lines
Otherwise looks good:
Reviewed-by Brian Foster <[email protected]>Alrighty, will fix. Thanks!
Allison
Quoted 124 lines
Quoted 123 lines
fs/xfs/libxfs/xfs_attr.c +4
-0+} + +/* +* Attempts to set an attr in shortform, or converts the tree to leaf form if
+ * there is not enough room. If the attr is set, the transaction is committed
+ * and set to NULL.
+ */fs/xfs/libxfs/xfs_attr.c +27
-0+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;
+ }fs/xfs/libxfs/xfs_attr.c +5
-0+ + return 0; +} + +/* * Set the attribute specified in @args.
*/
intfs/xfs/libxfs/xfs_attr.c +2
-3@@ -212,48 +272,25 @@ xfs_attr_set_args( { struct xfs_inode *dp = args->dp; struct xfs_buf *leaf_bp = NULL; - int error, error2 = 0; + int error = 0; /* -* If the attribute list is non-existent or a shortform list, -* upgrade it to a single-leaf-block attribute list. +* If the attribute list is already in leaf format, jump straight to
+ * leaf handling. Otherwise, try to add the attribute to the shortform
+ * list; if there's no room then convert the list to leaf format and try
+ * again.
*/
- if (dp->i_d.di_aformat==XFS_DINODE_FMT_LOCAL|| - (dp->i_d.di_aformat==XFS_DINODE_FMT_EXTENTS&& -dp->i_d.di_anextents== 0)) {fs/xfs/libxfs/xfs_attr.c +1
-18- - /* - * 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 (xfs_attr_is_shortform(dp)) {/*
- * 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.
+ * 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.
*/
-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_shortform(args, &leaf_bp);
+ if (error || !args->trans)
return error;
- }
}
if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {Signature · 1 line
2.7.4
Re: [PATCH v8 13/20] xfs: Add helpers xfs_attr_is_shortform and xfs_attr_set_shortform
In reply to Allison CollinsQuoted 21 lines · Allison Collins
In this patch, we hoist code from
xfs_attr_set_argsinto two new helpersxfs_attr_is_shortformandxfs_attr_set_shortform. These two will help to simplifyxfs_attr_set_argswhen we get into delayed attrs later.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 107 +++++++++++++++++++++++++++++++---------------- 1 file changed, 72 insertions(+), 35 deletions(-)fs/xfs/libxfs/xfs_attr.c +4
-0@@ -204,6 +204,66 @@ xfs_attr_try_sf_addname( }/* +* Check to see if the attr should be upgraded from non-existent or shortform to +* single-leaf-block attribute list. +*/ +static inline bool
fs/xfs/libxfs/xfs_attr.c xfs_attr_try_sf_addname( · line 220
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+xfs_attr_is_shortform ( + struct xfs_inode *ip) +{ +return ip->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL || + (ip->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS && + ip->i_d.di_anextents ==0 ); +} + +/* +* Attempts to set an attr in shortform, or converts the tree to leaf form if
I think you meant to say "converts short form to leaf form".
The functional changes look logically correct,
Quoted 111 lines
fs/xfs/libxfs/xfs_attr.c +58
-35+* 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 @@ -212,48 +272,25 @@ xfs_attr_set_args( {struct xfs_inode *dp = args->dp;struct xfs_buf *leaf_bp =NULL ; -int error, error2 =0 ; +int error =0 ;/* -* If the attribute list is non-existent or a shortform list, -* upgrade it to a single-leaf-block attribute list. +* If the attribute list is already in leaf format, jump straight to +* leaf handling. Otherwise, try to add the attribute to the shortform +* list; if there's no room then convert the list to leaf format and try +* again. */ -if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL || - (dp->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS && - dp->i_d.di_anextents ==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; +if (xfs_attr_is_shortform (dp)) {/* -* 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. +* 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. */ -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_shortform (args, &leaf_bp); +if (error || !args->trans)return error; - } }if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) {
Signature · 1 line
chandan
Re: [PATCH v8 13/20] xfs: Add helpers xfs_attr_is_shortform and xfs_attr_set_shortform
Quoted 35 lines · Chandan Rajendra
Quoted 21 lines · Allison Collins
In this patch, we hoist code from
xfs_attr_set_argsinto two new helpersxfs_attr_is_shortformandxfs_attr_set_shortform. These two will help to simplifyxfs_attr_set_argswhen we get into delayed attrs later.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 107 +++++++++++++++++++++++++++++++---------------- 1 file changed, 72 insertions(+), 35 deletions(-)fs/xfs/libxfs/xfs_attr.c +4
-0@@ -204,6 +204,66 @@ xfs_attr_try_sf_addname( }/* +* Check to see if the attr should be upgraded from non-existent or shortform to +* single-leaf-block attribute list. +*/ +static inline boolfs/xfs/libxfs/xfs_attr.c xfs_attr_try_sf_addname( · line 220
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+xfs_attr_is_shortform ( + struct xfs_inode *ip) +{ +return ip->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL || + (ip->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS && + ip->i_d.di_anextents ==0 ); +} + +/* +* Attempts to set an attr in shortform, or converts the tree to leaf form if I think you meant to say "converts short form to leaf form".
Quoted 1 line
The functional changes look logically correct,
Ok, will fix the comment. Thanks for the review!
Allison
Quoted 116 lines
Reviewed-by Chandan Rajendra <[email protected]>Quoted 111 lines
fs/xfs/libxfs/xfs_attr.c +58
-35+* 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 @@ -212,48 +272,25 @@ xfs_attr_set_args( {struct xfs_inode *dp = args->dp;struct xfs_buf *leaf_bp =NULL ; -int error, error2 =0 ; +int error =0 ;/* -* If the attribute list is non-existent or a shortform list, -* upgrade it to a single-leaf-block attribute list. +* If the attribute list is already in leaf format, jump straight to +* leaf handling. Otherwise, try to add the attribute to the shortform +* list; if there's no room then convert the list to leaf format and try +* again. */ -if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL || - (dp->i_d.di_aformat ==XFS_DINODE_FMT_EXTENTS && - dp->i_d.di_anextents ==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; +if (xfs_attr_is_shortform (dp)) {/* -* 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. +* 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. */ -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_shortform (args, &leaf_bp); +if (error || !args->trans)return error; - } }if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) {
PATCH v8 14/20 xfs: Add helper function xfs_attr_leaf_mark_incomplete
In reply to Allison CollinsThis patch helps to simplify xfs_attr_node_removename by modularizing the code around the transactions into helper functions. This will make the function easier to follow when we introduce delayed attributes.
--- fs/xfs/libxfs/xfs_attr.c | 45 +++++++++++++++++++++++++++++++-------------- 1 file changed, 31 insertions(+), 14 deletions(-)
fs/xfs/libxfs/xfs_attr.c +31 -14
@@ -1153,6 +1153,36 @@ xfs_attr_node_shrink( }/* +* Mark an attribute entry INCOMPLETE and save pointers to the relevant buffers +* for later deletion of the entry. +*/ +STATIC int +xfs_attr_leaf_mark_incomplete ( +struct xfs_da_args *args, +struct xfs_da_state *state) +{ +int error; + +/* +* Fill in disk block numbers in the state structure +* so that we can get the buffers back after we commit +* several transactions in the following calls. +*/ + error =xfs_attr_fillstate (state); +if (error) +return error; + +/* +* Mark the attribute as INCOMPLETE +*/ + error =xfs_attr3_leaf_setflag (args); +if (error) +return error; + +return 0 ; +} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining
@@ -1183,20 +1213,7 @@ xfs_attr_node_removename(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (args->rmtblkno >0 ) { -/* -* Fill in disk block numbers in the state structure -* so that we can get the buffers back after we commit -* several transactions in the following calls. -*/ - error =xfs_attr_fillstate (state); -if (error) - goto out; - -/* -* Mark the attribute as INCOMPLETE, then bunmapi() the -* remote value. -*/ - error =xfs_attr3_leaf_setflag (args); + error =xfs_attr_leaf_mark_incomplete (args, state);if (error) goto out;
Signature · 1 line
2.7.4
Re: [PATCH v8 14/20] xfs: Add helper function xfs_attr_leaf_mark_incomplete
Quoted 18 lines · Allison Collins
This patch helps to simplify
xfs_attr_node_removenameby modularizing the code around the transactions into helper functions. This will make the function easier to follow when we introduce delayed attributes.Signed-off-by Allison Collins <[email protected]>Reviewed-by Amir Goldstein <[email protected]>Reviewed-by Chandan Rajendra <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 45 +++++++++++++++++++++++++++++++-------------- 1 file changed, 31 insertions(+), 14 deletions(-)fs/xfs/libxfs/xfs_attr.c +0
-0@@ -1153,6 +1153,36 @@ xfs_attr_node_shrink( }
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_shrink( · line 1164
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +9
-0/* +* Mark an attribute entry INCOMPLETE and save pointers to the relevant buffers +* for later deletion of the entry. +*/ +STATIC int +xfs_attr_leaf_mark_incomplete ( +struct xfs_da_args *args, +struct xfs_da_state *state) +{ +int error;
int error;
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c +8
-0+ +/* +* Fill in disk block numbers in the state structure +* so that we can get the buffers back after we commit +* several transactions in the following calls. +*/ + error =xfs_attr_fillstate (state); +if (error)
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_shrink( · line 1182
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+return error; + +/* +* Mark the attribute as INCOMPLETE +*/ + error =xfs_attr3_leaf_setflag (args); +if (error) +return error; + +return 0 ;
return xfs_attr3_leaf_setflag(args);
Otherwise looks good:
Quoted 31 lines
fs/xfs/libxfs/xfs_attr.c +4
-14+} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining @@ -1183,20 +1213,7 @@ xfs_attr_node_removename(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (args->rmtblkno >0 ) { -/* -* Fill in disk block numbers in the state structure -* so that we can get the buffers back after we commit -* several transactions in the following calls. -*/ - error =xfs_attr_fillstate (state); -if (error) - goto out; - -/* -* Mark the attribute as INCOMPLETE, then bunmapi() the -* remote value. -*/ - error =xfs_attr3_leaf_setflag (args); + error =xfs_attr_leaf_mark_incomplete (args, state);if (error) goto out;Signature · 1 line
2.7.4
Re: [PATCH v8 14/20] xfs: Add helper function xfs_attr_leaf_mark_incomplete
Quoted 53 lines · Brian Foster
Quoted 18 lines · Allison Collins
This patch helps to simplify
xfs_attr_node_removenameby modularizing the code around the transactions into helper functions. This will make the function easier to follow when we introduce delayed attributes.Signed-off-by Allison Collins <[email protected]>Reviewed-by Amir Goldstein <[email protected]>Reviewed-by Chandan Rajendra <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 45 +++++++++++++++++++++++++++++++-------------- 1 file changed, 31 insertions(+), 14 deletions(-)fs/xfs/libxfs/xfs_attr.c +0
-0@@ -1153,6 +1153,36 @@ xfs_attr_node_shrink( }fs/xfs/libxfs/xfs_attr.c xfs_attr_node_shrink( · line 1164
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +9
-0/* +* Mark an attribute entry INCOMPLETE and save pointers to the relevant buffers +* for later deletion of the entry. +*/ +STATIC int +xfs_attr_leaf_mark_incomplete ( +struct xfs_da_args *args, +struct xfs_da_state *state) +{ +int error;int error;Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c +8
-0+ +/* +* Fill in disk block numbers in the state structure +* so that we can get the buffers back after we commit +* several transactions in the following calls. +*/ + error =xfs_attr_fillstate (state); +if (error)fs/xfs/libxfs/xfs_attr.c xfs_attr_node_shrink( · line 1182
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+return error; + +/* +* Mark the attribute as INCOMPLETE +*/ + error =xfs_attr3_leaf_setflag (args); +if (error) +return error; + +return 0 ;return xfs_attr3_leaf_setflag(args);
Quoted 3 lines
Otherwise looks good:
Reviewed-by Brian Foster <[email protected]>
Alrighty, will update. Thank you!
Allison
Quoted 33 lines
Quoted 32 lines
fs/xfs/libxfs/xfs_attr.c +4
-14+} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining @@ -1183,20 +1213,7 @@ xfs_attr_node_removename(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (args->rmtblkno >0 ) { -/* -* Fill in disk block numbers in the state structure -* so that we can get the buffers back after we commit -* several transactions in the following calls. -*/ - error =xfs_attr_fillstate (state); -if (error) - goto out; - -/* -* Mark the attribute as INCOMPLETE, then bunmapi() the -* remote value. -*/ - error =xfs_attr3_leaf_setflag (args); + error =xfs_attr_leaf_mark_incomplete (args, state);if (error) goto out;Signature · 1 line
2.7.4
PATCH v8 15/20 xfs: Add remote block helper functions
In reply to Allison CollinsThis patch adds two new helper functions xfs_attr_store_rmt_blk and xfs_attr_restore_rmt_blk. These two helpers assist to remove redundant code associated with storing and retrieving remote blocks during the attr set operations.
--- fs/xfs/libxfs/xfs_attr.c | 50 +++++++++++++++++++++++++++++------------------- 1 file changed, 30 insertions(+), 20 deletions(-)
fs/xfs/libxfs/xfs_attr.c +30 -20
@@ -565,6 +565,30 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)* External routines when attribute list is one block *========================================================================*/ +/* Store info about a remote block */ +STATIC void +xfs_attr_save_rmt_blk ( +struct xfs_da_args *args) +{ + args->blkno2 = args->blkno; + args->index2 = args->index; + args->rmtblkno2 = args->rmtblkno; + args->rmtblkcnt2 = args->rmtblkcnt; + args->rmtvaluelen2 = args->rmtvaluelen; +} + +/* Set stored info about a remote block */ +STATIC void +xfs_attr_restore_rmt_blk ( +struct xfs_da_args *args) +{ + args->blkno = args->blkno2; + args->index = args->index2; + args->rmtblkno = args->rmtblkno2; + args->rmtblkcnt = args->rmtblkcnt2; + args->rmtvaluelen = args->rmtvaluelen2; +} +/* * Tries to add an attribute to an inode in leaf form *
@@ -599,11 +623,7 @@ xfs_attr_leaf_try_add(/* save the attribute state for later removal*/ args->op_flags |=XFS_DA_OP_RENAME ;/* an atomic rename */ - args->blkno2 = args->blkno;/* set 2nd entry info*/ - args->index2 = args->index; - args->rmtblkno2 = args->rmtblkno; - args->rmtblkcnt2 = args->rmtblkcnt; - args->rmtvaluelen2 = args->rmtvaluelen; +xfs_attr_save_rmt_blk (args);/* * clear the remote attr state now that it is saved so that the
@@ -702,11 +722,8 @@ xfs_attr_leaf_addname(* Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ - args->index = args->index2; - args->blkno = args->blkno2; - args->rmtblkno = args->rmtblkno2; - args->rmtblkcnt = args->rmtblkcnt2; - args->rmtvaluelen = args->rmtvaluelen2; +xfs_attr_restore_rmt_blk (args); +if (args->rmtblkno) { error =xfs_attr_rmtval_remove (args);if (error)
@@ -934,11 +951,7 @@ xfs_attr_node_addname(/* save the attribute state for later removal*/ args->op_flags |=XFS_DA_OP_RENAME ;/* atomic rename op */ - args->blkno2 = args->blkno;/* set 2nd entry info*/ - args->index2 = args->index; - args->rmtblkno2 = args->rmtblkno; - args->rmtblkcnt2 = args->rmtblkcnt; - args->rmtvaluelen2 = args->rmtvaluelen; +xfs_attr_save_rmt_blk (args);/* * clear the remote attr state now that it is saved so that the
@@ -1050,11 +1063,8 @@ xfs_attr_node_addname(* Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ - args->index = args->index2; - args->blkno = args->blkno2; - args->rmtblkno = args->rmtblkno2; - args->rmtblkcnt = args->rmtblkcnt2; - args->rmtvaluelen = args->rmtvaluelen2; +xfs_attr_restore_rmt_blk (args); +if (args->rmtblkno) { error =xfs_attr_rmtval_remove (args);if (error)
Signature · 1 line
2.7.4
Re: [PATCH v8 15/20] xfs: Add remote block helper functions
Quoted 9 lines · Allison Collins
This patch adds two new helper functions
xfs_attr_store_rmt_blkandxfs_attr_restore_rmt_blk. These two helpers assist to remove redundant code associated with storing and retrieving remote blocks during the attr set operations.Signed-off-by Allison Collins <[email protected]>Reviewed-by Chandan Rajendra <[email protected]>Reviewed-by Amir Goldstein <[email protected]>---
Quoted 95 lines
fs/xfs/libxfs/xfs_attr.c | 50 +++++++++++++++++++++++++++++------------------- 1 file changed, 30 insertions(+), 20 deletions(-)fs/xfs/libxfs/xfs_attr.c +30
-20@@ -565,6 +565,30 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)* External routines when attribute list is one block *========================================================================*/ +/* Store info about a remote block */ +STATIC void +xfs_attr_save_rmt_blk ( +struct xfs_da_args *args) +{ + args->blkno2 = args->blkno; + args->index2 = args->index; + args->rmtblkno2 = args->rmtblkno; + args->rmtblkcnt2 = args->rmtblkcnt; + args->rmtvaluelen2 = args->rmtvaluelen; +} + +/* Set stored info about a remote block */ +STATIC void +xfs_attr_restore_rmt_blk ( +struct xfs_da_args *args) +{ + args->blkno = args->blkno2; + args->index = args->index2; + args->rmtblkno = args->rmtblkno2; + args->rmtblkcnt = args->rmtblkcnt2; + args->rmtvaluelen = args->rmtvaluelen2; +} +/* * Tries to add an attribute to an inode in leaf form * @@ -599,11 +623,7 @@ xfs_attr_leaf_try_add(/* save the attribute state for later removal*/ args->op_flags |=XFS_DA_OP_RENAME ;/* an atomic rename */ - args->blkno2 = args->blkno;/* set 2nd entry info*/ - args->index2 = args->index; - args->rmtblkno2 = args->rmtblkno; - args->rmtblkcnt2 = args->rmtblkcnt; - args->rmtvaluelen2 = args->rmtvaluelen; +xfs_attr_save_rmt_blk (args);/* * clear the remote attr state now that it is saved so that the @@ -702,11 +722,8 @@ xfs_attr_leaf_addname(* Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ - args->index = args->index2; - args->blkno = args->blkno2; - args->rmtblkno = args->rmtblkno2; - args->rmtblkcnt = args->rmtblkcnt2; - args->rmtvaluelen = args->rmtvaluelen2; +xfs_attr_restore_rmt_blk (args); +if (args->rmtblkno) { error =xfs_attr_rmtval_remove (args);if (error)@@ -934,11 +951,7 @@ xfs_attr_node_addname(/* save the attribute state for later removal*/ args->op_flags |=XFS_DA_OP_RENAME ;/* atomic rename op */ - args->blkno2 = args->blkno;/* set 2nd entry info*/ - args->index2 = args->index; - args->rmtblkno2 = args->rmtblkno; - args->rmtblkcnt2 = args->rmtblkcnt; - args->rmtvaluelen2 = args->rmtvaluelen; +xfs_attr_save_rmt_blk (args);/* * clear the remote attr state now that it is saved so that the @@ -1050,11 +1063,8 @@ xfs_attr_node_addname(* Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ - args->index = args->index2; - args->blkno = args->blkno2; - args->rmtblkno = args->rmtblkno2; - args->rmtblkcnt = args->rmtblkcnt2; - args->rmtvaluelen = args->rmtvaluelen2; +xfs_attr_restore_rmt_blk (args); +if (args->rmtblkno) { error =xfs_attr_rmtval_remove (args);if (error)Signature · 1 line
2.7.4
Re: [PATCH v8 15/20] xfs: Add remote block helper functions
Quoted 6 lines · Brian Foster
Quoted 5 lines · Allison Collins
This patch adds two new helper functions
xfs_attr_store_rmt_blkandxfs_attr_restore_rmt_blk. These two helpers assist to remove redundant code associated with storing and retrieving remote blocks during the attr set operations.
Quoted 6 lines
Quoted 4 lines
Signed-off-by Allison Collins <[email protected]>Reviewed-by Chandan Rajendra <[email protected]>Reviewed-by Amir Goldstein <[email protected]>---
Reviewed-by Brian Foster <[email protected]>
Alrighty, thank you!
Allison
Quoted 97 lines
Quoted 96 lines
fs/xfs/libxfs/xfs_attr.c | 50 +++++++++++++++++++++++++++++------------------- 1 file changed, 30 insertions(+), 20 deletions(-)fs/xfs/libxfs/xfs_attr.c +30
-20@@ -565,6 +565,30 @@ xfs_attr_shortform_addname(xfs_da_args_t *args)* External routines when attribute list is one block *========================================================================*/ +/* Store info about a remote block */ +STATIC void +xfs_attr_save_rmt_blk ( +struct xfs_da_args *args) +{ + args->blkno2 = args->blkno; + args->index2 = args->index; + args->rmtblkno2 = args->rmtblkno; + args->rmtblkcnt2 = args->rmtblkcnt; + args->rmtvaluelen2 = args->rmtvaluelen; +} + +/* Set stored info about a remote block */ +STATIC void +xfs_attr_restore_rmt_blk ( +struct xfs_da_args *args) +{ + args->blkno = args->blkno2; + args->index = args->index2; + args->rmtblkno = args->rmtblkno2; + args->rmtblkcnt = args->rmtblkcnt2; + args->rmtvaluelen = args->rmtvaluelen2; +} +/* * Tries to add an attribute to an inode in leaf form * @@ -599,11 +623,7 @@ xfs_attr_leaf_try_add(/* save the attribute state for later removal*/ args->op_flags |=XFS_DA_OP_RENAME ;/* an atomic rename */ - args->blkno2 = args->blkno;/* set 2nd entry info*/ - args->index2 = args->index; - args->rmtblkno2 = args->rmtblkno; - args->rmtblkcnt2 = args->rmtblkcnt; - args->rmtvaluelen2 = args->rmtvaluelen; +xfs_attr_save_rmt_blk (args);/* * clear the remote attr state now that it is saved so that the @@ -702,11 +722,8 @@ xfs_attr_leaf_addname(* Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ - args->index = args->index2; - args->blkno = args->blkno2; - args->rmtblkno = args->rmtblkno2; - args->rmtblkcnt = args->rmtblkcnt2; - args->rmtvaluelen = args->rmtvaluelen2; +xfs_attr_restore_rmt_blk (args); +if (args->rmtblkno) { error =xfs_attr_rmtval_remove (args);if (error)@@ -934,11 +951,7 @@ xfs_attr_node_addname(/* save the attribute state for later removal*/ args->op_flags |=XFS_DA_OP_RENAME ;/* atomic rename op */ - args->blkno2 = args->blkno;/* set 2nd entry info*/ - args->index2 = args->index; - args->rmtblkno2 = args->rmtblkno; - args->rmtblkcnt2 = args->rmtblkcnt; - args->rmtvaluelen2 = args->rmtvaluelen; +xfs_attr_save_rmt_blk (args);/* * clear the remote attr state now that it is saved so that the @@ -1050,11 +1063,8 @@ xfs_attr_node_addname(* Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ - args->index = args->index2; - args->blkno = args->blkno2; - args->rmtblkno = args->rmtblkno2; - args->rmtblkcnt = args->rmtblkcnt2; - args->rmtvaluelen = args->rmtvaluelen2; +xfs_attr_restore_rmt_blk (args); +if (args->rmtblkno) { error =xfs_attr_rmtval_remove (args);if (error)Signature · 1 line
2.7.4
PATCH v8 16/20 xfs: Add helper function xfs_attr_node_removename_setup
In reply to Allison CollinsThis patch adds a new helper function xfs_attr_node_removename_setup. This will help modularize xfs_attr_node_removename when we add delay ready attributes later.
--- fs/xfs/libxfs/xfs_attr.c | 40 +++++++++++++++++++++++++++++++--------- 1 file changed, 31 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_attr.c +31 -9
@@ -1193,6 +1193,35 @@ xfs_attr_leaf_mark_incomplete( }/* +* Initial setup for xfs_attr_node_removename. Make sure the attr is there and +* the blocks are valid. Any remote blocks will be marked incomplete. +*/ +STATIC +int xfs_attr_node_removename_setup( +struct xfs_da_args *args, +struct xfs_da_state **state) +{ +int error; +struct xfs_da_state_blk *blk; + + error =xfs_attr_node_hasname (args, state); +if (error != -EEXIST ) +return error; + + blk = &(*state)->path.blk[(*state)->path.active -1 ]; +ASSERT (blk->bp !=NULL ); +ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); + +if (args->rmtblkno >0 ) { + error =xfs_attr_leaf_mark_incomplete (args, *state); +if (error) +return error; + } + +return 0 ; +} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining
@@ -1210,8 +1239,8 @@ xfs_attr_node_removename(trace_xfs_attr_node_removename (args); - error =xfs_attr_node_hasname (args, &state); -if (error != -EEXIST ) + error =xfs_attr_node_removename_setup (args, &state); +if (error) goto out;/*
@@ -1219,14 +1248,7 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ - blk = &state->path.blk[ state->path.active-1 ]; -ASSERT (blk->bp !=NULL ); -ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (args->rmtblkno >0 ) { - error =xfs_attr_leaf_mark_incomplete (args, state); -if (error) - goto out; - error =xfs_attr_rmtval_remove (args);if (error) goto out;
Signature · 1 line
2.7.4
Re: [PATCH v8 16/20] xfs: Add helper function xfs_attr_node_removename_setup
Quoted 6 lines · Allison Collins
This patch adds a new helper function
xfs_attr_node_removename_setup. This will help modularizexfs_attr_node_removenamewhen we add delay ready attributes later.Signed-off-by Allison Collins <[email protected]>---
Quoted 72 lines
fs/xfs/libxfs/xfs_attr.c | 40 +++++++++++++++++++++++++++++++--------- 1 file changed, 31 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_attr.c +31
-9@@ -1193,6 +1193,35 @@ xfs_attr_leaf_mark_incomplete( }/* +* Initial setup for xfs_attr_node_removename. Make sure the attr is there and +* the blocks are valid. Any remote blocks will be marked incomplete. +*/ +STATIC +int xfs_attr_node_removename_setup( +struct xfs_da_args *args, +struct xfs_da_state **state) +{ +int error; +struct xfs_da_state_blk *blk; + + error =xfs_attr_node_hasname (args, state); +if (error != -EEXIST ) +return error; + + blk = &(*state)->path.blk[(*state)->path.active -1 ]; +ASSERT (blk->bp !=NULL ); +ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); + +if (args->rmtblkno >0 ) { + error =xfs_attr_leaf_mark_incomplete (args, *state); +if (error) +return error; + } + +return 0 ; +} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining @@ -1210,8 +1239,8 @@ xfs_attr_node_removename(trace_xfs_attr_node_removename (args); - error =xfs_attr_node_hasname (args, &state); -if (error != -EEXIST ) + error =xfs_attr_node_removename_setup (args, &state); +if (error) goto out;/* @@ -1219,14 +1248,7 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ - blk = &state->path.blk[ state->path.active-1 ]; -ASSERT (blk->bp !=NULL ); -ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (args->rmtblkno >0 ) { - error =xfs_attr_leaf_mark_incomplete (args, state); -if (error) - goto out; - error =xfs_attr_rmtval_remove (args);if (error) goto out;Signature · 1 line
2.7.4
Re: [PATCH v8 16/20] xfs: Add helper function xfs_attr_node_removename_setup
Quoted 9 lines · Brian Foster
Quoted 6 lines · Allison Collins
This patch adds a new helper function
xfs_attr_node_removename_setup. This will help modularizexfs_attr_node_removenamewhen we add delay ready attributes later.Signed-off-by Allison Collins <[email protected]>---
Reviewed-by Brian Foster <[email protected]>
Ok, thank you!
Allison
Quoted 74 lines
Quoted 73 lines
fs/xfs/libxfs/xfs_attr.c | 40 +++++++++++++++++++++++++++++++--------- 1 file changed, 31 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_attr.c +31
-9@@ -1193,6 +1193,35 @@ xfs_attr_leaf_mark_incomplete( }/* +* Initial setup for xfs_attr_node_removename. Make sure the attr is there and +* the blocks are valid. Any remote blocks will be marked incomplete. +*/ +STATIC +int xfs_attr_node_removename_setup( +struct xfs_da_args *args, +struct xfs_da_state **state) +{ +int error; +struct xfs_da_state_blk *blk; + + error =xfs_attr_node_hasname (args, state); +if (error != -EEXIST ) +return error; + + blk = &(*state)->path.blk[(*state)->path.active -1 ]; +ASSERT (blk->bp !=NULL ); +ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); + +if (args->rmtblkno >0 ) { + error =xfs_attr_leaf_mark_incomplete (args, *state); +if (error) +return error; + } + +return 0 ; +} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining @@ -1210,8 +1239,8 @@ xfs_attr_node_removename(trace_xfs_attr_node_removename (args); - error =xfs_attr_node_hasname (args, &state); -if (error != -EEXIST ) + error =xfs_attr_node_removename_setup (args, &state); +if (error) goto out;/* @@ -1219,14 +1248,7 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ - blk = &state->path.blk[ state->path.active-1 ]; -ASSERT (blk->bp !=NULL ); -ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (args->rmtblkno >0 ) { - error =xfs_attr_leaf_mark_incomplete (args, state); -if (error) - goto out; - error =xfs_attr_rmtval_remove (args);if (error) goto out;Signature · 1 line
2.7.4
Re: [PATCH v8 16/20] xfs: Add helper function xfs_attr_node_removename_setup
In reply to Allison CollinsQuoted 4 lines · Allison Collins
This patch adds a new helper function
xfs_attr_node_removename_setup. This will help modularizexfs_attr_node_removenamewhen we add delay ready attributes later.
The changes look good to me,
Quoted 72 lines
Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 40 +++++++++++++++++++++++++++++++--------- 1 file changed, 31 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_attr.c +31
-9@@ -1193,6 +1193,35 @@ xfs_attr_leaf_mark_incomplete( }/* +* Initial setup for xfs_attr_node_removename. Make sure the attr is there and +* the blocks are valid. Any remote blocks will be marked incomplete. +*/ +STATIC +int xfs_attr_node_removename_setup( +struct xfs_da_args *args, +struct xfs_da_state **state) +{ +int error; +struct xfs_da_state_blk *blk; + + error =xfs_attr_node_hasname (args, state); +if (error != -EEXIST ) +return error; + + blk = &(*state)->path.blk[(*state)->path.active -1 ]; +ASSERT (blk->bp !=NULL ); +ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); + +if (args->rmtblkno >0 ) { + error =xfs_attr_leaf_mark_incomplete (args, *state); +if (error) +return error; + } + +return 0 ; +} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining @@ -1210,8 +1239,8 @@ xfs_attr_node_removename(trace_xfs_attr_node_removename (args); - error =xfs_attr_node_hasname (args, &state); -if (error != -EEXIST ) + error =xfs_attr_node_removename_setup (args, &state); +if (error) goto out;/* @@ -1219,14 +1248,7 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ - blk = &state->path.blk[ state->path.active-1 ]; -ASSERT (blk->bp !=NULL ); -ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (args->rmtblkno >0 ) { - error =xfs_attr_leaf_mark_incomplete (args, state); -if (error) - goto out; - error =xfs_attr_rmtval_remove (args);if (error) goto out;
Signature · 1 line
chandan
Re: [PATCH v8 16/20] xfs: Add helper function xfs_attr_node_removename_setup
Quoted 8 lines · Chandan Rajendra
Quoted 4 lines · Allison Collins
This patch adds a new helper function
xfs_attr_node_removename_setup. This will help modularizexfs_attr_node_removenamewhen we add delay ready attributes later.The changes look good to me,
Reviewed-by Chandan Rajendra <[email protected]>
Alrighty, thank you!
Allison
Quoted 75 lines
Quoted 73 lines
Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 40 +++++++++++++++++++++++++++++++--------- 1 file changed, 31 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_attr.c +31
-9@@ -1193,6 +1193,35 @@ xfs_attr_leaf_mark_incomplete( }/* +* Initial setup for xfs_attr_node_removename. Make sure the attr is there and +* the blocks are valid. Any remote blocks will be marked incomplete. +*/ +STATIC +int xfs_attr_node_removename_setup( +struct xfs_da_args *args, +struct xfs_da_state **state) +{ +int error; +struct xfs_da_state_blk *blk; + + error =xfs_attr_node_hasname (args, state); +if (error != -EEXIST ) +return error; + + blk = &(*state)->path.blk[(*state)->path.active -1 ]; +ASSERT (blk->bp !=NULL ); +ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); + +if (args->rmtblkno >0 ) { + error =xfs_attr_leaf_mark_incomplete (args, *state); +if (error) +return error; + } + +return 0 ; +} + +/* * Remove a name from a B-tree attribute list. * * This will involve walking down the Btree, and may involve joining @@ -1210,8 +1239,8 @@ xfs_attr_node_removename(trace_xfs_attr_node_removename (args); - error =xfs_attr_node_hasname (args, &state); -if (error != -EEXIST ) + error =xfs_attr_node_removename_setup (args, &state); +if (error) goto out;/* @@ -1219,14 +1248,7 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ - blk = &state->path.blk[ state->path.active-1 ]; -ASSERT (blk->bp !=NULL ); -ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC );if (args->rmtblkno >0 ) { - error =xfs_attr_leaf_mark_incomplete (args, state); -if (error) - goto out; - error =xfs_attr_rmtval_remove (args);if (error) goto out;
PATCH v8 17/20 xfs: Add helper function xfs_attr_node_removename_rmt
In reply to Allison CollinsThis patch adds another new helper function xfs_attr_node_removename_rmt. This will also help modularize xfs_attr_node_removename when we add delay ready attributes later.
--- fs/xfs/libxfs/xfs_attr.c | 32 +++++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_attr.c +23 -9
@@ -1221,6 +1221,28 @@ int xfs_attr_node_removename_setup(return 0 ; } +STATIC int +xfs_attr_node_removename_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. +*/ + error =xfs_attr_refillstate (state); +if (error) +return error; + +return 0 ; +} +/* * Remove a name from a B-tree attribute list. *
@@ -1249,15 +1271,7 @@ xfs_attr_node_removename(* overflow the maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - 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); + error =xfs_attr_node_removename_rmt (args, state);if (error) goto out; }
Signature · 1 line
2.7.4
Re: [PATCH v8 17/20] xfs: Add helper function xfs_attr_node_removename_rmt
Quoted 22 lines · Allison Collins
This patch adds another new helper function
xfs_attr_node_removename_rmt. This will also help modularizexfs_attr_node_removenamewhen we add delay ready attributes later.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 32 +++++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_attr.c +5
-0@@ -1221,6 +1221,28 @@ int xfs_attr_node_removename_setup(return 0 ; } +STATIC int +xfs_attr_node_removename_rmt ( +struct xfs_da_args *args, +struct xfs_da_state *state) +{
fs/xfs/libxfs/xfs_attr.c int xfs_attr_node_removename_setup( · line 1238
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+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. +*/
The comment can be widened to 80 chars now that indentation has been reduced.
fs/xfs/libxfs/xfs_attr.c int xfs_attr_node_removename_setup( · line 1243
Quoted 5 lines
fs/xfs/libxfs/xfs_attr.c +5
-0+ error =xfs_attr_refillstate (state); +if (error) +return error; + +return 0 ;
return xfs_attr_refillstate(state);
With those nits fixed:
Quoted 25 lines
fs/xfs/libxfs/xfs_attr.c +3
-9+} +/* * Remove a name from a B-tree attribute list. * @@ -1249,15 +1271,7 @@ xfs_attr_node_removename(* overflow the maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - 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); + error =xfs_attr_node_removename_rmt (args, state);if (error) goto out; }Signature · 1 line
2.7.4
Re: [PATCH v8 17/20] xfs: Add helper function xfs_attr_node_removename_rmt
Quoted 45 lines · Brian Foster
Quoted 22 lines · Allison Collins
This patch adds another new helper function
xfs_attr_node_removename_rmt. This will also help modularizexfs_attr_node_removenamewhen we add delay ready attributes later.Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 32 +++++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_attr.c +5
-0@@ -1221,6 +1221,28 @@ int xfs_attr_node_removename_setup(return 0 ; } +STATIC int +xfs_attr_node_removename_rmt ( +struct xfs_da_args *args, +struct xfs_da_state *state) +{fs/xfs/libxfs/xfs_attr.c int xfs_attr_node_removename_setup( · line 1238
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+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. +*/ The comment can be widened to 80 chars now that indentation has been reduced.
fs/xfs/libxfs/xfs_attr.c int xfs_attr_node_removename_setup( · line 1243
Quoted 5 lines
fs/xfs/libxfs/xfs_attr.c +5
-0+ error =xfs_attr_refillstate (state); +if (error) +return error; + +return 0 ;return xfs_attr_refillstate(state);
Quoted 3 lines
With those nits fixed:
Reviewed-by Brian Foster <[email protected]>
Alrighty, will fix. Thanks!
Allison
Quoted 27 lines
Quoted 26 lines
fs/xfs/libxfs/xfs_attr.c +3
-9+} +/* * Remove a name from a B-tree attribute list. * @@ -1249,15 +1271,7 @@ xfs_attr_node_removename(* overflow the maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - 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); + error =xfs_attr_node_removename_rmt (args, state);if (error) goto out; }Signature · 1 line
2.7.4
Re: [PATCH v8 17/20] xfs: Add helper function xfs_attr_node_removename_rmt
In reply to Allison CollinsQuoted 4 lines · Allison Collins
This patch adds another new helper function
xfs_attr_node_removename_rmt. This will also help modularizexfs_attr_node_removenamewhen we add delay ready attributes later.
The changes look logically correct.
Quoted 56 lines
Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 32 +++++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_attr.c +23
-9@@ -1221,6 +1221,28 @@ int xfs_attr_node_removename_setup(return 0 ; } +STATIC int +xfs_attr_node_removename_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. +*/ + error =xfs_attr_refillstate (state); +if (error) +return error; + +return 0 ; +} +/* * Remove a name from a B-tree attribute list. * @@ -1249,15 +1271,7 @@ xfs_attr_node_removename(* overflow the maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - 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); + error =xfs_attr_node_removename_rmt (args, state);if (error) goto out; }
Signature · 1 line
chandan
Re: [PATCH v8 17/20] xfs: Add helper function xfs_attr_node_removename_rmt
Quoted 9 lines · Chandan Rajendra
Quoted 4 lines · Allison Collins
This patch adds another new helper function
xfs_attr_node_removename_rmt. This will also help modularizexfs_attr_node_removenamewhen we add delay ready attributes later.The changes look logically correct.
Reviewed-by Chandan Rajendra <[email protected]>
Thank you!
Allison
Quoted 59 lines
Quoted 57 lines
Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 32 +++++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_attr.c +23
-9@@ -1221,6 +1221,28 @@ int xfs_attr_node_removename_setup(return 0 ; } +STATIC int +xfs_attr_node_removename_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. +*/ + error =xfs_attr_refillstate (state); +if (error) +return error; + +return 0 ; +} +/* * Remove a name from a B-tree attribute list. * @@ -1249,15 +1271,7 @@ xfs_attr_node_removename(* overflow the maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - 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); + error =xfs_attr_node_removename_rmt (args, state);if (error) goto out; }
PATCH v8 18/20 xfs: Add delay ready attr remove routines
In reply to Allison CollinsThis 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 has become xfs_attr_remove_iter, which uses a sort of state machine like switch to keep track of where it was when EAGAIN was returned. xfs_attr_node_removename has also been modified to use the switch, and a new version of xfs_attr_remove_args consists of a simple loop to refresh the transaction until the operation is completed.
Calls to xfs_attr_rmtval_remove are replaced with the delay ready counter parts: xfs_attr_rmtval_invalidate (appearing in the setup helper) and then __xfs_attr_rmtval_remove. We will rename __xfs_attr_rmtval_remove back to xfs_attr_rmtval_remove when we are done.
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.
Below is a state machine diagram for attr remove operations. The XFS_DAS_* states indicate places where the function would return -EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_remove_iter()
XFS_DAS_RM_SHRINK ─┐
(subroutine state) │
│
XFS_DAS_RMTVAL_REMOVE ─┤
(subroutine state) │
└─>xfs_attr_node_removename()
│ v
need to remove
┌─n── rmt blocks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_RMTVAL_REMOVE
│ │ │
│ │ v
│ └──y── more blks
│ to remove?
│ │
│ n
│ │
│ v
│ need to
└─────> shrink tree? ─n─┐
│ │
y │
│ │
v │
XFS_DAS_RM_SHRINK │
│ │
v │
done <─────┘
--- fs/xfs/libxfs/xfs_attr.c | 168 ++++++++++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_attr.h | 38 +++++++++++ 2 files changed, 168 insertions(+), 38 deletions(-)
fs/xfs/libxfs/xfs_attr.c +130 -38
@@ -45,7 +45,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);*/ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);/*
@@ -53,12 +53,21 @@ 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_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC void +xfs_delattr_context_init ( +struct xfs_delattr_context *dac, +struct xfs_da_args *args) +{ +memset (dac,0 ,sizeof (struct xfs_delattr_context )); + dac->da_args = args; +} +int xfs_inode_hasattr (struct xfs_inode *ip)
@@ -356,20 +365,66 @@ xfs_has_attr(*/ int xfs_attr_remove_args ( -struct xfs_da_args *args) +struct xfs_da_args *args) { +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_remove_iter (&dac); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + }while (true); + +return error; +} + +/* +* Remove the attribute specified in @args. +* +* This function may return -EAGAIN to signal that the transaction needs to be +* rolled. Callers should continue calling this function until they receive a +* return value other than -EAGAIN. +*/ +int +xfs_attr_remove_iter ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args;struct xfs_inode *dp = args->dp;int error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RM_SHRINK : +case XFS_DAS_RMTVAL_REMOVE : +return xfs_attr_node_removename (dac); +default : +break ; + } +if (!xfs_inode_hasattr (dp)) { error = -ENOATTR ; }else if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL ) {ASSERT (dp->i_afp->if_flags &XFS_IFINLINE ); error =xfs_attr_shortform_remove (args); }else if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_removename (args); + error =xfs_attr_leaf_removename (dac); }else { - error =xfs_attr_node_removename (args); + error =xfs_attr_node_removename (dac); }return error;
@@ -794,11 +849,12 @@ xfs_attr_leaf_hasname(*/ STATIC intxfs_attr_leaf_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_inode *dp; -struct xfs_buf *bp; -int error, forkoff; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp; +struct xfs_buf *bp; +int error, forkoff;trace_xfs_attr_leaf_removename (args);
@@ -825,9 +881,8 @@ xfs_attr_leaf_removename(/* bp is gone due to xfs_da_shrink_inode */ if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; }return 0 ; }
@@ -1128,12 +1183,13 @@ xfs_attr_node_addname(*/ STATIC intxfs_attr_node_shrink ( -struct xfs_da_args *args, -struct xfs_da_state *state) +struct xfs_delattr_context *dac, +struct xfs_da_state *state) { -struct xfs_inode *dp = args->dp; -int error, forkoff; -struct xfs_buf *bp; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp;/* * Have to get rid of the copy of this dabuf in the state.
@@ -1153,9 +1209,7 @@ xfs_attr_node_shrink(if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + dac->flags |=XFS_DAC_DEFER_FINISH ; }else xfs_trans_brelse (args->trans, bp);
@@ -1194,13 +1248,15 @@ xfs_attr_leaf_mark_incomplete(/* * Initial setup for xfs_attr_node_removename. Make sure the attr is there and -* the blocks are valid. Any remote blocks will be marked incomplete. +* the blocks are valid. Any remote blocks will be marked incomplete and +* invalidated. */ STATIC int xfs_attr_node_removename_setup( -struct xfs_da_args *args, -struct xfs_da_state **state) +struct xfs_delattr_context *dac, +struct xfs_da_state **state) { +struct xfs_da_args *args = dac->da_args;int error;struct xfs_da_state_blk *blk;
@@ -1212,10 +1268,21 @@ int xfs_attr_node_removename_setup(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); +/* +* Store blk and state in the context incase we need to cycle out the +* transaction +*/ + dac->blk = blk; + dac->da_state = *state; +if (args->rmtblkno >0 ) { error =xfs_attr_leaf_mark_incomplete (args, *state);if (error)return error; + + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error; }return 0 ;
@@ -1228,7 +1295,10 @@ xfs_attr_node_removename_rmt ( {int error =0 ; - error =xfs_attr_rmtval_remove (args); +/* +* May return -EAGAIN to request that the caller recall this function +*/ + error =__xfs_attr_rmtval_remove (args);if (error)return error;
@@ -1249,19 +1319,37 @@ xfs_attr_node_removename_rmt (* This will involve walking down the Btree, and may involve joining * leaf nodes and even joining intermediate nodes up to and including * the root node (a special case of an intermediate node). +* +* This routine is meant to function as either an inline or delayed operation, +* and may return -EAGAIN when the transaction needs to be rolled. Calling +* functions will need to handle this, and recall the function until a +* successful error code is returned. */ STATIC intxfs_attr_node_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { +struct xfs_da_args *args = dac->da_args;struct xfs_da_state *state;struct xfs_da_state_blk *blk;int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); + state = dac->da_state; + blk = dac->blk; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RMTVAL_REMOVE : + goto das_rmtval_remove; +case XFS_DAS_RM_SHRINK : + goto das_rm_shrink; +default : +break ; + } - error =xfs_attr_node_removename_setup (args, &state); + error =xfs_attr_node_removename_setup (dac, &state);if (error) goto out;
@@ -1270,10 +1358,16 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ + +das_rmtval_remove: +if (args->rmtblkno >0 ) { error =xfs_attr_node_removename_rmt (args, state); -if (error) - goto out; +if (error) { +if (error == -EAGAIN ) + dac->dela_state =XFS_DAS_RMTVAL_REMOVE ; +return error; + } }/*
@@ -1291,22 +1385,20 @@ xfs_attr_node_removename( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; -/* -* Commit the Btree join operation and start a new trans. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_RM_SHRINK ; +return -EAGAIN ; } +das_rm_shrink: + dac->dela_state =XFS_DAS_RM_SHRINK ; +/* * If the result is small enough, push it all into the inode. */ if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) - error =xfs_attr_node_shrink (args, state); + error =xfs_attr_node_shrink (dac, state); error =0 ; out:
fs/xfs/libxfs/xfs_attr.h +38 -0
@@ -74,6 +74,43 @@ struct xfs_attr_list_context { }; +/* +* ======================================================================== +* Structure used to pass context around among the delayed routines. +* ======================================================================== +*/ + +/* +* Enum values for xfs_delattr_context.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 +* calling function to roll the transaction, and then recall the subroutine to +* finish the operation. The enum is then used by the subroutine to jump back +* to where it was and resume executing where it left off. +*/ +enum xfs_delattr_state { +/* Zero is uninitalized */ +XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ +XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +}; + +/* +* Defines for xfs_delattr_context.flags +*/ +#define XFS_DAC_DEFER_FINISH 0x1/* indicates to finish the transaction */ + +/* +* Context used for keeping track of delayed attribute operations +*/ +struct xfs_delattr_context { +struct xfs_da_args *da_args; +struct xfs_da_state *da_state; +struct xfs_da_state_blk *blk; +unsigned int flags; +enum xfs_delattr_state dela_state; +}; +/*======================================================================== * Function prototypes for the kernel. *========================================================================*/
@@ -91,6 +128,7 @@ int xfs_attr_set(struct xfs_da_args *args);int xfs_attr_set_args (struct xfs_da_args *args);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args); +int xfs_attr_remove_iter (struct xfs_delattr_context *dac);bool xfs_attr_namecheck (const void *name,size_t length);#endif /* __XFS_ATTR_H__ */
Signature · 1 line
2.7.4
Re: [PATCH v8 18/20] xfs: Add delay ready attr remove routines
Quoted 68 lines · Allison Collins
This patch modifies the attr remove routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_remove_argshas becomexfs_attr_remove_iter, which uses a sort of state machine like switch to keep track of where it was when EAGAIN was returned.xfs_attr_node_removenamehas also been modified to use the switch, and a new version ofxfs_attr_remove_argsconsists of a simple loop to refresh the transaction until the operation is completed.Calls to
xfs_attr_rmtval_removeare replaced with the delay ready counter parts:xfs_attr_rmtval_invalidate(appearing in the setup helper) and then__xfs_attr_rmtval_remove. We will rename__xfs_attr_rmtval_removeback toxfs_attr_rmtval_removewhen we are done.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 newxfs_delattr_stateenum 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.Below is a state machine diagram for attr remove operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_remove_iter()XFS_DAS_RM_SHRINK ─┐ (subroutine state) │ │ XFS_DAS_RMTVAL_REMOVE ─┤ (subroutine state) │ └─>xfs_attr_node_removename() │v
need to remove
┌─n── rmt blocks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_RMTVAL_REMOVE
│ │ │
│ │ v
│ └──y── more blks
│ to remove?
│ │
│ n
│ │
│ v
│ need to
└─────> shrink tree? ─n─┐
│ │
y │
│ │
v │
XFS_DAS_RM_SHRINK│
│ │
v │
done <─────┘
Quoted 2 lines
Signed-off-by Allison Collins <[email protected]>---
All in all this is starting to look much more simple to me, at least in the remove path. ;P There's only a few states and the markers that are introduced are fairly straightforward, etc. Comments to follow..
Quoted 86 lines
fs/xfs/libxfs/xfs_attr.c | 168 ++++++++++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_attr.h | 38 +++++++++++ 2 files changed, 168 insertions(+), 38 deletions(-)fs/xfs/libxfs/xfs_attr.c +49
-3@@ -45,7 +45,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);*/ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);/* @@ -53,12 +53,21 @@ 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_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC void +xfs_delattr_context_init ( +struct xfs_delattr_context *dac, +struct xfs_da_args *args) +{ +memset (dac,0 ,sizeof (struct xfs_delattr_context )); + dac->da_args = args; +} +int xfs_inode_hasattr (struct xfs_inode *ip)@@ -356,20 +365,66 @@ xfs_has_attr(*/ int xfs_attr_remove_args ( -struct xfs_da_args *args) +struct xfs_da_args *args) { +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_remove_iter (&dac); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + }while (true); + +return error; +} + +/* +* Remove the attribute specified in @args. +* +* This function may return -EAGAIN to signal that the transaction needs to be +* rolled. Callers should continue calling this function until they receive a +* return value other than -EAGAIN. +*/ +int +xfs_attr_remove_iter ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args;struct xfs_inode *dp = args->dp;int error;
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 418
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +9
-0+/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RM_SHRINK : +case XFS_DAS_RMTVAL_REMOVE : +return xfs_attr_node_removename (dac); +default : +break ; + } +
Hmm.. so we're duplicating the call instead of using labels..? I'm wondering if this can be elegantly combined with the if/else branches below, particularly since node format is the only situation that seems to require a roll here.
Quoted 32 lines
fs/xfs/libxfs/xfs_attr.c +7
-6if (!xfs_inode_hasattr (dp)) { error = -ENOATTR ; }else if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL ) {ASSERT (dp->i_afp->if_flags &XFS_IFINLINE ); error =xfs_attr_shortform_remove (args); }else if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_removename (args); + error =xfs_attr_leaf_removename (dac); }else { - error =xfs_attr_node_removename (args); + error =xfs_attr_node_removename (dac); }return error;@@ -794,11 +849,12 @@ xfs_attr_leaf_hasname(*/ STATIC intxfs_attr_leaf_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_inode *dp; -struct xfs_buf *bp; -int error, forkoff; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp; +struct xfs_buf *bp; +int error, forkoff;trace_xfs_attr_leaf_removename (args);
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_removename( · line 885
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c +2
-3@@ -825,9 +881,8 @@ xfs_attr_leaf_removename(/* bp is gone due to xfs_da_shrink_inode */ if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ;
There's no -EAGAIN return here, is this an exit path for the remove?
Quoted 23 lines
fs/xfs/libxfs/xfs_attr.c +6
-5}return 0 ; }@@ -1128,12 +1183,13 @@ xfs_attr_node_addname(*/ STATIC intxfs_attr_node_shrink ( -struct xfs_da_args *args, -struct xfs_da_state *state) +struct xfs_delattr_context *dac, +struct xfs_da_state *state) { -struct xfs_inode *dp = args->dp; -int error, forkoff; -struct xfs_buf *bp; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp;/* * Have to get rid of the copy of this dabuf in the state.
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_shrink( · line 1212
Quoted 7 lines
fs/xfs/libxfs/xfs_attr.c +1
-3@@ -1153,9 +1209,7 @@ xfs_attr_node_shrink(if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + dac->flags |=XFS_DAC_DEFER_FINISH ;
Same question here.
Quoted 31 lines
fs/xfs/libxfs/xfs_attr.c +10
-3}else xfs_trans_brelse (args->trans, bp);@@ -1194,13 +1248,15 @@ xfs_attr_leaf_mark_incomplete(/* * Initial setup for xfs_attr_node_removename. Make sure the attr is there and -* the blocks are valid. Any remote blocks will be marked incomplete. +* the blocks are valid. Any remote blocks will be marked incomplete and +* invalidated. */ STATIC int xfs_attr_node_removename_setup( -struct xfs_da_args *args, -struct xfs_da_state **state) +struct xfs_delattr_context *dac, +struct xfs_da_state **state) { +struct xfs_da_args *args = dac->da_args;int error;struct xfs_da_state_blk *blk;@@ -1212,10 +1268,21 @@ int xfs_attr_node_removename_setup(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); +/* +* Store blk and state in the context incase we need to cycle out the +* transaction +*/ + dac->blk = blk;
fs/xfs/libxfs/xfs_attr.c int xfs_attr_node_removename_setup( · line 1285
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +6
-0+ dac->da_state = *state; +if (args->rmtblkno >0 ) { error =xfs_attr_leaf_mark_incomplete (args, *state);if (error)return error; + + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error;
Seems like this moves code, which should probably happen in a separate patch.
Quoted 56 lines
fs/xfs/libxfs/xfs_attr.c +24
-3}return 0 ;@@ -1228,7 +1295,10 @@ xfs_attr_node_removename_rmt ( {int error =0 ; - error =xfs_attr_rmtval_remove (args); +/* +* May return -EAGAIN to request that the caller recall this function +*/ + error =__xfs_attr_rmtval_remove (args);if (error)return error;@@ -1249,19 +1319,37 @@ xfs_attr_node_removename_rmt (* This will involve walking down the Btree, and may involve joining * leaf nodes and even joining intermediate nodes up to and including * the root node (a special case of an intermediate node). +* +* This routine is meant to function as either an inline or delayed operation, +* and may return -EAGAIN when the transaction needs to be rolled. Calling +* functions will need to handle this, and recall the function until a +* successful error code is returned. */ STATIC intxfs_attr_node_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { +struct xfs_da_args *args = dac->da_args;struct xfs_da_state *state;struct xfs_da_state_blk *blk;int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); + state = dac->da_state; + blk = dac->blk; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RMTVAL_REMOVE : + goto das_rmtval_remove; +case XFS_DAS_RM_SHRINK : + goto das_rm_shrink; +default : +break ; + } - error =xfs_attr_node_removename_setup (args, &state); + error =xfs_attr_node_removename_setup (dac, &state);if (error) goto out;
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1363
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +3
-0@@ -1270,10 +1358,16 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ + +das_rmtval_remove: +
I wonder if we need this label just to protect the setup. Perhaps if we had something like:
/* set up the remove only once... */ if (dela_state == 0) error = xfs_attr_node_removename_setup(...);
... we could reduce another state.
We could also accomplish the same thing with an explicit state to indicate the setup already occurred or a new dac flag, though I'm not sure a flag is appropriate if it would only be used here.
Brian
Quoted 102 lines
fs/xfs/libxfs/xfs_attr.c +13
-12if (args->rmtblkno >0 ) { error =xfs_attr_node_removename_rmt (args, state); -if (error) - goto out; +if (error) { +if (error == -EAGAIN ) + dac->dela_state =XFS_DAS_RMTVAL_REMOVE ; +return error; + } }/* @@ -1291,22 +1385,20 @@ xfs_attr_node_removename( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; -/* -* Commit the Btree join operation and start a new trans. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_RM_SHRINK ; +return -EAGAIN ; } +das_rm_shrink: + dac->dela_state =XFS_DAS_RM_SHRINK ; +/* * If the result is small enough, push it all into the inode. */ if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) - error =xfs_attr_node_shrink (args, state); + error =xfs_attr_node_shrink (dac, state); error =0 ; out:fs/xfs/libxfs/xfs_attr.h +38
-0@@ -74,6 +74,43 @@ struct xfs_attr_list_context { }; +/* +* ======================================================================== +* Structure used to pass context around among the delayed routines. +* ======================================================================== +*/ + +/* +* Enum values for xfs_delattr_context.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 +* calling function to roll the transaction, and then recall the subroutine to +* finish the operation. The enum is then used by the subroutine to jump back +* to where it was and resume executing where it left off. +*/ +enum xfs_delattr_state { +/* Zero is uninitalized */ +XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ +XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +}; + +/* +* Defines for xfs_delattr_context.flags +*/ +#define XFS_DAC_DEFER_FINISH 0x1/* indicates to finish the transaction */ + +/* +* Context used for keeping track of delayed attribute operations +*/ +struct xfs_delattr_context { +struct xfs_da_args *da_args; +struct xfs_da_state *da_state; +struct xfs_da_state_blk *blk; +unsigned int flags; +enum xfs_delattr_state dela_state; +}; +/*======================================================================== * Function prototypes for the kernel. *========================================================================*/ @@ -91,6 +128,7 @@ int xfs_attr_set(struct xfs_da_args *args);int xfs_attr_set_args (struct xfs_da_args *args);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args); +int xfs_attr_remove_iter (struct xfs_delattr_context *dac);bool xfs_attr_namecheck (const void *name,size_t length);#endif /* __XFS_ATTR_H__ */ Signature · 1 line
2.7.4
Re: [PATCH v8 18/20] xfs: Add delay ready attr remove routines
Quoted 163 lines · Brian Foster
Quoted 68 lines · Allison Collins
This patch modifies the attr remove routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_remove_argshas becomexfs_attr_remove_iter, which uses a sort of state machine like switch to keep track of where it was when EAGAIN was returned.xfs_attr_node_removenamehas also been modified to use the switch, and a new version ofxfs_attr_remove_argsconsists of a simple loop to refresh the transaction until the operation is completed.Calls to
xfs_attr_rmtval_removeare replaced with the delay ready counter parts:xfs_attr_rmtval_invalidate(appearing in the setup helper) and then__xfs_attr_rmtval_remove. We will rename__xfs_attr_rmtval_removeback toxfs_attr_rmtval_removewhen we are done.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 newxfs_delattr_stateenum 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.Below is a state machine diagram for attr remove operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_remove_iter()XFS_DAS_RM_SHRINK ─┐ (subroutine state) │ │ XFS_DAS_RMTVAL_REMOVE ─┤ (subroutine state) │ └─>xfs_attr_node_removename() │v
need to remove
┌─n── rmt blocks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_RMTVAL_REMOVE
│ │ │
│ │ v
│ └──y── more blks
│ to remove?
│ │
│ n
│ │
│ v
│ need to
└─────> shrink tree? ─n─┐
│ │
y │
│ │
v │
XFS_DAS_RM_SHRINK│
│ │
v │
done <─────┘Quoted 2 lines
Signed-off-by Allison Collins <[email protected]>---
All in all this is starting to look much more simple to me, at least in the remove path. ;P There's only a few states and the markers that are introduced are fairly straightforward, etc. Comments to follow..
Quoted 87 lines
fs/xfs/libxfs/xfs_attr.c | 168 ++++++++++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_attr.h | 38 +++++++++++ 2 files changed, 168 insertions(+), 38 deletions(-)fs/xfs/libxfs/xfs_attr.c +49
-3@@ -45,7 +45,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);*/ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);/* @@ -53,12 +53,21 @@ 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_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC void +xfs_delattr_context_init ( +struct xfs_delattr_context *dac, +struct xfs_da_args *args) +{ +memset (dac,0 ,sizeof (struct xfs_delattr_context )); + dac->da_args = args; +} +int xfs_inode_hasattr (struct xfs_inode *ip)@@ -356,20 +365,66 @@ xfs_has_attr(*/ int xfs_attr_remove_args ( -struct xfs_da_args *args) +struct xfs_da_args *args) { +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_remove_iter (&dac); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + }while (true); + +return error; +} + +/* +* Remove the attribute specified in @args. +* +* This function may return -EAGAIN to signal that the transaction needs to be +* rolled. Callers should continue calling this function until they receive a +* return value other than -EAGAIN. +*/ +int +xfs_attr_remove_iter ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args;struct xfs_inode *dp = args->dp;int error;
Quoted 11 lines
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 418
Quoted 9 lines
fs/xfs/libxfs/xfs_attr.c +9
-0+/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RM_SHRINK : +case XFS_DAS_RMTVAL_REMOVE : +return xfs_attr_node_removename (dac); +default : +break ; + } +Hmm.. so we're duplicating the call instead of using labels..?
Yes, this was a suggestion made during v7. I suspect Dave may have been wanting to simplify things by escaping the use of labels. At least in so far as the remove path is concerned. Though he may not have realized this would create a duplication call? I will cc him here; the conditions for calling xfs_attr_node_removename are: the below if/else sequence exhausts with no successes, and defaults into the else case (ie: the entry condition), OR one of the above states is set (which is a re-entry condition)
I'm
Quoted 17 lines
wondering if this can be elegantly combined with the if/else branches below, particularly since node format is the only situation that seems to require a roll here.
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c +2
-2if (!xfs_inode_hasattr (dp)) { error = -ENOATTR ; }else if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL ) {ASSERT (dp->i_afp->if_flags &XFS_IFINLINE ); error =xfs_attr_shortform_remove (args); }else if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_removename (args); + error =xfs_attr_leaf_removename (dac); }else { - error =xfs_attr_node_removename (args); + error =xfs_attr_node_removename (dac); }
Quoted 1 line
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 430
Quoted 1 line
fs/xfs/libxfs/xfs_attr.c +0
-0return error;
If we want to try and combine this into if/elses with no duplication, I believe the simplest arrangement would look something like this:
int
xfs_attr_remove_iter(
struct xfs_delattr_context *dac)
{
struct xfs_da_args *args = dac->da_args;
struct xfs_inode *dp = args->dp;
if (dac->dela_state != XFS_DAS_RM_SHRINK &&
dac->dela_state != XFS_DAS_RMTVAL_REMOVE) {
if (!xfs_inode_hasattr(dp)) {
return -ENOATTR;
} else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) {
ASSERT(dp->i_afp->if_flags & XFS_IFINLINE);
return xfs_attr_shortform_remove(args);
} else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) {
return xfs_attr_leaf_removename(dac);
}
}
return xfs_attr_node_removename(dac);
}Let me know what folks think of that. I'm not always clear on where people stand with aesthetics. (IE, is it better to have a duplicate call if it gets rid of a label? Is the solution with the least amount of LOC always preferable?) This area seems simple enough maybe we can get it ironed out here with out another version.
IMHO I think the above code sort of obfuscates that the code flow is really just one if/else switch with one function that has the statemachine behavior. But its not bad either if that's what people prefer. I'd like to find something every can be sort of happy with. :-)
Quoted 17 lines
Quoted 17 lines
fs/xfs/libxfs/xfs_attr.c +5
-4@@ -794,11 +849,12 @@ xfs_attr_leaf_hasname(*/ STATIC intxfs_attr_leaf_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_inode *dp; -struct xfs_buf *bp; -int error, forkoff; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp; +struct xfs_buf *bp; +int error, forkoff;trace_xfs_attr_leaf_removename (args);
Quoted 11 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_removename( · line 885
Quoted 9 lines
fs/xfs/libxfs/xfs_attr.c +2
-3@@ -825,9 +881,8 @@ xfs_attr_leaf_removename(/* bp is gone due to xfs_da_shrink_inode */ if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ;There's no
-EAGAINreturn here, is this an exit path for the remove?
I think so, maybe I can remove this and the other one you pointed out in patch 12 along with the other unneeded transaction handling.
Quoted 70 lines
Quoted 24 lines
fs/xfs/libxfs/xfs_attr.c +6
-5}return 0 ; }@@ -1128,12 +1183,13 @@ xfs_attr_node_addname(*/ STATIC intxfs_attr_node_shrink ( -struct xfs_da_args *args, -struct xfs_da_state *state) +struct xfs_delattr_context *dac, +struct xfs_da_state *state) { -struct xfs_inode *dp = args->dp; -int error, forkoff; -struct xfs_buf *bp; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp;/* * Have to get rid of the copy of this dabuf in the state. fs/xfs/libxfs/xfs_attr.c xfs_attr_node_shrink( · line 1212
Quoted 7 lines
fs/xfs/libxfs/xfs_attr.c +1
-3@@ -1153,9 +1209,7 @@ xfs_attr_node_shrink(if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + dac->flags |=XFS_DAC_DEFER_FINISH ;Same question here.
Quoted 36 lines
fs/xfs/libxfs/xfs_attr.c +12
-3}else xfs_trans_brelse (args->trans, bp);@@ -1194,13 +1248,15 @@ xfs_attr_leaf_mark_incomplete(/* * Initial setup for xfs_attr_node_removename. Make sure the attr is there and -* the blocks are valid. Any remote blocks will be marked incomplete. +* the blocks are valid. Any remote blocks will be marked incomplete and +* invalidated. */ STATIC int xfs_attr_node_removename_setup( -struct xfs_da_args *args, -struct xfs_da_state **state) +struct xfs_delattr_context *dac, +struct xfs_da_state **state) { +struct xfs_da_args *args = dac->da_args;int error;struct xfs_da_state_blk *blk;@@ -1212,10 +1268,21 @@ int xfs_attr_node_removename_setup(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); +/* +* Store blk and state in the context incase we need to cycle out the +* transaction +*/ + dac->blk = blk; + dac->da_state = *state; +if (args->rmtblkno >0 ) { error =xfs_attr_leaf_mark_incomplete (args, *state);if (error)
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c int xfs_attr_node_removename_setup( · line 1285
Quoted 5 lines
fs/xfs/libxfs/xfs_attr.c +4
-0return error; + + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error;Seems like this moves code, which should probably happen in a separate patch.
Ok, this pairs with the xfs_attr_rmtval_remove to __xfs_attr_rmtval_remove below. Basically xfs_attr_rmtval_remove is the combination of xfs_attr_rmtval_invalidate and __xfs_attr_rmtval_remove. So thats why we see xfs_attr_rmtval_remove going away and xfs_attr_rmtval_invalidate + __xfs_attr_rmtval_remove coming in.
How about a patch that pulls xfs_attr_rmtval_invalidate out of xfs_attr_rmtval_remove and into the calling functions? I think that might be more clear.
Quoted 71 lines
Quoted 57 lines
fs/xfs/libxfs/xfs_attr.c +24
-3}return 0 ;@@ -1228,7 +1295,10 @@ xfs_attr_node_removename_rmt ( {int error =0 ; - error =xfs_attr_rmtval_remove (args); +/* +* May return -EAGAIN to request that the caller recall this function +*/ + error =__xfs_attr_rmtval_remove (args);if (error)return error;@@ -1249,19 +1319,37 @@ xfs_attr_node_removename_rmt (* This will involve walking down the Btree, and may involve joining * leaf nodes and even joining intermediate nodes up to and including * the root node (a special case of an intermediate node). +* +* This routine is meant to function as either an inline or delayed operation, +* and may return -EAGAIN when the transaction needs to be rolled. Calling +* functions will need to handle this, and recall the function until a +* successful error code is returned. */ STATIC intxfs_attr_node_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { +struct xfs_da_args *args = dac->da_args;struct xfs_da_state *state;struct xfs_da_state_blk *blk;int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); + state = dac->da_state; + blk = dac->blk; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RMTVAL_REMOVE : + goto das_rmtval_remove; +case XFS_DAS_RM_SHRINK : + goto das_rm_shrink; +default : +break ; + } - error =xfs_attr_node_removename_setup (args, &state); + error =xfs_attr_node_removename_setup (dac, &state);if (error) goto out;fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1363
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +3
-0@@ -1270,10 +1358,16 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ + +das_rmtval_remove: +I wonder if we need this label just to protect the setup. Perhaps if we had something like:
/* set up the remove only once... */ if (dela_state == 0) error = xfs_attr_node_removename_setup(...);
Quoted 7 lines
... we could reduce another state.
We could also accomplish the same thing with an explicit state to indicate the setup already occurred or a new dac flag, though I'm not sure a flag is appropriate if it would only be used here.
Brian
Mmmm, dela_state == 0 will conflict a bit when we get into fully delayed attrs. Basically when this is getting called from the delayed operations path, it sets dela_state to a new XFS_DAS_INIT. Because we have to set up args mid fight, we need the extra state to not do that twice.
But even without getting into that right away, what you're proposing only gets rid of the label. It doesnt get rid of the state. We still have to set the state to not be zero (or what ever the initial value is). So we still need the unique value of XFS_DAS_RMTVAL_REMOVE
Really what you would need here in order to do what you are describeing is dela_state != XFS_DAS_RMTVAL_REMOVE. If I assume to simplify away to the lease amount of LOC we get this:
STATIC int
xfs_attr_node_removename(
struct xfs_delattr_context *dac)
{
struct xfs_da_args *args = dac->da_args;
struct xfs_da_state *state;
struct xfs_da_state_blk *blk;
int retval, error;
struct xfs_inode *dp = args->dp;
trace_xfs_attr_node_removename(args);
state = dac->da_state;
blk = dac->blk;
if (dac->dela_state == XFS_DAS_RM_SHRINK) {
goto das_rm_shrink;
} else if (dac->dela_state != XFS_DAS_RMTVAL_REMOVE) {
error = xfs_attr_node_removename_setup(dac, &state);
if (error)
goto out;
}
/*
* If there is an out-of-line value, de-allocate the blocks.
* This is done before we remove 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_node_removename_rmt(args, state);
if (error) {
if (error == -EAGAIN)
dac->dela_state = XFS_DAS_RMTVAL_REMOVE;
return error;
}
}.....
Let me know what folks think of this. Again, I think I like the switches and the labels just because it makes it more clear where the jump points are, even if its more LOC. But again, this isnt bad either if this is more preferable to folks. If there's another arrangment that is preferable, let me know, it's not difficult to run it through the test cases to make sure it's functional. It may be a faster way to hash out what people want to see.
Thank you again for all the reviewing!!!
Allison
Quoted 104 lines
Quoted 103 lines
fs/xfs/libxfs/xfs_attr.c +13
-12if (args->rmtblkno >0 ) { error =xfs_attr_node_removename_rmt (args, state); -if (error) - goto out; +if (error) { +if (error == -EAGAIN ) + dac->dela_state =XFS_DAS_RMTVAL_REMOVE ; +return error; + } }/* @@ -1291,22 +1385,20 @@ xfs_attr_node_removename( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; -/* -* Commit the Btree join operation and start a new trans. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_RM_SHRINK ; +return -EAGAIN ; } +das_rm_shrink: + dac->dela_state =XFS_DAS_RM_SHRINK ; +/* * If the result is small enough, push it all into the inode. */ if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) - error =xfs_attr_node_shrink (args, state); + error =xfs_attr_node_shrink (dac, state); error =0 ; out:fs/xfs/libxfs/xfs_attr.h +38
-0@@ -74,6 +74,43 @@ struct xfs_attr_list_context { }; +/* +* ======================================================================== +* Structure used to pass context around among the delayed routines. +* ======================================================================== +*/ + +/* +* Enum values for xfs_delattr_context.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 +* calling function to roll the transaction, and then recall the subroutine to +* finish the operation. The enum is then used by the subroutine to jump back +* to where it was and resume executing where it left off. +*/ +enum xfs_delattr_state { +/* Zero is uninitalized */ +XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ +XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +}; + +/* +* Defines for xfs_delattr_context.flags +*/ +#define XFS_DAC_DEFER_FINISH 0x1/* indicates to finish the transaction */ + +/* +* Context used for keeping track of delayed attribute operations +*/ +struct xfs_delattr_context { +struct xfs_da_args *da_args; +struct xfs_da_state *da_state; +struct xfs_da_state_blk *blk; +unsigned int flags; +enum xfs_delattr_state dela_state; +}; +/*======================================================================== * Function prototypes for the kernel. *========================================================================*/ @@ -91,6 +128,7 @@ int xfs_attr_set(struct xfs_da_args *args);int xfs_attr_set_args (struct xfs_da_args *args);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args); +int xfs_attr_remove_iter (struct xfs_delattr_context *dac);bool xfs_attr_namecheck (const void *name,size_t length);#endif /* __XFS_ATTR_H__ */ Signature · 1 line
2.7.4
Re: [PATCH v8 18/20] xfs: Add delay ready attr remove routines
Quoted 175 lines · Allison Collins
Quoted 163 lines · Brian Foster
Quoted 68 lines · Allison Collins
This patch modifies the attr remove routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_remove_argshas becomexfs_attr_remove_iter, which uses a sort of state machine like switch to keep track of where it was when EAGAIN was returned.xfs_attr_node_removenamehas also been modified to use the switch, and a new version ofxfs_attr_remove_argsconsists of a simple loop to refresh the transaction until the operation is completed.Calls to
xfs_attr_rmtval_removeare replaced with the delay ready counter parts:xfs_attr_rmtval_invalidate(appearing in the setup helper) and then__xfs_attr_rmtval_remove. We will rename__xfs_attr_rmtval_removeback toxfs_attr_rmtval_removewhen we are done.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 newxfs_delattr_stateenum 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.Below is a state machine diagram for attr remove operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_remove_iter()XFS_DAS_RM_SHRINK ─┐ (subroutine state) │ │ XFS_DAS_RMTVAL_REMOVE ─┤ (subroutine state) │ └─>xfs_attr_node_removename() │v
need to remove
┌─n── rmt blocks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_RMTVAL_REMOVE
│ │ │
│ │ v
│ └──y── more blks
│ to remove?
│ │
│ n
│ │
│ v
│ need to
└─────> shrink tree? ─n─┐
│ │
y │
│ │
v │
XFS_DAS_RM_SHRINK│
│ │
v │
done <─────┘Quoted 2 lines
Signed-off-by Allison Collins <[email protected]>---
All in all this is starting to look much more simple to me, at least in the remove path. ;P There's only a few states and the markers that are introduced are fairly straightforward, etc. Comments to follow..
Quoted 87 lines
fs/xfs/libxfs/xfs_attr.c | 168 ++++++++++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_attr.h | 38 +++++++++++ 2 files changed, 168 insertions(+), 38 deletions(-)fs/xfs/libxfs/xfs_attr.c +52
-3@@ -45,7 +45,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);*/ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);/* @@ -53,12 +53,21 @@ 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_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC void +xfs_delattr_context_init ( +struct xfs_delattr_context *dac, +struct xfs_da_args *args) +{ +memset (dac,0 ,sizeof (struct xfs_delattr_context )); + dac->da_args = args; +} +int xfs_inode_hasattr (struct xfs_inode *ip)@@ -356,20 +365,66 @@ xfs_has_attr(*/ int xfs_attr_remove_args ( -struct xfs_da_args *args) +struct xfs_da_args *args) { +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_remove_iter (&dac); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + }while (true); + +return error; +} + +/* +* Remove the attribute specified in @args. +* +* This function may return -EAGAIN to signal that the transaction needs to be +* rolled. Callers should continue calling this function until they receive a +* return value other than -EAGAIN. +*/ +int +xfs_attr_remove_iter ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args;struct xfs_inode *dp = args->dp;int error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RM_SHRINK :Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 418
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +6
-0+case XFS_DAS_RMTVAL_REMOVE : +return xfs_attr_node_removename (dac); +default : +break ; + } +Hmm.. so we're duplicating the call instead of using labels..?
Quoted 9 lines
Yes, this was a suggestion made during v7. I suspect Dave may have been wanting to simplify things by escaping the use of labels. At least in so far as the remove path is concerned. Though he may not have realized this would create a duplication call? I will cc him here; the conditions for calling
xfs_attr_node_removenameare: the below if/else sequence exhausts with no successes, and defaults into the else case (ie: the entry condition), OR one of the above states is set (which is a re-entry condition)
Ok.
Quoted 52 lines
I'm
Quoted 4 lines
wondering if this can be elegantly combined with the if/else branches below, particularly since node format is the only situation that seems to require a roll here.
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 430
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c +2
-2if (!xfs_inode_hasattr (dp)) { error = -ENOATTR ; }else if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL ) {ASSERT (dp->i_afp->if_flags &XFS_IFINLINE ); error =xfs_attr_shortform_remove (args); }else if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_removename (args); + error =xfs_attr_leaf_removename (dac); }else { - error =xfs_attr_node_removename (args); + error =xfs_attr_node_removename (dac); }return error;If we want to try and combine this into if/elses with no duplication, I believe the simplest arrangement would look something like this:
int
xfs_attr_remove_iter(
structxfs_delattr_context*dac){ struct xfs_da_args *args = dac->da_args; struct xfs_inode *dp = args->dp; if (dac->dela_state != XFS_DAS_RM_SHRINK && dac->dela_state != XFS_DAS_RMTVAL_REMOVE) { if (!xfs_inode_hasattr(dp)) { return -ENOATTR; } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) { ASSERT(dp->i_afp->if_flags & XFS_IFINLINE); return xfs_attr_shortform_remove(args); } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) { return xfs_attr_leaf_removename(dac); } } return xfs_attr_node_removename(dac); }Let me know what folks think of that. I'm not always clear on where people stand with aesthetics. (IE, is it better to have a duplicate call if it gets rid of a label? Is the solution with the least amount of LOC always preferable?) This area seems simple enough maybe we can get it ironed out here with out another version.
Quoted 5 lines
IMHO I think the above code sort of obfuscates that the code flow is really just one if/else switch with one function that has the statemachine behavior. But its not bad either if that's what people prefer. I'd like to find something every can be sort of happy with. :-)
If you want my .02, some combination of the above is cleanest from an aesthetic pov:
{
...
if (RM_SHRINK || RMTVAL_REMOVE)
goto node;
if (!hasattr)
return -ENOATTR;
else if (local)
return shortform_remove();
else if (oneblock)
return leaf_removename();node:
return node_removename(); }
I find that easiest to read at a glance, but I don't feel terribly strongly about it I guess.
Quoted 107 lines
Quoted 18 lines
Quoted 18 lines
fs/xfs/libxfs/xfs_attr.c +5
-4@@ -794,11 +849,12 @@ xfs_attr_leaf_hasname(*/ STATIC intxfs_attr_leaf_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_inode *dp; -struct xfs_buf *bp; -int error, forkoff; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp; +struct xfs_buf *bp; +int error, forkoff;trace_xfs_attr_leaf_removename (args);@@ -825,9 +881,8 @@ xfs_attr_leaf_removename(/* bp is gone due to xfs_da_shrink_inode */ if (error)Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_removename( · line 885
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +2
-3return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ;There's no
-EAGAINreturn here, is this an exit path for the remove?I think so, maybe I can remove this and the other one you pointed out in patch 12 along with the other unneeded transaction handling.
Quoted 64 lines
Quoted 23 lines
fs/xfs/libxfs/xfs_attr.c +6
-5}return 0 ; }@@ -1128,12 +1183,13 @@ xfs_attr_node_addname(*/ STATIC intxfs_attr_node_shrink ( -struct xfs_da_args *args, -struct xfs_da_state *state) +struct xfs_delattr_context *dac, +struct xfs_da_state *state) { -struct xfs_inode *dp = args->dp; -int error, forkoff; -struct xfs_buf *bp; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp;/* * Have to get rid of the copy of this dabuf in the state. fs/xfs/libxfs/xfs_attr.c xfs_attr_node_shrink( · line 1211
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +1
-3@@ -1153,9 +1209,7 @@ xfs_attr_node_shrink(if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + dac->flags |=XFS_DAC_DEFER_FINISH ;Same question here.
Quoted 32 lines
fs/xfs/libxfs/xfs_attr.c +12
-3}else xfs_trans_brelse (args->trans, bp);@@ -1194,13 +1248,15 @@ xfs_attr_leaf_mark_incomplete(/* * Initial setup for xfs_attr_node_removename. Make sure the attr is there and -* the blocks are valid. Any remote blocks will be marked incomplete. +* the blocks are valid. Any remote blocks will be marked incomplete and +* invalidated. */ STATIC int xfs_attr_node_removename_setup( -struct xfs_da_args *args, -struct xfs_da_state **state) +struct xfs_delattr_context *dac, +struct xfs_da_state **state) { +struct xfs_da_args *args = dac->da_args;int error;struct xfs_da_state_blk *blk;@@ -1212,10 +1268,21 @@ int xfs_attr_node_removename_setup(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); +/* +* Store blk and state in the context incase we need to cycle out the +* transaction +*/ + dac->blk = blk; + dac->da_state = *state; +if (args->rmtblkno >0 ) { error =xfs_attr_leaf_mark_incomplete (args, *state);if (error)Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c int xfs_attr_node_removename_setup( · line 1285
Quoted 5 lines
fs/xfs/libxfs/xfs_attr.c +4
-0return error; + + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error;Seems like this moves code, which should probably happen in a separate patch.
Ok, this pairs with the
xfs_attr_rmtval_removeto__xfs_attr_rmtval_removebelow. Basicallyxfs_attr_rmtval_removeis the combination ofxfs_attr_rmtval_invalidateand__xfs_attr_rmtval_remove. So thats why we seexfs_attr_rmtval_removegoing away andxfs_attr_rmtval_invalidate+__xfs_attr_rmtval_removecoming in.
Quoted 4 lines
How about a patch that pulls
xfs_attr_rmtval_invalidateout ofxfs_attr_rmtval_removeand into the calling functions? I think that might be more clear.
Yes, separate patch please. I think that if the earlier refactoring parts of the series are split out properly (i.e., no dependencies on subsequent patches) and reviewed, perhaps we can start getting some of those patches merged while the latter bits are worked out.
Quoted 71 lines
Quoted 71 lines
Quoted 51 lines
fs/xfs/libxfs/xfs_attr.c +24
-3}return 0 ;@@ -1228,7 +1295,10 @@ xfs_attr_node_removename_rmt ( {int error =0 ; - error =xfs_attr_rmtval_remove (args); +/* +* May return -EAGAIN to request that the caller recall this function +*/ + error =__xfs_attr_rmtval_remove (args);if (error)return error;@@ -1249,19 +1319,37 @@ xfs_attr_node_removename_rmt (* This will involve walking down the Btree, and may involve joining * leaf nodes and even joining intermediate nodes up to and including * the root node (a special case of an intermediate node). +* +* This routine is meant to function as either an inline or delayed operation, +* and may return -EAGAIN when the transaction needs to be rolled. Calling +* functions will need to handle this, and recall the function until a +* successful error code is returned. */ STATIC intxfs_attr_node_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { +struct xfs_da_args *args = dac->da_args;struct xfs_da_state *state;struct xfs_da_state_blk *blk;int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); + state = dac->da_state; + blk = dac->blk; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RMTVAL_REMOVE : + goto das_rmtval_remove; +case XFS_DAS_RM_SHRINK : + goto das_rm_shrink; +default : +break ; + } - error =xfs_attr_node_removename_setup (args, &state); + error =xfs_attr_node_removename_setup (dac, &state);if (error) goto out;fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1363
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +3
-0@@ -1270,10 +1358,16 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ + +das_rmtval_remove: +I wonder if we need this label just to protect the setup. Perhaps if we had something like:
/* set up the remove only once... */ if (dela_state == 0) error = xfs_attr_node_removename_setup(...);... we could reduce another state.
We could also accomplish the same thing with an explicit state to indicate the setup already occurred or a new dac flag, though I'm not sure a flag is appropriate if it would only be used here.
Quoted 7 lines
Quoted 1 line
Brian
Mmmm,
dela_state== 0 will conflict a bit when we get into fully delayed attrs. Basically when this is getting called from the delayed operations path, it setsdela_stateto a newXFS_DAS_INIT. Because we have to set up args mid fight, we need the extra state to not do that twice.
Can we address that when the conflict is introduced?
Quoted 5 lines
But even without getting into that right away, what you're proposing only gets rid of the label. It doesnt get rid of the state. We still have to set the state to not be zero (or what ever the initial value is). So we still need the unique value of
XFS_DAS_RMTVAL_REMOVE
Yeah, I was partly thinking of the setup call being tied to a flag rather than a state. That way the logic is something like the typical:
if (!setup) do_setup(); ...
... and it's one less bit of code tied into the state machine. All in all, it's more that having a label right at the top of a function like that kind of looks like it's asking for some form of simplification.
Quoted 45 lines
Really what you would need here in order to do what you are describeing is
dela_state!=XFS_DAS_RMTVAL_REMOVE. If I assume to simplify away to the lease amount of LOC we get this:STATIC int
xfs_attr_node_removename(
structxfs_delattr_context*dac){ struct xfs_da_args *args = dac->da_args; struct xfs_da_state *state; struct xfs_da_state_blk *blk; int retval, error; struct xfs_inode *dp = args->dp; trace_xfs_attr_node_removename(args); state = dac->da_state; blk = dac->blk; if (dac->dela_state == XFS_DAS_RM_SHRINK) { goto das_rm_shrink; } else if (dac->dela_state != XFS_DAS_RMTVAL_REMOVE) { error = xfs_attr_node_removename_setup(dac, &state); if (error) goto out; } /* * If there is an out-of-line value, de-allocate the blocks. * This is done before we remove 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_node_removename_rmt(args, state); if (error) { if (error == -EAGAIN) dac->dela_state = XFS_DAS_RMTVAL_REMOVE; return error; } }.....
Quoted 8 lines
Let me know what folks think of this. Again, I think I like the switches and the labels just because it makes it more clear where the jump points are, even if its more LOC. But again, this isnt bad either if this is more preferable to folks. If there's another arrangment that is preferable, let me know, it's not difficult to run it through the test cases to make sure it's functional. It may be a faster way to hash out what people want to see.
I prefer to see the state management stuff as boilerplate as possible. The above pattern of creating separate reentry calls to the same functions is not nearly as clear to me, particularly in this instance where we have multiple branches of reentry logic (as opposed to the earlier example of only one).
IOW, I agree that the jumps are preferable and more intuitive. I'm just trying to be reductive by considering what could be factored out vs. trying to fundamentally rework the approach or aggressively reduce LOC or anything like that. IMO, simplicity of the code is usually top priority.
Brian
Quoted 103 lines
Thank you again for all the reviewing!!!
Allison
Quoted 98 lines
Quoted 97 lines
if (args->rmtblkno > 0) { error = xfs_attr_node_removename_rmt(args, state);fs/xfs/libxfs/xfs_attr.c +13
-12-if (error) - goto out; +if (error) { +if (error == -EAGAIN ) + dac->dela_state =XFS_DAS_RMTVAL_REMOVE ; +return error; + } }/* @@ -1291,22 +1385,20 @@ xfs_attr_node_removename( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; -/* -* Commit the Btree join operation and start a new trans. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_RM_SHRINK ; +return -EAGAIN ; } +das_rm_shrink: + dac->dela_state =XFS_DAS_RM_SHRINK ; +/* * If the result is small enough, push it all into the inode. */ if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) - error =xfs_attr_node_shrink (args, state); + error =xfs_attr_node_shrink (dac, state); error =0 ; out:fs/xfs/libxfs/xfs_attr.h +38
-0@@ -74,6 +74,43 @@ struct xfs_attr_list_context { }; +/* +* ======================================================================== +* Structure used to pass context around among the delayed routines. +* ======================================================================== +*/ + +/* +* Enum values for xfs_delattr_context.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 +* calling function to roll the transaction, and then recall the subroutine to +* finish the operation. The enum is then used by the subroutine to jump back +* to where it was and resume executing where it left off. +*/ +enum xfs_delattr_state { +/* Zero is uninitalized */ +XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ +XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +}; + +/* +* Defines for xfs_delattr_context.flags +*/ +#define XFS_DAC_DEFER_FINISH 0x1/* indicates to finish the transaction */ + +/* +* Context used for keeping track of delayed attribute operations +*/ +struct xfs_delattr_context { +struct xfs_da_args *da_args; +struct xfs_da_state *da_state; +struct xfs_da_state_blk *blk; +unsigned int flags; +enum xfs_delattr_state dela_state; +}; +/*======================================================================== * Function prototypes for the kernel. *========================================================================*/ @@ -91,6 +128,7 @@ int xfs_attr_set(struct xfs_da_args *args);int xfs_attr_set_args (struct xfs_da_args *args);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args); +int xfs_attr_remove_iter (struct xfs_delattr_context *dac);bool xfs_attr_namecheck (const void *name,size_t length);#endif /* __XFS_ATTR_H__ */ Signature · 1 line
2.7.4
Re: [PATCH v8 18/20] xfs: Add delay ready attr remove routines
Quoted 261 lines · Brian Foster
Quoted 175 lines · Allison Collins
Quoted 163 lines · Brian Foster
Quoted 68 lines · Allison Collins
This patch modifies the attr remove routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_remove_argshas becomexfs_attr_remove_iter, which uses a sort of state machine like switch to keep track of where it was when EAGAIN was returned.xfs_attr_node_removenamehas also been modified to use the switch, and a new version ofxfs_attr_remove_argsconsists of a simple loop to refresh the transaction until the operation is completed.Calls to
xfs_attr_rmtval_removeare replaced with the delay ready counter parts:xfs_attr_rmtval_invalidate(appearing in the setup helper) and then__xfs_attr_rmtval_remove. We will rename__xfs_attr_rmtval_removeback toxfs_attr_rmtval_removewhen we are done.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 newxfs_delattr_stateenum 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.Below is a state machine diagram for attr remove operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_remove_iter()XFS_DAS_RM_SHRINK ─┐ (subroutine state) │ │ XFS_DAS_RMTVAL_REMOVE ─┤ (subroutine state) │ └─>xfs_attr_node_removename() │v
need to remove
┌─n── rmt blocks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_RMTVAL_REMOVE
│ │ │
│ │ v
│ └──y── more blks
│ to remove?
│ │
│ n
│ │
│ v
│ need to
└─────> shrink tree? ─n─┐
│ │
y │
│ │
v │
XFS_DAS_RM_SHRINK│
│ │
v │
done <─────┘Quoted 2 lines
Signed-off-by Allison Collins <[email protected]>---
All in all this is starting to look much more simple to me, at least in the remove path. ;P There's only a few states and the markers that are introduced are fairly straightforward, etc. Comments to follow..
Quoted 87 lines
fs/xfs/libxfs/xfs_attr.c | 168 ++++++++++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_attr.h | 38 +++++++++++ 2 files changed, 168 insertions(+), 38 deletions(-)fs/xfs/libxfs/xfs_attr.c +52
-3@@ -45,7 +45,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);*/ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);/* @@ -53,12 +53,21 @@ 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_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC void +xfs_delattr_context_init ( +struct xfs_delattr_context *dac, +struct xfs_da_args *args) +{ +memset (dac,0 ,sizeof (struct xfs_delattr_context )); + dac->da_args = args; +} +int xfs_inode_hasattr (struct xfs_inode *ip)@@ -356,20 +365,66 @@ xfs_has_attr(*/ int xfs_attr_remove_args ( -struct xfs_da_args *args) +struct xfs_da_args *args) { +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_remove_iter (&dac); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + }while (true); + +return error; +} + +/* +* Remove the attribute specified in @args. +* +* This function may return -EAGAIN to signal that the transaction needs to be +* rolled. Callers should continue calling this function until they receive a +* return value other than -EAGAIN. +*/ +int +xfs_attr_remove_iter ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args;struct xfs_inode *dp = args->dp;int error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RM_SHRINK :Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 418
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +6
-0+case XFS_DAS_RMTVAL_REMOVE : +return xfs_attr_node_removename (dac); +default : +break ; + } +Hmm.. so we're duplicating the call instead of using labels..?
Quoted 9 lines
Yes, this was a suggestion made during v7. I suspect Dave may have been wanting to simplify things by escaping the use of labels. At least in so far as the remove path is concerned. Though he may not have realized this would create a duplication call? I will cc him here; the conditions for calling
xfs_attr_node_removenameare: the below if/else sequence exhausts with no successes, and defaults into the else case (ie: the entry condition), OR one of the above states is set (which is a re-entry condition)Ok.
Quoted 52 lines
I'm
Quoted 4 lines
wondering if this can be elegantly combined with the if/else branches below, particularly since node format is the only situation that seems to require a roll here.
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 430
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c +2
-2if (!xfs_inode_hasattr (dp)) { error = -ENOATTR ; }else if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL ) {ASSERT (dp->i_afp->if_flags &XFS_IFINLINE ); error =xfs_attr_shortform_remove (args); }else if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_removename (args); + error =xfs_attr_leaf_removename (dac); }else { - error =xfs_attr_node_removename (args); + error =xfs_attr_node_removename (dac); }return error;If we want to try and combine this into if/elses with no duplication, I believe the simplest arrangement would look something like this:
int
xfs_attr_remove_iter(
structxfs_delattr_context*dac){ struct xfs_da_args *args = dac->da_args; struct xfs_inode *dp = args->dp; if (dac->dela_state != XFS_DAS_RM_SHRINK && dac->dela_state != XFS_DAS_RMTVAL_REMOVE) { if (!xfs_inode_hasattr(dp)) { return -ENOATTR; } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) { ASSERT(dp->i_afp->if_flags & XFS_IFINLINE); return xfs_attr_shortform_remove(args); } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) { return xfs_attr_leaf_removename(dac); } } return xfs_attr_node_removename(dac); }Let me know what folks think of that. I'm not always clear on where people stand with aesthetics. (IE, is it better to have a duplicate call if it gets rid of a label? Is the solution with the least amount of LOC always preferable?) This area seems simple enough maybe we can get it ironed out here with out another version.
Quoted 5 lines
IMHO I think the above code sort of obfuscates that the code flow is really just one if/else switch with one function that has the statemachine behavior. But its not bad either if that's what people prefer. I'd like to find something every can be sort of happy with. :-)
If you want my .02, some combination of the above is cleanest from an aesthetic pov:
{ ... if (RM_SHRINK || RMTVAL_REMOVE) goto node; if (!hasattr) return -ENOATTR; else if (local) return shortform_remove(); else if (oneblock) return leaf_removename();
Quoted 6 lines
node:
return node_removename(); }I find that easiest to read at a glance, but I don't feel terribly strongly about it I guess.
I am entirely fine with that if everyone else is :-)
Quoted 113 lines
Quoted 108 lines
Quoted 19 lines
Quoted 19 lines
fs/xfs/libxfs/xfs_attr.c +5
-4@@ -794,11 +849,12 @@ xfs_attr_leaf_hasname(*/ STATIC intxfs_attr_leaf_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_inode *dp; -struct xfs_buf *bp; -int error, forkoff; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp; +struct xfs_buf *bp; +int error, forkoff;trace_xfs_attr_leaf_removename (args);@@ -825,9 +881,8 @@ xfs_attr_leaf_removename(/* bp is gone due to xfs_da_shrink_inode */ if (error)Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_removename( · line 885
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +2
-3return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ;There's no
-EAGAINreturn here, is this an exit path for the remove?I think so, maybe I can remove this and the other one you pointed out in patch 12 along with the other unneeded transaction handling.
Quoted 64 lines
Quoted 23 lines
fs/xfs/libxfs/xfs_attr.c +6
-5}return 0 ; }@@ -1128,12 +1183,13 @@ xfs_attr_node_addname(*/ STATIC intxfs_attr_node_shrink ( -struct xfs_da_args *args, -struct xfs_da_state *state) +struct xfs_delattr_context *dac, +struct xfs_da_state *state) { -struct xfs_inode *dp = args->dp; -int error, forkoff; -struct xfs_buf *bp; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp;/* * Have to get rid of the copy of this dabuf in the state. fs/xfs/libxfs/xfs_attr.c xfs_attr_node_shrink( · line 1211
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +1
-3@@ -1153,9 +1209,7 @@ xfs_attr_node_shrink(if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + dac->flags |=XFS_DAC_DEFER_FINISH ;Same question here.
Quoted 32 lines
fs/xfs/libxfs/xfs_attr.c +12
-3}else xfs_trans_brelse (args->trans, bp);@@ -1194,13 +1248,15 @@ xfs_attr_leaf_mark_incomplete(/* * Initial setup for xfs_attr_node_removename. Make sure the attr is there and -* the blocks are valid. Any remote blocks will be marked incomplete. +* the blocks are valid. Any remote blocks will be marked incomplete and +* invalidated. */ STATIC int xfs_attr_node_removename_setup( -struct xfs_da_args *args, -struct xfs_da_state **state) +struct xfs_delattr_context *dac, +struct xfs_da_state **state) { +struct xfs_da_args *args = dac->da_args;int error;struct xfs_da_state_blk *blk;@@ -1212,10 +1268,21 @@ int xfs_attr_node_removename_setup(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); +/* +* Store blk and state in the context incase we need to cycle out the +* transaction +*/ + dac->blk = blk; + dac->da_state = *state; +if (args->rmtblkno >0 ) { error =xfs_attr_leaf_mark_incomplete (args, *state);if (error)Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c int xfs_attr_node_removename_setup( · line 1285
Quoted 5 lines
fs/xfs/libxfs/xfs_attr.c +4
-0return error; + + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error;Seems like this moves code, which should probably happen in a separate patch.
Ok, this pairs with the
xfs_attr_rmtval_removeto__xfs_attr_rmtval_removebelow. Basicallyxfs_attr_rmtval_removeis the combination ofxfs_attr_rmtval_invalidateand__xfs_attr_rmtval_remove. So thats why we seexfs_attr_rmtval_removegoing away andxfs_attr_rmtval_invalidate+__xfs_attr_rmtval_removecoming in.Quoted 4 lines
How about a patch that pulls
xfs_attr_rmtval_invalidateout ofxfs_attr_rmtval_removeand into the calling functions? I think that might be more clear.
Quoted 4 lines
Yes, separate patch please. I think that if the earlier refactoring parts of the series are split out properly (i.e., no dependencies on subsequent patches) and reviewed, perhaps we can start getting some of those patches merged while the latter bits are worked out.
Ok then, will do
Quoted 74 lines
Quoted 74 lines
Quoted 73 lines
Quoted 52 lines
fs/xfs/libxfs/xfs_attr.c +24
-3}return 0 ;@@ -1228,7 +1295,10 @@ xfs_attr_node_removename_rmt ( {int error =0 ; - error =xfs_attr_rmtval_remove (args); +/* +* May return -EAGAIN to request that the caller recall this function +*/ + error =__xfs_attr_rmtval_remove (args);if (error)return error;@@ -1249,19 +1319,37 @@ xfs_attr_node_removename_rmt (* This will involve walking down the Btree, and may involve joining * leaf nodes and even joining intermediate nodes up to and including * the root node (a special case of an intermediate node). +* +* This routine is meant to function as either an inline or delayed operation, +* and may return -EAGAIN when the transaction needs to be rolled. Calling +* functions will need to handle this, and recall the function until a +* successful error code is returned. */ STATIC intxfs_attr_node_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { +struct xfs_da_args *args = dac->da_args;struct xfs_da_state *state;struct xfs_da_state_blk *blk;int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); + state = dac->da_state; + blk = dac->blk; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RMTVAL_REMOVE : + goto das_rmtval_remove; +case XFS_DAS_RM_SHRINK : + goto das_rm_shrink; +default : +break ; + } - error =xfs_attr_node_removename_setup (args, &state); + error =xfs_attr_node_removename_setup (dac, &state);if (error) goto out;fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1363
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +3
-0@@ -1270,10 +1358,16 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ + +das_rmtval_remove: +I wonder if we need this label just to protect the setup. Perhaps if we had something like:
/* set up the remove only once... */ if (dela_state == 0) error = xfs_attr_node_removename_setup(...);... we could reduce another state.
We could also accomplish the same thing with an explicit state to indicate the setup already occurred or a new dac flag, though I'm not sure a flag is appropriate if it would only be used here.
Brian
Quoted 7 lines
Quoted 5 lines
Mmmm,
dela_state== 0 will conflict a bit when we get into fully delayed attrs. Basically when this is getting called from the delayed operations path, it setsdela_stateto a newXFS_DAS_INIT. Because we have to set up args mid fight, we need the extra state to not do that twice.Can we address that when the conflict is introduced?
Sure, i was just looking ahead, but focus should stay here
Quoted 10 lines
Quoted 6 lines
But even without getting into that right away, what you're proposing only gets rid of the label. It doesnt get rid of the state. We still have to set the state to not be zero (or what ever the initial value is). So we still need the unique value of
XFS_DAS_RMTVAL_REMOVEYeah, I was partly thinking of the setup call being tied to a flag rather than a state. That way the logic is something like the typical:
Quoted 7 lines
if (!setup) do_setup(); ...... and it's one less bit of code tied into the state machine. All in all, it's more that having a label right at the top of a function like that kind of looks like it's asking for some form of simplification.
Ok, this is similar to the discussion going on in the next patch. To be clear, if we add a flag, we need to keep it in the delay_attr_context so that it persists across re-calls. We dont want multiple functions shareing the same setup flag, so really we're talking about a new flag scheme like XFS_DAC_SETUP_* for any function that needs a set up flag? Is that what you had in mind?
Quoted 61 lines
Quoted 46 lines
Really what you would need here in order to do what you are describeing is
dela_state!=XFS_DAS_RMTVAL_REMOVE. If I assume to simplify away to the lease amount of LOC we get this:STATIC int
xfs_attr_node_removename(
structxfs_delattr_context*dac){ struct xfs_da_args *args = dac->da_args; struct xfs_da_state *state; struct xfs_da_state_blk *blk; int retval, error; struct xfs_inode *dp = args->dp; trace_xfs_attr_node_removename(args); state = dac->da_state; blk = dac->blk; if (dac->dela_state == XFS_DAS_RM_SHRINK) { goto das_rm_shrink; } else if (dac->dela_state != XFS_DAS_RMTVAL_REMOVE) { error = xfs_attr_node_removename_setup(dac, &state); if (error) goto out; } /* * If there is an out-of-line value, de-allocate the blocks. * This is done before we remove 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_node_removename_rmt(args, state); if (error) { if (error == -EAGAIN) dac->dela_state = XFS_DAS_RMTVAL_REMOVE; return error; } }.....
Quoted 8 lines
Let me know what folks think of this. Again, I think I like the switches and the labels just because it makes it more clear where the jump points are, even if its more LOC. But again, this isnt bad either if this is more preferable to folks. If there's another arrangment that is preferable, let me know, it's not difficult to run it through the test cases to make sure it's functional. It may be a faster way to hash out what people want to see.
I prefer to see the state management stuff as boilerplate as possible. The above pattern of creating separate reentry calls to the same functions is not nearly as clear to me, particularly in this instance where we have multiple branches of reentry logic (as opposed to the earlier example of only one).
Quoted 7 lines
IOW, I agree that the jumps are preferable and more intuitive. I'm just trying to be reductive by considering what could be factored out vs. trying to fundamentally rework the approach or aggressively reduce LOC or anything like that. IMO, simplicity of the code is usually top priority.
Brian
Ok, lets firm up what we want this setup flag to look like, and then we can simplify the current label and goto scheme :-)
Thank you!!
Allison
Quoted 105 lines
Quoted 104 lines
Thank you again for all the reviewing!!!
Allison
Quoted 98 lines
Quoted 97 lines
if (args->rmtblkno > 0) { error = xfs_attr_node_removename_rmt(args, state);fs/xfs/libxfs/xfs_attr.c +13
-12-if (error) - goto out; +if (error) { +if (error == -EAGAIN ) + dac->dela_state =XFS_DAS_RMTVAL_REMOVE ; +return error; + } }/* @@ -1291,22 +1385,20 @@ xfs_attr_node_removename( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; -/* -* Commit the Btree join operation and start a new trans. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_RM_SHRINK ; +return -EAGAIN ; } +das_rm_shrink: + dac->dela_state =XFS_DAS_RM_SHRINK ; +/* * If the result is small enough, push it all into the inode. */ if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) - error =xfs_attr_node_shrink (args, state); + error =xfs_attr_node_shrink (dac, state); error =0 ; out:fs/xfs/libxfs/xfs_attr.h +38
-0@@ -74,6 +74,43 @@ struct xfs_attr_list_context { }; +/* +* ======================================================================== +* Structure used to pass context around among the delayed routines. +* ======================================================================== +*/ + +/* +* Enum values for xfs_delattr_context.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 +* calling function to roll the transaction, and then recall the subroutine to +* finish the operation. The enum is then used by the subroutine to jump back +* to where it was and resume executing where it left off. +*/ +enum xfs_delattr_state { +/* Zero is uninitalized */ +XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ +XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +}; + +/* +* Defines for xfs_delattr_context.flags +*/ +#define XFS_DAC_DEFER_FINISH 0x1/* indicates to finish the transaction */ + +/* +* Context used for keeping track of delayed attribute operations +*/ +struct xfs_delattr_context { +struct xfs_da_args *da_args; +struct xfs_da_state *da_state; +struct xfs_da_state_blk *blk; +unsigned int flags; +enum xfs_delattr_state dela_state; +}; +/*======================================================================== * Function prototypes for the kernel. *========================================================================*/ @@ -91,6 +128,7 @@ int xfs_attr_set(struct xfs_da_args *args);int xfs_attr_set_args (struct xfs_da_args *args);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args); +int xfs_attr_remove_iter (struct xfs_delattr_context *dac);bool xfs_attr_namecheck (const void *name,size_t length);#endif /* __XFS_ATTR_H__ */ Signature · 1 line
2.7.4
Re: [PATCH v8 18/20] xfs: Add delay ready attr remove routines
Quoted 492 lines · Allison Collins
Quoted 261 lines · Brian Foster
Quoted 175 lines · Allison Collins
Quoted 163 lines · Brian Foster
Quoted 68 lines · Allison Collins
This patch modifies the attr remove routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_remove_argshas becomexfs_attr_remove_iter, which uses a sort of state machine like switch to keep track of where it was when EAGAIN was returned.xfs_attr_node_removenamehas also been modified to use the switch, and a new version ofxfs_attr_remove_argsconsists of a simple loop to refresh the transaction until the operation is completed.Calls to
xfs_attr_rmtval_removeare replaced with the delay ready counter parts:xfs_attr_rmtval_invalidate(appearing in the setup helper) and then__xfs_attr_rmtval_remove. We will rename__xfs_attr_rmtval_removeback toxfs_attr_rmtval_removewhen we are done.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 newxfs_delattr_stateenum 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.Below is a state machine diagram for attr remove operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_remove_iter()XFS_DAS_RM_SHRINK ─┐ (subroutine state) │ │ XFS_DAS_RMTVAL_REMOVE ─┤ (subroutine state) │ └─>xfs_attr_node_removename() │v
need to remove
┌─n── rmt blocks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_RMTVAL_REMOVE
│ │ │
│ │ v
│ └──y── more blks
│ to remove?
│ │
│ n
│ │
│ v
│ need to
└─────> shrink tree? ─n─┐
│ │
y │
│ │
v │
XFS_DAS_RM_SHRINK│
│ │
v │
done <─────┘Quoted 2 lines
Signed-off-by Allison Collins <[email protected]>---
All in all this is starting to look much more simple to me, at least in the remove path. ;P There's only a few states and the markers that are introduced are fairly straightforward, etc. Comments to follow..
Quoted 87 lines
fs/xfs/libxfs/xfs_attr.c | 168 ++++++++++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_attr.h | 38 +++++++++++ 2 files changed, 168 insertions(+), 38 deletions(-)fs/xfs/libxfs/xfs_attr.c +52
-3@@ -45,7 +45,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);*/ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);/* @@ -53,12 +53,21 @@ 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_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC void +xfs_delattr_context_init ( +struct xfs_delattr_context *dac, +struct xfs_da_args *args) +{ +memset (dac,0 ,sizeof (struct xfs_delattr_context )); + dac->da_args = args; +} +int xfs_inode_hasattr (struct xfs_inode *ip)@@ -356,20 +365,66 @@ xfs_has_attr(*/ int xfs_attr_remove_args ( -struct xfs_da_args *args) +struct xfs_da_args *args) { +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_remove_iter (&dac); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + }while (true); + +return error; +} + +/* +* Remove the attribute specified in @args. +* +* This function may return -EAGAIN to signal that the transaction needs to be +* rolled. Callers should continue calling this function until they receive a +* return value other than -EAGAIN. +*/ +int +xfs_attr_remove_iter ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args;struct xfs_inode *dp = args->dp;int error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RM_SHRINK :Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 418
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +6
-0+case XFS_DAS_RMTVAL_REMOVE : +return xfs_attr_node_removename (dac); +default : +break ; + } +Hmm.. so we're duplicating the call instead of using labels..?
Quoted 9 lines
Yes, this was a suggestion made during v7. I suspect Dave may have been wanting to simplify things by escaping the use of labels. At least in so far as the remove path is concerned. Though he may not have realized this would create a duplication call? I will cc him here; the conditions for calling
xfs_attr_node_removenameare: the below if/else sequence exhausts with no successes, and defaults into the else case (ie: the entry condition), OR one of the above states is set (which is a re-entry condition)Ok.
Quoted 52 lines
I'm
Quoted 4 lines
wondering if this can be elegantly combined with the if/else branches below, particularly since node format is the only situation that seems to require a roll here.
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 430
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c +2
-2if (!xfs_inode_hasattr (dp)) { error = -ENOATTR ; }else if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL ) {ASSERT (dp->i_afp->if_flags &XFS_IFINLINE ); error =xfs_attr_shortform_remove (args); }else if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_removename (args); + error =xfs_attr_leaf_removename (dac); }else { - error =xfs_attr_node_removename (args); + error =xfs_attr_node_removename (dac); }return error;If we want to try and combine this into if/elses with no duplication, I believe the simplest arrangement would look something like this:
int
xfs_attr_remove_iter(
structxfs_delattr_context*dac){ struct xfs_da_args *args = dac->da_args; struct xfs_inode *dp = args->dp; if (dac->dela_state != XFS_DAS_RM_SHRINK && dac->dela_state != XFS_DAS_RMTVAL_REMOVE) { if (!xfs_inode_hasattr(dp)) { return -ENOATTR; } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) { ASSERT(dp->i_afp->if_flags & XFS_IFINLINE); return xfs_attr_shortform_remove(args); } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) { return xfs_attr_leaf_removename(dac); } } return xfs_attr_node_removename(dac); }Let me know what folks think of that. I'm not always clear on where people stand with aesthetics. (IE, is it better to have a duplicate call if it gets rid of a label? Is the solution with the least amount of LOC always preferable?) This area seems simple enough maybe we can get it ironed out here with out another version.
Quoted 5 lines
IMHO I think the above code sort of obfuscates that the code flow is really just one if/else switch with one function that has the statemachine behavior. But its not bad either if that's what people prefer. I'd like to find something every can be sort of happy with. :-)
If you want my .02, some combination of the above is cleanest from an aesthetic pov:
{ ... if (RM_SHRINK || RMTVAL_REMOVE) goto node; if (!hasattr) return -ENOATTR; else if (local) return shortform_remove(); else if (oneblock) return leaf_removename();Quoted 6 lines
node:
return node_removename(); }I find that easiest to read at a glance, but I don't feel terribly strongly about it I guess.
I am entirely fine with that if everyone else is :-)
Quoted 113 lines
Quoted 108 lines
Quoted 19 lines
Quoted 19 lines
fs/xfs/libxfs/xfs_attr.c +5
-4@@ -794,11 +849,12 @@ xfs_attr_leaf_hasname(*/ STATIC intxfs_attr_leaf_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_inode *dp; -struct xfs_buf *bp; -int error, forkoff; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp; +struct xfs_buf *bp; +int error, forkoff;trace_xfs_attr_leaf_removename (args);@@ -825,9 +881,8 @@ xfs_attr_leaf_removename(/* bp is gone due to xfs_da_shrink_inode */ if (error)Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_removename( · line 885
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +2
-3return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ;There's no
-EAGAINreturn here, is this an exit path for the remove?I think so, maybe I can remove this and the other one you pointed out in patch 12 along with the other unneeded transaction handling.
Quoted 64 lines
Quoted 23 lines
fs/xfs/libxfs/xfs_attr.c +6
-5}return 0 ; }@@ -1128,12 +1183,13 @@ xfs_attr_node_addname(*/ STATIC intxfs_attr_node_shrink ( -struct xfs_da_args *args, -struct xfs_da_state *state) +struct xfs_delattr_context *dac, +struct xfs_da_state *state) { -struct xfs_inode *dp = args->dp; -int error, forkoff; -struct xfs_buf *bp; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp;/* * Have to get rid of the copy of this dabuf in the state. fs/xfs/libxfs/xfs_attr.c xfs_attr_node_shrink( · line 1211
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +1
-3@@ -1153,9 +1209,7 @@ xfs_attr_node_shrink(if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + dac->flags |=XFS_DAC_DEFER_FINISH ;Same question here.
Quoted 32 lines
fs/xfs/libxfs/xfs_attr.c +12
-3}else xfs_trans_brelse (args->trans, bp);@@ -1194,13 +1248,15 @@ xfs_attr_leaf_mark_incomplete(/* * Initial setup for xfs_attr_node_removename. Make sure the attr is there and -* the blocks are valid. Any remote blocks will be marked incomplete. +* the blocks are valid. Any remote blocks will be marked incomplete and +* invalidated. */ STATIC int xfs_attr_node_removename_setup( -struct xfs_da_args *args, -struct xfs_da_state **state) +struct xfs_delattr_context *dac, +struct xfs_da_state **state) { +struct xfs_da_args *args = dac->da_args;int error;struct xfs_da_state_blk *blk;@@ -1212,10 +1268,21 @@ int xfs_attr_node_removename_setup(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); +/* +* Store blk and state in the context incase we need to cycle out the +* transaction +*/ + dac->blk = blk; + dac->da_state = *state; +if (args->rmtblkno >0 ) { error =xfs_attr_leaf_mark_incomplete (args, *state);if (error)Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c int xfs_attr_node_removename_setup( · line 1285
Quoted 5 lines
fs/xfs/libxfs/xfs_attr.c +4
-0return error; + + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error;Seems like this moves code, which should probably happen in a separate patch.
Ok, this pairs with the
xfs_attr_rmtval_removeto__xfs_attr_rmtval_removebelow. Basicallyxfs_attr_rmtval_removeis the combination ofxfs_attr_rmtval_invalidateand__xfs_attr_rmtval_remove. So thats why we seexfs_attr_rmtval_removegoing away andxfs_attr_rmtval_invalidate+__xfs_attr_rmtval_removecoming in.Quoted 4 lines
How about a patch that pulls
xfs_attr_rmtval_invalidateout ofxfs_attr_rmtval_removeand into the calling functions? I think that might be more clear.Quoted 4 lines
Yes, separate patch please. I think that if the earlier refactoring parts of the series are split out properly (i.e., no dependencies on subsequent patches) and reviewed, perhaps we can start getting some of those patches merged while the latter bits are worked out.
Ok then, will do
Quoted 74 lines
Quoted 74 lines
Quoted 73 lines
Quoted 52 lines
fs/xfs/libxfs/xfs_attr.c +24
-3}return 0 ;@@ -1228,7 +1295,10 @@ xfs_attr_node_removename_rmt ( {int error =0 ; - error =xfs_attr_rmtval_remove (args); +/* +* May return -EAGAIN to request that the caller recall this function +*/ + error =__xfs_attr_rmtval_remove (args);if (error)return error;@@ -1249,19 +1319,37 @@ xfs_attr_node_removename_rmt (* This will involve walking down the Btree, and may involve joining * leaf nodes and even joining intermediate nodes up to and including * the root node (a special case of an intermediate node). +* +* This routine is meant to function as either an inline or delayed operation, +* and may return -EAGAIN when the transaction needs to be rolled. Calling +* functions will need to handle this, and recall the function until a +* successful error code is returned. */ STATIC intxfs_attr_node_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { +struct xfs_da_args *args = dac->da_args;struct xfs_da_state *state;struct xfs_da_state_blk *blk;int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); + state = dac->da_state; + blk = dac->blk; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RMTVAL_REMOVE : + goto das_rmtval_remove; +case XFS_DAS_RM_SHRINK : + goto das_rm_shrink; +default : +break ; + } - error =xfs_attr_node_removename_setup (args, &state); + error =xfs_attr_node_removename_setup (dac, &state);if (error) goto out;fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1363
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +3
-0@@ -1270,10 +1358,16 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ + +das_rmtval_remove: +I wonder if we need this label just to protect the setup. Perhaps if we had something like:
/* set up the remove only once... */ if (dela_state == 0) error = xfs_attr_node_removename_setup(...);... we could reduce another state.
We could also accomplish the same thing with an explicit state to indicate the setup already occurred or a new dac flag, though I'm not sure a flag is appropriate if it would only be used here.
Brian
Quoted 7 lines
Quoted 5 lines
Mmmm,
dela_state== 0 will conflict a bit when we get into fully delayed attrs. Basically when this is getting called from the delayed operations path, it setsdela_stateto a newXFS_DAS_INIT. Because we have to set up args mid fight, we need the extra state to not do that twice.Can we address that when the conflict is introduced?
Sure, i was just looking ahead, but focus should stay here
Quoted 10 lines
Quoted 6 lines
But even without getting into that right away, what you're proposing only gets rid of the label. It doesnt get rid of the state. We still have to set the state to not be zero (or what ever the initial value is). So we still need the unique value of
XFS_DAS_RMTVAL_REMOVEYeah, I was partly thinking of the setup call being tied to a flag rather than a state. That way the logic is something like the typical:
Quoted 7 lines
if (!setup) do_setup(); ...... and it's one less bit of code tied into the state machine. All in all, it's more that having a label right at the top of a function like that kind of looks like it's asking for some form of simplification.
Quoted 7 lines
Ok, this is similar to the discussion going on in the next patch. To be clear, if we add a flag, we need to keep it in the
delay_attr_contextso that it persists across re-calls. We dont want multiple functions shareing the same setup flag, so really we're talking about a new flag scheme like XFS_DAC_SETUP_* for any function that needs a set up flag? Is that what you had in mind?
Yep, pretty much. It's not clear to me if we can reuse one general INIT flag across operations or need several such flags, but I'm not sure I understand why we couldn't reuse the existing dac->flags at least..
Brian
Quoted 182 lines
Quoted 61 lines
Quoted 46 lines
Really what you would need here in order to do what you are describeing is
dela_state!=XFS_DAS_RMTVAL_REMOVE. If I assume to simplify away to the lease amount of LOC we get this:STATIC int
xfs_attr_node_removename(
structxfs_delattr_context*dac){ struct xfs_da_args *args = dac->da_args; struct xfs_da_state *state; struct xfs_da_state_blk *blk; int retval, error; struct xfs_inode *dp = args->dp; trace_xfs_attr_node_removename(args); state = dac->da_state; blk = dac->blk; if (dac->dela_state == XFS_DAS_RM_SHRINK) { goto das_rm_shrink; } else if (dac->dela_state != XFS_DAS_RMTVAL_REMOVE) { error = xfs_attr_node_removename_setup(dac, &state); if (error) goto out; } /* * If there is an out-of-line value, de-allocate the blocks. * This is done before we remove 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_node_removename_rmt(args, state); if (error) { if (error == -EAGAIN) dac->dela_state = XFS_DAS_RMTVAL_REMOVE; return error; } }.....
Quoted 8 lines
Let me know what folks think of this. Again, I think I like the switches and the labels just because it makes it more clear where the jump points are, even if its more LOC. But again, this isnt bad either if this is more preferable to folks. If there's another arrangment that is preferable, let me know, it's not difficult to run it through the test cases to make sure it's functional. It may be a faster way to hash out what people want to see.
I prefer to see the state management stuff as boilerplate as possible. The above pattern of creating separate reentry calls to the same functions is not nearly as clear to me, particularly in this instance where we have multiple branches of reentry logic (as opposed to the earlier example of only one).
Quoted 7 lines
IOW, I agree that the jumps are preferable and more intuitive. I'm just trying to be reductive by considering what could be factored out vs. trying to fundamentally rework the approach or aggressively reduce LOC or anything like that. IMO, simplicity of the code is usually top priority.
Brian
Ok, lets firm up what we want this setup flag to look like, and then we can simplify the current label and goto scheme :-)
Thank you!!
AllisonQuoted 105 lines
Quoted 104 lines
Thank you again for all the reviewing!!!
Allison
Quoted 98 lines
Quoted 97 lines
if (args->rmtblkno > 0) { error = xfs_attr_node_removename_rmt(args, state);fs/xfs/libxfs/xfs_attr.c +13
-12-if (error) - goto out; +if (error) { +if (error == -EAGAIN ) + dac->dela_state =XFS_DAS_RMTVAL_REMOVE ; +return error; + } }/* @@ -1291,22 +1385,20 @@ xfs_attr_node_removename( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; -/* -* Commit the Btree join operation and start a new trans. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_RM_SHRINK ; +return -EAGAIN ; } +das_rm_shrink: + dac->dela_state =XFS_DAS_RM_SHRINK ; +/* * If the result is small enough, push it all into the inode. */ if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) - error =xfs_attr_node_shrink (args, state); + error =xfs_attr_node_shrink (dac, state); error =0 ; out:fs/xfs/libxfs/xfs_attr.h +38
-0@@ -74,6 +74,43 @@ struct xfs_attr_list_context { }; +/* +* ======================================================================== +* Structure used to pass context around among the delayed routines. +* ======================================================================== +*/ + +/* +* Enum values for xfs_delattr_context.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 +* calling function to roll the transaction, and then recall the subroutine to +* finish the operation. The enum is then used by the subroutine to jump back +* to where it was and resume executing where it left off. +*/ +enum xfs_delattr_state { +/* Zero is uninitalized */ +XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ +XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +}; + +/* +* Defines for xfs_delattr_context.flags +*/ +#define XFS_DAC_DEFER_FINISH 0x1/* indicates to finish the transaction */ + +/* +* Context used for keeping track of delayed attribute operations +*/ +struct xfs_delattr_context { +struct xfs_da_args *da_args; +struct xfs_da_state *da_state; +struct xfs_da_state_blk *blk; +unsigned int flags; +enum xfs_delattr_state dela_state; +}; +/*======================================================================== * Function prototypes for the kernel. *========================================================================*/ @@ -91,6 +128,7 @@ int xfs_attr_set(struct xfs_da_args *args);int xfs_attr_set_args (struct xfs_da_args *args);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args); +int xfs_attr_remove_iter (struct xfs_delattr_context *dac);bool xfs_attr_namecheck (const void *name,size_t length);#endif /* __XFS_ATTR_H__ */ Signature · 1 line
2.7.4
Re: [PATCH v8 18/20] xfs: Add delay ready attr remove routines
Quoted 501 lines · Brian Foster
Quoted 492 lines · Allison Collins
Quoted 261 lines · Brian Foster
Quoted 175 lines · Allison Collins
Quoted 163 lines · Brian Foster
Quoted 68 lines · Allison Collins
This patch modifies the attr remove routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_remove_argshas becomexfs_attr_remove_iter, which uses a sort of state machine like switch to keep track of where it was when EAGAIN was returned.xfs_attr_node_removenamehas also been modified to use the switch, and a new version ofxfs_attr_remove_argsconsists of a simple loop to refresh the transaction until the operation is completed.Calls to
xfs_attr_rmtval_removeare replaced with the delay ready counter parts:xfs_attr_rmtval_invalidate(appearing in the setup helper) and then__xfs_attr_rmtval_remove. We will rename__xfs_attr_rmtval_removeback toxfs_attr_rmtval_removewhen we are done.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 newxfs_delattr_stateenum 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.Below is a state machine diagram for attr remove operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_remove_iter()
XFS_DAS_RM_SHRINK─┐
(subroutine state) │
│
XFS_DAS_RMTVAL_REMOVE─┤
(subroutine state) │
└─>xfs_attr_node_removename()
│
v
need to remove
┌─n── rmt blocks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_RMTVAL_REMOVE
│ │ │
│ │ v
│ └──y── more blks
│ to remove?
│ │
│ n
│ │
│ v
│ need to
└─────> shrink tree? ─n─┐
│ │
y │
│ │
v │
XFS_DAS_RM_SHRINK│
│ │
v │
done <─────┘Quoted 2 lines
Signed-off-by Allison Collins <[email protected]>---
All in all this is starting to look much more simple to me, at least in the remove path. ;P There's only a few states and the markers that are introduced are fairly straightforward, etc. Comments to follow..
Quoted 87 lines
fs/xfs/libxfs/xfs_attr.c | 168 ++++++++++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_attr.h | 38 +++++++++++ 2 files changed, 168 insertions(+), 38 deletions(-)fs/xfs/libxfs/xfs_attr.c +52
-3@@ -45,7 +45,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);*/ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);/* @@ -53,12 +53,21 @@ 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_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC void +xfs_delattr_context_init ( +struct xfs_delattr_context *dac, +struct xfs_da_args *args) +{ +memset (dac,0 ,sizeof (struct xfs_delattr_context )); + dac->da_args = args; +} +int xfs_inode_hasattr (struct xfs_inode *ip)@@ -356,20 +365,66 @@ xfs_has_attr(*/ int xfs_attr_remove_args ( -struct xfs_da_args *args) +struct xfs_da_args *args) { +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_remove_iter (&dac); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + }while (true); + +return error; +} + +/* +* Remove the attribute specified in @args. +* +* This function may return -EAGAIN to signal that the transaction needs to be +* rolled. Callers should continue calling this function until they receive a +* return value other than -EAGAIN. +*/ +int +xfs_attr_remove_iter ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args;struct xfs_inode *dp = args->dp;int error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RM_SHRINK :Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 418
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +6
-0+case XFS_DAS_RMTVAL_REMOVE : +return xfs_attr_node_removename (dac); +default : +break ; + } +Hmm.. so we're duplicating the call instead of using labels..?
Quoted 9 lines
Yes, this was a suggestion made during v7. I suspect Dave may have been wanting to simplify things by escaping the use of labels. At least in so far as the remove path is concerned. Though he may not have realized this would create a duplication call? I will cc him here; the conditions for calling
xfs_attr_node_removenameare: the below if/else sequence exhausts with no successes, and defaults into the else case (ie: the entry condition), OR one of the above states is set (which is a re-entry condition)Ok.
Quoted 52 lines
I'm
Quoted 4 lines
wondering if this can be elegantly combined with the if/else branches below, particularly since node format is the only situation that seems to require a roll here.
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c xfs_has_attr( · line 430
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c +2
-2if (!xfs_inode_hasattr (dp)) { error = -ENOATTR ; }else if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL ) {ASSERT (dp->i_afp->if_flags &XFS_IFINLINE ); error =xfs_attr_shortform_remove (args); }else if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_removename (args); + error =xfs_attr_leaf_removename (dac); }else { - error =xfs_attr_node_removename (args); + error =xfs_attr_node_removename (dac); }return error;If we want to try and combine this into if/elses with no duplication, I believe the simplest arrangement would look something like this:
int
xfs_attr_remove_iter(
structxfs_delattr_context*dac){ struct xfs_da_args *args = dac->da_args; struct xfs_inode *dp = args->dp; if (dac->dela_state != XFS_DAS_RM_SHRINK && dac->dela_state != XFS_DAS_RMTVAL_REMOVE) { if (!xfs_inode_hasattr(dp)) { return -ENOATTR; } else if (dp->i_d.di_aformat == XFS_DINODE_FMT_LOCAL) { ASSERT(dp->i_afp->if_flags & XFS_IFINLINE); return xfs_attr_shortform_remove(args); } else if (xfs_bmap_one_block(dp, XFS_ATTR_FORK)) { return xfs_attr_leaf_removename(dac); } } return xfs_attr_node_removename(dac); }Let me know what folks think of that. I'm not always clear on where people stand with aesthetics. (IE, is it better to have a duplicate call if it gets rid of a label? Is the solution with the least amount of LOC always preferable?) This area seems simple enough maybe we can get it ironed out here with out another version.
Quoted 5 lines
IMHO I think the above code sort of obfuscates that the code flow is really just one if/else switch with one function that has the statemachine behavior. But its not bad either if that's what people prefer. I'd like to find something every can be sort of happy with. :-)
If you want my .02, some combination of the above is cleanest from an aesthetic pov:
{ ... if (RM_SHRINK || RMTVAL_REMOVE) goto node; if (!hasattr) return -ENOATTR; else if (local) return shortform_remove(); else if (oneblock) return leaf_removename();Quoted 6 lines
node:
return node_removename(); }I find that easiest to read at a glance, but I don't feel terribly strongly about it I guess.
I am entirely fine with that if everyone else is :-)
Quoted 113 lines
Quoted 108 lines
Quoted 19 lines
Quoted 19 lines
fs/xfs/libxfs/xfs_attr.c +5
-4@@ -794,11 +849,12 @@ xfs_attr_leaf_hasname(*/ STATIC intxfs_attr_leaf_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_inode *dp; -struct xfs_buf *bp; -int error, forkoff; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp; +struct xfs_buf *bp; +int error, forkoff;trace_xfs_attr_leaf_removename (args);@@ -825,9 +881,8 @@ xfs_attr_leaf_removename(/* bp is gone due to xfs_da_shrink_inode */ if (error)Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_removename( · line 885
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +2
-3return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ;There's no
-EAGAINreturn here, is this an exit path for the remove?I think so, maybe I can remove this and the other one you pointed out in patch 12 along with the other unneeded transaction handling.
Quoted 64 lines
Quoted 23 lines
fs/xfs/libxfs/xfs_attr.c +6
-5}return 0 ; }@@ -1128,12 +1183,13 @@ xfs_attr_node_addname(*/ STATIC intxfs_attr_node_shrink ( -struct xfs_da_args *args, -struct xfs_da_state *state) +struct xfs_delattr_context *dac, +struct xfs_da_state *state) { -struct xfs_inode *dp = args->dp; -int error, forkoff; -struct xfs_buf *bp; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp;/* * Have to get rid of the copy of this dabuf in the state. fs/xfs/libxfs/xfs_attr.c xfs_attr_node_shrink( · line 1211
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +1
-3@@ -1153,9 +1209,7 @@ xfs_attr_node_shrink(if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + dac->flags |=XFS_DAC_DEFER_FINISH ;Same question here.
Quoted 32 lines
fs/xfs/libxfs/xfs_attr.c +12
-3}else xfs_trans_brelse (args->trans, bp);@@ -1194,13 +1248,15 @@ xfs_attr_leaf_mark_incomplete(/* * Initial setup for xfs_attr_node_removename. Make sure the attr is there and -* the blocks are valid. Any remote blocks will be marked incomplete. +* the blocks are valid. Any remote blocks will be marked incomplete and +* invalidated. */ STATIC int xfs_attr_node_removename_setup( -struct xfs_da_args *args, -struct xfs_da_state **state) +struct xfs_delattr_context *dac, +struct xfs_da_state **state) { +struct xfs_da_args *args = dac->da_args;int error;struct xfs_da_state_blk *blk;@@ -1212,10 +1268,21 @@ int xfs_attr_node_removename_setup(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); +/* +* Store blk and state in the context incase we need to cycle out the +* transaction +*/ + dac->blk = blk; + dac->da_state = *state; +if (args->rmtblkno >0 ) { error =xfs_attr_leaf_mark_incomplete (args, *state);if (error)Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c int xfs_attr_node_removename_setup( · line 1285
Quoted 5 lines
fs/xfs/libxfs/xfs_attr.c +4
-0return error; + + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error;Seems like this moves code, which should probably happen in a separate patch.
Ok, this pairs with the
xfs_attr_rmtval_removeto__xfs_attr_rmtval_removebelow. Basicallyxfs_attr_rmtval_removeis the combination ofxfs_attr_rmtval_invalidateand__xfs_attr_rmtval_remove. So thats why we seexfs_attr_rmtval_removegoing away andxfs_attr_rmtval_invalidate+__xfs_attr_rmtval_removecoming in.Quoted 4 lines
How about a patch that pulls
xfs_attr_rmtval_invalidateout ofxfs_attr_rmtval_removeand into the calling functions? I think that might be more clear.Quoted 4 lines
Yes, separate patch please. I think that if the earlier refactoring parts of the series are split out properly (i.e., no dependencies on subsequent patches) and reviewed, perhaps we can start getting some of those patches merged while the latter bits are worked out.
Ok then, will do
Quoted 74 lines
Quoted 74 lines
Quoted 73 lines
Quoted 52 lines
fs/xfs/libxfs/xfs_attr.c +24
-3}return 0 ;@@ -1228,7 +1295,10 @@ xfs_attr_node_removename_rmt ( {int error =0 ; - error =xfs_attr_rmtval_remove (args); +/* +* May return -EAGAIN to request that the caller recall this function +*/ + error =__xfs_attr_rmtval_remove (args);if (error)return error;@@ -1249,19 +1319,37 @@ xfs_attr_node_removename_rmt (* This will involve walking down the Btree, and may involve joining * leaf nodes and even joining intermediate nodes up to and including * the root node (a special case of an intermediate node). +* +* This routine is meant to function as either an inline or delayed operation, +* and may return -EAGAIN when the transaction needs to be rolled. Calling +* functions will need to handle this, and recall the function until a +* successful error code is returned. */ STATIC intxfs_attr_node_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { +struct xfs_da_args *args = dac->da_args;struct xfs_da_state *state;struct xfs_da_state_blk *blk;int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); + state = dac->da_state; + blk = dac->blk; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RMTVAL_REMOVE : + goto das_rmtval_remove; +case XFS_DAS_RM_SHRINK : + goto das_rm_shrink; +default : +break ; + } - error =xfs_attr_node_removename_setup (args, &state); + error =xfs_attr_node_removename_setup (dac, &state);if (error) goto out;fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1363
Quoted 6 lines
fs/xfs/libxfs/xfs_attr.c +3
-0@@ -1270,10 +1358,16 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ + +das_rmtval_remove: +I wonder if we need this label just to protect the setup. Perhaps if we had something like:
/* set up the remove only once... */ if (dela_state == 0) error = xfs_attr_node_removename_setup(...);... we could reduce another state.
We could also accomplish the same thing with an explicit state to indicate the setup already occurred or a new dac flag, though I'm not sure a flag is appropriate if it would only be used here.
Brian
Quoted 7 lines
Quoted 5 lines
Mmmm,
dela_state== 0 will conflict a bit when we get into fully delayed attrs. Basically when this is getting called from the delayed operations path, it setsdela_stateto a newXFS_DAS_INIT. Because we have to set up args mid fight, we need the extra state to not do that twice.Can we address that when the conflict is introduced?
Sure, i was just looking ahead, but focus should stay here
Quoted 10 lines
Quoted 6 lines
But even without getting into that right away, what you're proposing only gets rid of the label. It doesnt get rid of the state. We still have to set the state to not be zero (or what ever the initial value is). So we still need the unique value of
XFS_DAS_RMTVAL_REMOVEYeah, I was partly thinking of the setup call being tied to a flag rather than a state. That way the logic is something like the typical:
Quoted 7 lines
if (!setup) do_setup(); ...... and it's one less bit of code tied into the state machine. All in all, it's more that having a label right at the top of a function like that kind of looks like it's asking for some form of simplification.
Quoted 7 lines
Ok, this is similar to the discussion going on in the next patch. To be clear, if we add a flag, we need to keep it in the
delay_attr_contextso that it persists across re-calls. We dont want multiple functions shareing the same setup flag, so really we're talking about a new flag scheme like XFS_DAC_SETUP_* for any function that needs a set up flag? Is that what you had in mind?
Quoted 5 lines
Yep, pretty much. It's not clear to me if we can reuse one general INIT flag across operations or need several such flags, but I'm not sure I understand why we couldn't reuse the existing
dac->flagsat least..Brian
Ok, I think I likely answered this in the discussion for the next patch.
I forgot I had already added a flag member to the delay attr context,
I will move forward with an init flag scheme. Thanks again for all the reviewing!
Allison
Quoted 184 lines
Quoted 183 lines
Quoted 62 lines
Quoted 47 lines
Really what you would need here in order to do what you are describeing is
dela_state!=XFS_DAS_RMTVAL_REMOVE. If I assume to simplify away to the lease amount of LOC we get this:STATIC int
xfs_attr_node_removename(
structxfs_delattr_context*dac){ struct xfs_da_args *args = dac->da_args; struct xfs_da_state *state; struct xfs_da_state_blk *blk; int retval, error; struct xfs_inode *dp = args->dp; trace_xfs_attr_node_removename(args); state = dac->da_state; blk = dac->blk; if (dac->dela_state == XFS_DAS_RM_SHRINK) { goto das_rm_shrink; } else if (dac->dela_state != XFS_DAS_RMTVAL_REMOVE) { error = xfs_attr_node_removename_setup(dac, &state); if (error) goto out; } /* * If there is an out-of-line value, de-allocate the blocks. * This is done before we remove 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_node_removename_rmt(args, state); if (error) { if (error == -EAGAIN) dac->dela_state = XFS_DAS_RMTVAL_REMOVE; return error; } }.....
Quoted 8 lines
Let me know what folks think of this. Again, I think I like the switches and the labels just because it makes it more clear where the jump points are, even if its more LOC. But again, this isnt bad either if this is more preferable to folks. If there's another arrangment that is preferable, let me know, it's not difficult to run it through the test cases to make sure it's functional. It may be a faster way to hash out what people want to see.
I prefer to see the state management stuff as boilerplate as possible. The above pattern of creating separate reentry calls to the same functions is not nearly as clear to me, particularly in this instance where we have multiple branches of reentry logic (as opposed to the earlier example of only one).
Quoted 7 lines
IOW, I agree that the jumps are preferable and more intuitive. I'm just trying to be reductive by considering what could be factored out vs. trying to fundamentally rework the approach or aggressively reduce LOC or anything like that. IMO, simplicity of the code is usually top priority.
Brian
Ok, lets firm up what we want this setup flag to look like, and then we can simplify the current label and goto scheme :-)
Thank you!!
AllisonQuoted 105 lines
Quoted 104 lines
Thank you again for all the reviewing!!!
Allison
Quoted 98 lines
Quoted 97 lines
if (args->rmtblkno > 0) { error = xfs_attr_node_removename_rmt(args, state);fs/xfs/libxfs/xfs_attr.c +13
-12-if (error) - goto out; +if (error) { +if (error == -EAGAIN ) + dac->dela_state =XFS_DAS_RMTVAL_REMOVE ; +return error; + } }/* @@ -1291,22 +1385,20 @@ xfs_attr_node_removename( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; -/* -* Commit the Btree join operation and start a new trans. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_RM_SHRINK ; +return -EAGAIN ; } +das_rm_shrink: + dac->dela_state =XFS_DAS_RM_SHRINK ; +/* * If the result is small enough, push it all into the inode. */ if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) - error =xfs_attr_node_shrink (args, state); + error =xfs_attr_node_shrink (dac, state); error =0 ; out:fs/xfs/libxfs/xfs_attr.h +38
-0@@ -74,6 +74,43 @@ struct xfs_attr_list_context { }; +/* +* ======================================================================== +* Structure used to pass context around among the delayed routines. +* ======================================================================== +*/ + +/* +* Enum values for xfs_delattr_context.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 +* calling function to roll the transaction, and then recall the subroutine to +* finish the operation. The enum is then used by the subroutine to jump back +* to where it was and resume executing where it left off. +*/ +enum xfs_delattr_state { +/* Zero is uninitalized */ +XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ +XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +}; + +/* +* Defines for xfs_delattr_context.flags +*/ +#define XFS_DAC_DEFER_FINISH 0x1/* indicates to finish the transaction */ + +/* +* Context used for keeping track of delayed attribute operations +*/ +struct xfs_delattr_context { +struct xfs_da_args *da_args; +struct xfs_da_state *da_state; +struct xfs_da_state_blk *blk; +unsigned int flags; +enum xfs_delattr_state dela_state; +}; +/*======================================================================== * Function prototypes for the kernel. *========================================================================*/ @@ -91,6 +128,7 @@ int xfs_attr_set(struct xfs_da_args *args);int xfs_attr_set_args (struct xfs_da_args *args);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args); +int xfs_attr_remove_iter (struct xfs_delattr_context *dac);bool xfs_attr_namecheck (const void *name,size_t length);#endif /* __XFS_ATTR_H__ */ Signature · 1 line
2.7.4
Re: [PATCH v8 18/20] xfs: Add delay ready attr remove routines
In reply to Allison CollinsQuoted 336 lines · Allison Collins
This patch modifies the attr remove routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_remove_argshas becomexfs_attr_remove_iter, which uses a sort of state machine like switch to keep track of where it was when EAGAIN was returned.xfs_attr_node_removenamehas also been modified to use the switch, and a new version ofxfs_attr_remove_argsconsists of a simple loop to refresh the transaction until the operation is completed.Calls to
xfs_attr_rmtval_removeare replaced with the delay ready counter parts:xfs_attr_rmtval_invalidate(appearing in the setup helper) and then__xfs_attr_rmtval_remove. We will rename__xfs_attr_rmtval_removeback toxfs_attr_rmtval_removewhen we are done.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 newxfs_delattr_stateenum 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.Below is a state machine diagram for attr remove operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_remove_iter()XFS_DAS_RM_SHRINK ─┐ (subroutine state) │ │ XFS_DAS_RMTVAL_REMOVE ─┤ (subroutine state) │ └─>xfs_attr_node_removename() │v
need to remove
┌─n── rmt blocks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_RMTVAL_REMOVE
│ │ │
│ │ v
│ └──y── more blks
│ to remove?
│ │
│ n
│ │
│ v
│ need to
└─────> shrink tree? ─n─┐
│ │
y │
│ │
v │
XFS_DAS_RM_SHRINK│
│ │
v │
done <─────┘Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 168 ++++++++++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_attr.h | 38 +++++++++++ 2 files changed, 168 insertions(+), 38 deletions(-)fs/xfs/libxfs/xfs_attr.c +114
-26@@ -45,7 +45,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);*/ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);/* @@ -53,12 +53,21 @@ 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_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC void +xfs_delattr_context_init ( +struct xfs_delattr_context *dac, +struct xfs_da_args *args) +{ +memset (dac,0 ,sizeof (struct xfs_delattr_context )); + dac->da_args = args; +} +int xfs_inode_hasattr (struct xfs_inode *ip)@@ -356,20 +365,66 @@ xfs_has_attr(*/ int xfs_attr_remove_args ( -struct xfs_da_args *args) +struct xfs_da_args *args) { +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_remove_iter (&dac); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + }while (true); + +return error; +} + +/* +* Remove the attribute specified in @args. +* +* This function may return -EAGAIN to signal that the transaction needs to be +* rolled. Callers should continue calling this function until they receive a +* return value other than -EAGAIN. +*/ +int +xfs_attr_remove_iter ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args;struct xfs_inode *dp = args->dp;int error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RM_SHRINK : +case XFS_DAS_RMTVAL_REMOVE : +return xfs_attr_node_removename (dac); +default : +break ; + } +if (!xfs_inode_hasattr (dp)) { error = -ENOATTR ; }else if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL ) {ASSERT (dp->i_afp->if_flags &XFS_IFINLINE ); error =xfs_attr_shortform_remove (args); }else if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_removename (args); + error =xfs_attr_leaf_removename (dac); }else { - error =xfs_attr_node_removename (args); + error =xfs_attr_node_removename (dac); }return error;@@ -794,11 +849,12 @@ xfs_attr_leaf_hasname(*/ STATIC intxfs_attr_leaf_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_inode *dp; -struct xfs_buf *bp; -int error, forkoff; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp; +struct xfs_buf *bp; +int error, forkoff;trace_xfs_attr_leaf_removename (args);@@ -825,9 +881,8 @@ xfs_attr_leaf_removename(/* bp is gone due to xfs_da_shrink_inode */ if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; }return 0 ; }@@ -1128,12 +1183,13 @@ xfs_attr_node_addname(*/ STATIC intxfs_attr_node_shrink ( -struct xfs_da_args *args, -struct xfs_da_state *state) +struct xfs_delattr_context *dac, +struct xfs_da_state *state) { -struct xfs_inode *dp = args->dp; -int error, forkoff; -struct xfs_buf *bp; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp;/* * Have to get rid of the copy of this dabuf in the state. @@ -1153,9 +1209,7 @@ xfs_attr_node_shrink(if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + dac->flags |=XFS_DAC_DEFER_FINISH ; }else xfs_trans_brelse (args->trans, bp);@@ -1194,13 +1248,15 @@ xfs_attr_leaf_mark_incomplete(/* * Initial setup for xfs_attr_node_removename. Make sure the attr is there and -* the blocks are valid. Any remote blocks will be marked incomplete. +* the blocks are valid. Any remote blocks will be marked incomplete and +* invalidated. */ STATIC int xfs_attr_node_removename_setup( -struct xfs_da_args *args, -struct xfs_da_state **state) +struct xfs_delattr_context *dac, +struct xfs_da_state **state) { +struct xfs_da_args *args = dac->da_args;int error;struct xfs_da_state_blk *blk;@@ -1212,10 +1268,21 @@ int xfs_attr_node_removename_setup(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); +/* +* Store blk and state in the context incase we need to cycle out the +* transaction +*/ + dac->blk = blk; + dac->da_state = *state; +if (args->rmtblkno >0 ) { error =xfs_attr_leaf_mark_incomplete (args, *state);if (error)return error; + + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error; }return 0 ;@@ -1228,7 +1295,10 @@ xfs_attr_node_removename_rmt ( {int error =0 ; - error =xfs_attr_rmtval_remove (args); +/* +* May return -EAGAIN to request that the caller recall this function +*/ + error =__xfs_attr_rmtval_remove (args);if (error)return error;@@ -1249,19 +1319,37 @@ xfs_attr_node_removename_rmt (* This will involve walking down the Btree, and may involve joining * leaf nodes and even joining intermediate nodes up to and including * the root node (a special case of an intermediate node). +* +* This routine is meant to function as either an inline or delayed operation, +* and may return -EAGAIN when the transaction needs to be rolled. Calling +* functions will need to handle this, and recall the function until a +* successful error code is returned. */ STATIC intxfs_attr_node_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { +struct xfs_da_args *args = dac->da_args;struct xfs_da_state *state;struct xfs_da_state_blk *blk;int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); + state = dac->da_state; + blk = dac->blk; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RMTVAL_REMOVE : + goto das_rmtval_remove; +case XFS_DAS_RM_SHRINK : + goto das_rm_shrink; +default : +break ; + } - error =xfs_attr_node_removename_setup (args, &state); + error =xfs_attr_node_removename_setup (dac, &state);if (error) goto out;@@ -1270,10 +1358,16 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1368
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +6
-2+ +das_rmtval_remove: +if (args->rmtblkno >0 ) { error =xfs_attr_node_removename_rmt (args, state); -if (error) - goto out; +if (error) { +if (error == -EAGAIN ) + dac->dela_state =XFS_DAS_RMTVAL_REMOVE ;
Shouldn't XFS_DAC_DEFER_FINISH be set in dac->flags? xfs_attr_node_removename_rmt() indirectly calls __xfs_bunmapi() which would have added items to the deferred list.
Signature · 1 line
chandan
Re: [PATCH v8 18/20] xfs: Add delay ready attr remove routines
Quoted 343 lines · Chandan Rajendra
Quoted 342 lines · Allison Collins
This patch modifies the attr remove routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_remove_argshas becomexfs_attr_remove_iter, which uses a sort of state machine like switch to keep track of where it was when EAGAIN was returned.xfs_attr_node_removenamehas also been modified to use the switch, and a new version ofxfs_attr_remove_argsconsists of a simple loop to refresh the transaction until the operation is completed.Calls to
xfs_attr_rmtval_removeare replaced with the delay ready counter parts:xfs_attr_rmtval_invalidate(appearing in the setup helper) and then__xfs_attr_rmtval_remove. We will rename__xfs_attr_rmtval_removeback toxfs_attr_rmtval_removewhen we are done.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 newxfs_delattr_stateenum 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.Below is a state machine diagram for attr remove operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_remove_iter()XFS_DAS_RM_SHRINK ─┐ (subroutine state) │ │ XFS_DAS_RMTVAL_REMOVE ─┤ (subroutine state) │ └─>xfs_attr_node_removename() │v
need to remove
┌─n── rmt blocks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_RMTVAL_REMOVE
│ │ │
│ │ v
│ └──y── more blks
│ to remove?
│ │
│ n
│ │
│ v
│ need to
└─────> shrink tree? ─n─┐
│ │
y │
│ │
v │
XFS_DAS_RM_SHRINK│
│ │
v │
done <─────┘Signed-off-by Allison Collins <[email protected]>--- fs/xfs/libxfs/xfs_attr.c | 168 ++++++++++++++++++++++++++++++++++++----------- fs/xfs/libxfs/xfs_attr.h | 38 +++++++++++ 2 files changed, 168 insertions(+), 38 deletions(-)fs/xfs/libxfs/xfs_attr.c +117
-27@@ -45,7 +45,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);*/ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_removename(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);/* @@ -53,12 +53,21 @@ 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_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC void +xfs_delattr_context_init ( +struct xfs_delattr_context *dac, +struct xfs_da_args *args) +{ +memset (dac,0 ,sizeof (struct xfs_delattr_context )); + dac->da_args = args; +} +int xfs_inode_hasattr (struct xfs_inode *ip)@@ -356,20 +365,66 @@ xfs_has_attr(*/ int xfs_attr_remove_args ( -struct xfs_da_args *args) +struct xfs_da_args *args) { +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_remove_iter (&dac); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + }while (true); + +return error; +} + +/* +* Remove the attribute specified in @args. +* +* This function may return -EAGAIN to signal that the transaction needs to be +* rolled. Callers should continue calling this function until they receive a +* return value other than -EAGAIN. +*/ +int +xfs_attr_remove_iter ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args;struct xfs_inode *dp = args->dp;int error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RM_SHRINK : +case XFS_DAS_RMTVAL_REMOVE : +return xfs_attr_node_removename (dac); +default : +break ; + } +if (!xfs_inode_hasattr (dp)) { error = -ENOATTR ; }else if (dp->i_d.di_aformat ==XFS_DINODE_FMT_LOCAL ) {ASSERT (dp->i_afp->if_flags &XFS_IFINLINE ); error =xfs_attr_shortform_remove (args); }else if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_removename (args); + error =xfs_attr_leaf_removename (dac); }else { - error =xfs_attr_node_removename (args); + error =xfs_attr_node_removename (dac); }return error;@@ -794,11 +849,12 @@ xfs_attr_leaf_hasname(*/ STATIC intxfs_attr_leaf_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_inode *dp; -struct xfs_buf *bp; -int error, forkoff; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp; +struct xfs_buf *bp; +int error, forkoff;trace_xfs_attr_leaf_removename (args);@@ -825,9 +881,8 @@ xfs_attr_leaf_removename(/* bp is gone due to xfs_da_shrink_inode */ if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; }return 0 ; }@@ -1128,12 +1183,13 @@ xfs_attr_node_addname(*/ STATIC intxfs_attr_node_shrink ( -struct xfs_da_args *args, -struct xfs_da_state *state) +struct xfs_delattr_context *dac, +struct xfs_da_state *state) { -struct xfs_inode *dp = args->dp; -int error, forkoff; -struct xfs_buf *bp; +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error, forkoff; +struct xfs_buf *bp;/* * Have to get rid of the copy of this dabuf in the state. @@ -1153,9 +1209,7 @@ xfs_attr_node_shrink(if (error)return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; + dac->flags |=XFS_DAC_DEFER_FINISH ; }else xfs_trans_brelse (args->trans, bp);@@ -1194,13 +1248,15 @@ xfs_attr_leaf_mark_incomplete(/* * Initial setup for xfs_attr_node_removename. Make sure the attr is there and -* the blocks are valid. Any remote blocks will be marked incomplete. +* the blocks are valid. Any remote blocks will be marked incomplete and +* invalidated. */ STATIC int xfs_attr_node_removename_setup( -struct xfs_da_args *args, -struct xfs_da_state **state) +struct xfs_delattr_context *dac, +struct xfs_da_state **state) { +struct xfs_da_args *args = dac->da_args;int error;struct xfs_da_state_blk *blk;@@ -1212,10 +1268,21 @@ int xfs_attr_node_removename_setup(ASSERT (blk->bp !=NULL );ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); +/* +* Store blk and state in the context incase we need to cycle out the +* transaction +*/ + dac->blk = blk; + dac->da_state = *state; +if (args->rmtblkno >0 ) { error =xfs_attr_leaf_mark_incomplete (args, *state);if (error)return error; + + error =xfs_attr_rmtval_invalidate (args); +if (error) +return error; }return 0 ;@@ -1228,7 +1295,10 @@ xfs_attr_node_removename_rmt ( {int error =0 ; - error =xfs_attr_rmtval_remove (args); +/* +* May return -EAGAIN to request that the caller recall this function +*/ + error =__xfs_attr_rmtval_remove (args);if (error)return error;@@ -1249,19 +1319,37 @@ xfs_attr_node_removename_rmt (* This will involve walking down the Btree, and may involve joining * leaf nodes and even joining intermediate nodes up to and including * the root node (a special case of an intermediate node). +* +* This routine is meant to function as either an inline or delayed operation, +* and may return -EAGAIN when the transaction needs to be rolled. Calling +* functions will need to handle this, and recall the function until a +* successful error code is returned. */ STATIC intxfs_attr_node_removename ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { +struct xfs_da_args *args = dac->da_args;struct xfs_da_state *state;struct xfs_da_state_blk *blk;int retval, error;struct xfs_inode *dp = args->dp;trace_xfs_attr_node_removename (args); + state = dac->da_state; + blk = dac->blk; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_RMTVAL_REMOVE : + goto das_rmtval_remove; +case XFS_DAS_RM_SHRINK : + goto das_rm_shrink; +default : +break ; + } - error =xfs_attr_node_removename_setup (args, &state); + error =xfs_attr_node_removename_setup (dac, &state);if (error) goto out;@@ -1270,10 +1358,16 @@ xfs_attr_node_removename(* This is done before we remove the attribute so that we don't * overflow the maximum size of a transaction and/or hit a deadlock. */ + +das_rmtval_remove: +if (args->rmtblkno >0 ) { error =xfs_attr_node_removename_rmt (args, state); -if (error)
Quoted 9 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_removename( · line 1368
Quoted 4 lines
fs/xfs/libxfs/xfs_attr.c +3
-1- goto out; +if (error) { +if (error == -EAGAIN ) + dac->dela_state =XFS_DAS_RMTVAL_REMOVE ;Shouldn't
XFS_DAC_DEFER_FINISHbe set indac->flags?xfs_attr_node_removename_rmt()indirectly calls__xfs_bunmapi()which would have added items to the deferred list.
Ok I see it. I think what I'll do based on the over all v8 feed back is: make __xfs_attr_rmtval_remove a helper function of xfs_attr_rmtval_remove in patch 10. I'll keep the xfs_defer_finish as part of that helper. Then when we come to this patch, the xfs_defer_finish will turn into the flag set. That should fix this I believe. Thank for the review!
Allison
PATCH v8 19/20 xfs: Add delay ready attr set routines
In reply to Allison CollinsThis 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.
Two new helper functions have been added: xfs_attr_rmtval_set_init 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.
Below is a state machine diagram for attr set operations. The XFS_DAS_* states indicate places where the function would return -EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_set_iter()
│
v
need to upgrade
from sf to leaf? ──n─┐
│ │
y │
│ │
V │
XFS_DAS_ADD_LEAF │
│ │
v │
┌──────n── fork has <──────┘
│ only 1 blk?
│ │
│ y
│ │
│ v
│ xfs_attr_leaf_try_add()
│ │
│ v
│ had enough
├──────n── space?
│ │
│ y
│ │
│ v
│ XFS_DAS_FOUND_LBLK ──┐
│ │
│ XFS_DAS_FLIP_LFLAG ──┤
│ (subroutine state) │
│ │
│ XFS_DAS_ALLOC_LEAF ──┤
│ (subroutine state) │
│ └─>xfs_attr_leaf_addname()
│ │
│ v
│ ┌─────n── need to
│ │ alloc blks?
│ │ │
│ │ y
│ │ │
│ │ v
│ │ ┌─>XFS_DAS_ALLOC_LEAF
│ │ │ │
│ │ │ v
│ │ └──y── need to alloc
│ │ more blocks?
│ │ │
│ │ n
│ │ │
│ │ v
│ │ was this
│ └────────> a rename? ──n─┐
│ │ │
│ y │
│ │ │
│ v │
│ flip incomplete │
│ flag │
│ │ │
│ v │
│ XFS_DAS_FLIP_LFLAG │
│ │ │
│ v │
│ remove │
│ XFS_DAS_RM_LBLK ─> old name │
│ ^ │ │
│ │ v │
│ └──────y── more to │
│ remove │
│ │ │
│ n │
│ │ │
│ v │
│ done <──────┘
└────> XFS_DAS_LEAF_TO_NODE ─┐
│
XFS_DAS_FOUND_NBLK ──┤
(subroutine state) │
│
XFS_DAS_ALLOC_NODE ──┤
(subroutine state) │
│
XFS_DAS_FLIP_NFLAG ──┤
(subroutine state) │
│
└─>xfs_attr_node_addname()
│ v
find space to store
attr. Split if needed
│ v
XFS_DAS_FOUND_NBLK
│ v
┌─────n── need to
│ alloc blks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_ALLOC_NODE
│ │ │
│ │ v
│ └──y── need to alloc
│ more blocks?
│ │
│ n
│ │
│ v
│ was this
└────────> a rename? ──n─┐
│ │
y │
│ │
v │
flip incomplete │
flag │
│ │
v │
XFS_DAS_FLIP_NFLAG │
│ │
v │
remove │
XFS_DAS_RM_NBLK ─> old name │
^ │ │
│ v │
└──────y── more to │
remove │
│ │
n │
│ │
v │
done <──────┘
--- fs/xfs/libxfs/xfs_attr.c | 384 +++++++++++++++++++++++++++------------- fs/xfs/libxfs/xfs_attr.h | 16 ++ fs/xfs/libxfs/xfs_attr_leaf.c | 1 + fs/xfs/libxfs/xfs_attr_remote.c | 111 +++++++----- fs/xfs/libxfs/xfs_attr_remote.h | 4 + fs/xfs/xfs_attr_inactive.c | 1 + fs/xfs/xfs_trace.h | 1 - 7 files changed, 351 insertions(+), 167 deletions(-)
fs/xfs/libxfs/xfs_attr.c +262 -122
@@ -44,7 +44,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);* Internal routines when attribute list is one block. */ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_addname(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);
@@ -52,12 +52,13 @@ 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_delattr_context *dac); STATIC int xfs_attr_node_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC int xfs_attr_leaf_try_add(struct xfs_da_args *args, struct xfs_buf *bp); STATIC void xfs_delattr_context_init(
@@ -227,8 +228,11 @@ xfs_attr_is_shortform(/* * Attempts to set an attr in shortform, or converts the tree to leaf form if -* there is not enough room. If the attr is set, the transaction is committed -* and set to NULL. +* there is not enough room. This function is meant to operate as a helper +* routine to the delayed attribute functions. It returns -EAGAIN to indicate +* that the calling function should roll the transaction, and then proceed to +* add the attr in leaf form. This subroutine does not expect to be recalled +* again like the other delayed attr routines do. */ STATIC int xfs_attr_set_shortform(
@@ -236,16 +240,16 @@ xfs_attr_set_shortform( struct xfs_buf **leaf_bp) {struct xfs_inode *dp = args->dp; -int error, error2 =0 ; +int error =0 ;/* * Try to add the attr to the attribute list in the inode. */ error =xfs_attr_try_sf_addname (dp, args); + +/* Should only be 0, -EEXIST or ENOSPC */ if (error != -ENOSPC ) { - error2 =xfs_trans_commit (args->trans); - args->trans =NULL ; -return error ? error : error2; +return error; }/* * It won't fit in the shortform, transform to a leaf block. GROT:
@@ -258,18 +262,10 @@ xfs_attr_set_shortform(/* * 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. +* 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 0 ; +return -EAGAIN ; }/*
@@ -279,9 +275,83 @@ intxfs_attr_set_args ( struct xfs_da_args *args) { -struct xfs_inode *dp = args->dp; -struct xfs_buf *leaf_bp =NULL ; -int error =0 ; +struct xfs_buf *leaf_bp =NULL ; +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_set_iter (&dac, &leaf_bp); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + +if (leaf_bp) { +xfs_trans_bjoin (args->trans, leaf_bp); +xfs_trans_bhold (args->trans, leaf_bp); + } + + }while (true); + +return error; +} + +/* +* Set the attribute specified in @args. +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +* returned. +*/ +int +xfs_attr_set_iter ( +struct xfs_delattr_context *dac, +struct xfs_buf **leaf_bp) +{ +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error =0 ; +int sf_size; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_ADD_LEAF : + goto das_add_leaf; +case XFS_DAS_ALLOC_LEAF : +case XFS_DAS_FLIP_LFLAG : +case XFS_DAS_FOUND_LBLK : + goto das_leaf; +case XFS_DAS_FOUND_NBLK : +case XFS_DAS_FLIP_NFLAG : +case XFS_DAS_ALLOC_NODE : +case XFS_DAS_LEAF_TO_NODE : + goto das_node; +default : +break ; + } + +/* +* New inodes may not have an attribute fork yet. So set the attribute +* fork appropriately +*/ +if (XFS_IFORK_Q ((args->dp)) ==0 ) { + sf_size =sizeof (struct xfs_attr_sf_hdr ) + +XFS_ATTR_SF_ENTSIZE_BYNAME (args->namelen, args->valuelen); +xfs_bmap_set_attrforkoff (args->dp, sf_size,NULL ); + args->dp->i_afp =kmem_zone_zalloc (xfs_ifork_zone,0 ); + args->dp->i_afp->if_flags =XFS_IFEXTENTS ; + }/* * If the attribute list is already in leaf format, jump straight to
@@ -292,40 +362,53 @@ xfs_attr_set_args(if (xfs_attr_is_shortform (dp)) {/* -* 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. +* If the attr was successfully set in shortform, no need to +* continue. Otherwise, is it converted from shortform to leaf +* and -EAGAIN is returned. */ - error =xfs_attr_set_shortform (args, &leaf_bp); -if (error || !args->trans) -return error; + error =xfs_attr_set_shortform (args, leaf_bp); +if (error == -EAGAIN ) { + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ADD_LEAF ; + } +return error; } -if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_addname (args); -if (error != -ENOSPC ) -return error; +das_add_leaf: -/* -* Commit that transaction so that the node_addname() -* call can manage its own transactions. -*/ - error =xfs_defer_finish (&args->trans); -if (error) -return error; +/* +* After a shortform to leaf conversion, we need to hold the leaf and +* cylce out the transaction. When we get back, we need to release +* the leaf. +*/ +if (*leaf_bp !=NULL ) { +xfs_trans_brelse (args->trans, *leaf_bp); + *leaf_bp =NULL ; + } -/* -* Commit the current trans (including the inode) and -* start a new one. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { + error =xfs_attr_leaf_try_add (args, *leaf_bp); +switch (error) { +case -ENOSPC : + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_LEAF_TO_NODE ; +return -EAGAIN ; +case 0 : + dac->dela_state =XFS_DAS_FOUND_LBLK ; +return -EAGAIN ; +default :return error; - + } +das_leaf: + error =xfs_attr_leaf_addname (dac); +if (error == -ENOSPC ) { + dac->dela_state =XFS_DAS_LEAF_TO_NODE ; +return -EAGAIN ; + } +return error; } - - error =xfs_attr_node_addname (args); +das_node: + error =xfs_attr_node_addname (dac);return error; }
@@ -716,28 +799,32 @@ xfs_attr_leaf_try_add(* * This leaf block cannot have a "remote" value, we only call this routine * if bmap_one_block() says there is only one block (ie: no remote blks). +* +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +* returned. */ STATIC intxfs_attr_leaf_addname ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -int error, forkoff; -struct xfs_buf *bp =NULL ; -struct xfs_inode *dp = args->dp; - -trace_xfs_attr_leaf_addname (args); - - error =xfs_attr_leaf_try_add (args, bp); -if (error) -return error; +struct xfs_da_args *args = dac->da_args; +struct xfs_buf *bp =NULL ; +int error, forkoff; +struct xfs_inode *dp = args->dp; -/* -* Commit the transaction that added the attr name so that -* later routines can manage their own transactions. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) -return error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_FLIP_LFLAG : + goto das_flip_flag; +case XFS_DAS_ALLOC_LEAF : + goto das_alloc_leaf; +case XFS_DAS_RM_LBLK : + goto das_rm_lblk; +default : +break ; + }/* * If there was an out-of-line value, allocate the blocks we
@@ -746,7 +833,28 @@ xfs_attr_leaf_addname(* maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - error =xfs_attr_rmtval_set (args); + +/* Open coded xfs_attr_rmtval_set without trans handling */ + error =xfs_attr_rmtval_set_init (dac); +if (error) +return error; + +/* +* Roll through the "value", allocating blocks on disk as +* required. +*/ +das_alloc_leaf: +while (dac->blkcnt >0 ) { + error =xfs_attr_rmtval_set_blk (dac); +if (error) +return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ALLOC_LEAF ; +return -EAGAIN ; + } + + error =xfs_attr_rmtval_set_value (args);if (error)return error; }
@@ -765,22 +873,25 @@ xfs_attr_leaf_addname( error =xfs_attr3_leaf_flipflags (args);if (error)return error; -/* -* Commit the flag value change and start the next trans in -* series. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) -return error; - + dac->dela_state =XFS_DAS_FLIP_LFLAG ; +return -EAGAIN ; +das_flip_flag:/* * Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ xfs_attr_restore_rmt_blk (args); +xfs_attr_rmtval_invalidate (args); +das_rm_lblk:if (args->rmtblkno) { - error =xfs_attr_rmtval_remove (args); + error =__xfs_attr_rmtval_remove (args); + +if (error == -EAGAIN ) { + dac->dela_state =XFS_DAS_RM_LBLK ; +return -EAGAIN ; + } +if (error)return error; }
@@ -799,15 +910,11 @@ xfs_attr_leaf_addname(/* * If the result is small enough, shrink it all into the inode. */ -if ((forkoff =xfs_attr_shortform_allfit (bp, dp))) { + forkoff =xfs_attr_shortform_allfit (bp, dp); +if (forkoff) error =xfs_attr3_leaf_to_shortform (bp, args, forkoff); -/* bp is gone due to xfs_da_shrink_inode */ -if (error) -return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; - } + + dac->flags |=XFS_DAC_DEFER_FINISH ; }else if (args->rmtblkno >0 ) {/*
@@ -967,16 +1074,23 @@ xfs_attr_node_hasname(* * "Remote" attribute values confuse the issue and atomic rename operations * add a whole extra layer of confusion on top of that. +* +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +*returned. */ STATIC intxfs_attr_node_addname ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_da_state *state; -struct xfs_da_state_blk *blk; -struct xfs_inode *dp; -struct xfs_mount *mp; -int retval, error; +struct xfs_da_args *args = dac->da_args; +struct xfs_da_state *state =NULL ; +struct xfs_da_state_blk *blk; +struct xfs_inode *dp; +struct xfs_mount *mp; +int retval =0 ; +int error =0 ;trace_xfs_attr_node_addname (args);
@@ -985,7 +1099,21 @@ xfs_attr_node_addname(*/ dp = args->dp; mp = dp->i_mount; -restart: + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_FLIP_NFLAG : + goto das_flip_flag; +case XFS_DAS_FOUND_NBLK : + goto das_found_nblk; +case XFS_DAS_ALLOC_NODE : + goto das_alloc_node; +case XFS_DAS_RM_NBLK : + goto das_rm_nblk; +default : +break ; + } +/* * Search to see if name already exists, and get back a pointer * to where it should go.
@@ -1031,19 +1159,13 @@ xfs_attr_node_addname( error =xfs_attr3_leaf_to_node (args);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out;/* -* Commit the node conversion and start the next -* trans in the chain. +* Restart routine from the top. No need to set the +* state */ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; - - goto restart; + dac->flags |=XFS_DAC_DEFER_FINISH ; +return -EAGAIN ; }/*
@@ -1055,9 +1177,7 @@ xfs_attr_node_addname( error =xfs_da3_split (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; + dac->flags |=XFS_DAC_DEFER_FINISH ; }else {/* * Addition succeeded, update Btree hashvals.
@@ -1072,13 +1192,9 @@ xfs_attr_node_addname(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; + dac->dela_state =XFS_DAS_FOUND_NBLK ; +return -EAGAIN ; +das_found_nblk:/* * If there was an out-of-line value, allocate the blocks we
@@ -1087,7 +1203,27 @@ xfs_attr_node_addname(* maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - error =xfs_attr_rmtval_set (args); +/* Open coded xfs_attr_rmtval_set without trans handling */ + error =xfs_attr_rmtval_set_init (dac); +if (error) +return error; + +/* +* Roll through the "value", allocating blocks on disk as +* required. +*/ +das_alloc_node: +while (dac->blkcnt >0 ) { + error =xfs_attr_rmtval_set_blk (dac); +if (error) +return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ALLOC_NODE ; +return -EAGAIN ; + } + + error =xfs_attr_rmtval_set_value (args);if (error)return error; }
@@ -1110,18 +1246,26 @@ xfs_attr_node_addname(* 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; - + dac->dela_state =XFS_DAS_FLIP_NFLAG ; +return -EAGAIN ; +das_flip_flag:/* * Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ xfs_attr_restore_rmt_blk (args); +xfs_attr_rmtval_invalidate (args); + +das_rm_nblk:if (args->rmtblkno) { - error =xfs_attr_rmtval_remove (args); + error =__xfs_attr_rmtval_remove (args); + +if (error == -EAGAIN ) { + dac->dela_state =XFS_DAS_RM_NBLK ; +return -EAGAIN ; + } +if (error)return error; }
@@ -1139,7 +1283,6 @@ xfs_attr_node_addname( error =xfs_da3_node_lookup_int (state, &retval);if (error) goto out; -/* * Remove the name and update the hashvals in the tree. */
@@ -1147,7 +1290,6 @@ xfs_attr_node_addname(ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); error =xfs_attr3_leaf_remove (blk->bp, args);xfs_da3_fixhashpath (state, &state->path); -/* * Check to see if the tree needs to be collapsed. */
@@ -1155,11 +1297,9 @@ xfs_attr_node_addname( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; - } + dac->flags |=XFS_DAC_DEFER_FINISH ; + } }else if (args->rmtblkno >0 ) {/* * Added a "remote" value, just clear the incomplete flag.
fs/xfs/libxfs/xfs_attr.h +16 -0
@@ -93,6 +93,16 @@ enum xfs_delattr_state {/* Zero is uninitalized */ XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +XFS_DAS_ADD_LEAF ,/* We are adding a leaf attr */ +XFS_DAS_FOUND_LBLK ,/* We found leaf blk for attr */ +XFS_DAS_LEAF_TO_NODE ,/* Converted leaf to node */ +XFS_DAS_FOUND_NBLK ,/* We found node blk for attr */ +XFS_DAS_ALLOC_LEAF ,/* We are allocating leaf blocks */ +XFS_DAS_FLIP_LFLAG ,/* Flipped leaf INCOMPLETE attr flag */ +XFS_DAS_RM_LBLK ,/* A rename is removing leaf blocks */ +XFS_DAS_ALLOC_NODE ,/* We are allocating node blocks */ +XFS_DAS_FLIP_NFLAG ,/* Flipped node INCOMPLETE attr flag */ + XFS_DAS_RM_NBLK, /* A rename is removing node blocks */ };/*
@@ -105,8 +115,13 @@ enum xfs_delattr_state {*/ struct xfs_delattr_context {struct xfs_da_args *da_args; +struct xfs_bmbt_irec map; +struct xfs_buf *leaf_bp; +xfs_fileoff_t lfileoff;struct xfs_da_state *da_state;struct xfs_da_state_blk *blk; +xfs_dablk_t lblkno; +int blkcnt;unsigned int flags;enum xfs_delattr_state dela_state; };
@@ -126,6 +141,7 @@ 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_args (struct xfs_da_args *args); +int xfs_attr_set_iter (struct xfs_delattr_context *dac,struct xfs_buf **leaf_bp);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args);int xfs_attr_remove_iter (struct xfs_delattr_context *dac);
fs/xfs/libxfs/xfs_attr_leaf.c +1 -0
@@ -19,6 +19,7 @@#include "xfs_bmap_btree.h" #include "xfs_bmap.h" #include "xfs_attr_sf.h" +#include "xfs_attr.h" #include "xfs_attr_remote.h" #include "xfs_attr.h" #include "xfs_attr_leaf.h"
fs/xfs/libxfs/xfs_attr_remote.c +67 -44
135 lines not on this page · raw message
fs/xfs/libxfs/xfs_attr_remote.h +4 -0
@@ -15,4 +15,8 @@ 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_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_set_init (struct xfs_delattr_context *dac);#endif /* __XFS_ATTR_REMOTE_H__ */
fs/xfs/xfs_attr_inactive.c +1 -0
@@ -15,6 +15,7 @@#include "xfs_da_format.h" #include "xfs_da_btree.h" #include "xfs_inode.h" +#include "xfs_attr.h" #include "xfs_attr_remote.h" #include "xfs_trans.h" #include "xfs_bmap.h"
fs/xfs/xfs_trace.h +0 -1
@@ -1784,7 +1784,6 @@ DEFINE_ATTR_EVENT(xfs_attr_refillstate);DEFINE_ATTR_EVENT (xfs_attr_rmtval_get);DEFINE_ATTR_EVENT (xfs_attr_rmtval_set); -DEFINE_ATTR_EVENT (xfs_attr_rmtval_remove);#define DEFINE_DA_EVENT (name) \ DEFINE_EVENT(xfs_da_class, name, \
Signature · 1 line
2.7.4
Re: [PATCH v8 19/20] xfs: Add delay ready attr set routines
Quoted 163 lines · Allison Collins
This patch modifies the attr set routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_set_argshas becomexfs_attr_set_iter, which uses a state machine like switch to keep track of where it was when EAGAIN was returned.Two new helper functions have been added:
xfs_attr_rmtval_set_initandxfs_attr_rmtval_set_blk. They provide a subset of logic similar toxfs_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 byxfs_attr_leaf_addnameandxfs_attr_node_addname.xfs_attr_set_argshas now become a simple loop to refresh the transaction until the operation is completed. Lastly,xfs_attr_rmtval_removeis no longer used, and is removed.Below is a state machine diagram for attr set operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_set_iter()
│
v
need to upgrade
from sf to leaf? ──n─┐
│ │
y │
│ │
V │
XFS_DAS_ADD_LEAF│
│ │
v │┌──────n── fork has <──────┘ │ only 1 blk? │ │ │ y │ │ │ v │ xfs_attr_leaf_try_add() │ │ │ v │ had enough ├──────n── space? │ │ │ y │ │ │ v │ XFS_DAS_FOUND_LBLK ──┐ │ │ │ XFS_DAS_FLIP_LFLAG ──┤ │ (subroutine state) │ │ │ │ XFS_DAS_ALLOC_LEAF ──┤ │ (subroutine state) │ │ └─>xfs_attr_leaf_addname() │ │ │ v │ ┌─────n── need to │ │ alloc blks? │ │ │ │ │ y │ │ │ │ │ v │ │ ┌─>XFS_DAS_ALLOC_LEAF │ │ │ │ │ │ │ v │ │ └──y── need to alloc │ │ more blocks? │ │ │ │ │ n │ │ │ │ │ v │ │ was this │ └────────> a rename? ──n─┐ │ │ │ │ y │ │ │ │ │ v │ │ flip incomplete │ │ flag │ │ │ │ │ v │ │ XFS_DAS_FLIP_LFLAG │ │ │ │ │ v │ │ remove │ │ XFS_DAS_RM_LBLK ─> old name │ │ ^ │ │ │ │ v │ │ └──────y── more to │ │ remove │ │ │ │ │ n │ │ │ │ │ v │ │ done <──────┘ └────> XFS_DAS_LEAF_TO_NODE ─┐ │ XFS_DAS_FOUND_NBLK ──┤ (subroutine state) │ │ XFS_DAS_ALLOC_NODE ──┤ (subroutine state) │ │ XFS_DAS_FLIP_NFLAG ──┤ (subroutine state) │ │ └─>xfs_attr_node_addname() │v
find space to store
attr. Split if needed
│ v
XFS_DAS_FOUND_NBLK
│ v
┌─────n── need to
│ alloc blks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_ALLOC_NODE
│ │ │
│ │ v
│ └──y── need to alloc
│ more blocks?
│ │
│ n
│ │
│ v
│ was this
└────────> a rename? ──n─┐
│ │
y │
│ │
v │
flip incomplete │
flag │
│ │
v │
XFS_DAS_FLIP_NFLAG│
│ │
v │
remove │
XFS_DAS_RM_NBLK─> old name │
^ │ │
│ v │
└──────y── more to │
remove │
│ │
n │
│ │
v │
done <──────┘
Quoted 2 lines
Signed-off-by Allison Collins <[email protected]>---
Only a cursory pass given the previous feedback...
Quoted 168 lines
fs/xfs/libxfs/xfs_attr.c | 384 +++++++++++++++++++++++++++------------- fs/xfs/libxfs/xfs_attr.h | 16 ++ fs/xfs/libxfs/xfs_attr_leaf.c | 1 + fs/xfs/libxfs/xfs_attr_remote.c | 111 +++++++----- fs/xfs/libxfs/xfs_attr_remote.h | 4 + fs/xfs/xfs_attr_inactive.c | 1 + fs/xfs/xfs_trace.h | 1 - 7 files changed, 351 insertions(+), 167 deletions(-)fs/xfs/libxfs/xfs_attr.c +82
-21@@ -44,7 +44,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);* Internal routines when attribute list is one block. */ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_addname(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);@@ -52,12 +52,13 @@ 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_delattr_context *dac); STATIC int xfs_attr_node_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC int xfs_attr_leaf_try_add(struct xfs_da_args *args, struct xfs_buf *bp); STATIC void xfs_delattr_context_init(@@ -227,8 +228,11 @@ xfs_attr_is_shortform(/* * Attempts to set an attr in shortform, or converts the tree to leaf form if -* there is not enough room. If the attr is set, the transaction is committed -* and set to NULL. +* there is not enough room. This function is meant to operate as a helper +* routine to the delayed attribute functions. It returns -EAGAIN to indicate +* that the calling function should roll the transaction, and then proceed to +* add the attr in leaf form. This subroutine does not expect to be recalled +* again like the other delayed attr routines do. */ STATIC int xfs_attr_set_shortform(@@ -236,16 +240,16 @@ xfs_attr_set_shortform( struct xfs_buf **leaf_bp) {struct xfs_inode *dp = args->dp; -int error, error2 =0 ; +int error =0 ;/* * Try to add the attr to the attribute list in the inode. */ error =xfs_attr_try_sf_addname (dp, args); + +/* Should only be 0, -EEXIST or ENOSPC */ if (error != -ENOSPC ) { - error2 =xfs_trans_commit (args->trans); - args->trans =NULL ; -return error ? error : error2; +return error; }/* * It won't fit in the shortform, transform to a leaf block. GROT: @@ -258,18 +262,10 @@ xfs_attr_set_shortform(/* * 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. +* 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 0 ; +return -EAGAIN ; }/* @@ -279,9 +275,83 @@ intxfs_attr_set_args ( struct xfs_da_args *args) { -struct xfs_inode *dp = args->dp; -struct xfs_buf *leaf_bp =NULL ; -int error =0 ; +struct xfs_buf *leaf_bp =NULL ; +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_set_iter (&dac, &leaf_bp); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + +if (leaf_bp) { +xfs_trans_bjoin (args->trans, leaf_bp); +xfs_trans_bhold (args->trans, leaf_bp); + } + + }while (true); + +return error; +} + +/* +* Set the attribute specified in @args. +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +* returned. +*/ +int +xfs_attr_set_iter ( +struct xfs_delattr_context *dac, +struct xfs_buf **leaf_bp) +{ +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error =0 ; +int sf_size; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_ADD_LEAF : + goto das_add_leaf; +case XFS_DAS_ALLOC_LEAF : +case XFS_DAS_FLIP_LFLAG : +case XFS_DAS_FOUND_LBLK : + goto das_leaf; +case XFS_DAS_FOUND_NBLK : +case XFS_DAS_FLIP_NFLAG : +case XFS_DAS_ALLOC_NODE : +case XFS_DAS_LEAF_TO_NODE : + goto das_node; +default : +break ; + } + +/* +* New inodes may not have an attribute fork yet. So set the attribute
fs/xfs/libxfs/xfs_attr.c int · line 355
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +9
-0+* fork appropriately +*/ +if (XFS_IFORK_Q ((args->dp)) ==0 ) { + sf_size =sizeof (struct xfs_attr_sf_hdr ) + +XFS_ATTR_SF_ENTSIZE_BYNAME (args->namelen, args->valuelen); +xfs_bmap_set_attrforkoff (args->dp, sf_size,NULL ); + args->dp->i_afp =kmem_zone_zalloc (xfs_ifork_zone,0 ); + args->dp->i_afp->if_flags =XFS_IFEXTENTS ; + }
Is this hunk moved from somewhere? If so, we should probably handle that in a separate patch. I think we really want these last couple of patches to introduce the state/markers and not much else.
Quoted 13 lines
fs/xfs/libxfs/xfs_attr.c +3
-4/* * If the attribute list is already in leaf format, jump straight to @@ -292,40 +362,53 @@ xfs_attr_set_args(if (xfs_attr_is_shortform (dp)) {/* -* 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. +* If the attr was successfully set in shortform, no need to +* continue. Otherwise, is it converted from shortform to leaf +* and -EAGAIN is returned.
fs/xfs/libxfs/xfs_attr.c xfs_attr_set_args( · line 374
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +6
-3*/ - error =xfs_attr_set_shortform (args, &leaf_bp); -if (error || !args->trans) -return error; + error =xfs_attr_set_shortform (args, leaf_bp); +if (error == -EAGAIN ) { + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ADD_LEAF ; + } +return error;
Similar to the previous patch, I wonder if we need the explicit states that are otherwise handled by existing inode state. For example, if the above returns -EAGAIN, xfs_attr_is_shortform() is no longer true on reentry, right? If that's the case for the other conversions, it seems like we might only need one state (XFS_DAS_FOUND_LBLK) for this function.
BTW, that general approach might be more clear if we lifted the format conversions into this level from down in the format specific add handlers. The goal would be to make the high level flow look something like:
if (shortform) {
error = sf_try_add();
if (error == -ENOSPC) {
shortform_to_leaf(...);
...
return -EAGAIN;
}
} else if (xfs_bmap_one_block(...)) {
error = xfs_attr_leaf_try_add(args, *leaf_bp);
if (error == -ENOSPC) {
leaf_to_node(...);
return -EAGAIN;
}
... state stuff for leaf add ...
} else {
error = xfs_attr_node_addname(dac);
}Hm? Of course, something like that should be incorporated via independent refactoring patches.
Quoted 116 lines
fs/xfs/libxfs/xfs_attr.c +53
-38} -if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_addname (args); -if (error != -ENOSPC ) -return error; +das_add_leaf: -/* -* Commit that transaction so that the node_addname() -* call can manage its own transactions. -*/ - error =xfs_defer_finish (&args->trans); -if (error) -return error; +/* +* After a shortform to leaf conversion, we need to hold the leaf and +* cylce out the transaction. When we get back, we need to release +* the leaf. +*/ +if (*leaf_bp !=NULL ) { +xfs_trans_brelse (args->trans, *leaf_bp); + *leaf_bp =NULL ; + } -/* -* Commit the current trans (including the inode) and -* start a new one. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { + error =xfs_attr_leaf_try_add (args, *leaf_bp); +switch (error) { +case -ENOSPC : + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_LEAF_TO_NODE ; +return -EAGAIN ; +case 0 : + dac->dela_state =XFS_DAS_FOUND_LBLK ; +return -EAGAIN ; +default :return error; - + } +das_leaf: + error =xfs_attr_leaf_addname (dac); +if (error == -ENOSPC ) { + dac->dela_state =XFS_DAS_LEAF_TO_NODE ; +return -EAGAIN ; + } +return error; } - - error =xfs_attr_node_addname (args); +das_node: + error =xfs_attr_node_addname (dac);return error; }@@ -716,28 +799,32 @@ xfs_attr_leaf_try_add(* * This leaf block cannot have a "remote" value, we only call this routine * if bmap_one_block() says there is only one block (ie: no remote blks). +* +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +* returned. */ STATIC intxfs_attr_leaf_addname ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -int error, forkoff; -struct xfs_buf *bp =NULL ; -struct xfs_inode *dp = args->dp; - -trace_xfs_attr_leaf_addname (args); - - error =xfs_attr_leaf_try_add (args, bp); -if (error) -return error; +struct xfs_da_args *args = dac->da_args; +struct xfs_buf *bp =NULL ; +int error, forkoff; +struct xfs_inode *dp = args->dp; -/* -* Commit the transaction that added the attr name so that -* later routines can manage their own transactions. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) -return error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_FLIP_LFLAG : + goto das_flip_flag; +case XFS_DAS_ALLOC_LEAF : + goto das_alloc_leaf; +case XFS_DAS_RM_LBLK : + goto das_rm_lblk; +default : +break ; + }/* * If there was an out-of-line value, allocate the blocks we @@ -746,7 +833,28 @@ xfs_attr_leaf_addname(* maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - error =xfs_attr_rmtval_set (args); +
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_addname( · line 846
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +10
-0+/* Open coded xfs_attr_rmtval_set without trans handling */ + error =xfs_attr_rmtval_set_init (dac); +if (error) +return error; + +/* +* Roll through the "value", allocating blocks on disk as +* required. +*/ +das_alloc_leaf:
If we filter out the setup above, it seems like this state could be reduced to check for ->blkcnt > 0.
Quoted 36 lines
fs/xfs/libxfs/xfs_attr.c +15
-8+while (dac->blkcnt >0 ) { + error =xfs_attr_rmtval_set_blk (dac); +if (error) +return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ALLOC_LEAF ; +return -EAGAIN ; + } + + error =xfs_attr_rmtval_set_value (args);if (error)return error; }@@ -765,22 +873,25 @@ xfs_attr_leaf_addname( error =xfs_attr3_leaf_flipflags (args);if (error)return error; -/* -* Commit the flag value change and start the next trans in -* series. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) -return error; - + dac->dela_state =XFS_DAS_FLIP_LFLAG ; +return -EAGAIN ; +das_flip_flag:/* * Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ xfs_attr_restore_rmt_blk (args); +xfs_attr_rmtval_invalidate (args);
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_addname( · line 894
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +8
-1+das_rm_lblk:if (args->rmtblkno) { - error =xfs_attr_rmtval_remove (args); + error =__xfs_attr_rmtval_remove (args); + +if (error == -EAGAIN ) { + dac->dela_state =XFS_DAS_RM_LBLK ; +return -EAGAIN ; + } +
This whole function looks like it could use more refactoring to split out the rename case.
Quoted 115 lines
fs/xfs/libxfs/xfs_attr.c +37
-28if (error)return error; }@@ -799,15 +910,11 @@ xfs_attr_leaf_addname(/* * If the result is small enough, shrink it all into the inode. */ -if ((forkoff =xfs_attr_shortform_allfit (bp, dp))) { + forkoff =xfs_attr_shortform_allfit (bp, dp); +if (forkoff) error =xfs_attr3_leaf_to_shortform (bp, args, forkoff); -/* bp is gone due to xfs_da_shrink_inode */ -if (error) -return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; - } + + dac->flags |=XFS_DAC_DEFER_FINISH ; }else if (args->rmtblkno >0 ) {/* @@ -967,16 +1074,23 @@ xfs_attr_node_hasname(* * "Remote" attribute values confuse the issue and atomic rename operations * add a whole extra layer of confusion on top of that. +* +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +*returned. */ STATIC intxfs_attr_node_addname ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_da_state *state; -struct xfs_da_state_blk *blk; -struct xfs_inode *dp; -struct xfs_mount *mp; -int retval, error; +struct xfs_da_args *args = dac->da_args; +struct xfs_da_state *state =NULL ; +struct xfs_da_state_blk *blk; +struct xfs_inode *dp; +struct xfs_mount *mp; +int retval =0 ; +int error =0 ;trace_xfs_attr_node_addname (args);@@ -985,7 +1099,21 @@ xfs_attr_node_addname(*/ dp = args->dp; mp = dp->i_mount; -restart: + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_FLIP_NFLAG : + goto das_flip_flag; +case XFS_DAS_FOUND_NBLK : + goto das_found_nblk; +case XFS_DAS_ALLOC_NODE : + goto das_alloc_node; +case XFS_DAS_RM_NBLK : + goto das_rm_nblk; +default : +break ; + } +/* * Search to see if name already exists, and get back a pointer * to where it should go. @@ -1031,19 +1159,13 @@ xfs_attr_node_addname( error =xfs_attr3_leaf_to_node (args);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out;/* -* Commit the node conversion and start the next -* trans in the chain. +* Restart routine from the top. No need to set the +* state */ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; - - goto restart; + dac->flags |=XFS_DAC_DEFER_FINISH ; +return -EAGAIN ; }/* @@ -1055,9 +1177,7 @@ xfs_attr_node_addname( error =xfs_da3_split (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; + dac->flags |=XFS_DAC_DEFER_FINISH ; }else {/* * Addition succeeded, update Btree hashvals. @@ -1072,13 +1192,9 @@ xfs_attr_node_addname(xfs_da_state_free (state); state =NULL ;
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_addname( · line 1197
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +3
-7-/* -* 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; + dac->dela_state =XFS_DAS_FOUND_NBLK ; +return -EAGAIN ; +das_found_nblk:
Same deal here. Any time we have this return -EAGAIN followed by a label pattern I think we're going to want to think about refactoring things more first to avoid dumping it in the middle of some unnecessarily large function.
Brian
Quoted 332 lines
fs/xfs/libxfs/xfs_attr.c +36
-12/* * If there was an out-of-line value, allocate the blocks we @@ -1087,7 +1203,27 @@ xfs_attr_node_addname(* maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - error =xfs_attr_rmtval_set (args); +/* Open coded xfs_attr_rmtval_set without trans handling */ + error =xfs_attr_rmtval_set_init (dac); +if (error) +return error; + +/* +* Roll through the "value", allocating blocks on disk as +* required. +*/ +das_alloc_node: +while (dac->blkcnt >0 ) { + error =xfs_attr_rmtval_set_blk (dac); +if (error) +return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ALLOC_NODE ; +return -EAGAIN ; + } + + error =xfs_attr_rmtval_set_value (args);if (error)return error; }@@ -1110,18 +1246,26 @@ xfs_attr_node_addname(* 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; - + dac->dela_state =XFS_DAS_FLIP_NFLAG ; +return -EAGAIN ; +das_flip_flag:/* * Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ xfs_attr_restore_rmt_blk (args); +xfs_attr_rmtval_invalidate (args); + +das_rm_nblk:if (args->rmtblkno) { - error =xfs_attr_rmtval_remove (args); + error =__xfs_attr_rmtval_remove (args); + +if (error == -EAGAIN ) { + dac->dela_state =XFS_DAS_RM_NBLK ; +return -EAGAIN ; + } +if (error)return error; }@@ -1139,7 +1283,6 @@ xfs_attr_node_addname( error =xfs_da3_node_lookup_int (state, &retval);if (error) goto out; -/* * Remove the name and update the hashvals in the tree. */ @@ -1147,7 +1290,6 @@ xfs_attr_node_addname(ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); error =xfs_attr3_leaf_remove (blk->bp, args);xfs_da3_fixhashpath (state, &state->path); -/* * Check to see if the tree needs to be collapsed. */ @@ -1155,11 +1297,9 @@ xfs_attr_node_addname( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; - } + dac->flags |=XFS_DAC_DEFER_FINISH ; + } }else if (args->rmtblkno >0 ) {/* * Added a "remote" value, just clear the incomplete flag. fs/xfs/libxfs/xfs_attr.h +16
-0@@ -93,6 +93,16 @@ enum xfs_delattr_state {/* Zero is uninitalized */ XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +XFS_DAS_ADD_LEAF ,/* We are adding a leaf attr */ +XFS_DAS_FOUND_LBLK ,/* We found leaf blk for attr */ +XFS_DAS_LEAF_TO_NODE ,/* Converted leaf to node */ +XFS_DAS_FOUND_NBLK ,/* We found node blk for attr */ +XFS_DAS_ALLOC_LEAF ,/* We are allocating leaf blocks */ +XFS_DAS_FLIP_LFLAG ,/* Flipped leaf INCOMPLETE attr flag */ +XFS_DAS_RM_LBLK ,/* A rename is removing leaf blocks */ +XFS_DAS_ALLOC_NODE ,/* We are allocating node blocks */ +XFS_DAS_FLIP_NFLAG ,/* Flipped node INCOMPLETE attr flag */ + XFS_DAS_RM_NBLK, /* A rename is removing node blocks */ };/* @@ -105,8 +115,13 @@ enum xfs_delattr_state {*/ struct xfs_delattr_context {struct xfs_da_args *da_args; +struct xfs_bmbt_irec map; +struct xfs_buf *leaf_bp; +xfs_fileoff_t lfileoff;struct xfs_da_state *da_state;struct xfs_da_state_blk *blk; +xfs_dablk_t lblkno; +int blkcnt;unsigned int flags;enum xfs_delattr_state dela_state; };@@ -126,6 +141,7 @@ 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_args (struct xfs_da_args *args); +int xfs_attr_set_iter (struct xfs_delattr_context *dac,struct xfs_buf **leaf_bp);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args);int xfs_attr_remove_iter (struct xfs_delattr_context *dac);fs/xfs/libxfs/xfs_attr_leaf.c +1
-0@@ -19,6 +19,7 @@#include "xfs_bmap_btree.h" #include "xfs_bmap.h" #include "xfs_attr_sf.h" +#include "xfs_attr.h" #include "xfs_attr_remote.h" #include "xfs_attr.h" #include "xfs_attr_leaf.h" fs/xfs/libxfs/xfs_attr_remote.c +67
-44@@ -443,7 +443,7 @@ xfs_attr_rmtval_get(* Find a "hole" in the attribute address space large enough for us to drop the * new attribute's value into */ -STATIC int +int xfs_attr_rmt_find_hole (struct xfs_da_args *args) {@@ -470,7 +470,7 @@ xfs_attr_rmt_find_hole(return 0 ; } -STATIC int +int xfs_attr_rmtval_set_value (struct xfs_da_args *args) {@@ -630,6 +630,71 @@ xfs_attr_rmtval_set( }/* +* Find a hole for the attr and store it in the delayed attr context. This +* initializes the context to roll through allocating an attr extent for a +* delayed attr operation +*/ +int +xfs_attr_rmtval_set_init ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args; +struct xfs_bmbt_irec *map = &dac->map; +int error; + + dac->lblkno =0 ; + dac->lfileoff =0 ; + dac->blkcnt =0 ; + args->rmtblkcnt =0 ; + args->rmtblkno =0 ; +memset (map,0 ,sizeof (struct xfs_bmbt_irec )); + + error =xfs_attr_rmt_find_hole (args); +if (error) +return error; + + dac->blkcnt = args->rmtblkcnt; + dac->lblkno = args->rmtblkno; + +return error; +} + +/* +* Write one block of the value associated with an attribute into the +* out-of-line buffer that we have defined for it. This is similar to a subset +* of xfs_attr_rmtval_set, but records the current block to the delayed attr +* context, and leaves transaction handling to the caller. +*/ +int +xfs_attr_rmtval_set_blk ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +struct xfs_bmbt_irec *map = &dac->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, map, &nmap); +if (error) +return error; + +ASSERT (nmap ==1 ); +ASSERT ((map->br_startblock !=DELAYSTARTBLOCK ) && + (map->br_startblock !=HOLESTARTBLOCK )); + +/* roll attribute extent map forwards */ + dac->lblkno += map->br_blockcount; + dac->blkcnt -= map->br_blockcount; + +return 0 ; +} + +/* * Remove the value associated with an attribute by deleting the * out-of-line buffer that it is stored on. */ @@ -671,48 +736,6 @@ xfs_attr_rmtval_invalidate( }/* -* Remove the value associated with an attribute by deleting the -* out-of-line buffer that it is stored on. -*/ -int -xfs_attr_rmtval_remove ( -struct xfs_da_args *args) -{ -xfs_dablk_t lblkno; -int blkcnt; -int error =0 ; -int done =0 ; - -trace_xfs_attr_rmtval_remove (args); - - error =xfs_attr_rmtval_invalidate (args); -if (error) -return error; -/* -* Keep de-allocating extents until the remote-value region is gone. -*/ - lblkno = args->rmtblkno; - blkcnt = args->rmtblkcnt; -while (!done) { - error =xfs_bunmapi (args->trans, args->dp, lblkno, blkcnt, -XFS_BMAPI_ATTRFORK ,1 , &done); -if (error) -return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; - -/* -* Close out trans and start the next one in the chain. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) -return error; - } -return 0 ; -} - -/* * Remove the value associated with an attribute by deleting the out-of-line * buffer that it is stored on. Returns EAGAIN for the caller to refresh the * transaction and recall the function fs/xfs/libxfs/xfs_attr_remote.h +4
-0@@ -15,4 +15,8 @@ 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_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_set_init (struct xfs_delattr_context *dac);#endif /* __XFS_ATTR_REMOTE_H__ */ fs/xfs/xfs_attr_inactive.c +1
-0@@ -15,6 +15,7 @@#include "xfs_da_format.h" #include "xfs_da_btree.h" #include "xfs_inode.h" +#include "xfs_attr.h" #include "xfs_attr_remote.h" #include "xfs_trans.h" #include "xfs_bmap.h" fs/xfs/xfs_trace.h +0
-1@@ -1784,7 +1784,6 @@ DEFINE_ATTR_EVENT(xfs_attr_refillstate);DEFINE_ATTR_EVENT (xfs_attr_rmtval_get);DEFINE_ATTR_EVENT (xfs_attr_rmtval_set); -DEFINE_ATTR_EVENT (xfs_attr_rmtval_remove);#define DEFINE_DA_EVENT (name) \ DEFINE_EVENT(xfs_da_class, name, \Signature · 1 line
2.7.4
Re: [PATCH v8 19/20] xfs: Add delay ready attr set routines
Quoted 343 lines · Brian Foster
Quoted 163 lines · Allison Collins
This patch modifies the attr set routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_set_argshas becomexfs_attr_set_iter, which uses a state machine like switch to keep track of where it was when EAGAIN was returned.Two new helper functions have been added:
xfs_attr_rmtval_set_initandxfs_attr_rmtval_set_blk. They provide a subset of logic similar toxfs_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 byxfs_attr_leaf_addnameandxfs_attr_node_addname.xfs_attr_set_argshas now become a simple loop to refresh the transaction until the operation is completed. Lastly,xfs_attr_rmtval_removeis no longer used, and is removed.Below is a state machine diagram for attr set operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_set_iter()
│
v
need to upgrade
from sf to leaf? ──n─┐
│ │
y │
│ │
V │
XFS_DAS_ADD_LEAF│
│ │
v │┌──────n── fork has <──────┘ │ only 1 blk? │ │ │ y │ │ │ v │ xfs_attr_leaf_try_add() │ │ │ v │ had enough ├──────n── space? │ │ │ y │ │ │ v │ XFS_DAS_FOUND_LBLK ──┐ │ │ │ XFS_DAS_FLIP_LFLAG ──┤ │ (subroutine state) │ │ │ │ XFS_DAS_ALLOC_LEAF ──┤ │ (subroutine state) │ │ └─>xfs_attr_leaf_addname() │ │ │ v │ ┌─────n── need to │ │ alloc blks? │ │ │ │ │ y │ │ │ │ │ v │ │ ┌─>XFS_DAS_ALLOC_LEAF │ │ │ │ │ │ │ v │ │ └──y── need to alloc │ │ more blocks? │ │ │ │ │ n │ │ │ │ │ v │ │ was this │ └────────> a rename? ──n─┐ │ │ │ │ y │ │ │ │ │ v │ │ flip incomplete │ │ flag │ │ │ │ │ v │ │ XFS_DAS_FLIP_LFLAG │ │ │ │ │ v │ │ remove │ │ XFS_DAS_RM_LBLK ─> old name │ │ ^ │ │ │ │ v │ │ └──────y── more to │ │ remove │ │ │ │ │ n │ │ │ │ │ v │ │ done <──────┘ └────> XFS_DAS_LEAF_TO_NODE ─┐ │ XFS_DAS_FOUND_NBLK ──┤ (subroutine state) │ │ XFS_DAS_ALLOC_NODE ──┤ (subroutine state) │ │ XFS_DAS_FLIP_NFLAG ──┤ (subroutine state) │ │ └─>xfs_attr_node_addname() │v
find space to store
attr. Split if needed
│ v
XFS_DAS_FOUND_NBLK
│ v
┌─────n── need to
│ alloc blks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_ALLOC_NODE
│ │ │
│ │ v
│ └──y── need to alloc
│ more blocks?
│ │
│ n
│ │
│ v
│ was this
└────────> a rename? ──n─┐
│ │
y │
│ │
v │
flip incomplete │
flag │
│ │
v │
XFS_DAS_FLIP_NFLAG│
│ │
v │
remove │
XFS_DAS_RM_NBLK─> old name │
^ │ │
│ v │
└──────y── more to │
remove │
│ │
n │
│ │
v │
done <──────┘Quoted 2 lines
Signed-off-by Allison Collins <[email protected]>---
Only a cursory pass given the previous feedback...
Quoted 174 lines
fs/xfs/libxfs/xfs_attr.c | 384 +++++++++++++++++++++++++++------------- fs/xfs/libxfs/xfs_attr.h | 16 ++ fs/xfs/libxfs/xfs_attr_leaf.c | 1 + fs/xfs/libxfs/xfs_attr_remote.c | 111 +++++++----- fs/xfs/libxfs/xfs_attr_remote.h | 4 + fs/xfs/xfs_attr_inactive.c | 1 + fs/xfs/xfs_trace.h | 1 - 7 files changed, 351 insertions(+), 167 deletions(-)fs/xfs/libxfs/xfs_attr.c +88
-21@@ -44,7 +44,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);* Internal routines when attribute list is one block. */ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_addname(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);@@ -52,12 +52,13 @@ 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_delattr_context *dac); STATIC int xfs_attr_node_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC int xfs_attr_leaf_try_add(struct xfs_da_args *args, struct xfs_buf *bp); STATIC void xfs_delattr_context_init(@@ -227,8 +228,11 @@ xfs_attr_is_shortform(/* * Attempts to set an attr in shortform, or converts the tree to leaf form if -* there is not enough room. If the attr is set, the transaction is committed -* and set to NULL. +* there is not enough room. This function is meant to operate as a helper +* routine to the delayed attribute functions. It returns -EAGAIN to indicate +* that the calling function should roll the transaction, and then proceed to +* add the attr in leaf form. This subroutine does not expect to be recalled +* again like the other delayed attr routines do. */ STATIC int xfs_attr_set_shortform(@@ -236,16 +240,16 @@ xfs_attr_set_shortform( struct xfs_buf **leaf_bp) {struct xfs_inode *dp = args->dp; -int error, error2 =0 ; +int error =0 ;/* * Try to add the attr to the attribute list in the inode. */ error =xfs_attr_try_sf_addname (dp, args); + +/* Should only be 0, -EEXIST or ENOSPC */ if (error != -ENOSPC ) { - error2 =xfs_trans_commit (args->trans); - args->trans =NULL ; -return error ? error : error2; +return error; }/* * It won't fit in the shortform, transform to a leaf block. GROT: @@ -258,18 +262,10 @@ xfs_attr_set_shortform(/* * 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. +* 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 0 ; +return -EAGAIN ; }/* @@ -279,9 +275,83 @@ intxfs_attr_set_args ( struct xfs_da_args *args) { -struct xfs_inode *dp = args->dp; -struct xfs_buf *leaf_bp =NULL ; -int error =0 ; +struct xfs_buf *leaf_bp =NULL ; +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_set_iter (&dac, &leaf_bp); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + +if (leaf_bp) { +xfs_trans_bjoin (args->trans, leaf_bp); +xfs_trans_bhold (args->trans, leaf_bp); + } + + }while (true); + +return error; +} + +/* +* Set the attribute specified in @args. +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +* returned. +*/ +int +xfs_attr_set_iter ( +struct xfs_delattr_context *dac, +struct xfs_buf **leaf_bp) +{ +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error =0 ; +int sf_size; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_ADD_LEAF : + goto das_add_leaf; +case XFS_DAS_ALLOC_LEAF : +case XFS_DAS_FLIP_LFLAG : +case XFS_DAS_FOUND_LBLK : + goto das_leaf; +case XFS_DAS_FOUND_NBLK : +case XFS_DAS_FLIP_NFLAG : +case XFS_DAS_ALLOC_NODE : +case XFS_DAS_LEAF_TO_NODE : + goto das_node; +default : +break ; + } + +/* +* New inodes may not have an attribute fork yet. So set the attribute +* fork appropriately +*/ +if (XFS_IFORK_Q ((args->dp)) ==0 ) { + sf_size =sizeof (struct xfs_attr_sf_hdr ) + +XFS_ATTR_SF_ENTSIZE_BYNAME (args->namelen, args->valuelen); +xfs_bmap_set_attrforkoff (args->dp, sf_size,NULL );
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c int · line 355
Quoted 4 lines
fs/xfs/libxfs/xfs_attr.c +3
-0+ args->dp->i_afp =kmem_zone_zalloc (xfs_ifork_zone,0 ); + args->dp->i_afp->if_flags =XFS_IFEXTENTS ; + }Is this hunk moved from somewhere? If so, we should probably handle that in a separate patch. I think we really want these last couple of patches to introduce the state/markers and not much else.
Oh, this hunk is new, not moved, I believe it's been here since I picked up the series quite a while ago. It actually has more to do with parent pointers than delayed atts. Basically when we try to add the parent pointer during a create, the inode isnt fully constructed yet, so we have add the fork here. I will put this in a separate patch and move it further up the set.
Quoted 23 lines
Quoted 23 lines
fs/xfs/libxfs/xfs_attr.c +8
-7/* * If the attribute list is already in leaf format, jump straight to @@ -292,40 +362,53 @@ xfs_attr_set_args(if (xfs_attr_is_shortform (dp)) {/* -* 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. +* If the attr was successfully set in shortform, no need to +* continue. Otherwise, is it converted from shortform to leaf +* and -EAGAIN is returned. */ - error =xfs_attr_set_shortform (args, &leaf_bp); -if (error || !args->trans) -return error; + error =xfs_attr_set_shortform (args, leaf_bp); +if (error == -EAGAIN ) { + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ADD_LEAF ; + }
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_set_args( · line 374
Quoted 1 line
fs/xfs/libxfs/xfs_attr.c +1
-0+return error;Similar to the previous patch, I wonder if we need the explicit states that are otherwise handled by existing inode state. For example, if the above returns
-EAGAIN,xfs_attr_is_shortform()is no longer true on reentry, right? If that's the case for the other conversions, it seems like we might only need one state (XFS_DAS_FOUND_LBLK) for this function.
Ok, it looks like I can get away with out XFS_DAS_ADD_LEAF and XFS_DAS_LEAF_TO_NODE.
This is actually a little similar to how it was done when I was trying to use flags instead of the state enums a long time ago. At the time, I got the impression people were concerned about the complexity and maintainability. So we went back to the enums because the explicite jumping made it clear where the re-entry was to resume, and reduced the risk that a person may mistakenly introduce a change that disrupts the reentry flow. Though perhaps the current arrangement of refactoring has made that less concerning?
Quoted 6 lines
BTW, that general approach might be more clear if we lifted the format conversions into this level from down in the format specific add handlers. The goal would be to make the high level flow look something like:
Quoted 7 lines
if (shortform) {
error = sf_try_add();
if (error == -ENOSPC) {
shortform_to_leaf(...);
...
return -EAGAIN;
}Well, actually this piece was hoisted out into the helper function in patch 13. So pulling this up is sort of like letting go of patch 13. :-)
The history is: initially I had tried to reduce indentation here in v6 by taking advantage of the _add_leaf label. Because I think in v5 we were trying to unnest where some of the jump points were. So in v6 I had: "if(!shortform) goto leaf;" Which un-nests this shortform code.
Then in the v7 review I think Dave suggested I should add the helper and invert the check. So now we have "if(shortform()){ call_helper(); handle -EAGAIN; }"
So pulling up is a bit of a circle now. But still functional if people prefer it as it was. Just need to keep track of the history so we avoid going around again. :-)
Quoted 1 line
} else if (xfs_bmap_one_block(...)) {Mmm.... cant jump into the leaf logic right away. We need to handle releasing leaf_bp which looks like it got lost in the pseudo code? IIRC there is a race condition with the AIL that is resolved by holding the leaf buffer across the transaction roll. So we need to check for that and release it upon reentry.
Quoted 5 lines
error = xfs_attr_leaf_try_add(args, *leaf_bp);
if (error == -ENOSPC) {
leaf_to_node(...);
return -EAGAIN;
}Ok, so lift ENOSPC handler from xfs_attr_leaf_try_add
Quoted 8 lines
... state stuff for leaf add ... } else { error = xfs_attr_node_addname(dac); }Hm? Of course, something like that should be incorporated via independent refactoring patches.
I think what this becomes right now is:
Drop patch 13
Add new patch xfs: Lift ENOSPC handler from xfs_attr_leaf_try_add
?
Quoted 122 lines
Quoted 122 lines
fs/xfs/libxfs/xfs_attr.c +58
-38} -if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_addname (args); -if (error != -ENOSPC ) -return error; +das_add_leaf: -/* -* Commit that transaction so that the node_addname() -* call can manage its own transactions. -*/ - error =xfs_defer_finish (&args->trans); -if (error) -return error; +/* +* After a shortform to leaf conversion, we need to hold the leaf and +* cylce out the transaction. When we get back, we need to release +* the leaf. +*/ +if (*leaf_bp !=NULL ) { +xfs_trans_brelse (args->trans, *leaf_bp); + *leaf_bp =NULL ; + } -/* -* Commit the current trans (including the inode) and -* start a new one. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { + error =xfs_attr_leaf_try_add (args, *leaf_bp); +switch (error) { +case -ENOSPC : + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_LEAF_TO_NODE ; +return -EAGAIN ; +case 0 : + dac->dela_state =XFS_DAS_FOUND_LBLK ; +return -EAGAIN ; +default :return error; - + } +das_leaf: + error =xfs_attr_leaf_addname (dac); +if (error == -ENOSPC ) { + dac->dela_state =XFS_DAS_LEAF_TO_NODE ; +return -EAGAIN ; + } +return error; } - - error =xfs_attr_node_addname (args); +das_node: + error =xfs_attr_node_addname (dac);return error; }@@ -716,28 +799,32 @@ xfs_attr_leaf_try_add(* * This leaf block cannot have a "remote" value, we only call this routine * if bmap_one_block() says there is only one block (ie: no remote blks). +* +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +* returned. */ STATIC intxfs_attr_leaf_addname ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -int error, forkoff; -struct xfs_buf *bp =NULL ; -struct xfs_inode *dp = args->dp; - -trace_xfs_attr_leaf_addname (args); - - error =xfs_attr_leaf_try_add (args, bp); -if (error) -return error; +struct xfs_da_args *args = dac->da_args; +struct xfs_buf *bp =NULL ; +int error, forkoff; +struct xfs_inode *dp = args->dp; -/* -* Commit the transaction that added the attr name so that -* later routines can manage their own transactions. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) -return error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_FLIP_LFLAG : + goto das_flip_flag; +case XFS_DAS_ALLOC_LEAF : + goto das_alloc_leaf; +case XFS_DAS_RM_LBLK : + goto das_rm_lblk; +default : +break ; + }/* * If there was an out-of-line value, allocate the blocks we @@ -746,7 +833,28 @@ xfs_attr_leaf_addname(* maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - error =xfs_attr_rmtval_set (args); + +/* Open coded xfs_attr_rmtval_set without trans handling */ + error =xfs_attr_rmtval_set_init (dac); +if (error) +return error; +
Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_addname( · line 846
Quoted 5 lines
fs/xfs/libxfs/xfs_attr.c +5
-0+/* +* Roll through the "value", allocating blocks on disk as +* required. +*/ +das_alloc_leaf:If we filter out the setup above, it seems like this state could be reduced to check for ->blkcnt > 0.
By filter out the set up, you mean to introduce the setup flag like you mentioned earlier? For example:
if(flags & setup == 0){
setup();
flags |= setup;
}To be clear, if we did that, we're talking about adding an "int setup_flags" to the dac. And then defineing a XFS_DAC_SETUP_* scheme. Like a XFS_DAC_SETUP_ADD_NAME, and an XFS_DAC_SETUP_NODE_REMVE_NAME and so on. Because we cant have multiple functions sharing the same set up flag if they ever call each others.
Is that what you mean to imply? Otherwise I may not be clear on what you mean by filtering out the set up.
Quoted 36 lines
Quoted 36 lines
fs/xfs/libxfs/xfs_attr.c +14
-8+while (dac->blkcnt >0 ) { + error =xfs_attr_rmtval_set_blk (dac); +if (error) +return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ALLOC_LEAF ; +return -EAGAIN ; + } + + error =xfs_attr_rmtval_set_value (args);if (error)return error; }@@ -765,22 +873,25 @@ xfs_attr_leaf_addname( error =xfs_attr3_leaf_flipflags (args);if (error)return error; -/* -* Commit the flag value change and start the next trans in -* series. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) -return error; - + dac->dela_state =XFS_DAS_FLIP_LFLAG ; +return -EAGAIN ; +das_flip_flag:/* * Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ xfs_attr_restore_rmt_blk (args);
Quoted 14 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_addname( · line 894
Quoted 11 lines
fs/xfs/libxfs/xfs_attr.c +9
-1+xfs_attr_rmtval_invalidate (args); +das_rm_lblk:if (args->rmtblkno) { - error =xfs_attr_rmtval_remove (args); + error =__xfs_attr_rmtval_remove (args); + +if (error == -EAGAIN ) { + dac->dela_state =XFS_DAS_RM_LBLK ; +return -EAGAIN ; + } +This whole function looks like it could use more refactoring to split out the rename case.
Hmm, how about we take every thing inside the "if (args->op_flags & XFS_DA_OP_RENAME) {" and put it in a xfs_attr_leaf_rename() helper? Then pull the helper into the calling function?
Quoted 116 lines
Quoted 116 lines
fs/xfs/libxfs/xfs_attr.c +37
-28if (error)return error; }@@ -799,15 +910,11 @@ xfs_attr_leaf_addname(/* * If the result is small enough, shrink it all into the inode. */ -if ((forkoff =xfs_attr_shortform_allfit (bp, dp))) { + forkoff =xfs_attr_shortform_allfit (bp, dp); +if (forkoff) error =xfs_attr3_leaf_to_shortform (bp, args, forkoff); -/* bp is gone due to xfs_da_shrink_inode */ -if (error) -return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; - } + + dac->flags |=XFS_DAC_DEFER_FINISH ; }else if (args->rmtblkno >0 ) {/* @@ -967,16 +1074,23 @@ xfs_attr_node_hasname(* * "Remote" attribute values confuse the issue and atomic rename operations * add a whole extra layer of confusion on top of that. +* +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +*returned. */ STATIC intxfs_attr_node_addname ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_da_state *state; -struct xfs_da_state_blk *blk; -struct xfs_inode *dp; -struct xfs_mount *mp; -int retval, error; +struct xfs_da_args *args = dac->da_args; +struct xfs_da_state *state =NULL ; +struct xfs_da_state_blk *blk; +struct xfs_inode *dp; +struct xfs_mount *mp; +int retval =0 ; +int error =0 ;trace_xfs_attr_node_addname (args);@@ -985,7 +1099,21 @@ xfs_attr_node_addname(*/ dp = args->dp; mp = dp->i_mount; -restart: + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_FLIP_NFLAG : + goto das_flip_flag; +case XFS_DAS_FOUND_NBLK : + goto das_found_nblk; +case XFS_DAS_ALLOC_NODE : + goto das_alloc_node; +case XFS_DAS_RM_NBLK : + goto das_rm_nblk; +default : +break ; + } +/* * Search to see if name already exists, and get back a pointer * to where it should go. @@ -1031,19 +1159,13 @@ xfs_attr_node_addname( error =xfs_attr3_leaf_to_node (args);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out;/* -* Commit the node conversion and start the next -* trans in the chain. +* Restart routine from the top. No need to set the +* state */ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; - - goto restart; + dac->flags |=XFS_DAC_DEFER_FINISH ; +return -EAGAIN ; }/* @@ -1055,9 +1177,7 @@ xfs_attr_node_addname( error =xfs_da3_split (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; + dac->flags |=XFS_DAC_DEFER_FINISH ; }else {/* * Addition succeeded, update Btree hashvals. @@ -1072,13 +1192,9 @@ xfs_attr_node_addname(xfs_da_state_free (state); state =NULL ;
Quoted 15 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_addname( · line 1197
Quoted 10 lines
fs/xfs/libxfs/xfs_attr.c +3
-7-/* -* 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; + dac->dela_state =XFS_DAS_FOUND_NBLK ; +return -EAGAIN ; +das_found_nblk:Same deal here. Any time we have this return
-EAGAINfollowed by a label pattern I think we're going to want to think about refactoring things more first to avoid dumping it in the middle of some unnecessarily large function.
Ok, similar pattern here too then? Everything in "if (args->op_flags & XFS_DA_OP_RENAME) {" goes in a new xfs_attr_node_rename() helper? Then hoist upwards?
Thanks for the reviewing!!
Allison
Quoted 336 lines
Brian
Quoted 332 lines
fs/xfs/libxfs/xfs_attr.c +36
-12/* * If there was an out-of-line value, allocate the blocks we @@ -1087,7 +1203,27 @@ xfs_attr_node_addname(* maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - error =xfs_attr_rmtval_set (args); +/* Open coded xfs_attr_rmtval_set without trans handling */ + error =xfs_attr_rmtval_set_init (dac); +if (error) +return error; + +/* +* Roll through the "value", allocating blocks on disk as +* required. +*/ +das_alloc_node: +while (dac->blkcnt >0 ) { + error =xfs_attr_rmtval_set_blk (dac); +if (error) +return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ALLOC_NODE ; +return -EAGAIN ; + } + + error =xfs_attr_rmtval_set_value (args);if (error)return error; }@@ -1110,18 +1246,26 @@ xfs_attr_node_addname(* 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; - + dac->dela_state =XFS_DAS_FLIP_NFLAG ; +return -EAGAIN ; +das_flip_flag:/* * Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ xfs_attr_restore_rmt_blk (args); +xfs_attr_rmtval_invalidate (args); + +das_rm_nblk:if (args->rmtblkno) { - error =xfs_attr_rmtval_remove (args); + error =__xfs_attr_rmtval_remove (args); + +if (error == -EAGAIN ) { + dac->dela_state =XFS_DAS_RM_NBLK ; +return -EAGAIN ; + } +if (error)return error; }@@ -1139,7 +1283,6 @@ xfs_attr_node_addname( error =xfs_da3_node_lookup_int (state, &retval);if (error) goto out; -/* * Remove the name and update the hashvals in the tree. */ @@ -1147,7 +1290,6 @@ xfs_attr_node_addname(ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); error =xfs_attr3_leaf_remove (blk->bp, args);xfs_da3_fixhashpath (state, &state->path); -/* * Check to see if the tree needs to be collapsed. */ @@ -1155,11 +1297,9 @@ xfs_attr_node_addname( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; - } + dac->flags |=XFS_DAC_DEFER_FINISH ; + } }else if (args->rmtblkno >0 ) {/* * Added a "remote" value, just clear the incomplete flag. fs/xfs/libxfs/xfs_attr.h +16
-0@@ -93,6 +93,16 @@ enum xfs_delattr_state {/* Zero is uninitalized */ XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +XFS_DAS_ADD_LEAF ,/* We are adding a leaf attr */ +XFS_DAS_FOUND_LBLK ,/* We found leaf blk for attr */ +XFS_DAS_LEAF_TO_NODE ,/* Converted leaf to node */ +XFS_DAS_FOUND_NBLK ,/* We found node blk for attr */ +XFS_DAS_ALLOC_LEAF ,/* We are allocating leaf blocks */ +XFS_DAS_FLIP_LFLAG ,/* Flipped leaf INCOMPLETE attr flag */ +XFS_DAS_RM_LBLK ,/* A rename is removing leaf blocks */ +XFS_DAS_ALLOC_NODE ,/* We are allocating node blocks */ +XFS_DAS_FLIP_NFLAG ,/* Flipped node INCOMPLETE attr flag */ + XFS_DAS_RM_NBLK, /* A rename is removing node blocks */ };/* @@ -105,8 +115,13 @@ enum xfs_delattr_state {*/ struct xfs_delattr_context {struct xfs_da_args *da_args; +struct xfs_bmbt_irec map; +struct xfs_buf *leaf_bp; +xfs_fileoff_t lfileoff;struct xfs_da_state *da_state;struct xfs_da_state_blk *blk; +xfs_dablk_t lblkno; +int blkcnt;unsigned int flags;enum xfs_delattr_state dela_state; };@@ -126,6 +141,7 @@ 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_args (struct xfs_da_args *args); +int xfs_attr_set_iter (struct xfs_delattr_context *dac,struct xfs_buf **leaf_bp);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args);int xfs_attr_remove_iter (struct xfs_delattr_context *dac);fs/xfs/libxfs/xfs_attr_leaf.c +1
-0@@ -19,6 +19,7 @@#include "xfs_bmap_btree.h" #include "xfs_bmap.h" #include "xfs_attr_sf.h" +#include "xfs_attr.h" #include "xfs_attr_remote.h" #include "xfs_attr.h" #include "xfs_attr_leaf.h" fs/xfs/libxfs/xfs_attr_remote.c +67
-44@@ -443,7 +443,7 @@ xfs_attr_rmtval_get(* Find a "hole" in the attribute address space large enough for us to drop the * new attribute's value into */ -STATIC int +int xfs_attr_rmt_find_hole (struct xfs_da_args *args) {@@ -470,7 +470,7 @@ xfs_attr_rmt_find_hole(return 0 ; } -STATIC int +int xfs_attr_rmtval_set_value (struct xfs_da_args *args) {@@ -630,6 +630,71 @@ xfs_attr_rmtval_set( }/* +* Find a hole for the attr and store it in the delayed attr context. This +* initializes the context to roll through allocating an attr extent for a +* delayed attr operation +*/ +int +xfs_attr_rmtval_set_init ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args; +struct xfs_bmbt_irec *map = &dac->map; +int error; + + dac->lblkno =0 ; + dac->lfileoff =0 ; + dac->blkcnt =0 ; + args->rmtblkcnt =0 ; + args->rmtblkno =0 ; +memset (map,0 ,sizeof (struct xfs_bmbt_irec )); + + error =xfs_attr_rmt_find_hole (args); +if (error) +return error; + + dac->blkcnt = args->rmtblkcnt; + dac->lblkno = args->rmtblkno; + +return error; +} + +/* +* Write one block of the value associated with an attribute into the +* out-of-line buffer that we have defined for it. This is similar to a subset +* of xfs_attr_rmtval_set, but records the current block to the delayed attr +* context, and leaves transaction handling to the caller. +*/ +int +xfs_attr_rmtval_set_blk ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +struct xfs_bmbt_irec *map = &dac->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, map, &nmap); +if (error) +return error; + +ASSERT (nmap ==1 ); +ASSERT ((map->br_startblock !=DELAYSTARTBLOCK ) && + (map->br_startblock !=HOLESTARTBLOCK )); + +/* roll attribute extent map forwards */ + dac->lblkno += map->br_blockcount; + dac->blkcnt -= map->br_blockcount; + +return 0 ; +} + +/* * Remove the value associated with an attribute by deleting the * out-of-line buffer that it is stored on. */ @@ -671,48 +736,6 @@ xfs_attr_rmtval_invalidate( }/* -* Remove the value associated with an attribute by deleting the -* out-of-line buffer that it is stored on. -*/ -int -xfs_attr_rmtval_remove ( -struct xfs_da_args *args) -{ -xfs_dablk_t lblkno; -int blkcnt; -int error =0 ; -int done =0 ; - -trace_xfs_attr_rmtval_remove (args); - - error =xfs_attr_rmtval_invalidate (args); -if (error) -return error; -/* -* Keep de-allocating extents until the remote-value region is gone. -*/ - lblkno = args->rmtblkno; - blkcnt = args->rmtblkcnt; -while (!done) { - error =xfs_bunmapi (args->trans, args->dp, lblkno, blkcnt, -XFS_BMAPI_ATTRFORK ,1 , &done); -if (error) -return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; - -/* -* Close out trans and start the next one in the chain. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) -return error; - } -return 0 ; -} - -/* * Remove the value associated with an attribute by deleting the out-of-line * buffer that it is stored on. Returns EAGAIN for the caller to refresh the * transaction and recall the function fs/xfs/libxfs/xfs_attr_remote.h +4
-0@@ -15,4 +15,8 @@ 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_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_set_init (struct xfs_delattr_context *dac);#endif /* __XFS_ATTR_REMOTE_H__ */ fs/xfs/xfs_attr_inactive.c +1
-0@@ -15,6 +15,7 @@#include "xfs_da_format.h" #include "xfs_da_btree.h" #include "xfs_inode.h" +#include "xfs_attr.h" #include "xfs_attr_remote.h" #include "xfs_trans.h" #include "xfs_bmap.h" fs/xfs/xfs_trace.h +0
-1@@ -1784,7 +1784,6 @@ DEFINE_ATTR_EVENT(xfs_attr_refillstate);DEFINE_ATTR_EVENT (xfs_attr_rmtval_get);DEFINE_ATTR_EVENT (xfs_attr_rmtval_set); -DEFINE_ATTR_EVENT (xfs_attr_rmtval_remove);#define DEFINE_DA_EVENT (name) \ DEFINE_EVENT(xfs_da_class, name, \Signature · 1 line
2.7.4
Re: [PATCH v8 19/20] xfs: Add delay ready attr set routines
Quoted 348 lines · Allison Collins
Quoted 337 lines · Brian Foster
Quoted 163 lines · Allison Collins
This patch modifies the attr set routines to be delay ready. This means they no longer roll or commit transactions, but instead return
-EAGAINto have the calling routine roll and refresh the transaction. In this series,xfs_attr_set_argshas becomexfs_attr_set_iter, which uses a state machine like switch to keep track of where it was when EAGAIN was returned.Two new helper functions have been added:
xfs_attr_rmtval_set_initandxfs_attr_rmtval_set_blk. They provide a subset of logic similar toxfs_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 byxfs_attr_leaf_addnameandxfs_attr_node_addname.xfs_attr_set_argshas now become a simple loop to refresh the transaction until the operation is completed. Lastly,xfs_attr_rmtval_removeis no longer used, and is removed.Below is a state machine diagram for attr set operations. The XFS_DAS_* states indicate places where the function would return
-EAGAIN, and then immediately resume from after being recalled by the calling function. States marked as a "subroutine state" indicate that they belong to a subroutine, and so the calling function needs to pass them back to that subroutine to allow it to finish where it left off. But they otherwise do not have a role in the calling function other than just passing through.
xfs_attr_set_iter()
│
v
need to upgrade
from sf to leaf? ──n─┐
│ │
y │
│ │
V │
XFS_DAS_ADD_LEAF│
│ │
v │┌──────n── fork has <──────┘ │ only 1 blk? │ │ │ y │ │ │ v │ xfs_attr_leaf_try_add() │ │ │ v │ had enough ├──────n── space? │ │ │ y │ │ │ v │ XFS_DAS_FOUND_LBLK ──┐ │ │ │ XFS_DAS_FLIP_LFLAG ──┤ │ (subroutine state) │ │ │ │ XFS_DAS_ALLOC_LEAF ──┤ │ (subroutine state) │ │ └─>xfs_attr_leaf_addname() │ │ │ v │ ┌─────n── need to │ │ alloc blks? │ │ │ │ │ y │ │ │ │ │ v │ │ ┌─>XFS_DAS_ALLOC_LEAF │ │ │ │ │ │ │ v │ │ └──y── need to alloc │ │ more blocks? │ │ │ │ │ n │ │ │ │ │ v │ │ was this │ └────────> a rename? ──n─┐ │ │ │ │ y │ │ │ │ │ v │ │ flip incomplete │ │ flag │ │ │ │ │ v │ │ XFS_DAS_FLIP_LFLAG │ │ │ │ │ v │ │ remove │ │ XFS_DAS_RM_LBLK ─> old name │ │ ^ │ │ │ │ v │ │ └──────y── more to │ │ remove │ │ │ │ │ n │ │ │ │ │ v │ │ done <──────┘ └────> XFS_DAS_LEAF_TO_NODE ─┐ │ XFS_DAS_FOUND_NBLK ──┤ (subroutine state) │ │ XFS_DAS_ALLOC_NODE ──┤ (subroutine state) │ │ XFS_DAS_FLIP_NFLAG ──┤ (subroutine state) │ │ └─>xfs_attr_node_addname() │v
find space to store
attr. Split if needed
│ v
XFS_DAS_FOUND_NBLK
│ v
┌─────n── need to
│ alloc blks?
│ │
│ y
│ │
│ v
│ ┌─>XFS_DAS_ALLOC_NODE
│ │ │
│ │ v
│ └──y── need to alloc
│ more blocks?
│ │
│ n
│ │
│ v
│ was this
└────────> a rename? ──n─┐
│ │
y │
│ │
v │
flip incomplete │
flag │
│ │
v │
XFS_DAS_FLIP_NFLAG│
│ │
v │
remove │
XFS_DAS_RM_NBLK─> old name │
^ │ │
│ v │
└──────y── more to │
remove │
│ │
n │
│ │
v │
done <──────┘Quoted 2 lines
Signed-off-by Allison Collins <[email protected]>---
Only a cursory pass given the previous feedback...
Quoted 168 lines
fs/xfs/libxfs/xfs_attr.c | 384 +++++++++++++++++++++++++++------------- fs/xfs/libxfs/xfs_attr.h | 16 ++ fs/xfs/libxfs/xfs_attr_leaf.c | 1 + fs/xfs/libxfs/xfs_attr_remote.c | 111 +++++++----- fs/xfs/libxfs/xfs_attr_remote.h | 4 + fs/xfs/xfs_attr_inactive.c | 1 + fs/xfs/xfs_trace.h | 1 - 7 files changed, 351 insertions(+), 167 deletions(-)fs/xfs/libxfs/xfs_attr.c +87
-21@@ -44,7 +44,7 @@ STATIC int xfs_attr_shortform_addname(xfs_da_args_t *args);* Internal routines when attribute list is one block. */ STATIC int xfs_attr_leaf_get(xfs_da_args_t *args); -STATIC int xfs_attr_leaf_addname(xfs_da_args_t *args); +STATIC int xfs_attr_leaf_addname(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_removename(struct xfs_delattr_context *dac); STATIC int xfs_attr_leaf_hasname(struct xfs_da_args *args, struct xfs_buf **bp);@@ -52,12 +52,13 @@ 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_delattr_context *dac); STATIC int xfs_attr_node_removename(struct xfs_delattr_context *dac); 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); STATIC int xfs_attr_refillstate(xfs_da_state_t *state); +STATIC int xfs_attr_leaf_try_add(struct xfs_da_args *args, struct xfs_buf *bp); STATIC void xfs_delattr_context_init(@@ -227,8 +228,11 @@ xfs_attr_is_shortform(/* * Attempts to set an attr in shortform, or converts the tree to leaf form if -* there is not enough room. If the attr is set, the transaction is committed -* and set to NULL. +* there is not enough room. This function is meant to operate as a helper +* routine to the delayed attribute functions. It returns -EAGAIN to indicate +* that the calling function should roll the transaction, and then proceed to +* add the attr in leaf form. This subroutine does not expect to be recalled +* again like the other delayed attr routines do. */ STATIC int xfs_attr_set_shortform(@@ -236,16 +240,16 @@ xfs_attr_set_shortform( struct xfs_buf **leaf_bp) {struct xfs_inode *dp = args->dp; -int error, error2 =0 ; +int error =0 ;/* * Try to add the attr to the attribute list in the inode. */ error =xfs_attr_try_sf_addname (dp, args); + +/* Should only be 0, -EEXIST or ENOSPC */ if (error != -ENOSPC ) { - error2 =xfs_trans_commit (args->trans); - args->trans =NULL ; -return error ? error : error2; +return error; }/* * It won't fit in the shortform, transform to a leaf block. GROT: @@ -258,18 +262,10 @@ xfs_attr_set_shortform(/* * 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. +* 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 0 ; +return -EAGAIN ; }/* @@ -279,9 +275,83 @@ intxfs_attr_set_args ( struct xfs_da_args *args) { -struct xfs_inode *dp = args->dp; -struct xfs_buf *leaf_bp =NULL ; -int error =0 ; +struct xfs_buf *leaf_bp =NULL ; +int error =0 ; +struct xfs_delattr_context dac; + +xfs_delattr_context_init (&dac, args); + +do { + error =xfs_attr_set_iter (&dac, &leaf_bp); +if (error != -EAGAIN ) +break ; + +if (dac.flags &XFS_DAC_DEFER_FINISH ) { + dac.flags &= ~XFS_DAC_DEFER_FINISH ; + error =xfs_defer_finish (&args->trans); +if (error) +break ; + } + + error =xfs_trans_roll_inode (&args->trans, args->dp); +if (error) +break ; + +if (leaf_bp) { +xfs_trans_bjoin (args->trans, leaf_bp); +xfs_trans_bhold (args->trans, leaf_bp); + } + + }while (true); + +return error; +} + +/* +* Set the attribute specified in @args. +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +* returned. +*/ +int +xfs_attr_set_iter ( +struct xfs_delattr_context *dac, +struct xfs_buf **leaf_bp) +{ +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +int error =0 ; +int sf_size; + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_ADD_LEAF : + goto das_add_leaf; +case XFS_DAS_ALLOC_LEAF : +case XFS_DAS_FLIP_LFLAG : +case XFS_DAS_FOUND_LBLK : + goto das_leaf; +case XFS_DAS_FOUND_NBLK : +case XFS_DAS_FLIP_NFLAG : +case XFS_DAS_ALLOC_NODE : +case XFS_DAS_LEAF_TO_NODE : + goto das_node; +default : +break ; + } + +/* +* New inodes may not have an attribute fork yet. So set the attribute +* fork appropriately +*/ +if (XFS_IFORK_Q ((args->dp)) ==0 ) { + sf_size =sizeof (struct xfs_attr_sf_hdr ) + +XFS_ATTR_SF_ENTSIZE_BYNAME (args->namelen, args->valuelen);Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c int · line 354
Quoted 4 lines
fs/xfs/libxfs/xfs_attr.c +4
-0+xfs_bmap_set_attrforkoff (args->dp, sf_size,NULL ); + args->dp->i_afp =kmem_zone_zalloc (xfs_ifork_zone,0 ); + args->dp->i_afp->if_flags =XFS_IFEXTENTS ; + }Is this hunk moved from somewhere? If so, we should probably handle that in a separate patch. I think we really want these last couple of patches to introduce the state/markers and not much else.
Quoted 7 lines
Oh, this hunk is new, not moved, I believe it's been here since I picked up the series quite a while ago. It actually has more to do with parent pointers than delayed atts. Basically when we try to add the parent pointer during a create, the inode isnt fully constructed yet, so we have add the fork here. I will put this in a separate patch and move it further up the set.
Ok.
Quoted 33 lines
Quoted 22 lines
Quoted 22 lines
fs/xfs/libxfs/xfs_attr.c +8
-7/* * If the attribute list is already in leaf format, jump straight to @@ -292,40 +362,53 @@ xfs_attr_set_args(if (xfs_attr_is_shortform (dp)) {/* -* 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. +* If the attr was successfully set in shortform, no need to +* continue. Otherwise, is it converted from shortform to leaf +* and -EAGAIN is returned. */ - error =xfs_attr_set_shortform (args, &leaf_bp); -if (error || !args->trans) -return error; + error =xfs_attr_set_shortform (args, leaf_bp); +if (error == -EAGAIN ) { + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ADD_LEAF ; + }Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_set_args( · line 373
Quoted 1 line
fs/xfs/libxfs/xfs_attr.c +1
-0+return error;Similar to the previous patch, I wonder if we need the explicit states that are otherwise handled by existing inode state. For example, if the above returns
-EAGAIN,xfs_attr_is_shortform()is no longer true on reentry, right? If that's the case for the other conversions, it seems like we might only need one state (XFS_DAS_FOUND_LBLK) for this function.Ok, it looks like I can get away with out
XFS_DAS_ADD_LEAFandXFS_DAS_LEAF_TO_NODE.
Quoted 9 lines
This is actually a little similar to how it was done when I was trying to use flags instead of the state enums a long time ago. At the time, I got the impression people were concerned about the complexity and maintainability. So we went back to the enums because the explicite jumping made it clear where the re-entry was to resume, and reduced the risk that a person may mistakenly introduce a change that disrupts the reentry flow. Though perhaps the current arrangement of refactoring has made that less concerning?
Perhaps. I think it just depends on context. It might not make sense to try and implement such a reentry model down in the node code where we have N different non-deterministic states to deal with; as opposed to here where we're looking at one of a handful of high level formats and the behavior is very predictable: try to add to the current format, else convert to the next.
Quoted 21 lines
Quoted 6 lines
BTW, that general approach might be more clear if we lifted the format conversions into this level from down in the format specific add handlers. The goal would be to make the high level flow look something like:
Quoted 7 lines
if (shortform) { error = sf_try_add(); if (error == -ENOSPC) { shortform_to_leaf(...); ... return -EAGAIN; }Well, actually this piece was hoisted out into the helper function in patch
13. So pulling this up is sort of like letting go of patch 13. :-)The history is: initially I had tried to reduce indentation here in v6 by taking advantage of the
_add_leaflabel. Because I think in v5 we were trying to unnest where some of the jump points were. So in v6 I had:
"if(!shortform) goto leaf;" Which un-nests this shortform code.
Quoted 8 lines
Then in the v7 review I think Dave suggested I should add the helper and invert the check. So now we have "if(shortform()){
call_helper(); handle-EAGAIN; }"So pulling up is a bit of a circle now. But still functional if people prefer it as it was. Just need to keep track of the history so we avoid going around again. :-)
I don't think you need to drop that patch necessarily, but perhaps keep the conversion part to a separate helper and then introduce a similar patch for other formats..? In any event, that was just a followup thought so it might be reasonable to defer it to the next version and for now just see what it looks like to rely on the format states.
Quoted 8 lines
Quoted 2 lines
} else if (xfs_bmap_one_block(...)) {Mmm.... cant jump into the leaf logic right away. We need to handle releasing
leaf_bpwhich looks like it got lost in the pseudo code? IIRC there is a race condition with the AIL that is resolved by holding the leaf buffer across the transaction roll. So we need to check for that and release it upon reentry.
That sounds more like an implementation detail. leaf_bp is set when we convert from shortform, so isn't this the next state either way?
Quoted 14 lines
Quoted 6 lines
error = xfs_attr_leaf_try_add(args, *leaf_bp); if (error == -ENOSPC) { leaf_to_node(...); return -EAGAIN; }Ok, so lift ENOSPC handler from
xfs_attr_leaf_try_addQuoted 6 lines
... state stuff for leaf add ... } else { error = xfs_attr_node_addname(dac); }
Quoted 9 lines
Quoted 2 lines
Hm? Of course, something like that should be incorporated via independent refactoring patches.
I think what this becomes right now is:
Drop patch 13
Add new patch xfs: Lift ENOSPC handler fromxfs_attr_leaf_try_add?
Re: above, I don't think the patch needs to necessarily go away. Feel free to table this for now, just something to think about...
Quoted 131 lines
Quoted 116 lines
Quoted 116 lines
fs/xfs/libxfs/xfs_attr.c +58
-38} -if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { - error =xfs_attr_leaf_addname (args); -if (error != -ENOSPC ) -return error; +das_add_leaf: -/* -* Commit that transaction so that the node_addname() -* call can manage its own transactions. -*/ - error =xfs_defer_finish (&args->trans); -if (error) -return error; +/* +* After a shortform to leaf conversion, we need to hold the leaf and +* cylce out the transaction. When we get back, we need to release +* the leaf. +*/ +if (*leaf_bp !=NULL ) { +xfs_trans_brelse (args->trans, *leaf_bp); + *leaf_bp =NULL ; + } -/* -* Commit the current trans (including the inode) and -* start a new one. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) +if (xfs_bmap_one_block (dp,XFS_ATTR_FORK )) { + error =xfs_attr_leaf_try_add (args, *leaf_bp); +switch (error) { +case -ENOSPC : + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_LEAF_TO_NODE ; +return -EAGAIN ; +case 0 : + dac->dela_state =XFS_DAS_FOUND_LBLK ; +return -EAGAIN ; +default :return error; - + } +das_leaf: + error =xfs_attr_leaf_addname (dac); +if (error == -ENOSPC ) { + dac->dela_state =XFS_DAS_LEAF_TO_NODE ; +return -EAGAIN ; + } +return error; } - - error =xfs_attr_node_addname (args); +das_node: + error =xfs_attr_node_addname (dac);return error; }@@ -716,28 +799,32 @@ xfs_attr_leaf_try_add(* * This leaf block cannot have a "remote" value, we only call this routine * if bmap_one_block() says there is only one block (ie: no remote blks). +* +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +* returned. */ STATIC intxfs_attr_leaf_addname ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -int error, forkoff; -struct xfs_buf *bp =NULL ; -struct xfs_inode *dp = args->dp; - -trace_xfs_attr_leaf_addname (args); - - error =xfs_attr_leaf_try_add (args, bp); -if (error) -return error; +struct xfs_da_args *args = dac->da_args; +struct xfs_buf *bp =NULL ; +int error, forkoff; +struct xfs_inode *dp = args->dp; -/* -* Commit the transaction that added the attr name so that -* later routines can manage their own transactions. -*/ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) -return error; +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_FLIP_LFLAG : + goto das_flip_flag; +case XFS_DAS_ALLOC_LEAF : + goto das_alloc_leaf; +case XFS_DAS_RM_LBLK : + goto das_rm_lblk; +default : +break ; + }/* * If there was an out-of-line value, allocate the blocks we @@ -746,7 +833,28 @@ xfs_attr_leaf_addname(* maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - error =xfs_attr_rmtval_set (args); + +/* Open coded xfs_attr_rmtval_set without trans handling */ + error =xfs_attr_rmtval_set_init (dac); +if (error) +return error; +Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_addname( · line 846
Quoted 5 lines
fs/xfs/libxfs/xfs_attr.c +5
-0+/* +* Roll through the "value", allocating blocks on disk as +* required. +*/ +das_alloc_leaf:If we filter out the setup above, it seems like this state could be reduced to check for ->blkcnt > 0.
By filter out the set up, you mean to introduce the setup flag like you mentioned earlier? For example:
if(flags & setup == 0){ setup(); flags |= setup; }
Quoted 9 lines
To be clear, if we did that, we're talking about adding an "int
setup_flags" to the dac. And then defineing a XFS_DAC_SETUP_* scheme. Like aXFS_DAC_SETUP_ADD_NAME, and anXFS_DAC_SETUP_NODE_REMVE_NAMEand so on. Because we cant have multiple functions sharing the same set up flag if they ever call each others.Is that what you mean to imply? Otherwise I may not be clear on what you mean by filtering out the set up.
Well we already have a flag scheme for the defer thing, right? Is there any reason we couldn't define a similar DAC_DEFER_INIT and let each operation (add/remove) use it as appropriate? Note again that I'm just trying to think about potential simplifications. If there are isolated functions that can be made clearly/simply idempotent (like init/setup helpers tend to be), then doing so might be helpful. I.e., if xfs_attr_rmtval_set_init() could do something like:
{
if (dax->flags & DAC_RMTVAL_SET_INIT)
return;
dax->flags |= DAC_RMTVAL_SET_INIT;
...
}... and that removes an execution state, then that might be a win. If it requires more complexity than that, then perhaps the suggestion is not worthwile. ;P
Quoted 49 lines
Quoted 41 lines
Quoted 41 lines
fs/xfs/libxfs/xfs_attr.c +18
-9+while (dac->blkcnt >0 ) { + error =xfs_attr_rmtval_set_blk (dac); +if (error) +return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ALLOC_LEAF ; +return -EAGAIN ; + } + + error =xfs_attr_rmtval_set_value (args);if (error)return error; }@@ -765,22 +873,25 @@ xfs_attr_leaf_addname( error =xfs_attr3_leaf_flipflags (args);if (error)return error; -/* -* Commit the flag value change and start the next trans in -* series. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) -return error; - + dac->dela_state =XFS_DAS_FLIP_LFLAG ; +return -EAGAIN ; +das_flip_flag:/* * Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ xfs_attr_restore_rmt_blk (args); +xfs_attr_rmtval_invalidate (args); +das_rm_lblk:if (args->rmtblkno) { - error =xfs_attr_rmtval_remove (args); + error =__xfs_attr_rmtval_remove (args); +Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_leaf_addname( · line 894
Quoted 5 lines
fs/xfs/libxfs/xfs_attr.c +5
-0+if (error == -EAGAIN ) { + dac->dela_state =XFS_DAS_RM_LBLK ; +return -EAGAIN ; + } +This whole function looks like it could use more refactoring to split out the rename case.
Quoted 4 lines
Hmm, how about we take every thing inside the "if (
args->op_flags&XFS_DA_OP_RENAME) {" and put it in axfs_attr_leaf_rename()helper? Then pull the helper into the calling function?
That would help. I'm not sure what the optimal breakdown is off the top of my head tbh. This function is kind of a logical beast between dealing with remote blocks and rename and combinations of the two, so I'd have to stare at that one some more. In general the goal should be to try and avoid jumping in the middle of logic branches as much as possible so there's a nice and visible distinction between the state code and the functional code.
Brian
Quoted 460 lines
Quoted 117 lines
Quoted 117 lines
fs/xfs/libxfs/xfs_attr.c +37
-35if (error)return error; }@@ -799,15 +910,11 @@ xfs_attr_leaf_addname(/* * If the result is small enough, shrink it all into the inode. */ -if ((forkoff =xfs_attr_shortform_allfit (bp, dp))) { + forkoff =xfs_attr_shortform_allfit (bp, dp); +if (forkoff) error =xfs_attr3_leaf_to_shortform (bp, args, forkoff); -/* bp is gone due to xfs_da_shrink_inode */ -if (error) -return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; - } + + dac->flags |=XFS_DAC_DEFER_FINISH ; }else if (args->rmtblkno >0 ) {/* @@ -967,16 +1074,23 @@ xfs_attr_node_hasname(* * "Remote" attribute values confuse the issue and atomic rename operations * add a whole extra layer of confusion on top of that. +* +* This routine is meant to function as a delayed operation, and may return +* -EAGAIN when the transaction needs to be rolled. Calling functions will need +* to handle this, and recall the function until a successful error code is +*returned. */ STATIC intxfs_attr_node_addname ( -struct xfs_da_args *args) +struct xfs_delattr_context *dac) { -struct xfs_da_state *state; -struct xfs_da_state_blk *blk; -struct xfs_inode *dp; -struct xfs_mount *mp; -int retval, error; +struct xfs_da_args *args = dac->da_args; +struct xfs_da_state *state =NULL ; +struct xfs_da_state_blk *blk; +struct xfs_inode *dp; +struct xfs_mount *mp; +int retval =0 ; +int error =0 ;trace_xfs_attr_node_addname (args);@@ -985,7 +1099,21 @@ xfs_attr_node_addname(*/ dp = args->dp; mp = dp->i_mount; -restart: + +/* State machine switch */ +switch (dac->dela_state) { +case XFS_DAS_FLIP_NFLAG : + goto das_flip_flag; +case XFS_DAS_FOUND_NBLK : + goto das_found_nblk; +case XFS_DAS_ALLOC_NODE : + goto das_alloc_node; +case XFS_DAS_RM_NBLK : + goto das_rm_nblk; +default : +break ; + } +/* * Search to see if name already exists, and get back a pointer * to where it should go. @@ -1031,19 +1159,13 @@ xfs_attr_node_addname( error =xfs_attr3_leaf_to_node (args);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out;/* -* Commit the node conversion and start the next -* trans in the chain. +* Restart routine from the top. No need to set the +* state */ - error =xfs_trans_roll_inode (&args->trans, dp); -if (error) - goto out; - - goto restart; + dac->flags |=XFS_DAC_DEFER_FINISH ; +return -EAGAIN ; }/* @@ -1055,9 +1177,7 @@ xfs_attr_node_addname( error =xfs_da3_split (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; + dac->flags |=XFS_DAC_DEFER_FINISH ; }else {/* * Addition succeeded, update Btree hashvals. @@ -1072,13 +1192,9 @@ xfs_attr_node_addname(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;Quoted 8 lines
fs/xfs/libxfs/xfs_attr.c xfs_attr_node_addname( · line 1197
Quoted 3 lines
fs/xfs/libxfs/xfs_attr.c +3
-0+ dac->dela_state =XFS_DAS_FOUND_NBLK ; +return -EAGAIN ; +das_found_nblk:Same deal here. Any time we have this return
-EAGAINfollowed by a label pattern I think we're going to want to think about refactoring things more first to avoid dumping it in the middle of some unnecessarily large function.Ok, similar pattern here too then? Everything in "if (
args->op_flags&XFS_DA_OP_RENAME) {" goes in a newxfs_attr_node_rename()helper? Then hoist upwards?Thanks for the reviewing!!
AllisonQuoted 327 lines
Brian
Quoted 323 lines
fs/xfs/libxfs/xfs_attr.c +36
-12/* * If there was an out-of-line value, allocate the blocks we @@ -1087,7 +1203,27 @@ xfs_attr_node_addname(* maximum size of a transaction and/or hit a deadlock. */ if (args->rmtblkno >0 ) { - error =xfs_attr_rmtval_set (args); +/* Open coded xfs_attr_rmtval_set without trans handling */ + error =xfs_attr_rmtval_set_init (dac); +if (error) +return error; + +/* +* Roll through the "value", allocating blocks on disk as +* required. +*/ +das_alloc_node: +while (dac->blkcnt >0 ) { + error =xfs_attr_rmtval_set_blk (dac); +if (error) +return error; + + dac->flags |=XFS_DAC_DEFER_FINISH ; + dac->dela_state =XFS_DAS_ALLOC_NODE ; +return -EAGAIN ; + } + + error =xfs_attr_rmtval_set_value (args);if (error)return error; }@@ -1110,18 +1246,26 @@ xfs_attr_node_addname(* 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; - + dac->dela_state =XFS_DAS_FLIP_NFLAG ; +return -EAGAIN ; +das_flip_flag:/* * Dismantle the "old" attribute/value pair by removing * a "remote" value (if it exists). */ xfs_attr_restore_rmt_blk (args); +xfs_attr_rmtval_invalidate (args); + +das_rm_nblk:if (args->rmtblkno) { - error =xfs_attr_rmtval_remove (args); + error =__xfs_attr_rmtval_remove (args); + +if (error == -EAGAIN ) { + dac->dela_state =XFS_DAS_RM_NBLK ; +return -EAGAIN ; + } +if (error)return error; }@@ -1139,7 +1283,6 @@ xfs_attr_node_addname( error =xfs_da3_node_lookup_int (state, &retval);if (error) goto out; -/* * Remove the name and update the hashvals in the tree. */ @@ -1147,7 +1290,6 @@ xfs_attr_node_addname(ASSERT (blk->magic ==XFS_ATTR_LEAF_MAGIC ); error =xfs_attr3_leaf_remove (blk->bp, args);xfs_da3_fixhashpath (state, &state->path); -/* * Check to see if the tree needs to be collapsed. */ @@ -1155,11 +1297,9 @@ xfs_attr_node_addname( error =xfs_da3_join (state);if (error) goto out; - error =xfs_defer_finish (&args->trans); -if (error) - goto out; - } + dac->flags |=XFS_DAC_DEFER_FINISH ; + } }else if (args->rmtblkno >0 ) {/* * Added a "remote" value, just clear the incomplete flag. fs/xfs/libxfs/xfs_attr.h +16
-0@@ -93,6 +93,16 @@ enum xfs_delattr_state {/* Zero is uninitalized */ XFS_DAS_RM_SHRINK =1 ,/* We are shrinking the tree */ XFS_DAS_RMTVAL_REMOVE ,/* We are removing remote value blocks */ +XFS_DAS_ADD_LEAF ,/* We are adding a leaf attr */ +XFS_DAS_FOUND_LBLK ,/* We found leaf blk for attr */ +XFS_DAS_LEAF_TO_NODE ,/* Converted leaf to node */ +XFS_DAS_FOUND_NBLK ,/* We found node blk for attr */ +XFS_DAS_ALLOC_LEAF ,/* We are allocating leaf blocks */ +XFS_DAS_FLIP_LFLAG ,/* Flipped leaf INCOMPLETE attr flag */ +XFS_DAS_RM_LBLK ,/* A rename is removing leaf blocks */ +XFS_DAS_ALLOC_NODE ,/* We are allocating node blocks */ +XFS_DAS_FLIP_NFLAG ,/* Flipped node INCOMPLETE attr flag */ + XFS_DAS_RM_NBLK, /* A rename is removing node blocks */ };/* @@ -105,8 +115,13 @@ enum xfs_delattr_state {*/ struct xfs_delattr_context {struct xfs_da_args *da_args; +struct xfs_bmbt_irec map; +struct xfs_buf *leaf_bp; +xfs_fileoff_t lfileoff;struct xfs_da_state *da_state;struct xfs_da_state_blk *blk; +xfs_dablk_t lblkno; +int blkcnt;unsigned int flags;enum xfs_delattr_state dela_state; };@@ -126,6 +141,7 @@ 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_args (struct xfs_da_args *args); +int xfs_attr_set_iter (struct xfs_delattr_context *dac,struct xfs_buf **leaf_bp);int xfs_has_attr (struct xfs_da_args *args);int xfs_attr_remove_args (struct xfs_da_args *args);int xfs_attr_remove_iter (struct xfs_delattr_context *dac);fs/xfs/libxfs/xfs_attr_leaf.c +1
-0@@ -19,6 +19,7 @@#include "xfs_bmap_btree.h" #include "xfs_bmap.h" #include "xfs_attr_sf.h" +#include "xfs_attr.h" #include "xfs_attr_remote.h" #include "xfs_attr.h" #include "xfs_attr_leaf.h" fs/xfs/libxfs/xfs_attr_remote.c +67
-44@@ -443,7 +443,7 @@ xfs_attr_rmtval_get(* Find a "hole" in the attribute address space large enough for us to drop the * new attribute's value into */ -STATIC int +int xfs_attr_rmt_find_hole (struct xfs_da_args *args) {@@ -470,7 +470,7 @@ xfs_attr_rmt_find_hole(return 0 ; } -STATIC int +int xfs_attr_rmtval_set_value (struct xfs_da_args *args) {@@ -630,6 +630,71 @@ xfs_attr_rmtval_set( }/* +* Find a hole for the attr and store it in the delayed attr context. This +* initializes the context to roll through allocating an attr extent for a +* delayed attr operation +*/ +int +xfs_attr_rmtval_set_init ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args; +struct xfs_bmbt_irec *map = &dac->map; +int error; + + dac->lblkno =0 ; + dac->lfileoff =0 ; + dac->blkcnt =0 ; + args->rmtblkcnt =0 ; + args->rmtblkno =0 ; +memset (map,0 ,sizeof (struct xfs_bmbt_irec )); + + error =xfs_attr_rmt_find_hole (args); +if (error) +return error; + + dac->blkcnt = args->rmtblkcnt; + dac->lblkno = args->rmtblkno; + +return error; +} + +/* +* Write one block of the value associated with an attribute into the +* out-of-line buffer that we have defined for it. This is similar to a subset +* of xfs_attr_rmtval_set, but records the current block to the delayed attr +* context, and leaves transaction handling to the caller. +*/ +int +xfs_attr_rmtval_set_blk ( +struct xfs_delattr_context *dac) +{ +struct xfs_da_args *args = dac->da_args; +struct xfs_inode *dp = args->dp; +struct xfs_bmbt_irec *map = &dac->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, map, &nmap); +if (error) +return error; + +ASSERT (nmap ==1 ); +ASSERT ((map->br_startblock !=DELAYSTARTBLOCK ) && + (map->br_startblock !=HOLESTARTBLOCK )); + +/* roll attribute extent map forwards */ + dac->lblkno += map->br_blockcount; + dac->blkcnt -= map->br_blockcount; + +return 0 ; +} + +/* * Remove the value associated with an attribute by deleting the * out-of-line buffer that it is stored on. */ @@ -671,48 +736,6 @@ xfs_attr_rmtval_invalidate( }/* -* Remove the value associated with an attribute by deleting the -* out-of-line buffer that it is stored on. -*/ -int -xfs_attr_rmtval_remove ( -struct xfs_da_args *args) -{ -xfs_dablk_t lblkno; -int blkcnt; -int error =0 ; -int done =0 ; - -trace_xfs_attr_rmtval_remove (args); - - error =xfs_attr_rmtval_invalidate (args); -if (error) -return error; -/* -* Keep de-allocating extents until the remote-value region is gone. -*/ - lblkno = args->rmtblkno; - blkcnt = args->rmtblkcnt; -while (!done) { - error =xfs_bunmapi (args->trans, args->dp, lblkno, blkcnt, -XFS_BMAPI_ATTRFORK ,1 , &done); -if (error) -return error; - error =xfs_defer_finish (&args->trans); -if (error) -return error; - -/* -* Close out trans and start the next one in the chain. -*/ - error =xfs_trans_roll_inode (&args->trans, args->dp); -if (error) -return error; - } -return 0 ; -} - -/* * Remove the value associated with an attribute by deleting the out-of-line * buffer that it is stored on. Returns EAGAIN for the caller to refresh the * transaction and recall the function fs/xfs/libxfs/xfs_attr_remote.h +4
-0@@ -15,4 +15,8 @@ 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_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_set_init (struct xfs_delattr_context *dac);#endif /* __XFS_ATTR_REMOTE_H__ */ fs/xfs/xfs_attr_inactive.c +1
-0@@ -15,6 +15,7 @@#include "xfs_da_format.h" #include "xfs_da_btree.h" #include "xfs_inode.h" +#include "xfs_attr.h" #include "xfs_attr_remote.h" #include "xfs_trans.h" #include "xfs_bmap.h" fs/xfs/xfs_trace.h +0
-1@@ -1784,7 +1784,6 @@ DEFINE_ATTR_EVENT(xfs_attr_refillstate);DEFINE_ATTR_EVENT (xfs_attr_rmtval_get);DEFINE_ATTR_EVENT (xfs_attr_rmtval_set); -DEFINE_ATTR_EVENT (xfs_attr_rmtval_remove);#define DEFINE_DA_EVENT (name) \ DEFINE_EVENT(xfs_da_class, name, \Signature · 1 line
2.7.4