linuxmsm/laptops-kernel
0
0
Fork 0
mirror of https://github.com/linux-msm/laptops-kernel.git synced 2026-08-13 14:19:53 -07:00
Code Issues Packages Projects Releases Wiki Activity

btrfs: zoned: flush active metadata block group at btree_writepages() start

Browse Source 
btree_writepages() writes the btree inode's dirty metadata in ascending
logical address order. On a zoned filesystem only one metadata and one
system block group is active for writing at a time, and
check_bg_is_active() (via btrfs_check_meta_write_pointer()) pivots the
active block group as writeback moves from one block group to the next.

If the active block group sits at a higher logical address than another
block group that also holds dirty metadata, the ascending walk reaches
the lower one first and, to write it, has to finish the active block
group and activate the lower one. It cannot finish a block group that
still has unsent IO, and during WB_SYNC_ALL && !for_sync (commit)
writeback it deliberately refuses to wait for that IO under
fs_info->zoned_meta_io_lock, as that can deadlock. The pivot thus cannot
issue the submission itself either, so it gives up:
btrfs_check_meta_write_pointer() returns -EAGAIN, which
btrfs_write_and_wait_transaction() treats as fatal and aborts the
transaction, forcing the filesystem read-only. This happens
intermittently under metadata-heavy relocation (e.g. fstests btrfs/187).

Flush the active metadata and system block groups at the start of
btree_writepages(), under the fs_info->zoned_meta_io_lock it already
holds, so they have no unsent IO left and the later pivot can finish
them and make forward progress.

Fixes: 13bb483d32 ("btrfs: zoned: activate metadata block group on write time")
Assisted-by: LLM (debugging, commit message)
Reviewed-by: Boris Burkov <boris@bur.io>
Signed-off-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
Johannes Thumshirn
2026-07-31 13:30:31 +02:00
committed by David Sterba
parent db3000cd54
commit dcbf1015d8
1 changed files with 92 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files
fs/btrfs/extent_io.c
+92 -21
View File
@@ -2383,6 +2383,76 @@ void btrfs_btree_wait_writeback_range(struct btrfs_fs_info *fs_info, u64 start,
}
}
static int write_meta_extent_buffer(struct btrfs_eb_write_context *ctx,
struct writeback_control *wbc)
{
struct extent_buffer *eb = ctx->eb;
int ret;
ret = btrfs_check_meta_write_pointer(eb->fs_info, ctx);
if (ret)
return ret;
if (!lock_extent_buffer_for_io(eb, wbc))
return 0;
/* Implies write in zoned mode. */
if (ctx->zoned_bg) {
/* Mark the last eb in the block group. */
btrfs_schedule_zone_finish_bg(ctx->zoned_bg, eb);
ctx->zoned_bg->meta_write_pointer += eb->len;
}
write_one_eb(eb, wbc);
return 0;
}
/*
* On a zoned filesystem, write out the currently dirty metadata extent buffers
* of @bg. Used to flush the active metadata/system block group before the
* ascending-address walk in btree_writepages(), so that walk can pivot the
* active block group away (finishing it) instead of aborting the commit; see
* the caller for details.
*/
static void flush_active_meta_bg(struct address_space *mapping,
struct writeback_control *wbc,
struct btrfs_eb_write_context *ctx,
struct btrfs_block_group *bg)
{
struct btrfs_fs_info *fs_info = inode_to_fs_info(mapping->host);
unsigned long index = bg->start >> fs_info->nodesize_bits;
unsigned long end = (btrfs_block_group_end(bg) - 1) >> fs_info->nodesize_bits;
struct eb_batch batch;
unsigned int nr_ebs;
ASSERT(btrfs_is_zoned(fs_info));
lockdep_assert_held(&fs_info->zoned_meta_io_lock);
eb_batch_init(&batch);
while (index <= end &&
(nr_ebs = buffer_tree_get_ebs_tag(fs_info, &index, end,
PAGECACHE_TAG_DIRTY, &batch))) {
struct extent_buffer *eb;
while ((eb = eb_batch_next(&batch)) != NULL) {
ctx->eb = eb;
/*
* If the eb is behind the write pointer (-EBUSY, e.g.
* already being written by someone else) skip it and
* carry on. Only a hole at the write pointer (-EAGAIN)
* stops the flush. The main walk in btree_writepages()
* then deals with it.
*/
if (write_meta_extent_buffer(ctx, wbc) == -EAGAIN) {
eb_batch_release(&batch);
return;
}
}
eb_batch_release(&batch);
cond_resched();
}
}
int btree_writepages(struct address_space *mapping, struct writeback_control *wbc)
{
struct btrfs_eb_write_context ctx = { .wbc = wbc };
@@ -2418,6 +2488,22 @@ int btree_writepages(struct address_space *mapping, struct writeback_control *wb
else
tag = PAGECACHE_TAG_DIRTY;
btrfs_zoned_meta_io_lock(fs_info);
/*
* On a zoned filesystem, flush the currently active metadata/system
* block group(s) first, under this same lock, so the ascending-address
* walk below can pivot the active block group instead of aborting the
* transaction commit with -EAGAIN.
*/
if (btrfs_is_zoned(fs_info) && wbc->sync_mode == WB_SYNC_ALL &&
!wbc->for_sync) {
if (fs_info->active_meta_bg)
flush_active_meta_bg(mapping, wbc, &ctx,
fs_info->active_meta_bg);
if (fs_info->active_system_bg)
flush_active_meta_bg(mapping, wbc, &ctx,
fs_info->active_system_bg);
}
retry:
if (wbc->sync_mode == WB_SYNC_ALL)
buffer_tree_tag_for_writeback(fs_info, index, end);
@@ -2428,28 +2514,13 @@ retry:
while ((eb = eb_batch_next(&batch)) != NULL) {
ctx.eb = eb;
ret = btrfs_check_meta_write_pointer(eb->fs_info, &ctx);
if (ret) {
if (ret == -EBUSY)
ret = 0;
if (ret) {
done = true;
break;
}
continue;
ret = write_meta_extent_buffer(&ctx, wbc);
if (ret == -EBUSY) {
ret = 0;
} else if (ret) {
done = true;
break;
}
if (!lock_extent_buffer_for_io(eb, wbc))
continue;
/* Implies write in zoned mode. */
if (ctx.zoned_bg) {
/* Mark the last eb in the block group. */
btrfs_schedule_zone_finish_bg(ctx.zoned_bg, eb);
ctx.zoned_bg->meta_write_pointer += eb->len;
}
write_one_eb(eb, wbc);
}
nr_to_write_done = (wbc->nr_to_write <= 0);
eb_batch_release(&batch);