diff mbox series

[5/8] xfs: factor out log write ordering from xlog_cil_push_work()

Message ID 20210617082617.971602-6-david@fromorbit.com (mailing list archive)
State Superseded
Headers show
Series xfs: log fixes for for-next | expand

Commit Message

Dave Chinner June 17, 2021, 8:26 a.m. UTC 
From: Dave Chinner <dchinner@redhat.com>

So we can use it for start record ordering as well as commit record
ordering in future.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 fs/xfs/xfs_log_cil.c | 89 ++++++++++++++++++++++++++------------------
 1 file changed, 52 insertions(+), 37 deletions(-)

Comments

Darrick J. Wong June 17, 2021, 7:59 p.m. UTC | #1 
On Thu, Jun 17, 2021 at 06:26:14PM +1000, Dave Chinner wrote:
> From: Dave Chinner <dchinner@redhat.com>
> 
> So we can use it for start record ordering as well as commit record
> ordering in future.
> 
> Signed-off-by: Dave Chinner <dchinner@redhat.com>

This tricked me for a second until I realized that xlog_cil_order_write
is the chunk of code just prior to the xlog_cil_write_commit_record
call.

Reviewed-by: Darrick J. Wong <djwong@kernel.org>

--D

> ---
>  fs/xfs/xfs_log_cil.c | 89 ++++++++++++++++++++++++++------------------
>  1 file changed, 52 insertions(+), 37 deletions(-)
> 
> diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
> index 35fc3e57d870..f993ec69fc97 100644
> --- a/fs/xfs/xfs_log_cil.c
> +++ b/fs/xfs/xfs_log_cil.c
> @@ -784,9 +784,54 @@ xlog_cil_build_trans_hdr(
>  }
>  
>  /*
> - * Write out the commit record of a checkpoint transaction associated with the
> - * given ticket to close off a running log write. Return the lsn of the commit
> - * record.
> + * Ensure that the order of log writes follows checkpoint sequence order. This
> + * relies on the context LSN being zero until the log write has guaranteed the
> + * LSN that the log write will start at via xlog_state_get_iclog_space().
> + */
> +static int
> +xlog_cil_order_write(
> +	struct xfs_cil		*cil,
> +	xfs_csn_t		sequence)
> +{
> +	struct xfs_cil_ctx	*ctx;
> +
> +restart:
> +	spin_lock(&cil->xc_push_lock);
> +	list_for_each_entry(ctx, &cil->xc_committing, committing) {
> +		/*
> +		 * Avoid getting stuck in this loop because we were woken by the
> +		 * shutdown, but then went back to sleep once already in the
> +		 * shutdown state.
> +		 */
> +		if (XLOG_FORCED_SHUTDOWN(cil->xc_log)) {
> +			spin_unlock(&cil->xc_push_lock);
> +			return -EIO;
> +		}
> +
> +		/*
> +		 * Higher sequences will wait for this one so skip them.
> +		 * Don't wait for our own sequence, either.
> +		 */
> +		if (ctx->sequence >= sequence)
> +			continue;
> +		if (!ctx->commit_lsn) {
> +			/*
> +			 * It is still being pushed! Wait for the push to
> +			 * complete, then start again from the beginning.
> +			 */
> +			xlog_wait(&cil->xc_commit_wait, &cil->xc_push_lock);
> +			goto restart;
> +		}
> +	}
> +	spin_unlock(&cil->xc_push_lock);
> +	return 0;
> +}
> +
> +/*
> + * Write out the commit record of a checkpoint transaction to close off a
> + * running log write. These commit records are strictly ordered in ascending CIL
> + * sequence order so that log recovery will always replay the checkpoints in the
> + * correct order.
>   */
>  int
>  xlog_cil_write_commit_record(
> @@ -816,6 +861,10 @@ xlog_cil_write_commit_record(
>  	if (XLOG_FORCED_SHUTDOWN(log))
>  		return -EIO;
>  
> +	error = xlog_cil_order_write(ctx->cil, ctx->sequence);
> +	if (error)
> +		return error;
> +
>  	/* account for space used by record data */
>  	ctx->ticket->t_curr_res -= reg.i_len;
>  	error = xlog_write(log, ctx, &lv_chain, ctx->ticket, iclog, reg.i_len);
> @@ -1048,40 +1097,6 @@ xlog_cil_push_work(
>  	if (error)
>  		goto out_abort_free_ticket;
>  
> -	/*
> -	 * now that we've written the checkpoint into the log, strictly
> -	 * order the commit records so replay will get them in the right order.
> -	 */
> -restart:
> -	spin_lock(&cil->xc_push_lock);
> -	list_for_each_entry(new_ctx, &cil->xc_committing, committing) {
> -		/*
> -		 * Avoid getting stuck in this loop because we were woken by the
> -		 * shutdown, but then went back to sleep once already in the
> -		 * shutdown state.
> -		 */
> -		if (XLOG_FORCED_SHUTDOWN(log)) {
> -			spin_unlock(&cil->xc_push_lock);
> -			goto out_abort_free_ticket;
> -		}
> -
> -		/*
> -		 * Higher sequences will wait for this one so skip them.
> -		 * Don't wait for our own sequence, either.
> -		 */
> -		if (new_ctx->sequence >= ctx->sequence)
> -			continue;
> -		if (!new_ctx->commit_lsn) {
> -			/*
> -			 * It is still being pushed! Wait for the push to
> -			 * complete, then start again from the beginning.
> -			 */
> -			xlog_wait(&cil->xc_commit_wait, &cil->xc_push_lock);
> -			goto restart;
> -		}
> -	}
> -	spin_unlock(&cil->xc_push_lock);
> -
>  	error = xlog_cil_write_commit_record(ctx, &commit_iclog);
>  	if (error)
>  		goto out_abort_free_ticket;
> -- 
> 2.31.1
>
Christoph Hellwig June 18, 2021, 2:27 p.m. UTC | #2 
On Thu, Jun 17, 2021 at 12:59:04PM -0700, Darrick J. Wong wrote:
> On Thu, Jun 17, 2021 at 06:26:14PM +1000, Dave Chinner wrote:
> > From: Dave Chinner <dchinner@redhat.com>
> > 
> > So we can use it for start record ordering as well as commit record
> > ordering in future.
> > 
> > Signed-off-by: Dave Chinner <dchinner@redhat.com>
> 
> This tricked me for a second until I realized that xlog_cil_order_write
> is the chunk of code just prior to the xlog_cil_write_commit_record
> call.

Yeah, moving the caller at the same time as the factoring is a trick
test for every reader.  I think this needs to be documented in the
commit log.  Or even better moved to a separate log, but it seems you
get shot for that kind of suggestion on the xfs list these days..
Dave Chinner June 18, 2021, 10:34 p.m. UTC | #3 
On Fri, Jun 18, 2021 at 03:27:49PM +0100, Christoph Hellwig wrote:
> On Thu, Jun 17, 2021 at 12:59:04PM -0700, Darrick J. Wong wrote:
> > On Thu, Jun 17, 2021 at 06:26:14PM +1000, Dave Chinner wrote:
> > > From: Dave Chinner <dchinner@redhat.com>
> > > 
> > > So we can use it for start record ordering as well as commit record
> > > ordering in future.
> > > 
> > > Signed-off-by: Dave Chinner <dchinner@redhat.com>
> > 
> > This tricked me for a second until I realized that xlog_cil_order_write
> > is the chunk of code just prior to the xlog_cil_write_commit_record
> > call.
> 
> Yeah, moving the caller at the same time as the factoring is a trick
> test for every reader.  I think this needs to be documented in the
> commit log.  Or even better moved to a separate log, but it seems you
> get shot for that kind of suggestion on the xfs list these days..

Sorry, what? This should be a straight factoring - the place we do
the ordering check must not change because that'll break shit.

Ngggh.

Yeah, thanks git. When I rebased the patch, it's merged the hunk
into the wrong place. It gets fixed up later when I move the ordering
inside the xlog_cil_write_commit_record() function, but this patch
by itself was silently broken by the tooling.

-Dave.
diff mbox series

Patch

diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
index 35fc3e57d870..f993ec69fc97 100644
--- a/fs/xfs/xfs_log_cil.c
+++ b/fs/xfs/xfs_log_cil.c
@@ -784,9 +784,54 @@  xlog_cil_build_trans_hdr(
 }
 
 /*
- * Write out the commit record of a checkpoint transaction associated with the
- * given ticket to close off a running log write. Return the lsn of the commit
- * record.
+ * Ensure that the order of log writes follows checkpoint sequence order. This
+ * relies on the context LSN being zero until the log write has guaranteed the
+ * LSN that the log write will start at via xlog_state_get_iclog_space().
+ */
+static int
+xlog_cil_order_write(
+	struct xfs_cil		*cil,
+	xfs_csn_t		sequence)
+{
+	struct xfs_cil_ctx	*ctx;
+
+restart:
+	spin_lock(&cil->xc_push_lock);
+	list_for_each_entry(ctx, &cil->xc_committing, committing) {
+		/*
+		 * Avoid getting stuck in this loop because we were woken by the
+		 * shutdown, but then went back to sleep once already in the
+		 * shutdown state.
+		 */
+		if (XLOG_FORCED_SHUTDOWN(cil->xc_log)) {
+			spin_unlock(&cil->xc_push_lock);
+			return -EIO;
+		}
+
+		/*
+		 * Higher sequences will wait for this one so skip them.
+		 * Don't wait for our own sequence, either.
+		 */
+		if (ctx->sequence >= sequence)
+			continue;
+		if (!ctx->commit_lsn) {
+			/*
+			 * It is still being pushed! Wait for the push to
+			 * complete, then start again from the beginning.
+			 */
+			xlog_wait(&cil->xc_commit_wait, &cil->xc_push_lock);
+			goto restart;
+		}
+	}
+	spin_unlock(&cil->xc_push_lock);
+	return 0;
+}
+
+/*
+ * Write out the commit record of a checkpoint transaction to close off a
+ * running log write. These commit records are strictly ordered in ascending CIL
+ * sequence order so that log recovery will always replay the checkpoints in the
+ * correct order.
  */
 int
 xlog_cil_write_commit_record(
@@ -816,6 +861,10 @@  xlog_cil_write_commit_record(
 	if (XLOG_FORCED_SHUTDOWN(log))
 		return -EIO;
 
+	error = xlog_cil_order_write(ctx->cil, ctx->sequence);
+	if (error)
+		return error;
+
 	/* account for space used by record data */
 	ctx->ticket->t_curr_res -= reg.i_len;
 	error = xlog_write(log, ctx, &lv_chain, ctx->ticket, iclog, reg.i_len);
@@ -1048,40 +1097,6 @@  xlog_cil_push_work(
 	if (error)
 		goto out_abort_free_ticket;
 
-	/*
-	 * now that we've written the checkpoint into the log, strictly
-	 * order the commit records so replay will get them in the right order.
-	 */
-restart:
-	spin_lock(&cil->xc_push_lock);
-	list_for_each_entry(new_ctx, &cil->xc_committing, committing) {
-		/*
-		 * Avoid getting stuck in this loop because we were woken by the
-		 * shutdown, but then went back to sleep once already in the
-		 * shutdown state.
-		 */
-		if (XLOG_FORCED_SHUTDOWN(log)) {
-			spin_unlock(&cil->xc_push_lock);
-			goto out_abort_free_ticket;
-		}
-
-		/*
-		 * Higher sequences will wait for this one so skip them.
-		 * Don't wait for our own sequence, either.
-		 */
-		if (new_ctx->sequence >= ctx->sequence)
-			continue;
-		if (!new_ctx->commit_lsn) {
-			/*
-			 * It is still being pushed! Wait for the push to
-			 * complete, then start again from the beginning.
-			 */
-			xlog_wait(&cil->xc_commit_wait, &cil->xc_push_lock);
-			goto restart;
-		}
-	}
-	spin_unlock(&cil->xc_push_lock);
-
 	error = xlog_cil_write_commit_record(ctx, &commit_iclog);
 	if (error)
 		goto out_abort_free_ticket;