summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--fs/xfs/libxfs/xfs_defer.c146
-rw-r--r--fs/xfs/libxfs/xfs_defer.h1
-rw-r--r--fs/xfs/xfs_trace.h5
-rw-r--r--fs/xfs/xfs_trans.c2
-rw-r--r--fs/xfs/xfs_trans.h1
5 files changed, 71 insertions, 84 deletions
diff --git a/fs/xfs/libxfs/xfs_defer.c b/fs/xfs/libxfs/xfs_defer.c
index b656a399cd71..1cbddcf539da 100644
--- a/fs/xfs/libxfs/xfs_defer.c
+++ b/fs/xfs/libxfs/xfs_defer.c
@@ -180,7 +180,7 @@ static const struct xfs_defer_op_type *defer_op_types[XFS_DEFER_OPS_TYPE_MAX];
* the pending list.
*/
STATIC void
-xfs_defer_intake_work(
+xfs_defer_create_intents(
struct xfs_trans *tp)
{
struct xfs_defer_ops *dop = tp->t_dfops;
@@ -190,21 +190,19 @@ xfs_defer_intake_work(
list_for_each_entry(dfp, &dop->dop_intake, dfp_list) {
dfp->dfp_intent = dfp->dfp_type->create_intent(tp,
dfp->dfp_count);
- trace_xfs_defer_intake_work(tp->t_mountp, dfp);
+ trace_xfs_defer_create_intent(tp->t_mountp, dfp);
list_sort(tp->t_mountp, &dfp->dfp_work,
dfp->dfp_type->diff_items);
list_for_each(li, &dfp->dfp_work)
dfp->dfp_type->log_item(tp, dfp->dfp_intent, li);
}
-
- list_splice_tail_init(&dop->dop_intake, &dop->dop_pending);
}
/* Abort all the intents that were committed. */
STATIC void
xfs_defer_trans_abort(
struct xfs_trans *tp,
- int error)
+ struct list_head *dop_pending)
{
struct xfs_defer_ops *dop = tp->t_dfops;
struct xfs_defer_pending *dfp;
@@ -212,24 +210,21 @@ xfs_defer_trans_abort(
trace_xfs_defer_trans_abort(tp->t_mountp, dop, _RET_IP_);
/* Abort intent items that don't have a done item. */
- list_for_each_entry(dfp, &dop->dop_pending, dfp_list) {
+ list_for_each_entry(dfp, dop_pending, dfp_list) {
trace_xfs_defer_pending_abort(tp->t_mountp, dfp);
if (dfp->dfp_intent && !dfp->dfp_done) {
dfp->dfp_type->abort_intent(dfp->dfp_intent);
dfp->dfp_intent = NULL;
}
}
-
- /* Shut down FS. */
- xfs_force_shutdown(tp->t_mountp, (error == -EFSCORRUPTED) ?
- SHUTDOWN_CORRUPT_INCORE : SHUTDOWN_META_IO_ERROR);
}
/* Roll a transaction so we can do some deferred op processing. */
STATIC int
xfs_defer_trans_roll(
- struct xfs_trans **tp)
+ struct xfs_trans **tpp)
{
+ struct xfs_trans *tp = *tpp;
struct xfs_buf_log_item *bli;
struct xfs_inode_log_item *ili;
struct xfs_log_item *lip;
@@ -239,7 +234,7 @@ xfs_defer_trans_roll(
int i;
int error;
- list_for_each_entry(lip, &(*tp)->t_items, li_trans) {
+ list_for_each_entry(lip, &tp->t_items, li_trans) {
switch (lip->li_type) {
case XFS_LI_BUF:
bli = container_of(lip, struct xfs_buf_log_item,
@@ -249,7 +244,7 @@ xfs_defer_trans_roll(
ASSERT(0);
return -EFSCORRUPTED;
}
- xfs_trans_dirty_buf(*tp, bli->bli_buf);
+ xfs_trans_dirty_buf(tp, bli->bli_buf);
bplist[bpcount++] = bli->bli_buf;
}
break;
@@ -261,7 +256,7 @@ xfs_defer_trans_roll(
ASSERT(0);
return -EFSCORRUPTED;
}
- xfs_trans_log_inode(*tp, ili->ili_inode,
+ xfs_trans_log_inode(tp, ili->ili_inode,
XFS_ILOG_CORE);
iplist[ipcount++] = ili->ili_inode;
}
@@ -271,39 +266,30 @@ xfs_defer_trans_roll(
}
}
- trace_xfs_defer_trans_roll((*tp)->t_mountp, (*tp)->t_dfops, _RET_IP_);
+ trace_xfs_defer_trans_roll(tp->t_mountp, tp->t_dfops, _RET_IP_);
/* Roll the transaction. */
- error = xfs_trans_roll(tp);
+ error = xfs_trans_roll(tpp);
+ tp = *tpp;
if (error) {
- trace_xfs_defer_trans_roll_error((*tp)->t_mountp,
- (*tp)->t_dfops, error);
- xfs_defer_trans_abort(*tp, error);
+ trace_xfs_defer_trans_roll_error(tp->t_mountp,
+ tp->t_dfops, error);
return error;
}
/* Rejoin the joined inodes. */
for (i = 0; i < ipcount; i++)
- xfs_trans_ijoin(*tp, iplist[i], 0);
+ xfs_trans_ijoin(tp, iplist[i], 0);
/* Rejoin the buffers and dirty them so the log moves forward. */
for (i = 0; i < bpcount; i++) {
- xfs_trans_bjoin(*tp, bplist[i]);
- xfs_trans_bhold(*tp, bplist[i]);
+ xfs_trans_bjoin(tp, bplist[i]);
+ xfs_trans_bhold(tp, bplist[i]);
}
return error;
}
-/* Do we have any work items to finish? */
-bool
-xfs_defer_has_unfinished_work(
- struct xfs_trans *tp)
-{
- return !list_empty(&tp->t_dfops->dop_pending) ||
- !list_empty(&tp->t_dfops->dop_intake);
-}
-
/*
* Reset an already used dfops after finish.
*/
@@ -311,7 +297,7 @@ static void
xfs_defer_reset(
struct xfs_trans *tp)
{
- ASSERT(!xfs_defer_has_unfinished_work(tp));
+ ASSERT(list_empty(&tp->t_dfops->dop_intake));
/*
* Low mode state transfers across transaction rolls to mirror dfops
@@ -321,6 +307,36 @@ xfs_defer_reset(
}
/*
+ * Free up any items left in the list.
+ */
+static void
+xfs_defer_cancel_list(
+ struct xfs_mount *mp,
+ struct list_head *dop_list)
+{
+ struct xfs_defer_pending *dfp;
+ struct xfs_defer_pending *pli;
+ struct list_head *pwi;
+ struct list_head *n;
+
+ /*
+ * Free the pending items. Caller should already have arranged
+ * for the intent items to be released.
+ */
+ list_for_each_entry_safe(dfp, pli, dop_list, dfp_list) {
+ trace_xfs_defer_cancel_list(mp, dfp);
+ list_del(&dfp->dfp_list);
+ list_for_each_safe(pwi, n, &dfp->dfp_work) {
+ list_del(pwi);
+ dfp->dfp_count--;
+ dfp->dfp_type->cancel_item(pwi);
+ }
+ ASSERT(dfp->dfp_count == 0);
+ kmem_free(dfp);
+ }
+}
+
+/*
* Finish all the pending work. This involves logging intent items for
* any work items that wandered in since the last transaction roll (if
* one has even happened), rolling the transaction, and finishing the
@@ -338,15 +354,19 @@ xfs_defer_finish_noroll(
void *state;
int error = 0;
void (*cleanup_fn)(struct xfs_trans *, void *, int);
+ LIST_HEAD(dop_pending);
ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
trace_xfs_defer_finish((*tp)->t_mountp, (*tp)->t_dfops, _RET_IP_);
/* Until we run out of pending work to finish... */
- while (xfs_defer_has_unfinished_work(*tp)) {
- /* Log intents for work items sitting in the intake. */
- xfs_defer_intake_work(*tp);
+ while (!list_empty(&dop_pending) ||
+ !list_empty(&(*tp)->t_dfops->dop_intake)) {
+ /* log intents and pull in intake items */
+ xfs_defer_create_intents(*tp);
+ list_splice_tail_init(&(*tp)->t_dfops->dop_intake,
+ &dop_pending);
/*
* Roll the transaction.
@@ -356,8 +376,8 @@ xfs_defer_finish_noroll(
goto out;
/* Log an intent-done item for the first pending item. */
- dfp = list_first_entry(&(*tp)->t_dfops->dop_pending,
- struct xfs_defer_pending, dfp_list);
+ dfp = list_first_entry(&dop_pending, struct xfs_defer_pending,
+ dfp_list);
trace_xfs_defer_pending_finish((*tp)->t_mountp, dfp);
dfp->dfp_done = dfp->dfp_type->create_done(*tp, dfp->dfp_intent,
dfp->dfp_count);
@@ -387,7 +407,6 @@ xfs_defer_finish_noroll(
*/
if (cleanup_fn)
cleanup_fn(*tp, state, error);
- xfs_defer_trans_abort(*tp, error);
goto out;
}
}
@@ -417,8 +436,11 @@ xfs_defer_finish_noroll(
out:
if (error) {
+ xfs_defer_trans_abort(*tp, &dop_pending);
+ xfs_force_shutdown((*tp)->t_mountp, SHUTDOWN_CORRUPT_INCORE);
trace_xfs_defer_finish_error((*tp)->t_mountp, (*tp)->t_dfops,
error);
+ xfs_defer_cancel_list((*tp)->t_mountp, &dop_pending);
xfs_defer_cancel(*tp);
return error;
}
@@ -442,54 +464,24 @@ xfs_defer_finish(
return error;
if ((*tp)->t_flags & XFS_TRANS_DIRTY) {
error = xfs_defer_trans_roll(tp);
- if (error)
+ if (error) {
+ xfs_force_shutdown((*tp)->t_mountp,
+ SHUTDOWN_CORRUPT_INCORE);
return error;
+ }
}
xfs_defer_reset(*tp);
return 0;
}
-/*
- * Free up any items left in the list.
- */
void
xfs_defer_cancel(
- struct xfs_trans *tp)
+ struct xfs_trans *tp)
{
- struct xfs_defer_ops *dop = tp->t_dfops;
- struct xfs_defer_pending *dfp;
- struct xfs_defer_pending *pli;
- struct list_head *pwi;
- struct list_head *n;
+ struct xfs_mount *mp = tp->t_mountp;
- trace_xfs_defer_cancel(NULL, dop, _RET_IP_);
-
- /*
- * Free the pending items. Caller should already have arranged
- * for the intent items to be released.
- */
- list_for_each_entry_safe(dfp, pli, &dop->dop_intake, dfp_list) {
- trace_xfs_defer_intake_cancel(NULL, dfp);
- list_del(&dfp->dfp_list);
- list_for_each_safe(pwi, n, &dfp->dfp_work) {
- list_del(pwi);
- dfp->dfp_count--;
- dfp->dfp_type->cancel_item(pwi);
- }
- ASSERT(dfp->dfp_count == 0);
- kmem_free(dfp);
- }
- list_for_each_entry_safe(dfp, pli, &dop->dop_pending, dfp_list) {
- trace_xfs_defer_pending_cancel(NULL, dfp);
- list_del(&dfp->dfp_list);
- list_for_each_safe(pwi, n, &dfp->dfp_work) {
- list_del(pwi);
- dfp->dfp_count--;
- dfp->dfp_type->cancel_item(pwi);
- }
- ASSERT(dfp->dfp_count == 0);
- kmem_free(dfp);
- }
+ trace_xfs_defer_cancel(mp, tp->t_dfops, _RET_IP_);
+ xfs_defer_cancel_list(mp, &tp->t_dfops->dop_intake);
}
/* Add an item for later deferred processing. */
@@ -547,7 +539,6 @@ xfs_defer_init(
memset(dop, 0, sizeof(struct xfs_defer_ops));
INIT_LIST_HEAD(&dop->dop_intake);
- INIT_LIST_HEAD(&dop->dop_pending);
if (tp) {
ASSERT(tp->t_firstblock == NULLFSBLOCK);
tp->t_dfops = dop;
@@ -571,7 +562,6 @@ xfs_defer_move(
ASSERT(dst != src);
list_splice_init(&src->dop_intake, &dst->dop_intake);
- list_splice_init(&src->dop_pending, &dst->dop_pending);
/*
* Low free space mode was historically controlled by a dfops field.
diff --git a/fs/xfs/libxfs/xfs_defer.h b/fs/xfs/libxfs/xfs_defer.h
index f051c8056141..f091bf3abeaf 100644
--- a/fs/xfs/libxfs/xfs_defer.h
+++ b/fs/xfs/libxfs/xfs_defer.h
@@ -41,7 +41,6 @@ int xfs_defer_finish_noroll(struct xfs_trans **tp);
int xfs_defer_finish(struct xfs_trans **tp);
void xfs_defer_cancel(struct xfs_trans *);
void xfs_defer_init(struct xfs_trans *tp, struct xfs_defer_ops *dop);
-bool xfs_defer_has_unfinished_work(struct xfs_trans *tp);
void xfs_defer_move(struct xfs_trans *dtp, struct xfs_trans *stp);
/* Description of a deferred type. */
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 8807f1bb814a..fec9cfe3dfb4 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -2392,9 +2392,8 @@ DEFINE_DEFER_EVENT(xfs_defer_finish_done);
DEFINE_DEFER_ERROR_EVENT(xfs_defer_trans_roll_error);
DEFINE_DEFER_ERROR_EVENT(xfs_defer_finish_error);
-DEFINE_DEFER_PENDING_EVENT(xfs_defer_intake_work);
-DEFINE_DEFER_PENDING_EVENT(xfs_defer_intake_cancel);
-DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_cancel);
+DEFINE_DEFER_PENDING_EVENT(xfs_defer_create_intent);
+DEFINE_DEFER_PENDING_EVENT(xfs_defer_cancel_list);
DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_finish);
DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_abort);
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index b050663c2a70..413e4138357f 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -929,7 +929,7 @@ __xfs_trans_commit(
* Finish deferred items on final commit. Only permanent transactions
* should ever have deferred ops.
*/
- WARN_ON_ONCE(xfs_defer_has_unfinished_work(tp) &&
+ WARN_ON_ONCE(!list_empty(&tp->t_dfops->dop_intake) &&
!(tp->t_flags & XFS_TRANS_PERM_LOG_RES));
if (!regrant && (tp->t_flags & XFS_TRANS_PERM_LOG_RES)) {
error = xfs_defer_finish_noroll(&tp);
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index 299656dbf324..1cdc7c0ebeac 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -96,7 +96,6 @@ void xfs_log_item_init(struct xfs_mount *mp, struct xfs_log_item *item,
#define XFS_DEFER_OPS_NR_BUFS 2 /* join up to two buffers */
struct xfs_defer_ops {
struct list_head dop_intake; /* unlogged pending work */
- struct list_head dop_pending; /* logged pending work */
};
/*
generated by cgit v1.2.3-55-g7522 (git 2.39.0) at 2024-06-29 16:04:55 +0200