mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Qu Wenruo <quwenruo.btrfs@gmx.com>
To: Josef Bacik <josef@toxicpanda.com>,
	David Sterba <dsterba@suse.com>, Chris Mason <mason@kernel.org>,
	Naohiro Aota <naohiro.aota@wdc.com>,
	Johannes Thumshirn <johannes.thumshirn@wdc.com>,
	Qu Wenruo <wqu@suse.com>, Boris Burkov <boris@bur.io>,
	Filipe Manana <fdmanana@suse.com>
Cc: linux-btrfs@vger.kernel.org, linux-kernel@vger.kernel.org,
	stable@vger.kernel.org
Subject: Re: [PATCH v3 4/6] btrfs: wait for ordered extent IO in fast fsync
Date: Sun, 22 Nov 2026 07:39:04 +1030	[thread overview]
Message-ID: <4aa0cdbf-98a4-4d44-887e-3924cd075c27@gmx.com> (raw)
In-Reply-To: <20261120-b4-btrfs-data-integrity-v3-4-4de4b91b826e@toxicpanda.com>



在 2026/11/21 07:21, Josef Bacik 写道:
> A fast fsync waits for writeback and then checks whether a write failed
> or was truncated, in which case it waits for the ordered extents to
> complete. The check can come too early, because end_bbio_data_write()
> clears writeback before it finishes the ordered extent, which is where
> a failure is recorded:
> 
>    end_bbio_data_write()            fsync
> 
>    btrfs_folio_clear_writeback()
>                                     filemap_fdatawait_range()
>                                     BTRFS_INODE_INCOMPLETE_COW_WRITE clear
>                                     btrfs_log_changed_extents()
>    btrfs_finish_ordered_extent()
>      set BTRFS_INODE_INCOMPLETE_COW_WRITE
> 
> A direct IO write has no writeback for the fsync to wait for at all, so
> the failure of an asynchronous direct IO write still in flight is missed
> too.
> 
> The buffered case comes from commit a11d6912fdd9 ("btrfs: remove folio
> parameter from ordered io related functions"), which moved the call to
> btrfs_finish_ordered_extent() after the loop that clears writeback. The
> direct IO case has been there since commit f13e01b89daf ("btrfs: ensure
> fast fsync waits for ordered extents after a write failure") added the
> flag.
> 
> Fix by having a fast fsync wait for BTRFS_ORDERED_IO_DONE on the ordered
> extents it collected for logging before it checks. Since "btrfs: make
> fsync wait for all incomplete COW writes", a failure or truncation is
> recorded before that bit is set, and a barrier in
> can_finish_ordered_extent() now orders the two, pairing with the fully
> ordered test_and_clear_bit() of the flag in fsync. For a buffered write
> the bit is set right after writeback is cleared. The writeback of a
> buffered write that is not done yet is started first, and fsync returns
> the error if that fails, since the rest of the ordered extent may then
> not be submitted.
> 
> This depends on "btrfs: make fsync wait for all incomplete COW writes".
> 
> Fixes: a11d6912fdd9 ("btrfs: remove folio parameter from ordered io related functions")
> Fixes: f13e01b89daf ("btrfs: ensure fast fsync waits for ordered extents after a write failure")
> CC: stable@vger.kernel.org # 6.10+
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>

This also fixes a potential race with async data csum generation from 
experimental features, where a data write bio can be submitted but 
without its csum generated.

Without the wait, fast fsync can log the OE without unpopulated csum and 
after a power loss, the unpopulated csum will be inserted and cause 
future csum mismatch.

Reviewed-by: Qu Wenruo <wqu@suse.com>

Thanks,
Qu

> ---
>   fs/btrfs/file.c         | 67 ++++++++++++++++++++++++++++++++++++++++---------
>   fs/btrfs/ordered-data.c |  6 +++++
>   2 files changed, 61 insertions(+), 12 deletions(-)
> 
> diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
> index 4208587abff1..ee09c4ecbd4c 100644
> --- a/fs/btrfs/file.c
> +++ b/fs/btrfs/file.c
> @@ -1512,8 +1512,8 @@ static inline bool skip_inode_logging(const struct btrfs_log_ctx *ctx)
>   	 * If we are doing a fast fsync we can not bail out if the inode's
>   	 * last_trans is <= then the last committed transaction, because we only
>   	 * update the last_trans of the inode during ordered extent completion,
> -	 * and for a fast fsync we don't wait for that, we only wait for the
> -	 * writeback to complete.
> +	 * and for a fast fsync we don't wait for that, we only wait for the IO
> +	 * of the writes to complete.
>   	 */
>   	if (inode->last_trans <= btrfs_get_last_trans_committed(fs_info) &&
>   	    (test_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags) ||
> @@ -1523,6 +1523,41 @@ static inline bool skip_inode_logging(const struct btrfs_log_ctx *ctx)
>   	return false;
>   }
>   
> +/*
> + * Wait for the IO of the ordered extents collected for logging to be accounted,
> + * starting IO on the dirty folios of a buffered write that is not done yet.
> + *
> + * Waiting for writeback is not enough: the end IO handler clears writeback
> + * before it finishes the ordered extent, and a direct IO write has no
> + * writeback. A failed or truncated write sets BTRFS_INODE_INCOMPLETE_COW_WRITE
> + * before BTRFS_ORDERED_IO_DONE is set, see can_finish_ordered_extent().
> + *
> + * If starting IO fails, the rest of the ordered extent may never be submitted,
> + * so return the error instead of waiting.
> + */
> +static int wait_ordered_io_done(struct btrfs_inode *inode,
> +				struct list_head *ordered_extents)
> +{
> +	struct btrfs_ordered_extent *ordered;
> +	int ret;
> +
> +	list_for_each_entry(ordered, ordered_extents, log_list) {
> +		if (test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags))
> +			continue;
> +		if (!test_bit(BTRFS_ORDERED_DIRECT, &ordered->flags)) {
> +			ret = btrfs_fdatawrite_range(inode, ordered->file_offset,
> +						     ordered->file_offset +
> +						     ordered->num_bytes - 1);
> +			if (ret)
> +				return ret;
> +		}
> +		wait_event(ordered->wait,
> +			   test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags));
> +	}
> +
> +	return 0;
> +}
> +
>   /*
>    * fsync call for both files and directories.  This logs the inode into
>    * the tree log instead of forcing full commits whenever possible.
> @@ -1626,11 +1661,11 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
>   	 * IO of a lower priority task while holding a transaction open.
>   	 *
>   	 * For a full fsync we wait for the ordered extents to complete while
> -	 * for a fast fsync we wait just for writeback to complete, and then
> -	 * attach the ordered extents to the transaction so that a transaction
> -	 * commit waits for their completion, to avoid data loss if we fsync,
> -	 * the current transaction commits before the ordered extents complete
> -	 * and a power failure happens right after that.
> +	 * for a fast fsync we wait just for the IO of the writes to complete,
> +	 * and then attach the ordered extents to the transaction so that a
> +	 * transaction commit waits for their completion, to avoid data loss if
> +	 * we fsync, the current transaction commits before the ordered extents
> +	 * complete and a power failure happens right after that.
>   	 *
>   	 * For zoned filesystem, if a write IO uses a ZONE_APPEND command, the
>   	 * logical address recorded in the ordered extent may change. We need
> @@ -1650,13 +1685,21 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
>   		if (ret)
>   			goto out_release_extents;
>   
> +		ret = wait_ordered_io_done(inode, &ctx.ordered_extents);
> +		if (ret)
> +			goto out_release_extents;
> +
>   		/*
>   		 * Check and clear BTRFS_INODE_INCOMPLETE_COW_WRITE now after
> -		 * starting and waiting for writeback, because it may have been
> -		 * set while we waited, and if a write failed or was truncated
> -		 * we need to wait for ordered extents to complete so that any
> -		 * extent maps that point to unwritten locations are dropped and
> -		 * we don't log them.
> +		 * waiting for the IO of the ordered extents, because it may
> +		 * have been set while we waited, and if a write failed or was
> +		 * truncated we need to wait for ordered extents to complete so
> +		 * that any extent maps that point to unwritten locations are
> +		 * dropped and we don't log them.
> +		 *
> +		 * test_and_clear_bit() is fully ordered, which pairs with the
> +		 * barrier before BTRFS_ORDERED_IO_DONE is set in
> +		 * can_finish_ordered_extent().
>   		 */
>   		if (test_and_clear_bit(BTRFS_INODE_INCOMPLETE_COW_WRITE, &inode->runtime_flags))
>   			ret = btrfs_wait_ordered_range(inode, start, len);
> diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
> index 1a4e3e34ec11..728e73baf15e 100644
> --- a/fs/btrfs/ordered-data.c
> +++ b/fs/btrfs/ordered-data.c
> @@ -420,7 +420,13 @@ static bool can_finish_ordered_extent(struct btrfs_ordered_extent *ordered,
>   	/*
>   	 * All the IO of the ordered extent is finished, we need to queue
>   	 * the finish_func to be executed.
> +	 *
> +	 * Order BTRFS_INODE_INCOMPLETE_COW_WRITE, if set above, before
> +	 * BTRFS_ORDERED_IO_DONE, as a fast fsync tests the latter without
> +	 * the ordered_tree_lock. Pairs with the test_and_clear_bit() in
> +	 * btrfs_sync_file().
>   	 */
> +	smp_mb__before_atomic();
>   	set_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags);
>   	cond_wake_up(&ordered->wait);
>   	refcount_inc(&ordered->refs);
> 


  reply	other threads:[~2026-11-21 21:09 UTC|newest]

