xfs: periodically relog deferred intent items
Source kernel commit: 934c2d0559e0eb53460da113cd9a8c0c1618de0a
There's a subtle design flaw in the deferred log item code that can lead
to pinning the log tail. Taking up the defer ops chain examples from
the previous commit, we can get trapped in sequences like this:
Caller hands us a transaction t0 with D0-D3 attached. The defer ops
chain will look like the following if the transaction rolls succeed:
t1: D0(t0), D1(t0), D2(t0), D3(t0)
t2: d4(t1), d5(t1), D1(t0), D2(t0), D3(t0)
t3: d5(t1), D1(t0), D2(t0), D3(t0)
...
t9: d9(t7), D3(t0)
t10: D3(t0)
t11: d10(t10), d11(t10)
t12: d11(t10)
In transaction 9, we finish d9 and try to roll to t10 while holding onto
an intent item for D3 that we logged in t0.
The previous commit changed the order in which we place new defer ops in
the defer ops processing chain to reduce the maximum chain length. Now
make xfs_defer_finish_noroll capable of relogging the entire chain
periodically so that we can always move the log tail forward. We do
this every seven loops, having observed that while most chains never
exceed seven items in length, the rest go far over that and seem to
be involved in most of the stall problems.
Callers are now required to ensure that the transaction reservation is
large enough to handle logging done items and new intent items for the
maximum possible chain length. Most callers are careful to keep the
chain lengths low, so the overhead should be minimal.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
diff --git a/include/xfs_trace.h b/include/xfs_trace.h
index 91f2b98..a100263 100644
--- a/include/xfs_trace.h
+++ b/include/xfs_trace.h
@@ -63,6 +63,8 @@
#define trace_xfs_iext_insert(a,b,c,d) ((void) 0)
#define trace_xfs_iext_remove(a,b,c,d) ((void) 0)
+#define trace_xfs_defer_relog_intent(a,b) ((void) 0)
+
#define trace_xfs_dir2_grow_inode(a,b) ((void) 0)
#define trace_xfs_dir2_shrink_inode(a,b) ((void) 0)
diff --git a/include/xfs_trans.h b/include/xfs_trans.h
index 1f08767..b86be25 100644
--- a/include/xfs_trans.h
+++ b/include/xfs_trans.h
@@ -12,6 +12,28 @@
struct xfs_buf;
struct xfs_buf_map;
+struct xfs_log_item;
+
+#define xfs_trans_item_relog(lip, tp) (NULL)
+#define xfs_log_item_in_current_chkpt(lip) (true)
+#define xlog_grant_push_threshold(log, need) (NULLCOMMITLSN)
+
+/*
+ * By comparing each component, we don't have to worry about extra
+ * endian issues in treating two 32 bit numbers as one 64 bit number
+ */
+static inline xfs_lsn_t _lsn_cmp(xfs_lsn_t lsn1, xfs_lsn_t lsn2)
+{
+ if (CYCLE_LSN(lsn1) != CYCLE_LSN(lsn2))
+ return (CYCLE_LSN(lsn1)<CYCLE_LSN(lsn2))? -999 : 999;
+
+ if (BLOCK_LSN(lsn1) != BLOCK_LSN(lsn2))
+ return (BLOCK_LSN(lsn1)<BLOCK_LSN(lsn2))? -999 : 999;
+
+ return 0;
+}
+#define XFS_LSN_CMP(a, b) _lsn_cmp(a, b)
+
/*
* Userspace Transaction interface
*/
diff --git a/libxfs/xfs_defer.c b/libxfs/xfs_defer.c
index fd500d2..4c46184 100644
--- a/libxfs/xfs_defer.c
+++ b/libxfs/xfs_defer.c
@@ -343,6 +343,52 @@
}
/*
+ * Prevent a log intent item from pinning the tail of the log by logging a
+ * done item to release the intent item; and then log a new intent item.
+ * The caller should provide a fresh transaction and roll it after we're done.
+ */
+static int
+xfs_defer_relog(
+ struct xfs_trans **tpp,
+ struct list_head *dfops)
+{
+ struct xfs_defer_pending *dfp;
+ xfs_lsn_t threshold_lsn;
+
+ ASSERT((*tpp)->t_flags & XFS_TRANS_PERM_LOG_RES);
+
+ /*
+ * Figure out where we need the tail to be in order to maintain the
+ * minimum required free space in the log.
+ */
+ threshold_lsn = xlog_grant_push_threshold((*tpp)->t_mountp->m_log, 0);
+ if (threshold_lsn == NULLCOMMITLSN)
+ return 0;
+
+ list_for_each_entry(dfp, dfops, dfp_list) {
+ /*
+ * If the log intent item for this deferred op is behind the
+ * desired log tail threshold and is not a part of the current
+ * log checkpoint, relog the intent item to keep the log tail
+ * moving forward. We're ok with this being racy because an
+ * incorrect decision means we'll be a little slower at pushing
+ * the tail.
+ */
+ if (dfp->dfp_intent == NULL ||
+ XFS_LSN_CMP(dfp->dfp_intent->li_lsn, threshold_lsn) >= 0 ||
+ xfs_log_item_in_current_chkpt(dfp->dfp_intent))
+ continue;
+
+ trace_xfs_defer_relog_intent((*tpp)->t_mountp, dfp);
+ dfp->dfp_intent = xfs_trans_item_relog(dfp->dfp_intent, *tpp);
+ }
+
+ if ((*tpp)->t_flags & XFS_TRANS_DIRTY)
+ return xfs_defer_trans_roll(tpp);
+ return 0;
+}
+
+/*
* Log an intent-done item for the first pending intent, and finish the work
* items.
*/
@@ -428,6 +474,11 @@
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);
error = xfs_defer_finish_one(*tp, dfp);
