* [PATCH v25 01/14] xfs: allow setting and clearing of log incompat feature flags
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 02/14] xfs: add attr state machine tracepoints Allison Henderson
` (12 subsequent siblings)
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
From: "Darrick J. Wong" <djwong@kernel.org>
Source kernel commit: a9642049d91105c676526817b527a1a62940888f
Log incompat feature flags in the superblock exist for one purpose: to
protect the contents of a dirty log from replay on a kernel that isn't
prepared to handle those dirty contents. This means that they can be
cleared if (a) we know the log is clean and (b) we know that there
aren't any other threads in the system that might be setting or relying
upon a log incompat flag.
Therefore, clear the log incompat flags when we've finished recovering
the log, when we're unmounting cleanly, remounting read-only, or
freezing; and provide a function so that subsequent patches can start
using this.
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Allison Henderson <allison.henderson@oracle.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
libxfs/xfs_format.h | 15 +++++++++++++++
1 file changed, 15 insertions(+)
diff --git a/libxfs/xfs_format.h b/libxfs/xfs_format.h
index 37570cf0537e..5d8a129150d5 100644
--- a/libxfs/xfs_format.h
+++ b/libxfs/xfs_format.h
@@ -495,6 +495,21 @@ xfs_sb_has_incompat_log_feature(
return (sbp->sb_features_log_incompat & feature) != 0;
}
+static inline void
+xfs_sb_remove_incompat_log_features(
+ struct xfs_sb *sbp)
+{
+ sbp->sb_features_log_incompat &= ~XFS_SB_FEAT_INCOMPAT_LOG_ALL;
+}
+
+static inline void
+xfs_sb_add_incompat_log_features(
+ struct xfs_sb *sbp,
+ unsigned int features)
+{
+ sbp->sb_features_log_incompat |= features;
+}
+
/*
* V5 superblock specific feature checks
*/
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 02/14] xfs: add attr state machine tracepoints
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
2021-11-17 4:16 ` [PATCH v25 01/14] xfs: allow setting and clearing of log incompat feature flags Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 03/14] xfsprogs: Rename __xfs_attr_rmtval_remove Allison Henderson
` (11 subsequent siblings)
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
Source kernel commit: df0826312a23e495faa91eee0d6ac31bca35dc09
This is a quick patch to add a new xfs_attr_*_return tracepoints. We
use these to track when ever a new state is set or -EAGAIN is returned
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
include/xfs_trace.h | 6 ++++++
libxfs/xfs_attr.c | 31 +++++++++++++++++++++++++++++--
libxfs/xfs_attr_remote.c | 1 +
3 files changed, 36 insertions(+), 2 deletions(-)
diff --git a/include/xfs_trace.h b/include/xfs_trace.h
index a1002638f39a..227193a1e8fa 100644
--- a/include/xfs_trace.h
+++ b/include/xfs_trace.h
@@ -314,4 +314,10 @@
#define trace_xfs_perag_get_tag(a,b,c,d) ((c) = (c))
#define trace_xfs_perag_put(a,b,c,d) ((c) = (c))
+#define trace_xfs_attr_sf_addname_return(a,b) ((void) 0)
+#define trace_xfs_attr_set_iter_return(a,b) ((void) 0)
+#define trace_xfs_attr_node_addname_return(a,b) ((void) 0)
+#define trace_xfs_attr_remove_iter_return(a,b) ((void) 0)
+#define trace_xfs_attr_rmtval_remove_return(a,b) ((void) 0)
+
#endif /* __TRACE_H__ */
diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index 80a6a96fe2d3..354c7c3fd38b 100644
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -335,6 +335,7 @@ xfs_attr_sf_addname(
* the attr fork to leaf format and will restart with the leaf
* add.
*/
+ trace_xfs_attr_sf_addname_return(XFS_DAS_UNINIT, args->dp);
dac->flags |= XFS_DAC_DEFER_FINISH;
return -EAGAIN;
}
@@ -394,6 +395,8 @@ xfs_attr_set_iter(
* handling code below
*/
dac->flags |= XFS_DAC_DEFER_FINISH;
+ trace_xfs_attr_set_iter_return(
+ dac->dela_state, args->dp);
return -EAGAIN;
} else if (error) {
return error;
@@ -411,6 +414,7 @@ xfs_attr_set_iter(
dac->dela_state = XFS_DAS_FOUND_NBLK;
}
+ trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
return -EAGAIN;
case XFS_DAS_FOUND_LBLK:
/*
@@ -438,6 +442,8 @@ xfs_attr_set_iter(
error = xfs_attr_rmtval_set_blk(dac);
if (error)
return error;
+ trace_xfs_attr_set_iter_return(dac->dela_state,
+ args->dp);
return -EAGAIN;
}
@@ -472,6 +478,7 @@ xfs_attr_set_iter(
* series.
*/
dac->dela_state = XFS_DAS_FLIP_LFLAG;
+ trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
return -EAGAIN;
case XFS_DAS_FLIP_LFLAG:
/*
@@ -489,10 +496,14 @@ xfs_attr_set_iter(
dac->dela_state = XFS_DAS_RM_LBLK;
if (args->rmtblkno) {
error = __xfs_attr_rmtval_remove(dac);
+ if (error == -EAGAIN)
+ trace_xfs_attr_set_iter_return(
+ dac->dela_state, args->dp);
if (error)
return error;
dac->dela_state = XFS_DAS_RD_LEAF;
+ trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
return -EAGAIN;
}
@@ -542,6 +553,8 @@ xfs_attr_set_iter(
error = xfs_attr_rmtval_set_blk(dac);
if (error)
return error;
+ trace_xfs_attr_set_iter_return(
+ dac->dela_state, args->dp);
return -EAGAIN;
}
@@ -577,6 +590,7 @@ xfs_attr_set_iter(
* series
*/
dac->dela_state = XFS_DAS_FLIP_NFLAG;
+ trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
return -EAGAIN;
case XFS_DAS_FLIP_NFLAG:
@@ -596,10 +610,15 @@ xfs_attr_set_iter(
dac->dela_state = XFS_DAS_RM_NBLK;
if (args->rmtblkno) {
error = __xfs_attr_rmtval_remove(dac);
+ if (error == -EAGAIN)
+ trace_xfs_attr_set_iter_return(
+ dac->dela_state, args->dp);
+
if (error)
return error;
dac->dela_state = XFS_DAS_CLR_FLAG;
+ trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
return -EAGAIN;
}
@@ -1176,6 +1195,8 @@ xfs_attr_node_addname(
* this point.
*/
dac->flags |= XFS_DAC_DEFER_FINISH;
+ trace_xfs_attr_node_addname_return(
+ dac->dela_state, args->dp);
return -EAGAIN;
}
@@ -1422,10 +1443,13 @@ xfs_attr_remove_iter(
* blocks are removed.
*/
error = __xfs_attr_rmtval_remove(dac);
- if (error == -EAGAIN)
+ if (error == -EAGAIN) {
+ trace_xfs_attr_remove_iter_return(
+ dac->dela_state, args->dp);
return error;
- else if (error)
+ } else if (error) {
goto out;
+ }
/*
* Refill the state structure with buffers (the prior
@@ -1438,6 +1462,7 @@ xfs_attr_remove_iter(
goto out;
dac->dela_state = XFS_DAS_RM_NAME;
dac->flags |= XFS_DAC_DEFER_FINISH;
+ trace_xfs_attr_remove_iter_return(dac->dela_state, args->dp);
return -EAGAIN;
}
@@ -1466,6 +1491,8 @@ xfs_attr_remove_iter(
dac->flags |= XFS_DAC_DEFER_FINISH;
dac->dela_state = XFS_DAS_RM_SHRINK;
+ trace_xfs_attr_remove_iter_return(
+ dac->dela_state, args->dp);
return -EAGAIN;
}
diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
index d474ad7d969d..137e5698c15d 100644
--- a/libxfs/xfs_attr_remote.c
+++ b/libxfs/xfs_attr_remote.c
@@ -695,6 +695,7 @@ __xfs_attr_rmtval_remove(
*/
if (!done) {
dac->flags |= XFS_DAC_DEFER_FINISH;
+ trace_xfs_attr_rmtval_remove_return(dac->dela_state, args->dp);
return -EAGAIN;
}
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 03/14] xfsprogs: Rename __xfs_attr_rmtval_remove
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
2021-11-17 4:16 ` [PATCH v25 01/14] xfs: allow setting and clearing of log incompat feature flags Allison Henderson
2021-11-17 4:16 ` [PATCH v25 02/14] xfs: add attr state machine tracepoints Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 04/14] xfs: don't commit the first deferred transaction without intents Allison Henderson
` (10 subsequent siblings)
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
Now that xfs_attr_rmtval_remove is gone, rename __xfs_attr_rmtval_remove
to xfs_attr_rmtval_remove
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
libxfs/xfs_attr.c | 6 +++---
libxfs/xfs_attr_remote.c | 2 +-
libxfs/xfs_attr_remote.h | 2 +-
3 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index 354c7c3fd38b..2957fd030423 100644
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -495,7 +495,7 @@ xfs_attr_set_iter(
/* Set state in case xfs_attr_rmtval_remove returns -EAGAIN */
dac->dela_state = XFS_DAS_RM_LBLK;
if (args->rmtblkno) {
- error = __xfs_attr_rmtval_remove(dac);
+ error = xfs_attr_rmtval_remove(dac);
if (error == -EAGAIN)
trace_xfs_attr_set_iter_return(
dac->dela_state, args->dp);
@@ -609,7 +609,7 @@ xfs_attr_set_iter(
/* Set state in case xfs_attr_rmtval_remove returns -EAGAIN */
dac->dela_state = XFS_DAS_RM_NBLK;
if (args->rmtblkno) {
- error = __xfs_attr_rmtval_remove(dac);
+ error = xfs_attr_rmtval_remove(dac);
if (error == -EAGAIN)
trace_xfs_attr_set_iter_return(
dac->dela_state, args->dp);
@@ -1442,7 +1442,7 @@ xfs_attr_remove_iter(
* May return -EAGAIN. Roll and repeat until all remote
* blocks are removed.
*/
- error = __xfs_attr_rmtval_remove(dac);
+ error = xfs_attr_rmtval_remove(dac);
if (error == -EAGAIN) {
trace_xfs_attr_remove_iter_return(
dac->dela_state, args->dp);
diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
index 137e5698c15d..b781e44d9c5a 100644
--- a/libxfs/xfs_attr_remote.c
+++ b/libxfs/xfs_attr_remote.c
@@ -671,7 +671,7 @@ xfs_attr_rmtval_invalidate(
* routine until it returns something other than -EAGAIN.
*/
int
-__xfs_attr_rmtval_remove(
+xfs_attr_rmtval_remove(
struct xfs_delattr_context *dac)
{
struct xfs_da_args *args = dac->da_args;
diff --git a/libxfs/xfs_attr_remote.h b/libxfs/xfs_attr_remote.h
index 61b85b918db8..d72eff30ca18 100644
--- a/libxfs/xfs_attr_remote.h
+++ b/libxfs/xfs_attr_remote.h
@@ -12,7 +12,7 @@ int xfs_attr_rmtval_get(struct xfs_da_args *args);
int xfs_attr_rmtval_stale(struct xfs_inode *ip, struct xfs_bmbt_irec *map,
xfs_buf_flags_t incore_flags);
int xfs_attr_rmtval_invalidate(struct xfs_da_args *args);
-int __xfs_attr_rmtval_remove(struct xfs_delattr_context *dac);
+int xfs_attr_rmtval_remove(struct xfs_delattr_context *dac);
int xfs_attr_rmt_find_hole(struct xfs_da_args *args);
int xfs_attr_rmtval_set_value(struct xfs_da_args *args);
int xfs_attr_rmtval_set_blk(struct xfs_delattr_context *dac);
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 04/14] xfs: don't commit the first deferred transaction without intents
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (2 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 03/14] xfsprogs: Rename __xfs_attr_rmtval_remove Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 05/14] xfsprogs: Return from xfs_attr_set_iter if there are no more rmtblks to process Allison Henderson
` (9 subsequent siblings)
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
If the first operation in a string of defer ops has no intents,
then there is no reason to commit it before running the first call
to xfs_defer_finish_one(). This allows the defer ops to be used
effectively for non-intent based operations without requiring an
unnecessary extra transaction commit when first called.
This fixes a regression in per-attribute modification transaction
count when delayed attributes are not being used.
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
libxfs/xfs_defer.c | 29 +++++++++++++++++------------
1 file changed, 17 insertions(+), 12 deletions(-)
diff --git a/libxfs/xfs_defer.c b/libxfs/xfs_defer.c
index 1fdf6c720357..006277cffdef 100644
--- a/libxfs/xfs_defer.c
+++ b/libxfs/xfs_defer.c
@@ -176,7 +176,7 @@ static const struct xfs_defer_op_type *defer_op_types[] = {
[XFS_DEFER_OPS_TYPE_AGFL_FREE] = &xfs_agfl_free_defer_type,
};
-static void
+static bool
xfs_defer_create_intent(
struct xfs_trans *tp,
struct xfs_defer_pending *dfp,
@@ -187,6 +187,7 @@ xfs_defer_create_intent(
if (!dfp->dfp_intent)
dfp->dfp_intent = ops->create_intent(tp, &dfp->dfp_work,
dfp->dfp_count, sort);
+ return dfp->dfp_intent;
}
/*
@@ -194,16 +195,18 @@ xfs_defer_create_intent(
* associated extents, then add the entire intake list to the end of
* the pending list.
*/
-STATIC void
+STATIC bool
xfs_defer_create_intents(
struct xfs_trans *tp)
{
struct xfs_defer_pending *dfp;
+ bool ret = false;
list_for_each_entry(dfp, &tp->t_dfops, dfp_list) {
trace_xfs_defer_create_intent(tp->t_mountp, dfp);
- xfs_defer_create_intent(tp, dfp, true);
+ ret |= xfs_defer_create_intent(tp, dfp, true);
}
+ return ret;
}
/* Abort all the intents that were committed. */
@@ -454,7 +457,7 @@ int
xfs_defer_finish_noroll(
struct xfs_trans **tp)
{
- struct xfs_defer_pending *dfp;
+ struct xfs_defer_pending *dfp = NULL;
int error = 0;
LIST_HEAD(dop_pending);
@@ -473,17 +476,19 @@ xfs_defer_finish_noroll(
* of time that any one intent item can stick around in memory,
* pinning the log tail.
*/
- xfs_defer_create_intents(*tp);
+ bool has_intents = xfs_defer_create_intents(*tp);
list_splice_init(&(*tp)->t_dfops, &dop_pending);
- error = xfs_defer_trans_roll(tp);
- if (error)
- goto out_shutdown;
+ if (has_intents || dfp) {
+ error = xfs_defer_trans_roll(tp);
+ if (error)
+ goto out_shutdown;
- /* Possibly relog intent items to keep the log moving. */
- error = xfs_defer_relog(tp, &dop_pending);
- if (error)
- goto out_shutdown;
+ /* Possibly relog intent items to keep the log moving. */
+ error = xfs_defer_relog(tp, &dop_pending);
+ if (error)
+ goto out_shutdown;
+ }
dfp = list_first_entry(&dop_pending, struct xfs_defer_pending,
dfp_list);
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 05/14] xfsprogs: Return from xfs_attr_set_iter if there are no more rmtblks to process
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (3 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 04/14] xfs: don't commit the first deferred transaction without intents Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 06/14] xfsprogs: Set up infrastructure for log attribute replay Allison Henderson
` (8 subsequent siblings)
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
Source kernel commit: df21062113850c5aaeaa38b5194ee4c64767fb7a
During an attr rename operation, blocks are saved for later removal
as rmtblkno2. The rmtblkno is used in the case of needing to alloc
more blocks if not enough were available. However, in the case
that no further blocks need to be added or removed, we can return as soon
as xfs_attr_node_addname completes, rather than rolling the transaction
with an -EAGAIN return. This extra loop does not hurt anything right
now, but it will be a problem later when we get into log items because
we end up with an empty log transaction. So, add a simple check to
cut out the unneeded iteration.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
libxfs/xfs_attr.c | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index 2957fd030423..53f4d546ed6e 100644
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -412,6 +412,14 @@ xfs_attr_set_iter(
if (error)
return error;
+ /*
+ * If addname was successful, and we dont need to alloc
+ * or remove anymore blks, we're done.
+ */
+ if (!args->rmtblkno &&
+ !(args->op_flags & XFS_DA_OP_RENAME))
+ return 0;
+
dac->dela_state = XFS_DAS_FOUND_NBLK;
}
trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 06/14] xfsprogs: Set up infrastructure for log attribute replay
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (4 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 05/14] xfsprogs: Return from xfs_attr_set_iter if there are no more rmtblks to process Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 07/14] xfsprogs: Implement attr logging and replay Allison Henderson
` (7 subsequent siblings)
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
Currently attributes are modified directly across one or more
transactions. But they are not logged or replayed in the event of an
error. The goal of log attr replay is to enable logging and replaying
of attribute operations using the existing delayed operations
infrastructure. This will later enable the attributes to become part of
larger multi part operations that also must first be recorded to the
log. This is mostly of interest in the scheme of parent pointers which
would need to maintain an attribute containing parent inode information
any time an inode is moved, created, or removed. Parent pointers would
then be of interest to any feature that would need to quickly derive an
inode path from the mount point. Online scrub, nfs lookups and fs grow
or shrink operations are all features that could take advantage of this.
This patch adds two new log item types for setting or removing
attributes as deferred operations. The xfs_attri_log_item will log an
intent to set or remove an attribute. The corresponding
xfs_attrd_log_item holds a reference to the xfs_attri_log_item and is
freed once the transaction is done. Both log items use a generic
xfs_attr_log_format structure that contains the attribute name, value,
flags, inode, and an op_flag that indicates if the operations is a set
or remove.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
---
libxfs/defer_item.c | 3 +++
libxfs/xfs_attr.c | 4 +---
libxfs/xfs_attr.h | 30 ++++++++++++++++++++++++++++
libxfs/xfs_defer.h | 1 +
libxfs/xfs_log_format.h | 43 +++++++++++++++++++++++++++++++++++++++--
5 files changed, 76 insertions(+), 5 deletions(-)
diff --git a/libxfs/defer_item.c b/libxfs/defer_item.c
index b18182e95ac8..a1f0d7e52ff3 100644
--- a/libxfs/defer_item.c
+++ b/libxfs/defer_item.c
@@ -20,6 +20,9 @@
#include "xfs_refcount.h"
#include "xfs_bmap.h"
#include "xfs_inode.h"
+#include "xfs_da_format.h"
+#include "xfs_da_btree.h"
+#include "xfs_attr.h"
/* Dummy defer item ops, since we don't do logging. */
diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index 53f4d546ed6e..61cb7ea9ff5b 100644
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -61,8 +61,6 @@ 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_set_iter(struct xfs_delattr_context *dac,
- struct xfs_buf **leaf_bp);
STATIC int xfs_attr_node_removename(struct xfs_da_args *args,
struct xfs_da_state *state);
@@ -166,7 +164,7 @@ xfs_attr_get(
/*
* Calculate how many blocks we need for the new attribute,
*/
-STATIC int
+int
xfs_attr_calc_size(
struct xfs_da_args *args,
int *local)
diff --git a/libxfs/xfs_attr.h b/libxfs/xfs_attr.h
index 8de5d1d2733e..26f67cc79082 100644
--- a/libxfs/xfs_attr.h
+++ b/libxfs/xfs_attr.h
@@ -28,6 +28,11 @@ struct xfs_attr_list_context;
*/
#define ATTR_MAX_VALUELEN (64*1024) /* max length of a value */
+static inline bool xfs_has_larp(struct xfs_mount *mp)
+{
+ return false;
+}
+
/*
* Kernel-internal version of the attrlist cursor.
*/
@@ -461,6 +466,11 @@ enum xfs_delattr_state {
struct xfs_delattr_context {
struct xfs_da_args *da_args;
+ /*
+ * Used by xfs_attr_set to hold a leaf buffer across a transaction roll
+ */
+ struct xfs_buf *leaf_bp;
+
/* Used in xfs_attr_rmtval_set_blk to roll through allocating blocks */
struct xfs_bmbt_irec map;
xfs_dablk_t lblkno;
@@ -474,6 +484,23 @@ struct xfs_delattr_context {
enum xfs_delattr_state dela_state;
};
+/*
+ * List of attrs to commit later.
+ */
+struct xfs_attr_item {
+ struct xfs_delattr_context xattri_dac;
+
+ /*
+ * Indicates if the attr operation is a set or a remove
+ * XFS_ATTR_OP_FLAGS_{SET,REMOVE}
+ */
+ unsigned int xattri_op_flags;
+
+ /* used to log this item to an intent */
+ struct list_head xattri_list;
+};
+
+
/*========================================================================
* Function prototypes for the kernel.
*========================================================================*/
@@ -490,11 +517,14 @@ 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);
bool xfs_attr_namecheck(const void *name, size_t length);
void xfs_delattr_context_init(struct xfs_delattr_context *dac,
struct xfs_da_args *args);
+int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
#endif /* __XFS_ATTR_H__ */
diff --git a/libxfs/xfs_defer.h b/libxfs/xfs_defer.h
index 05472f71fffe..7566f61cd1b3 100644
--- a/libxfs/xfs_defer.h
+++ b/libxfs/xfs_defer.h
@@ -63,6 +63,7 @@ extern const struct xfs_defer_op_type xfs_refcount_update_defer_type;
extern const struct xfs_defer_op_type xfs_rmap_update_defer_type;
extern const struct xfs_defer_op_type xfs_extent_free_defer_type;
extern const struct xfs_defer_op_type xfs_agfl_free_defer_type;
+extern const struct xfs_defer_op_type xfs_attr_defer_type;
/*
* This structure enables a dfops user to detach the chain of deferred
diff --git a/libxfs/xfs_log_format.h b/libxfs/xfs_log_format.h
index 2c5bcbc19264..f2cfa9724448 100644
--- a/libxfs/xfs_log_format.h
+++ b/libxfs/xfs_log_format.h
@@ -114,7 +114,11 @@ struct xfs_unmount_log_format {
#define XLOG_REG_TYPE_CUD_FORMAT 24
#define XLOG_REG_TYPE_BUI_FORMAT 25
#define XLOG_REG_TYPE_BUD_FORMAT 26
-#define XLOG_REG_TYPE_MAX 26
+#define XLOG_REG_TYPE_ATTRI_FORMAT 27
+#define XLOG_REG_TYPE_ATTRD_FORMAT 28
+#define XLOG_REG_TYPE_ATTR_NAME 29
+#define XLOG_REG_TYPE_ATTR_VALUE 30
+#define XLOG_REG_TYPE_MAX 30
/*
* Flags to log operation header
@@ -237,6 +241,8 @@ typedef struct xfs_trans_header {
#define XFS_LI_CUD 0x1243
#define XFS_LI_BUI 0x1244 /* bmbt update intent */
#define XFS_LI_BUD 0x1245
+#define XFS_LI_ATTRI 0x1246 /* attr set/remove intent*/
+#define XFS_LI_ATTRD 0x1247 /* attr set/remove done */
#define XFS_LI_TYPE_DESC \
{ XFS_LI_EFI, "XFS_LI_EFI" }, \
@@ -252,7 +258,9 @@ typedef struct xfs_trans_header {
{ XFS_LI_CUI, "XFS_LI_CUI" }, \
{ XFS_LI_CUD, "XFS_LI_CUD" }, \
{ XFS_LI_BUI, "XFS_LI_BUI" }, \
- { XFS_LI_BUD, "XFS_LI_BUD" }
+ { XFS_LI_BUD, "XFS_LI_BUD" }, \
+ { XFS_LI_ATTRI, "XFS_LI_ATTRI" }, \
+ { XFS_LI_ATTRD, "XFS_LI_ATTRD" }
/*
* Inode Log Item Format definitions.
@@ -869,4 +877,35 @@ struct xfs_icreate_log {
__be32 icl_gen; /* inode generation number to use */
};
+/*
+ * Flags for deferred attribute operations.
+ * Upper bits are flags, lower byte is type code
+ */
+#define XFS_ATTR_OP_FLAGS_SET 1 /* Set the attribute */
+#define XFS_ATTR_OP_FLAGS_REMOVE 2 /* Remove the attribute */
+#define XFS_ATTR_OP_FLAGS_TYPE_MASK 0xFF /* Flags type mask */
+
+/*
+ * This is the structure used to lay out an attr log item in the
+ * log.
+ */
+struct xfs_attri_log_format {
+ uint16_t alfi_type; /* attri log item type */
+ uint16_t alfi_size; /* size of this item */
+ uint32_t __pad; /* pad to 64 bit aligned */
+ uint64_t alfi_id; /* attri identifier */
+ uint64_t alfi_ino; /* the inode for this attr operation */
+ uint32_t alfi_op_flags; /* marks the op as a set or remove */
+ uint32_t alfi_name_len; /* attr name length */
+ uint32_t alfi_value_len; /* attr value length */
+ uint32_t alfi_attr_flags;/* attr flags */
+};
+
+struct xfs_attrd_log_format {
+ uint16_t alfd_type; /* attrd log item type */
+ uint16_t alfd_size; /* size of this item */
+ uint32_t __pad; /* pad to 64 bit aligned */
+ uint64_t alfd_alf_id; /* id of corresponding attri */
+};
+
#endif /* __XFS_LOG_FORMAT_H__ */
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 07/14] xfsprogs: Implement attr logging and replay
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (5 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 06/14] xfsprogs: Set up infrastructure for log attribute replay Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 08/14] xfsprogs: Skip flip flags for delayed attrs Allison Henderson
` (6 subsequent siblings)
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
This patch adds the needed routines to create, log and recover logged
extended attribute intents.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
---
libxfs/defer_item.c | 119 ++++++++++++++++++++++++++++++++++++++++++++
libxfs/xfs_defer.c | 1 +
libxfs/xfs_defer.h | 1 +
libxfs/xfs_format.h | 11 +++-
4 files changed, 131 insertions(+), 1 deletion(-)
diff --git a/libxfs/defer_item.c b/libxfs/defer_item.c
index a1f0d7e52ff3..46026084f44b 100644
--- a/libxfs/defer_item.c
+++ b/libxfs/defer_item.c
@@ -115,6 +115,125 @@ const struct xfs_defer_op_type xfs_extent_free_defer_type = {
.cancel_item = xfs_extent_free_cancel_item,
};
+/*
+ * Performs one step of an attribute update intent and marks the attrd item
+ * dirty.. An attr operation may be a set or a remove. Note that the
+ * transaction is marked dirty regardless of whether the operation succeeds or
+ * fails to support the ATTRI/ATTRD lifecycle rules.
+ */
+STATIC int
+xfs_trans_attr_finish_update(
+ struct xfs_delattr_context *dac,
+ struct xfs_buf **leaf_bp,
+ uint32_t op_flags)
+{
+ struct xfs_da_args *args = dac->da_args;
+ unsigned int op = op_flags &
+ XFS_ATTR_OP_FLAGS_TYPE_MASK;
+ int error;
+
+ switch (op) {
+ case XFS_ATTR_OP_FLAGS_SET:
+ error = xfs_attr_set_iter(dac, leaf_bp);
+ break;
+ case XFS_ATTR_OP_FLAGS_REMOVE:
+ ASSERT(XFS_IFORK_Q(args->dp));
+ error = xfs_attr_remove_iter(dac);
+ break;
+ default:
+ error = -EFSCORRUPTED;
+ break;
+ }
+
+ /*
+ * Mark the transaction dirty, even on error. This ensures the
+ * transaction is aborted, which:
+ *
+ * 1.) releases the ATTRI and frees the ATTRD
+ * 2.) shuts down the filesystem
+ */
+ args->trans->t_flags |= XFS_TRANS_DIRTY;
+
+ return error;
+}
+
+/* Get an ATTRI. */
+static struct xfs_log_item *
+xfs_attr_create_intent(
+ struct xfs_trans *tp,
+ struct list_head *items,
+ unsigned int count,
+ bool sort)
+{
+ return NULL;
+}
+
+/* Abort all pending ATTRs. */
+STATIC void
+xfs_attr_abort_intent(
+ struct xfs_log_item *intent)
+{
+}
+
+/* Get an ATTRD so we can process all the attrs. */
+static struct xfs_log_item *
+xfs_attr_create_done(
+ struct xfs_trans *tp,
+ struct xfs_log_item *intent,
+ unsigned int count)
+{
+ return NULL;
+}
+
+/* Process an attr. */
+STATIC int
+xfs_attr_finish_item(
+ struct xfs_trans *tp,
+ struct xfs_log_item *done,
+ struct list_head *item,
+ struct xfs_btree_cur **state)
+{
+ struct xfs_attr_item *attr;
+ int error;
+ struct xfs_delattr_context *dac;
+
+ attr = container_of(item, struct xfs_attr_item, xattri_list);
+ dac = &attr->xattri_dac;
+
+ /*
+ * Always reset trans after EAGAIN cycle
+ * since the transaction is new
+ */
+ dac->da_args->trans = tp;
+
+ error = xfs_trans_attr_finish_update(dac, &dac->leaf_bp,
+ attr->xattri_op_flags);
+ if (error != -EAGAIN)
+ kmem_free(attr);
+
+ return error;
+}
+
+/* Cancel an attr */
+STATIC void
+xfs_attr_cancel_item(
+ struct list_head *item)
+{
+ struct xfs_attr_item *attr;
+
+ attr = container_of(item, struct xfs_attr_item, xattri_list);
+ kmem_free(attr);
+}
+
+const struct xfs_defer_op_type xfs_attr_defer_type = {
+ .max_items = 1,
+ .create_intent = xfs_attr_create_intent,
+ .abort_intent = xfs_attr_abort_intent,
+ .create_done = xfs_attr_create_done,
+ .finish_item = xfs_attr_finish_item,
+ .cancel_item = xfs_attr_cancel_item,
+};
+
/*
* AGFL blocks are accounted differently in the reserve pools and are not
* inserted into the busy extent list.
diff --git a/libxfs/xfs_defer.c b/libxfs/xfs_defer.c
index 006277cffdef..c03390643942 100644
--- a/libxfs/xfs_defer.c
+++ b/libxfs/xfs_defer.c
@@ -174,6 +174,7 @@ static const struct xfs_defer_op_type *defer_op_types[] = {
[XFS_DEFER_OPS_TYPE_RMAP] = &xfs_rmap_update_defer_type,
[XFS_DEFER_OPS_TYPE_FREE] = &xfs_extent_free_defer_type,
[XFS_DEFER_OPS_TYPE_AGFL_FREE] = &xfs_agfl_free_defer_type,
+ [XFS_DEFER_OPS_TYPE_ATTR] = &xfs_attr_defer_type,
};
static bool
diff --git a/libxfs/xfs_defer.h b/libxfs/xfs_defer.h
index 7566f61cd1b3..58cf4e290c3d 100644
--- a/libxfs/xfs_defer.h
+++ b/libxfs/xfs_defer.h
@@ -19,6 +19,7 @@ enum xfs_defer_ops_type {
XFS_DEFER_OPS_TYPE_RMAP,
XFS_DEFER_OPS_TYPE_FREE,
XFS_DEFER_OPS_TYPE_AGFL_FREE,
+ XFS_DEFER_OPS_TYPE_ATTR,
XFS_DEFER_OPS_TYPE_MAX,
};
diff --git a/libxfs/xfs_format.h b/libxfs/xfs_format.h
index 5d8a129150d5..37ef0e627292 100644
--- a/libxfs/xfs_format.h
+++ b/libxfs/xfs_format.h
@@ -485,7 +485,9 @@ xfs_sb_has_incompat_feature(
return (sbp->sb_features_incompat & feature) != 0;
}
-#define XFS_SB_FEAT_INCOMPAT_LOG_ALL 0
+#define XFS_SB_FEAT_INCOMPAT_LOG_XATTRS (1 << 0) /* Delayed Attributes */
+#define XFS_SB_FEAT_INCOMPAT_LOG_ALL \
+ (XFS_SB_FEAT_INCOMPAT_LOG_XATTRS)
#define XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_LOG_ALL
static inline bool
xfs_sb_has_incompat_log_feature(
@@ -590,6 +592,13 @@ static inline bool xfs_sb_version_hasbigtime(struct xfs_sb *sbp)
(sbp->sb_features_incompat & XFS_SB_FEAT_INCOMPAT_BIGTIME);
}
+static inline bool xfs_sb_version_haslogxattrs(struct xfs_sb *sbp)
+{
+ return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 &&
+ (sbp->sb_features_log_incompat &
+ XFS_SB_FEAT_INCOMPAT_LOG_XATTRS);
+}
+
/*
* Inode btree block counter. We record the number of inobt and finobt blocks
* in the AGI header so that we can skip the finobt walk at mount time when
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 08/14] xfsprogs: Skip flip flags for delayed attrs
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (6 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 07/14] xfsprogs: Implement attr logging and replay Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 09/14] xfsprogs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred Allison Henderson
` (5 subsequent siblings)
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
Source kernel commit: 2b1c81a8c3f453ba16b6db8dae256723bf53c051
This is a clean up patch that skips the flip flag logic for delayed attr
renames. Since the log replay keeps the inode locked, we do not need to
worry about race windows with attr lookups. So we can skip over
flipping the flag and the extra transaction roll for it
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
---
libxfs/xfs_attr.c | 54 ++++++++++++++++++++++++++----------------
libxfs/xfs_attr_leaf.c | 3 ++-
2 files changed, 35 insertions(+), 22 deletions(-)
diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index 61cb7ea9ff5b..6306bcf1d1ba 100644
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -354,6 +354,7 @@ xfs_attr_set_iter(
struct xfs_inode *dp = args->dp;
struct xfs_buf *bp = NULL;
int forkoff, error = 0;
+ struct xfs_mount *mp = args->dp->i_mount;
/* State machine switch */
switch (dac->dela_state) {
@@ -476,16 +477,21 @@ xfs_attr_set_iter(
* In a separate transaction, set the incomplete flag on the
* "old" attr and clear the incomplete flag on the "new" attr.
*/
- error = xfs_attr3_leaf_flipflags(args);
- if (error)
- return error;
- /*
- * Commit the flag value change and start the next trans in
- * series.
- */
- dac->dela_state = XFS_DAS_FLIP_LFLAG;
- trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
- return -EAGAIN;
+ if (!xfs_has_larp(mp)) {
+ error = xfs_attr3_leaf_flipflags(args);
+ if (error)
+ return error;
+ /*
+ * Commit the flag value change and start the next trans
+ * in series.
+ */
+ dac->dela_state = XFS_DAS_FLIP_LFLAG;
+ trace_xfs_attr_set_iter_return(dac->dela_state,
+ args->dp);
+ return -EAGAIN;
+ }
+
+ fallthrough;
case XFS_DAS_FLIP_LFLAG:
/*
* Dismantle the "old" attribute/value pair by removing a
@@ -588,17 +594,21 @@ xfs_attr_set_iter(
* In a separate transaction, set the incomplete flag on the
* "old" attr and clear the incomplete flag on the "new" attr.
*/
- error = xfs_attr3_leaf_flipflags(args);
- if (error)
- goto out;
- /*
- * Commit the flag value change and start the next trans in
- * series
- */
- dac->dela_state = XFS_DAS_FLIP_NFLAG;
- trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
- return -EAGAIN;
+ if (!xfs_has_larp(mp)) {
+ error = xfs_attr3_leaf_flipflags(args);
+ if (error)
+ goto out;
+ /*
+ * Commit the flag value change and start the next trans
+ * in series
+ */
+ dac->dela_state = XFS_DAS_FLIP_NFLAG;
+ trace_xfs_attr_set_iter_return(dac->dela_state,
+ args->dp);
+ return -EAGAIN;
+ }
+ fallthrough;
case XFS_DAS_FLIP_NFLAG:
/*
* Dismantle the "old" attribute/value pair by removing a
@@ -1236,6 +1246,7 @@ xfs_attr_node_addname_clear_incomplete(
{
struct xfs_da_args *args = dac->da_args;
struct xfs_da_state *state = NULL;
+ struct xfs_mount *mp = args->dp->i_mount;
int retval = 0;
int error = 0;
@@ -1243,7 +1254,8 @@ xfs_attr_node_addname_clear_incomplete(
* Re-find the "old" attribute entry after any split ops. The INCOMPLETE
* flag means that we will find the "old" attr, not the "new" one.
*/
- args->attr_filter |= XFS_ATTR_INCOMPLETE;
+ if (!xfs_has_larp(mp))
+ args->attr_filter |= XFS_ATTR_INCOMPLETE;
state = xfs_da_state_alloc(args);
state->inleaf = 0;
error = xfs_da3_node_lookup_int(state, &retval);
diff --git a/libxfs/xfs_attr_leaf.c b/libxfs/xfs_attr_leaf.c
index cfb6bf171090..6c0997c51fd6 100644
--- a/libxfs/xfs_attr_leaf.c
+++ b/libxfs/xfs_attr_leaf.c
@@ -1479,7 +1479,8 @@ xfs_attr3_leaf_add_work(
if (tmp)
entry->flags |= XFS_ATTR_LOCAL;
if (args->op_flags & XFS_DA_OP_RENAME) {
- entry->flags |= XFS_ATTR_INCOMPLETE;
+ if (!xfs_has_larp(mp))
+ entry->flags |= XFS_ATTR_INCOMPLETE;
if ((args->blkno2 == args->blkno) &&
(args->index2 <= args->index)) {
args->index2++;
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 09/14] xfsprogs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (7 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 08/14] xfsprogs: Skip flip flags for delayed attrs Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 10/14] xfsprogs: Remove unused xfs_attr_*_args Allison Henderson
` (4 subsequent siblings)
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
From: Allison Collins <allison.henderson@oracle.com>
These routines set up and queue a new deferred attribute operations.
These functions are meant to be called by any routine needing to
initiate a deferred attribute operation as opposed to the existing
inline operations. New helper function xfs_attr_item_init also added.
Finally enable delayed attributes in xfs_attr_set and xfs_attr_remove.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
---
libxfs/libxfs_priv.h | 4 +++
libxfs/xfs_attr.c | 69 ++++++++++++++++++++++++++++++++++++++++++--
libxfs/xfs_attr.h | 2 ++
3 files changed, 72 insertions(+), 3 deletions(-)
diff --git a/libxfs/libxfs_priv.h b/libxfs/libxfs_priv.h
index 15bae1ffde88..7f6dc14e476f 100644
--- a/libxfs/libxfs_priv.h
+++ b/libxfs/libxfs_priv.h
@@ -609,9 +609,13 @@ typedef int (*xfs_rtalloc_query_range_fn)(
int libxfs_zero_extent(struct xfs_inode *ip, xfs_fsblock_t start_fsb,
xfs_off_t count_fsb);
+/* xfs_log.c */
+struct xlog;
bool xfs_log_check_lsn(struct xfs_mount *, xfs_lsn_t);
void xfs_log_item_init(struct xfs_mount *, struct xfs_log_item *, int);
+int xfs_attr_use_log_assist(struct xfs_mount *mp);
+void xlog_drop_incompat_feat(struct xlog *log);
#define xfs_log_in_recovery(mp) (false)
/* xfs_icache.c */
diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index 6306bcf1d1ba..806272017cb1 100644
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -725,6 +725,7 @@ xfs_attr_set(
int error, local;
int rmt_blks = 0;
unsigned int total;
+ int delayed = xfs_has_larp(mp);
if (XFS_FORCED_SHUTDOWN(dp->i_mount))
return -EIO;
@@ -781,13 +782,19 @@ xfs_attr_set(
rmt_blks = xfs_attr3_rmt_blocks(mp, XFS_XATTR_SIZE_MAX);
}
+ if (delayed) {
+ error = xfs_attr_use_log_assist(mp);
+ if (error)
+ return error;
+ }
+
/*
* Root fork attributes can use reserved data blocks for this
* operation if necessary
*/
error = xfs_trans_alloc_inode(dp, &tres, total, 0, rsvd, &args->trans);
if (error)
- return error;
+ goto drop_incompat;
if (args->value || xfs_inode_hasattr(dp)) {
error = xfs_iext_count_may_overflow(dp, XFS_ATTR_FORK,
@@ -805,9 +812,10 @@ xfs_attr_set(
if (error != -ENOATTR && error != -EEXIST)
goto out_trans_cancel;
- error = xfs_attr_set_args(args);
+ error = xfs_attr_set_deferred(args);
if (error)
goto out_trans_cancel;
+
/* shortform attribute has already been committed */
if (!args->trans)
goto out_unlock;
@@ -816,7 +824,7 @@ xfs_attr_set(
if (error != -EEXIST)
goto out_trans_cancel;
- error = xfs_attr_remove_args(args);
+ error = xfs_attr_remove_deferred(args);
if (error)
goto out_trans_cancel;
}
@@ -838,6 +846,9 @@ xfs_attr_set(
error = xfs_trans_commit(args->trans);
out_unlock:
xfs_iunlock(dp, XFS_ILOCK_EXCL);
+drop_incompat:
+ if (delayed)
+ xlog_drop_incompat_feat(mp->m_log);
return error;
out_trans_cancel:
@@ -846,6 +857,58 @@ out_trans_cancel:
goto out_unlock;
}
+STATIC int
+xfs_attr_item_init(
+ struct xfs_da_args *args,
+ unsigned int op_flags, /* op flag (set or remove) */
+ struct xfs_attr_item **attr) /* new xfs_attr_item */
+{
+
+ struct xfs_attr_item *new;
+
+ new = kmem_zalloc(sizeof(struct xfs_attr_item), KM_NOFS);
+ new->xattri_op_flags = op_flags;
+ new->xattri_dac.da_args = args;
+
+ *attr = new;
+ return 0;
+}
+
+/* Sets an attribute for an inode as a deferred operation */
+int
+xfs_attr_set_deferred(
+ struct xfs_da_args *args)
+{
+ struct xfs_attr_item *new;
+ int error = 0;
+
+ error = xfs_attr_item_init(args, XFS_ATTR_OP_FLAGS_SET, &new);
+ if (error)
+ return error;
+
+ xfs_defer_add(args->trans, XFS_DEFER_OPS_TYPE_ATTR, &new->xattri_list);
+
+ return 0;
+}
+
+/* Removes an attribute for an inode as a deferred operation */
+int
+xfs_attr_remove_deferred(
+ struct xfs_da_args *args)
+{
+
+ struct xfs_attr_item *new;
+ int error;
+
+ error = xfs_attr_item_init(args, XFS_ATTR_OP_FLAGS_REMOVE, &new);
+ if (error)
+ return error;
+
+ xfs_defer_add(args->trans, XFS_DEFER_OPS_TYPE_ATTR, &new->xattri_list);
+
+ return 0;
+}
+
/*========================================================================
* External routines when attribute list is inside the inode
*========================================================================*/
diff --git a/libxfs/xfs_attr.h b/libxfs/xfs_attr.h
index 26f67cc79082..4c48bd46bb32 100644
--- a/libxfs/xfs_attr.h
+++ b/libxfs/xfs_attr.h
@@ -526,5 +526,7 @@ bool xfs_attr_namecheck(const void *name, size_t length);
void xfs_delattr_context_init(struct xfs_delattr_context *dac,
struct xfs_da_args *args);
int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
+int xfs_attr_set_deferred(struct xfs_da_args *args);
+int xfs_attr_remove_deferred(struct xfs_da_args *args);
#endif /* __XFS_ATTR_H__ */
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 10/14] xfsprogs: Remove unused xfs_attr_*_args
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (8 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 09/14] xfsprogs: Add xfs_attr_set_deferred and xfs_attr_remove_deferred Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 11/14] xfsprogs: Add log attribute error tag Allison Henderson
` (3 subsequent siblings)
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
Remove xfs_attr_set_args, xfs_attr_remove_args, and xfs_attr_trans_roll.
These high level loops are now driven by the delayed operations code,
and can be removed.
Additionally collapse in the leaf_bp parameter of xfs_attr_set_iter
since we only have one caller that passes dac->leaf_bp
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
---
libxfs/defer_item.c | 6 +--
libxfs/xfs_attr.c | 106 ++++-----------------------------------
libxfs/xfs_attr.h | 8 +--
libxfs/xfs_attr_remote.c | 1 -
4 files changed, 13 insertions(+), 108 deletions(-)
diff --git a/libxfs/defer_item.c b/libxfs/defer_item.c
index 46026084f44b..594f5e92e668 100644
--- a/libxfs/defer_item.c
+++ b/libxfs/defer_item.c
@@ -124,7 +124,6 @@ const struct xfs_defer_op_type xfs_extent_free_defer_type = {
STATIC int
xfs_trans_attr_finish_update(
struct xfs_delattr_context *dac,
- struct xfs_buf **leaf_bp,
uint32_t op_flags)
{
struct xfs_da_args *args = dac->da_args;
@@ -134,7 +133,7 @@ xfs_trans_attr_finish_update(
switch (op) {
case XFS_ATTR_OP_FLAGS_SET:
- error = xfs_attr_set_iter(dac, leaf_bp);
+ error = xfs_attr_set_iter(dac);
break;
case XFS_ATTR_OP_FLAGS_REMOVE:
ASSERT(XFS_IFORK_Q(args->dp));
@@ -206,8 +205,7 @@ xfs_attr_finish_item(
*/
dac->da_args->trans = tp;
- error = xfs_trans_attr_finish_update(dac, &dac->leaf_bp,
- attr->xattri_op_flags);
+ error = xfs_trans_attr_finish_update(dac, attr->xattri_op_flags);
if (error != -EAGAIN)
kmem_free(attr);
diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index 806272017cb1..7d28914894ce 100644
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -241,64 +241,9 @@ xfs_attr_is_shortform(
ip->i_afp->if_nextents == 0);
}
-/*
- * Checks to see if a delayed attribute transaction should be rolled. If so,
- * transaction is finished or rolled as needed.
- */
-STATIC int
-xfs_attr_trans_roll(
- struct xfs_delattr_context *dac)
-{
- struct xfs_da_args *args = dac->da_args;
- int error;
-
- if (dac->flags & XFS_DAC_DEFER_FINISH) {
- /*
- * The caller wants us to finish all the deferred ops so that we
- * avoid pinning the log tail with a large number of deferred
- * ops.
- */
- dac->flags &= ~XFS_DAC_DEFER_FINISH;
- error = xfs_defer_finish(&args->trans);
- } else
- error = xfs_trans_roll_inode(&args->trans, args->dp);
-
- return error;
-}
-
-/*
- * Set the attribute specified in @args.
- */
-int
-xfs_attr_set_args(
- struct xfs_da_args *args)
-{
- struct xfs_buf *leaf_bp = NULL;
- int error = 0;
- struct xfs_delattr_context dac = {
- .da_args = args,
- };
-
- do {
- error = xfs_attr_set_iter(&dac, &leaf_bp);
- if (error != -EAGAIN)
- break;
-
- error = xfs_attr_trans_roll(&dac);
- if (error) {
- if (leaf_bp)
- xfs_trans_brelse(args->trans, leaf_bp);
- return error;
- }
- } while (true);
-
- return error;
-}
-
STATIC int
xfs_attr_sf_addname(
- struct xfs_delattr_context *dac,
- struct xfs_buf **leaf_bp)
+ struct xfs_delattr_context *dac)
{
struct xfs_da_args *args = dac->da_args;
struct xfs_inode *dp = args->dp;
@@ -317,7 +262,7 @@ xfs_attr_sf_addname(
* It won't fit in the shortform, transform to a leaf block. GROT:
* another possible req'mt for a double-split btree op.
*/
- error = xfs_attr_shortform_to_leaf(args, leaf_bp);
+ error = xfs_attr_shortform_to_leaf(args, &dac->leaf_bp);
if (error)
return error;
@@ -326,7 +271,7 @@ xfs_attr_sf_addname(
* push cannot grab the half-baked leaf buffer and run into problems
* with the write verifier.
*/
- xfs_trans_bhold(args->trans, *leaf_bp);
+ xfs_trans_bhold(args->trans, dac->leaf_bp);
/*
* We're still in XFS_DAS_UNINIT state here. We've converted
@@ -334,7 +279,6 @@ xfs_attr_sf_addname(
* add.
*/
trace_xfs_attr_sf_addname_return(XFS_DAS_UNINIT, args->dp);
- dac->flags |= XFS_DAC_DEFER_FINISH;
return -EAGAIN;
}
@@ -347,8 +291,7 @@ xfs_attr_sf_addname(
*/
int
xfs_attr_set_iter(
- struct xfs_delattr_context *dac,
- struct xfs_buf **leaf_bp)
+ struct xfs_delattr_context *dac)
{
struct xfs_da_args *args = dac->da_args;
struct xfs_inode *dp = args->dp;
@@ -367,14 +310,14 @@ xfs_attr_set_iter(
* release the hold once we return with a clean transaction.
*/
if (xfs_attr_is_shortform(dp))
- return xfs_attr_sf_addname(dac, leaf_bp);
- if (*leaf_bp != NULL) {
- xfs_trans_bhold_release(args->trans, *leaf_bp);
- *leaf_bp = NULL;
+ return xfs_attr_sf_addname(dac);
+ if (dac->leaf_bp != NULL) {
+ xfs_trans_bhold_release(args->trans, dac->leaf_bp);
+ dac->leaf_bp = NULL;
}
if (xfs_attr_is_leaf(dp)) {
- error = xfs_attr_leaf_try_add(args, *leaf_bp);
+ error = xfs_attr_leaf_try_add(args, dac->leaf_bp);
if (error == -ENOSPC) {
error = xfs_attr3_leaf_to_node(args);
if (error)
@@ -393,7 +336,6 @@ xfs_attr_set_iter(
* be a node, so we'll fall down into the node
* handling code below
*/
- dac->flags |= XFS_DAC_DEFER_FINISH;
trace_xfs_attr_set_iter_return(
dac->dela_state, args->dp);
return -EAGAIN;
@@ -684,32 +626,6 @@ xfs_has_attr(
return xfs_attr_node_hasname(args, NULL);
}
-/*
- * Remove the attribute specified in @args.
- */
-int
-xfs_attr_remove_args(
- struct xfs_da_args *args)
-{
- int error;
- struct xfs_delattr_context dac = {
- .da_args = args,
- };
-
- do {
- error = xfs_attr_remove_iter(&dac);
- if (error != -EAGAIN)
- break;
-
- error = xfs_attr_trans_roll(&dac);
- if (error)
- return error;
-
- } while (true);
-
- return error;
-}
-
/*
* Note: If args->value is NULL the attribute will be removed, just like the
* Linux ->setattr API.
@@ -1273,7 +1189,6 @@ xfs_attr_node_addname(
* this. dela_state is still unset by this function at
* this point.
*/
- dac->flags |= XFS_DAC_DEFER_FINISH;
trace_xfs_attr_node_addname_return(
dac->dela_state, args->dp);
return -EAGAIN;
@@ -1288,7 +1203,6 @@ xfs_attr_node_addname(
error = xfs_da3_split(state);
if (error)
goto out;
- dac->flags |= XFS_DAC_DEFER_FINISH;
} else {
/*
* Addition succeeded, update Btree hashvals.
@@ -1542,7 +1456,6 @@ xfs_attr_remove_iter(
if (error)
goto out;
dac->dela_state = XFS_DAS_RM_NAME;
- dac->flags |= XFS_DAC_DEFER_FINISH;
trace_xfs_attr_remove_iter_return(dac->dela_state, args->dp);
return -EAGAIN;
}
@@ -1570,7 +1483,6 @@ xfs_attr_remove_iter(
if (error)
goto out;
- dac->flags |= XFS_DAC_DEFER_FINISH;
dac->dela_state = XFS_DAS_RM_SHRINK;
trace_xfs_attr_remove_iter_return(
dac->dela_state, args->dp);
diff --git a/libxfs/xfs_attr.h b/libxfs/xfs_attr.h
index 4c48bd46bb32..60806dcd5e5d 100644
--- a/libxfs/xfs_attr.h
+++ b/libxfs/xfs_attr.h
@@ -457,8 +457,7 @@ enum xfs_delattr_state {
/*
* Defines for xfs_delattr_context.flags
*/
-#define XFS_DAC_DEFER_FINISH 0x01 /* finish the transaction */
-#define XFS_DAC_LEAF_ADDNAME_INIT 0x02 /* xfs_attr_leaf_addname init*/
+#define XFS_DAC_LEAF_ADDNAME_INIT 0x01 /* xfs_attr_leaf_addname init*/
/*
* Context used for keeping track of delayed attribute operations
@@ -516,11 +515,8 @@ bool xfs_attr_is_leaf(struct xfs_inode *ip);
int xfs_attr_get_ilocked(struct xfs_da_args *args);
int xfs_attr_get(struct xfs_da_args *args);
int xfs_attr_set(struct xfs_da_args *args);
-int xfs_attr_set_args(struct xfs_da_args *args);
-int xfs_attr_set_iter(struct xfs_delattr_context *dac,
- struct xfs_buf **leaf_bp);
+int xfs_attr_set_iter(struct xfs_delattr_context *dac);
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);
void xfs_delattr_context_init(struct xfs_delattr_context *dac,
diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
index b781e44d9c5a..42943b3542c4 100644
--- a/libxfs/xfs_attr_remote.c
+++ b/libxfs/xfs_attr_remote.c
@@ -694,7 +694,6 @@ xfs_attr_rmtval_remove(
* the parent
*/
if (!done) {
- dac->flags |= XFS_DAC_DEFER_FINISH;
trace_xfs_attr_rmtval_remove_return(dac->dela_state, args->dp);
return -EAGAIN;
}
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 11/14] xfsprogs: Add log attribute error tag
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (9 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 10/14] xfsprogs: Remove unused xfs_attr_*_args Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
[not found] ` <11E93260-33C2-46BE-82B1-0402CB52BCD4@oracle.com>
2021-11-17 4:16 ` [PATCH v25 12/14] xfsprogs: Merge xfs_delattr_context into xfs_attr_item Allison Henderson
` (2 subsequent siblings)
13 siblings, 1 reply; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
This patch adds an error tag that we can use to test log attribute
recovery and replay
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
---
io/inject.c | 1 +
libxfs/defer_item.c | 6 ++++++
libxfs/xfs_errortag.h | 4 +++-
3 files changed, 10 insertions(+), 1 deletion(-)
diff --git a/io/inject.c b/io/inject.c
index b8b0977e139e..43b51db5b9cc 100644
--- a/io/inject.c
+++ b/io/inject.c
@@ -58,6 +58,7 @@ error_tag(char *name)
{ XFS_ERRTAG_REDUCE_MAX_IEXTENTS, "reduce_max_iextents" },
{ XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT, "bmap_alloc_minlen_extent" },
{ XFS_ERRTAG_AG_RESV_FAIL, "ag_resv_fail" },
+ { XFS_ERRTAG_LARP, "larp" },
{ XFS_ERRTAG_MAX, NULL }
};
int count;
diff --git a/libxfs/defer_item.c b/libxfs/defer_item.c
index 594f5e92e668..5392a1bcb961 100644
--- a/libxfs/defer_item.c
+++ b/libxfs/defer_item.c
@@ -131,6 +131,11 @@ xfs_trans_attr_finish_update(
XFS_ATTR_OP_FLAGS_TYPE_MASK;
int error;
+ if (XFS_TEST_ERROR(false, args->dp->i_mount, XFS_ERRTAG_LARP)) {
+ error = -EIO;
+ goto out;
+ }
+
switch (op) {
case XFS_ATTR_OP_FLAGS_SET:
error = xfs_attr_set_iter(dac);
@@ -144,6 +149,7 @@ xfs_trans_attr_finish_update(
break;
}
+out:
/*
* Mark the transaction dirty, even on error. This ensures the
* transaction is aborted, which:
diff --git a/libxfs/xfs_errortag.h b/libxfs/xfs_errortag.h
index a23a52e643ad..c15d2340220c 100644
--- a/libxfs/xfs_errortag.h
+++ b/libxfs/xfs_errortag.h
@@ -59,7 +59,8 @@
#define XFS_ERRTAG_REDUCE_MAX_IEXTENTS 36
#define XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT 37
#define XFS_ERRTAG_AG_RESV_FAIL 38
-#define XFS_ERRTAG_MAX 39
+#define XFS_ERRTAG_LARP 39
+#define XFS_ERRTAG_MAX 40
/*
* Random factors for above tags, 1 means always, 2 means 1/2 time, etc.
@@ -103,5 +104,6 @@
#define XFS_RANDOM_REDUCE_MAX_IEXTENTS 1
#define XFS_RANDOM_BMAP_ALLOC_MINLEN_EXTENT 1
#define XFS_RANDOM_AG_RESV_FAIL 1
+#define XFS_RANDOM_LARP 1
#endif /* __XFS_ERRORTAG_H_ */
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 12/14] xfsprogs: Merge xfs_delattr_context into xfs_attr_item
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (10 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 11/14] xfsprogs: Add log attribute error tag Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 13/14] xfsprogs: Add helper function xfs_attr_leaf_addname Allison Henderson
2021-11-17 4:16 ` [PATCH v25 14/14] xfsprogs: Add log item printing for ATTRI and ATTRD Allison Henderson
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
This is a clean up patch that merges xfs_delattr_context into
xfs_attr_item. Now that the refactoring is complete and the delayed
operation infrastructure is in place, we can combine these to eliminate
the extra struct
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
---
libxfs/defer_item.c | 14 ++--
libxfs/xfs_attr.c | 161 ++++++++++++++++++++-------------------
libxfs/xfs_attr.h | 40 +++++-----
libxfs/xfs_attr_remote.c | 36 ++++-----
libxfs/xfs_attr_remote.h | 6 +-
5 files changed, 128 insertions(+), 129 deletions(-)
diff --git a/libxfs/defer_item.c b/libxfs/defer_item.c
index 5392a1bcb961..4b669b769968 100644
--- a/libxfs/defer_item.c
+++ b/libxfs/defer_item.c
@@ -123,10 +123,10 @@ const struct xfs_defer_op_type xfs_extent_free_defer_type = {
*/
STATIC int
xfs_trans_attr_finish_update(
- struct xfs_delattr_context *dac,
+ struct xfs_attr_item *attr,
uint32_t op_flags)
{
- struct xfs_da_args *args = dac->da_args;
+ struct xfs_da_args *args = attr->xattri_da_args;
unsigned int op = op_flags &
XFS_ATTR_OP_FLAGS_TYPE_MASK;
int error;
@@ -138,11 +138,11 @@ xfs_trans_attr_finish_update(
switch (op) {
case XFS_ATTR_OP_FLAGS_SET:
- error = xfs_attr_set_iter(dac);
+ error = xfs_attr_set_iter(attr);
break;
case XFS_ATTR_OP_FLAGS_REMOVE:
ASSERT(XFS_IFORK_Q(args->dp));
- error = xfs_attr_remove_iter(dac);
+ error = xfs_attr_remove_iter(attr);
break;
default:
error = -EFSCORRUPTED;
@@ -200,18 +200,16 @@ xfs_attr_finish_item(
{
struct xfs_attr_item *attr;
int error;
- struct xfs_delattr_context *dac;
attr = container_of(item, struct xfs_attr_item, xattri_list);
- dac = &attr->xattri_dac;
/*
* Always reset trans after EAGAIN cycle
* since the transaction is new
*/
- dac->da_args->trans = tp;
+ attr->xattri_da_args->trans = tp;
- error = xfs_trans_attr_finish_update(dac, attr->xattri_op_flags);
+ error = xfs_trans_attr_finish_update(attr, attr->xattri_op_flags);
if (error != -EAGAIN)
kmem_free(attr);
diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index 7d28914894ce..c5b0abb5df20 100644
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -53,10 +53,9 @@ STATIC int xfs_attr_leaf_try_add(struct xfs_da_args *args, struct xfs_buf *bp);
*/
STATIC int xfs_attr_node_get(xfs_da_args_t *args);
STATIC void xfs_attr_restore_rmt_blk(struct xfs_da_args *args);
-STATIC int xfs_attr_node_addname(struct xfs_delattr_context *dac);
-STATIC int xfs_attr_node_addname_find_attr(struct xfs_delattr_context *dac);
-STATIC int xfs_attr_node_addname_clear_incomplete(
- struct xfs_delattr_context *dac);
+STATIC int xfs_attr_node_addname(struct xfs_attr_item *attr);
+STATIC int xfs_attr_node_addname_find_attr(struct xfs_attr_item *attr);
+STATIC int xfs_attr_node_addname_clear_incomplete(struct xfs_attr_item *attr);
STATIC int xfs_attr_node_hasname(xfs_da_args_t *args,
struct xfs_da_state **state);
STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
@@ -243,9 +242,9 @@ xfs_attr_is_shortform(
STATIC int
xfs_attr_sf_addname(
- struct xfs_delattr_context *dac)
+ struct xfs_attr_item *attr)
{
- struct xfs_da_args *args = dac->da_args;
+ struct xfs_da_args *args = attr->xattri_da_args;
struct xfs_inode *dp = args->dp;
int error = 0;
@@ -262,7 +261,7 @@ xfs_attr_sf_addname(
* It won't fit in the shortform, transform to a leaf block. GROT:
* another possible req'mt for a double-split btree op.
*/
- error = xfs_attr_shortform_to_leaf(args, &dac->leaf_bp);
+ error = xfs_attr_shortform_to_leaf(args, &attr->xattri_leaf_bp);
if (error)
return error;
@@ -271,7 +270,7 @@ xfs_attr_sf_addname(
* push cannot grab the half-baked leaf buffer and run into problems
* with the write verifier.
*/
- xfs_trans_bhold(args->trans, dac->leaf_bp);
+ xfs_trans_bhold(args->trans, attr->xattri_leaf_bp);
/*
* We're still in XFS_DAS_UNINIT state here. We've converted
@@ -291,16 +290,16 @@ xfs_attr_sf_addname(
*/
int
xfs_attr_set_iter(
- struct xfs_delattr_context *dac)
+ struct xfs_attr_item *attr)
{
- struct xfs_da_args *args = dac->da_args;
+ struct xfs_da_args *args = attr->xattri_da_args;
struct xfs_inode *dp = args->dp;
struct xfs_buf *bp = NULL;
int forkoff, error = 0;
struct xfs_mount *mp = args->dp->i_mount;
/* State machine switch */
- switch (dac->dela_state) {
+ switch (attr->xattri_dela_state) {
case XFS_DAS_UNINIT:
/*
* If the fork is shortform, attempt to add the attr. If there
@@ -310,14 +309,16 @@ xfs_attr_set_iter(
* release the hold once we return with a clean transaction.
*/
if (xfs_attr_is_shortform(dp))
- return xfs_attr_sf_addname(dac);
- if (dac->leaf_bp != NULL) {
- xfs_trans_bhold_release(args->trans, dac->leaf_bp);
- dac->leaf_bp = NULL;
+ return xfs_attr_sf_addname(attr);
+ if (attr->xattri_leaf_bp != NULL) {
+ xfs_trans_bhold_release(args->trans,
+ attr->xattri_leaf_bp);
+ attr->xattri_leaf_bp = NULL;
}
if (xfs_attr_is_leaf(dp)) {
- error = xfs_attr_leaf_try_add(args, dac->leaf_bp);
+ error = xfs_attr_leaf_try_add(args,
+ attr->xattri_leaf_bp);
if (error == -ENOSPC) {
error = xfs_attr3_leaf_to_node(args);
if (error)
@@ -337,19 +338,19 @@ xfs_attr_set_iter(
* handling code below
*/
trace_xfs_attr_set_iter_return(
- dac->dela_state, args->dp);
+ attr->xattri_dela_state, args->dp);
return -EAGAIN;
} else if (error) {
return error;
}
- dac->dela_state = XFS_DAS_FOUND_LBLK;
+ attr->xattri_dela_state = XFS_DAS_FOUND_LBLK;
} else {
- error = xfs_attr_node_addname_find_attr(dac);
+ error = xfs_attr_node_addname_find_attr(attr);
if (error)
return error;
- error = xfs_attr_node_addname(dac);
+ error = xfs_attr_node_addname(attr);
if (error)
return error;
@@ -361,9 +362,10 @@ xfs_attr_set_iter(
!(args->op_flags & XFS_DA_OP_RENAME))
return 0;
- dac->dela_state = XFS_DAS_FOUND_NBLK;
+ attr->xattri_dela_state = XFS_DAS_FOUND_NBLK;
}
- trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
+ trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
+ args->dp);
return -EAGAIN;
case XFS_DAS_FOUND_LBLK:
/*
@@ -374,10 +376,10 @@ xfs_attr_set_iter(
*/
/* Open coded xfs_attr_rmtval_set without trans handling */
- if ((dac->flags & XFS_DAC_LEAF_ADDNAME_INIT) == 0) {
- dac->flags |= XFS_DAC_LEAF_ADDNAME_INIT;
+ if ((attr->xattri_flags & XFS_DAC_LEAF_ADDNAME_INIT) == 0) {
+ attr->xattri_flags |= XFS_DAC_LEAF_ADDNAME_INIT;
if (args->rmtblkno > 0) {
- error = xfs_attr_rmtval_find_space(dac);
+ error = xfs_attr_rmtval_find_space(attr);
if (error)
return error;
}
@@ -387,11 +389,11 @@ xfs_attr_set_iter(
* Repeat allocating remote blocks for the attr value until
* blkcnt drops to zero.
*/
- if (dac->blkcnt > 0) {
- error = xfs_attr_rmtval_set_blk(dac);
+ if (attr->xattri_blkcnt > 0) {
+ error = xfs_attr_rmtval_set_blk(attr);
if (error)
return error;
- trace_xfs_attr_set_iter_return(dac->dela_state,
+ trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
args->dp);
return -EAGAIN;
}
@@ -427,8 +429,8 @@ xfs_attr_set_iter(
* Commit the flag value change and start the next trans
* in series.
*/
- dac->dela_state = XFS_DAS_FLIP_LFLAG;
- trace_xfs_attr_set_iter_return(dac->dela_state,
+ attr->xattri_dela_state = XFS_DAS_FLIP_LFLAG;
+ trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
args->dp);
return -EAGAIN;
}
@@ -447,17 +449,18 @@ xfs_attr_set_iter(
fallthrough;
case XFS_DAS_RM_LBLK:
/* Set state in case xfs_attr_rmtval_remove returns -EAGAIN */
- dac->dela_state = XFS_DAS_RM_LBLK;
+ attr->xattri_dela_state = XFS_DAS_RM_LBLK;
if (args->rmtblkno) {
- error = xfs_attr_rmtval_remove(dac);
+ error = xfs_attr_rmtval_remove(attr);
if (error == -EAGAIN)
trace_xfs_attr_set_iter_return(
- dac->dela_state, args->dp);
+ attr->xattri_dela_state, args->dp);
if (error)
return error;
- dac->dela_state = XFS_DAS_RD_LEAF;
- trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
+ attr->xattri_dela_state = XFS_DAS_RD_LEAF;
+ trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
+ args->dp);
return -EAGAIN;
}
@@ -488,7 +491,7 @@ xfs_attr_set_iter(
* state.
*/
if (args->rmtblkno > 0) {
- error = xfs_attr_rmtval_find_space(dac);
+ error = xfs_attr_rmtval_find_space(attr);
if (error)
return error;
}
@@ -501,14 +504,14 @@ xfs_attr_set_iter(
* after we create the attribute so that we don't overflow the
* maximum size of a transaction and/or hit a deadlock.
*/
- dac->dela_state = XFS_DAS_ALLOC_NODE;
+ attr->xattri_dela_state = XFS_DAS_ALLOC_NODE;
if (args->rmtblkno > 0) {
- if (dac->blkcnt > 0) {
- error = xfs_attr_rmtval_set_blk(dac);
+ if (attr->xattri_blkcnt > 0) {
+ error = xfs_attr_rmtval_set_blk(attr);
if (error)
return error;
trace_xfs_attr_set_iter_return(
- dac->dela_state, args->dp);
+ attr->xattri_dela_state, args->dp);
return -EAGAIN;
}
@@ -544,8 +547,8 @@ xfs_attr_set_iter(
* Commit the flag value change and start the next trans
* in series
*/
- dac->dela_state = XFS_DAS_FLIP_NFLAG;
- trace_xfs_attr_set_iter_return(dac->dela_state,
+ attr->xattri_dela_state = XFS_DAS_FLIP_NFLAG;
+ trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
args->dp);
return -EAGAIN;
}
@@ -565,18 +568,19 @@ xfs_attr_set_iter(
fallthrough;
case XFS_DAS_RM_NBLK:
/* Set state in case xfs_attr_rmtval_remove returns -EAGAIN */
- dac->dela_state = XFS_DAS_RM_NBLK;
+ attr->xattri_dela_state = XFS_DAS_RM_NBLK;
if (args->rmtblkno) {
- error = xfs_attr_rmtval_remove(dac);
+ error = xfs_attr_rmtval_remove(attr);
if (error == -EAGAIN)
trace_xfs_attr_set_iter_return(
- dac->dela_state, args->dp);
+ attr->xattri_dela_state, args->dp);
if (error)
return error;
- dac->dela_state = XFS_DAS_CLR_FLAG;
- trace_xfs_attr_set_iter_return(dac->dela_state, args->dp);
+ attr->xattri_dela_state = XFS_DAS_CLR_FLAG;
+ trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
+ args->dp);
return -EAGAIN;
}
@@ -586,7 +590,7 @@ xfs_attr_set_iter(
* The last state for node format. Look up the old attr and
* remove it.
*/
- error = xfs_attr_node_addname_clear_incomplete(dac);
+ error = xfs_attr_node_addname_clear_incomplete(attr);
break;
default:
ASSERT(0);
@@ -784,7 +788,7 @@ xfs_attr_item_init(
new = kmem_zalloc(sizeof(struct xfs_attr_item), KM_NOFS);
new->xattri_op_flags = op_flags;
- new->xattri_dac.da_args = args;
+ new->xattri_da_args = args;
*attr = new;
return 0;
@@ -1097,16 +1101,16 @@ xfs_attr_node_hasname(
STATIC int
xfs_attr_node_addname_find_attr(
- struct xfs_delattr_context *dac)
+ struct xfs_attr_item *attr)
{
- struct xfs_da_args *args = dac->da_args;
+ struct xfs_da_args *args = attr->xattri_da_args;
int retval;
/*
* Search to see if name already exists, and get back a pointer
* to where it should go.
*/
- retval = xfs_attr_node_hasname(args, &dac->da_state);
+ retval = xfs_attr_node_hasname(args, &attr->xattri_da_state);
if (retval != -ENOATTR && retval != -EEXIST)
return retval;
@@ -1134,8 +1138,8 @@ xfs_attr_node_addname_find_attr(
return 0;
error:
- if (dac->da_state)
- xfs_da_state_free(dac->da_state);
+ if (attr->xattri_da_state)
+ xfs_da_state_free(attr->xattri_da_state);
return retval;
}
@@ -1156,10 +1160,10 @@ error:
*/
STATIC int
xfs_attr_node_addname(
- struct xfs_delattr_context *dac)
+ struct xfs_attr_item *attr)
{
- struct xfs_da_args *args = dac->da_args;
- struct xfs_da_state *state = dac->da_state;
+ struct xfs_da_args *args = attr->xattri_da_args;
+ struct xfs_da_state *state = attr->xattri_da_state;
struct xfs_da_state_blk *blk;
int error;
@@ -1190,7 +1194,7 @@ xfs_attr_node_addname(
* this point.
*/
trace_xfs_attr_node_addname_return(
- dac->dela_state, args->dp);
+ attr->xattri_dela_state, args->dp);
return -EAGAIN;
}
@@ -1219,9 +1223,9 @@ out:
STATIC int
xfs_attr_node_addname_clear_incomplete(
- struct xfs_delattr_context *dac)
+ struct xfs_attr_item *attr)
{
- struct xfs_da_args *args = dac->da_args;
+ struct xfs_da_args *args = attr->xattri_da_args;
struct xfs_da_state *state = NULL;
struct xfs_mount *mp = args->dp->i_mount;
int retval = 0;
@@ -1325,10 +1329,10 @@ xfs_attr_leaf_mark_incomplete(
*/
STATIC
int xfs_attr_node_removename_setup(
- struct xfs_delattr_context *dac)
+ struct xfs_attr_item *attr)
{
- struct xfs_da_args *args = dac->da_args;
- struct xfs_da_state **state = &dac->da_state;
+ struct xfs_da_args *args = attr->xattri_da_args;
+ struct xfs_da_state **state = &attr->xattri_da_state;
int error;
error = xfs_attr_node_hasname(args, state);
@@ -1387,16 +1391,16 @@ xfs_attr_node_removename(
*/
int
xfs_attr_remove_iter(
- struct xfs_delattr_context *dac)
+ struct xfs_attr_item *attr)
{
- struct xfs_da_args *args = dac->da_args;
- struct xfs_da_state *state = dac->da_state;
+ struct xfs_da_args *args = attr->xattri_da_args;
+ struct xfs_da_state *state = attr->xattri_da_state;
int retval, error = 0;
struct xfs_inode *dp = args->dp;
trace_xfs_attr_node_removename(args);
- switch (dac->dela_state) {
+ switch (attr->xattri_dela_state) {
case XFS_DAS_UNINIT:
if (!xfs_inode_hasattr(dp))
return -ENOATTR;
@@ -1415,16 +1419,16 @@ xfs_attr_remove_iter(
* Node format may require transaction rolls. Set up the
* state context and fall into the state machine.
*/
- if (!dac->da_state) {
- error = xfs_attr_node_removename_setup(dac);
+ if (!attr->xattri_da_state) {
+ error = xfs_attr_node_removename_setup(attr);
if (error)
return error;
- state = dac->da_state;
+ state = attr->xattri_da_state;
}
fallthrough;
case XFS_DAS_RMTBLK:
- dac->dela_state = XFS_DAS_RMTBLK;
+ attr->xattri_dela_state = XFS_DAS_RMTBLK;
/*
* If there is an out-of-line value, de-allocate the blocks.
@@ -1437,10 +1441,10 @@ xfs_attr_remove_iter(
* May return -EAGAIN. Roll and repeat until all remote
* blocks are removed.
*/
- error = xfs_attr_rmtval_remove(dac);
+ error = xfs_attr_rmtval_remove(attr);
if (error == -EAGAIN) {
trace_xfs_attr_remove_iter_return(
- dac->dela_state, args->dp);
+ attr->xattri_dela_state, args->dp);
return error;
} else if (error) {
goto out;
@@ -1455,8 +1459,9 @@ xfs_attr_remove_iter(
error = xfs_attr_refillstate(state);
if (error)
goto out;
- dac->dela_state = XFS_DAS_RM_NAME;
- trace_xfs_attr_remove_iter_return(dac->dela_state, args->dp);
+ attr->xattri_dela_state = XFS_DAS_RM_NAME;
+ trace_xfs_attr_remove_iter_return(
+ attr->xattri_dela_state, args->dp);
return -EAGAIN;
}
@@ -1466,7 +1471,7 @@ xfs_attr_remove_iter(
* If we came here fresh from a transaction roll, reattach all
* the buffers to the current transaction.
*/
- if (dac->dela_state == XFS_DAS_RM_NAME) {
+ if (attr->xattri_dela_state == XFS_DAS_RM_NAME) {
error = xfs_attr_refillstate(state);
if (error)
goto out;
@@ -1483,9 +1488,9 @@ xfs_attr_remove_iter(
if (error)
goto out;
- dac->dela_state = XFS_DAS_RM_SHRINK;
+ attr->xattri_dela_state = XFS_DAS_RM_SHRINK;
trace_xfs_attr_remove_iter_return(
- dac->dela_state, args->dp);
+ attr->xattri_dela_state, args->dp);
return -EAGAIN;
}
diff --git a/libxfs/xfs_attr.h b/libxfs/xfs_attr.h
index 60806dcd5e5d..089a39a6bc7d 100644
--- a/libxfs/xfs_attr.h
+++ b/libxfs/xfs_attr.h
@@ -430,7 +430,7 @@ struct xfs_attr_list_context {
*/
/*
- * Enum values for xfs_delattr_context.da_state
+ * Enum values for xfs_attr_item.xattri_da_state
*
* These values are used by delayed attribute operations to keep track of where
* they were before they returned -EAGAIN. A return code of -EAGAIN signals the
@@ -455,39 +455,32 @@ enum xfs_delattr_state {
};
/*
- * Defines for xfs_delattr_context.flags
+ * Defines for xfs_attr_item.xattri_flags
*/
#define XFS_DAC_LEAF_ADDNAME_INIT 0x01 /* xfs_attr_leaf_addname init*/
/*
* Context used for keeping track of delayed attribute operations
*/
-struct xfs_delattr_context {
- struct xfs_da_args *da_args;
+struct xfs_attr_item {
+ struct xfs_da_args *xattri_da_args;
/*
* Used by xfs_attr_set to hold a leaf buffer across a transaction roll
*/
- struct xfs_buf *leaf_bp;
+ struct xfs_buf *xattri_leaf_bp;
/* Used in xfs_attr_rmtval_set_blk to roll through allocating blocks */
- struct xfs_bmbt_irec map;
- xfs_dablk_t lblkno;
- int blkcnt;
+ struct xfs_bmbt_irec xattri_map;
+ xfs_dablk_t xattri_lblkno;
+ int xattri_blkcnt;
/* Used in xfs_attr_node_removename to roll through removing blocks */
- struct xfs_da_state *da_state;
+ struct xfs_da_state *xattri_da_state;
/* Used to keep track of current state of delayed operation */
- unsigned int flags;
- enum xfs_delattr_state dela_state;
-};
-
-/*
- * List of attrs to commit later.
- */
-struct xfs_attr_item {
- struct xfs_delattr_context xattri_dac;
+ unsigned int xattri_flags;
+ enum xfs_delattr_state xattri_dela_state;
/*
* Indicates if the attr operation is a set or a remove
@@ -495,7 +488,10 @@ struct xfs_attr_item {
*/
unsigned int xattri_op_flags;
- /* used to log this item to an intent */
+ /*
+ * used to log this item to an intent containing a list of attrs to
+ * commit later
+ */
struct list_head xattri_list;
};
@@ -515,12 +511,10 @@ bool xfs_attr_is_leaf(struct xfs_inode *ip);
int xfs_attr_get_ilocked(struct xfs_da_args *args);
int xfs_attr_get(struct xfs_da_args *args);
int xfs_attr_set(struct xfs_da_args *args);
-int xfs_attr_set_iter(struct xfs_delattr_context *dac);
int xfs_has_attr(struct xfs_da_args *args);
-int xfs_attr_remove_iter(struct xfs_delattr_context *dac);
+int xfs_attr_set_iter(struct xfs_attr_item *attr);
+int xfs_attr_remove_iter(struct xfs_attr_item *attr);
bool xfs_attr_namecheck(const void *name, size_t length);
-void xfs_delattr_context_init(struct xfs_delattr_context *dac,
- struct xfs_da_args *args);
int xfs_attr_calc_size(struct xfs_da_args *args, int *local);
int xfs_attr_set_deferred(struct xfs_da_args *args);
int xfs_attr_remove_deferred(struct xfs_da_args *args);
diff --git a/libxfs/xfs_attr_remote.c b/libxfs/xfs_attr_remote.c
index 42943b3542c4..72461bd47f3b 100644
--- a/libxfs/xfs_attr_remote.c
+++ b/libxfs/xfs_attr_remote.c
@@ -567,14 +567,14 @@ xfs_attr_rmtval_stale(
*/
int
xfs_attr_rmtval_find_space(
- struct xfs_delattr_context *dac)
+ struct xfs_attr_item *attr)
{
- struct xfs_da_args *args = dac->da_args;
- struct xfs_bmbt_irec *map = &dac->map;
+ struct xfs_da_args *args = attr->xattri_da_args;
+ struct xfs_bmbt_irec *map = &attr->xattri_map;
int error;
- dac->lblkno = 0;
- dac->blkcnt = 0;
+ attr->xattri_lblkno = 0;
+ attr->xattri_blkcnt = 0;
args->rmtblkcnt = 0;
args->rmtblkno = 0;
memset(map, 0, sizeof(struct xfs_bmbt_irec));
@@ -583,8 +583,8 @@ xfs_attr_rmtval_find_space(
if (error)
return error;
- dac->blkcnt = args->rmtblkcnt;
- dac->lblkno = args->rmtblkno;
+ attr->xattri_blkcnt = args->rmtblkcnt;
+ attr->xattri_lblkno = args->rmtblkno;
return 0;
}
@@ -597,17 +597,18 @@ xfs_attr_rmtval_find_space(
*/
int
xfs_attr_rmtval_set_blk(
- struct xfs_delattr_context *dac)
+ struct xfs_attr_item *attr)
{
- struct xfs_da_args *args = dac->da_args;
+ struct xfs_da_args *args = attr->xattri_da_args;
struct xfs_inode *dp = args->dp;
- struct xfs_bmbt_irec *map = &dac->map;
+ struct xfs_bmbt_irec *map = &attr->xattri_map;
int nmap;
int error;
nmap = 1;
- error = xfs_bmapi_write(args->trans, dp, (xfs_fileoff_t)dac->lblkno,
- dac->blkcnt, XFS_BMAPI_ATTRFORK, args->total,
+ error = xfs_bmapi_write(args->trans, dp,
+ (xfs_fileoff_t)attr->xattri_lblkno,
+ attr->xattri_blkcnt, XFS_BMAPI_ATTRFORK, args->total,
map, &nmap);
if (error)
return error;
@@ -617,8 +618,8 @@ xfs_attr_rmtval_set_blk(
(map->br_startblock != HOLESTARTBLOCK));
/* roll attribute extent map forwards */
- dac->lblkno += map->br_blockcount;
- dac->blkcnt -= map->br_blockcount;
+ attr->xattri_lblkno += map->br_blockcount;
+ attr->xattri_blkcnt -= map->br_blockcount;
return 0;
}
@@ -672,9 +673,9 @@ xfs_attr_rmtval_invalidate(
*/
int
xfs_attr_rmtval_remove(
- struct xfs_delattr_context *dac)
+ struct xfs_attr_item *attr)
{
- struct xfs_da_args *args = dac->da_args;
+ struct xfs_da_args *args = attr->xattri_da_args;
int error, done;
/*
@@ -694,7 +695,8 @@ xfs_attr_rmtval_remove(
* the parent
*/
if (!done) {
- trace_xfs_attr_rmtval_remove_return(dac->dela_state, args->dp);
+ trace_xfs_attr_rmtval_remove_return(attr->xattri_dela_state,
+ args->dp);
return -EAGAIN;
}
diff --git a/libxfs/xfs_attr_remote.h b/libxfs/xfs_attr_remote.h
index d72eff30ca18..62b398edec3f 100644
--- a/libxfs/xfs_attr_remote.h
+++ b/libxfs/xfs_attr_remote.h
@@ -12,9 +12,9 @@ int xfs_attr_rmtval_get(struct xfs_da_args *args);
int xfs_attr_rmtval_stale(struct xfs_inode *ip, struct xfs_bmbt_irec *map,
xfs_buf_flags_t incore_flags);
int xfs_attr_rmtval_invalidate(struct xfs_da_args *args);
-int xfs_attr_rmtval_remove(struct xfs_delattr_context *dac);
+int xfs_attr_rmtval_remove(struct xfs_attr_item *attr);
int xfs_attr_rmt_find_hole(struct xfs_da_args *args);
int xfs_attr_rmtval_set_value(struct xfs_da_args *args);
-int xfs_attr_rmtval_set_blk(struct xfs_delattr_context *dac);
-int xfs_attr_rmtval_find_space(struct xfs_delattr_context *dac);
+int xfs_attr_rmtval_set_blk(struct xfs_attr_item *attr);
+int xfs_attr_rmtval_find_space(struct xfs_attr_item *attr);
#endif /* __XFS_ATTR_REMOTE_H__ */
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 13/14] xfsprogs: Add helper function xfs_attr_leaf_addname
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (11 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 12/14] xfsprogs: Merge xfs_delattr_context into xfs_attr_item Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
2021-11-17 4:16 ` [PATCH v25 14/14] xfsprogs: Add log item printing for ATTRI and ATTRD Allison Henderson
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
Source kernel commit: 6d9d518192a3f633fce0821601847966280857f7
This patch adds a helper function xfs_attr_leaf_addname. While this
does help to break down xfs_attr_set_iter, it does also hoist out some
of the state management. This patch has been moved to the end of the
clean up series for further discussion.
Suggested-by: Darrick J. Wong <djwong@kernel.org>
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
---
include/xfs_trace.h | 1 +
libxfs/xfs_attr.c | 110 ++++++++++++++++++++++++--------------------
2 files changed, 61 insertions(+), 50 deletions(-)
diff --git a/include/xfs_trace.h b/include/xfs_trace.h
index 227193a1e8fa..e920e4b0db8e 100644
--- a/include/xfs_trace.h
+++ b/include/xfs_trace.h
@@ -316,6 +316,7 @@
#define trace_xfs_attr_sf_addname_return(a,b) ((void) 0)
#define trace_xfs_attr_set_iter_return(a,b) ((void) 0)
+#define trace_xfs_attr_leaf_addname_return(a,b) ((void) 0)
#define trace_xfs_attr_node_addname_return(a,b) ((void) 0)
#define trace_xfs_attr_remove_iter_return(a,b) ((void) 0)
#define trace_xfs_attr_rmtval_remove_return(a,b) ((void) 0)
diff --git a/libxfs/xfs_attr.c b/libxfs/xfs_attr.c
index c5b0abb5df20..0f90d5897c8d 100644
--- a/libxfs/xfs_attr.c
+++ b/libxfs/xfs_attr.c
@@ -281,6 +281,65 @@ xfs_attr_sf_addname(
return -EAGAIN;
}
+STATIC int
+xfs_attr_leaf_addname(
+ struct xfs_attr_item *attr)
+{
+ struct xfs_da_args *args = attr->xattri_da_args;
+ struct xfs_inode *dp = args->dp;
+ int error;
+
+ if (xfs_attr_is_leaf(dp)) {
+ error = xfs_attr_leaf_try_add(args, attr->xattri_leaf_bp);
+ if (error == -ENOSPC) {
+ error = xfs_attr3_leaf_to_node(args);
+ if (error)
+ return error;
+
+ /*
+ * Finish any deferred work items and roll the
+ * transaction once more. The goal here is to call
+ * node_addname with the inode and transaction in the
+ * same state (inode locked and joined, transaction
+ * clean) no matter how we got to this step.
+ *
+ * At this point, we are still in XFS_DAS_UNINIT, but
+ * when we come back, we'll be a node, so we'll fall
+ * down into the node handling code below
+ */
+ trace_xfs_attr_set_iter_return(
+ attr->xattri_dela_state, args->dp);
+ return -EAGAIN;
+ }
+
+ if (error)
+ return error;
+
+ attr->xattri_dela_state = XFS_DAS_FOUND_LBLK;
+ } else {
+ error = xfs_attr_node_addname_find_attr(attr);
+ if (error)
+ return error;
+
+ error = xfs_attr_node_addname(attr);
+ if (error)
+ return error;
+
+ /*
+ * If addname was successful, and we dont need to alloc or
+ * remove anymore blks, we're done.
+ */
+ if (!args->rmtblkno &&
+ !(args->op_flags & XFS_DA_OP_RENAME))
+ return 0;
+
+ attr->xattri_dela_state = XFS_DAS_FOUND_NBLK;
+ }
+
+ trace_xfs_attr_leaf_addname_return(attr->xattri_dela_state, args->dp);
+ return -EAGAIN;
+}
+
/*
* Set the attribute specified in @args.
* This routine is meant to function as a delayed operation, and may return
@@ -316,57 +375,8 @@ xfs_attr_set_iter(
attr->xattri_leaf_bp = NULL;
}
- if (xfs_attr_is_leaf(dp)) {
- error = xfs_attr_leaf_try_add(args,
- attr->xattri_leaf_bp);
- if (error == -ENOSPC) {
- error = xfs_attr3_leaf_to_node(args);
- if (error)
- return error;
-
- /*
- * Finish any deferred work items and roll the
- * transaction once more. The goal here is to
- * call node_addname with the inode and
- * transaction in the same state (inode locked
- * and joined, transaction clean) no matter how
- * we got to this step.
- *
- * At this point, we are still in
- * XFS_DAS_UNINIT, but when we come back, we'll
- * be a node, so we'll fall down into the node
- * handling code below
- */
- trace_xfs_attr_set_iter_return(
- attr->xattri_dela_state, args->dp);
- return -EAGAIN;
- } else if (error) {
- return error;
- }
-
- attr->xattri_dela_state = XFS_DAS_FOUND_LBLK;
- } else {
- error = xfs_attr_node_addname_find_attr(attr);
- if (error)
- return error;
+ return xfs_attr_leaf_addname(attr);
- error = xfs_attr_node_addname(attr);
- if (error)
- return error;
-
- /*
- * If addname was successful, and we dont need to alloc
- * or remove anymore blks, we're done.
- */
- if (!args->rmtblkno &&
- !(args->op_flags & XFS_DA_OP_RENAME))
- return 0;
-
- attr->xattri_dela_state = XFS_DAS_FOUND_NBLK;
- }
- trace_xfs_attr_set_iter_return(attr->xattri_dela_state,
- args->dp);
- return -EAGAIN;
case XFS_DAS_FOUND_LBLK:
/*
* If there was an out-of-line value, allocate the blocks we
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v25 14/14] xfsprogs: Add log item printing for ATTRI and ATTRD
2021-11-17 4:15 [PATCH v25 00/14] Log Attribute Replay Allison Henderson
` (12 preceding siblings ...)
2021-11-17 4:16 ` [PATCH v25 13/14] xfsprogs: Add helper function xfs_attr_leaf_addname Allison Henderson
@ 2021-11-17 4:16 ` Allison Henderson
13 siblings, 0 replies; 16+ messages in thread
From: Allison Henderson @ 2021-11-17 4:16 UTC (permalink / raw)
To: linux-xfs
This patch implements a new set of log printing functions to print the
ATTRI and ATTRD items and vectors in the log. These will be used during
log dump and log recover operations.
RFC: Though most attributes are strings, the attribute operations accept
any binary payload, so we cannot assume them printable. This was done
intentionally in preparation for parent pointers. And until parent
pointers get here, attributes have no discernible format. So the print
routines are just a simple hex dump for now. It's not pretty, but works
for now.
Signed-off-by: Allison Henderson <allison.henderson@oracle.com>
---
logprint/log_misc.c | 48 +++++++++-
logprint/log_print_all.c | 12 +++
logprint/log_redo.c | 197 +++++++++++++++++++++++++++++++++++++++
logprint/logprint.h | 12 +++
4 files changed, 268 insertions(+), 1 deletion(-)
diff --git a/logprint/log_misc.c b/logprint/log_misc.c
index 35e926a3baec..d8c60388375b 100644
--- a/logprint/log_misc.c
+++ b/logprint/log_misc.c
@@ -54,11 +54,46 @@ print_stars(void)
"***********************************\n");
} /* print_stars */
+void
+print_hex_dump(char *ptr, int len) {
+ int i = 0;
+
+ for (i = 0; i < len; i++) {
+ if (i % 16 == 0)
+ printf("%08x ", i);
+
+ printf("%02x", ptr[i]);
+
+ if ((i+1)%16 == 0)
+ printf("\n");
+ else if ((i+1)%2 == 0)
+ printf(" ");
+ }
+ printf("\n");
+}
+
+bool
+is_printable(char *ptr, int len) {
+ int i = 0;
+
+ for (i = 0; i < len; i++)
+ if (!isprint(ptr[i]) )
+ return false;
+ return true;
+}
+
+void print_or_dump(char *ptr, int len) {
+ if (is_printable(ptr, len))
+ printf("%.*s\n", len, ptr);
+ else
+ print_hex_dump(ptr, len);
+}
+
/*
* Given a pointer to a data segment, print out the data as if it were
* a log operation header.
*/
-static void
+void
xlog_print_op_header(xlog_op_header_t *op_head,
int i,
char **ptr)
@@ -961,6 +996,17 @@ xlog_print_record(
be32_to_cpu(op_head->oh_len));
break;
}
+ case XFS_LI_ATTRI: {
+ skip = xlog_print_trans_attri(&ptr,
+ be32_to_cpu(op_head->oh_len),
+ &i);
+ break;
+ }
+ case XFS_LI_ATTRD: {
+ skip = xlog_print_trans_attrd(&ptr,
+ be32_to_cpu(op_head->oh_len));
+ break;
+ }
case XFS_LI_RUI: {
skip = xlog_print_trans_rui(&ptr,
be32_to_cpu(op_head->oh_len),
diff --git a/logprint/log_print_all.c b/logprint/log_print_all.c
index c9c453f6086d..89cb6492d027 100644
--- a/logprint/log_print_all.c
+++ b/logprint/log_print_all.c
@@ -404,6 +404,12 @@ xlog_recover_print_logitem(
case XFS_LI_EFI:
xlog_recover_print_efi(item);
break;
+ case XFS_LI_ATTRD:
+ xlog_recover_print_attrd(item);
+ break;
+ case XFS_LI_ATTRI:
+ xlog_recover_print_attri(item);
+ break;
case XFS_LI_RUD:
xlog_recover_print_rud(item);
break;
@@ -456,6 +462,12 @@ xlog_recover_print_item(
case XFS_LI_EFI:
printf("EFI");
break;
+ case XFS_LI_ATTRD:
+ printf("ATTRD");
+ break;
+ case XFS_LI_ATTRI:
+ printf("ATTRI");
+ break;
case XFS_LI_RUD:
printf("RUD");
break;
diff --git a/logprint/log_redo.c b/logprint/log_redo.c
index 297e203d0976..502345d1a842 100644
--- a/logprint/log_redo.c
+++ b/logprint/log_redo.c
@@ -653,3 +653,200 @@ xlog_recover_print_bud(
f = item->ri_buf[0].i_addr;
xlog_print_trans_bud(&f, sizeof(struct xfs_bud_log_format));
}
+
+/* Attr Items */
+
+static int
+xfs_attri_copy_log_format(
+ char *buf,
+ uint len,
+ struct xfs_attri_log_format *dst_attri_fmt)
+{
+ uint dst_len = sizeof(struct xfs_attri_log_format);
+
+ if (len == dst_len) {
+ memcpy((char *)dst_attri_fmt, buf, len);
+ return 0;
+ }
+
+ fprintf(stderr, _("%s: bad size of attri format: %u; expected %u\n"),
+ progname, len, dst_len);
+ return 1;
+}
+
+int
+xlog_print_trans_attri(
+ char **ptr,
+ uint src_len,
+ int *i)
+{
+ struct xfs_attri_log_format *src_f = NULL;
+ xlog_op_header_t *head = NULL;
+ uint dst_len;
+ int error = 0;
+
+ dst_len = sizeof(struct xfs_attri_log_format);
+ if (src_len != dst_len) {
+ fprintf(stderr, _("%s: bad size of attri format: %u; expected %u\n"),
+ progname, src_len, dst_len);
+ return 1;
+ }
+
+ /*
+ * memmove to ensure 8-byte alignment for the long longs in
+ * xfs_attri_log_format_t structure
+ */
+ src_f = malloc(src_len);
+ if (!src_f) {
+ fprintf(stderr, _("%s: xlog_print_trans_attri: malloc failed\n"),
+ progname);
+ exit(1);
+ }
+ memmove((char*)src_f, *ptr, src_len);
+ *ptr += src_len;
+
+ printf(_("ATTRI: #regs: %d name_len: %d, value_len: %d id: 0x%llx\n"),
+ src_f->alfi_size, src_f->alfi_name_len, src_f->alfi_value_len,
+ (unsigned long long)src_f->alfi_id);
+
+ if (src_f->alfi_name_len > 0) {
+ printf(_("\n"));
+ (*i)++;
+ head = (xlog_op_header_t *)*ptr;
+ xlog_print_op_header(head, *i, ptr);
+ error = xlog_print_trans_attri_name(ptr, be32_to_cpu(head->oh_len));
+ if (error)
+ goto error;
+ }
+
+ if (src_f->alfi_value_len > 0) {
+ printf(_("\n"));
+ (*i)++;
+ head = (xlog_op_header_t *)*ptr;
+ xlog_print_op_header(head, *i, ptr);
+ error = xlog_print_trans_attri_value(ptr, be32_to_cpu(head->oh_len),
+ src_f->alfi_value_len);
+ }
+error:
+ free(src_f);
+
+ return error;
+} /* xlog_print_trans_attri */
+
+int
+xlog_print_trans_attri_name(
+ char **ptr,
+ uint src_len)
+{
+ printf(_("ATTRI: name len:%u\n"), src_len);
+ print_or_dump(*ptr, src_len);
+
+ *ptr += src_len;
+
+ return 0;
+} /* xlog_print_trans_attri */
+
+int
+xlog_print_trans_attri_value(
+ char **ptr,
+ uint src_len,
+ int value_len)
+{
+ int len = value_len;
+
+ if (len > MAX_ATTR_VAL_PRINT)
+ len = MAX_ATTR_VAL_PRINT;
+
+ printf(_("ATTRI: value len:%u\n"), value_len);
+ print_or_dump(*ptr, len);
+
+ *ptr += src_len;
+
+ return 0;
+} /* xlog_print_trans_attri_value */
+
+void
+xlog_recover_print_attri(
+ struct xlog_recover_item *item)
+{
+ struct xfs_attri_log_format *f, *src_f = NULL;
+ uint src_len, dst_len;
+
+ int region = 0;
+
+ src_f = (struct xfs_attri_log_format *)item->ri_buf[0].i_addr;
+ src_len = item->ri_buf[region].i_len;
+
+ /*
+ * An xfs_attri_log_format structure contains a attribute name and
+ * variable length value as the last field.
+ */
+ dst_len = sizeof(struct xfs_attri_log_format);
+
+ if ((f = ((struct xfs_attri_log_format *)malloc(dst_len))) == NULL) {
+ fprintf(stderr, _("%s: xlog_recover_print_attri: malloc failed\n"),
+ progname);
+ exit(1);
+ }
+ if (xfs_attri_copy_log_format((char*)src_f, src_len, f))
+ goto out;
+
+ printf(_("ATTRI: #regs: %d name_len: %d, value_len: %d id: 0x%llx\n"),
+ f->alfi_size, f->alfi_name_len, f->alfi_value_len, (unsigned long long)f->alfi_id);
+
+ if (f->alfi_name_len > 0) {
+ region++;
+ printf(_("ATTRI: name len:%u\n"), f->alfi_name_len);
+ print_or_dump((char *)item->ri_buf[region].i_addr,
+ f->alfi_name_len);
+ }
+
+ if (f->alfi_value_len > 0) {
+ int len = f->alfi_value_len;
+
+ if (len > MAX_ATTR_VAL_PRINT)
+ len = MAX_ATTR_VAL_PRINT;
+
+ region++;
+ printf(_("ATTRI: value len:%u\n"), f->alfi_value_len);
+ print_or_dump((char *)item->ri_buf[region].i_addr, len);
+ }
+
+out:
+ free(f);
+
+}
+
+int
+xlog_print_trans_attrd(char **ptr, uint len)
+{
+ struct xfs_attrd_log_format *f;
+ struct xfs_attrd_log_format lbuf;
+ uint core_size = sizeof(struct xfs_attrd_log_format);
+
+ memcpy(&lbuf, *ptr, MIN(core_size, len));
+ f = &lbuf;
+ *ptr += len;
+ if (len >= core_size) {
+ printf(_("ATTRD: #regs: %d id: 0x%llx\n"),
+ f->alfd_size,
+ (unsigned long long)f->alfd_alf_id);
+ return 0;
+ } else {
+ printf(_("ATTRD: Not enough data to decode further\n"));
+ return 1;
+ }
+} /* xlog_print_trans_attrd */
+
+void
+xlog_recover_print_attrd(
+ struct xlog_recover_item *item)
+{
+ struct xfs_attrd_log_format *f;
+
+ f = (struct xfs_attrd_log_format *)item->ri_buf[0].i_addr;
+
+ printf(_(" ATTRD: #regs: %d id: 0x%llx\n"),
+ f->alfd_size,
+ (unsigned long long)f->alfd_alf_id);
+}
diff --git a/logprint/logprint.h b/logprint/logprint.h
index 38a7d3fa80a9..b4479c240d94 100644
--- a/logprint/logprint.h
+++ b/logprint/logprint.h
@@ -29,6 +29,9 @@ extern void xfs_log_print_trans(struct xlog *, int);
extern void print_xlog_record_line(void);
extern void print_xlog_op_line(void);
extern void print_stars(void);
+extern void print_hex_dump(char* ptr, int len);
+extern bool is_printable(char* ptr, int len);
+extern void print_or_dump(char* ptr, int len);
extern struct xfs_inode_log_format *
xfs_inode_item_format_convert(char *, uint, struct xfs_inode_log_format *);
@@ -53,4 +56,13 @@ extern void xlog_recover_print_bui(struct xlog_recover_item *item);
extern int xlog_print_trans_bud(char **ptr, uint len);
extern void xlog_recover_print_bud(struct xlog_recover_item *item);
+#define MAX_ATTR_VAL_PRINT 128
+
+extern int xlog_print_trans_attri(char **ptr, uint src_len, int *i);
+extern int xlog_print_trans_attri_name(char **ptr, uint src_len);
+extern int xlog_print_trans_attri_value(char **ptr, uint src_len, int value_len);
+extern void xlog_recover_print_attri(struct xlog_recover_item *item);
+extern int xlog_print_trans_attrd(char **ptr, uint len);
+extern void xlog_recover_print_attrd(struct xlog_recover_item *item);
+extern void xlog_print_op_header(xlog_op_header_t *op_head, int i, char **ptr);
#endif /* LOGPRINT_H */
--
2.25.1
^ permalink raw reply related [flat|nested] 16+ messages in thread