Thread overview: 9+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-20 20:51 [PATCH v3 0/6] btrfs: data integrity fixes Josef Bacik
2026-11-20 20:51 ` [PATCH v3 1/6] btrfs: don't drop the error of the last split bio Josef Bacik
2026-11-20 20:51 ` [PATCH v3 2/6] btrfs: clear dirty blocks after a delalloc failure Josef Bacik
2026-11-20 20:51 ` [PATCH v3 3/6] btrfs: make fsync wait for all incomplete COW writes Josef Bacik
2026-11-21 21:00   ` Qu Wenruo
2026-11-20 20:51 ` [PATCH v3 4/6] btrfs: wait for ordered extent IO in fast fsync Josef Bacik
2026-11-21 21:09   ` Qu Wenruo [this message]
2026-11-20 20:51 ` [PATCH v3 5/6] btrfs: don't report success for a skipped log sync Josef Bacik
2026-11-20 20:51 ` [PATCH v3 6/6] btrfs: don't trim the target of a device replace Josef Bacik

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=4aa0cdbf-98a4-4d44-887e-3924cd075c27@gmx.com \
    --to=quwenruo.btrfs@gmx.com \
    --cc=boris@bur.io \
    --cc=dsterba@suse.com \
    --cc=fdmanana@suse.com \
    --cc=johannes.thumshirn@wdc.com \
    --cc=josef@toxicpanda.com \
    --cc=linux-btrfs@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=mason@kernel.org \
    --cc=naohiro.aota@wdc.com \
    --cc=stable@vger.kernel.org \
    --cc=wqu@suse.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®