dlan17/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ext4: restart handle if credits are insufficient during allocating blocks

Browse Source 
After large folios are supported on ext4, writing back a sufficiently
large and discontinuous folio may consume a significant number of
journal credits, placing considerable strain on the journal. For
example, in a 20GB filesystem with 1K block size and 1MB journal size,
writing back a 2MB folio could require thousands of credits in the
worst-case scenario (when each block is discontinuous and distributed
across different block groups), potentially exceeding the journal size.
This issue can also occur in ext4_write_begin() and ext4_page_mkwrite()
when delalloc is not enabled.

Fix this by ensuring that there are sufficient journal credits before
allocating an extent in mpage_map_one_extent() and
ext4_block_write_begin(). If there are not enough credits, return
-EAGAIN, exit the current mapping loop, restart a new handle and a new
transaction, and allocating blocks on this folio again in the next
iteration.

Suggested-by: Jan Kara <jack@suse.cz>
Signed-off-by: Zhang Yi <yi.zhang@huawei.com>
Reviewed-by: Jan Kara <jack@suse.cz>
Link: https://patch.msgid.link/20250707140814.542883-6-yi.zhang@huaweicloud.com
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
This commit is contained in:
Zhang Yi
2025-07-13 23:41:51 -04:00
committed by Theodore Ts'o
parent 2bddafea3d
commit e2c4c49dee
1 changed files with 36 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
fs/ext4/inode.c
+36 -5
View File
@@ -875,6 +875,26 @@ static void ext4_update_bh_state(struct buffer_head *bh, unsigned long flags)
} while (unlikely(!try_cmpxchg(&bh->b_state, &old_state, new_state)));
}
/*
* Make sure that the current journal transaction has enough credits to map
* one extent. Return -EAGAIN if it cannot extend the current running
* transaction.
*/
static inline int ext4_journal_ensure_extent_credits(handle_t *handle,
struct inode *inode)
{
int credits;
int ret;
/* Called from ext4_da_write_begin() which has no handle started? */
if (!handle)
return 0;
credits = ext4_chunk_trans_blocks(inode, 1);
ret = __ext4_journal_ensure_credits(handle, credits, credits, 0);
return ret <= 0 ? ret : -EAGAIN;
}
static int _ext4_get_block(struct inode *inode, sector_t iblock,
struct buffer_head *bh, int flags)
{
@@ -1173,7 +1193,9 @@ int ext4_block_write_begin(handle_t *handle, struct folio *folio,
clear_buffer_new(bh);
if (!buffer_mapped(bh)) {
WARN_ON(bh->b_size != blocksize);
err = get_block(inode, block, bh, 1);
err = ext4_journal_ensure_extent_credits(handle, inode);
if (!err)
err = get_block(inode, block, bh, 1);
if (err)
break;
if (buffer_new(bh)) {
@@ -1372,8 +1394,9 @@ retry_journal:
ext4_orphan_del(NULL, inode);
}
if (ret == -ENOSPC &&
ext4_should_retry_alloc(inode->i_sb, &retries))
if (ret == -EAGAIN ||
(ret == -ENOSPC &&
ext4_should_retry_alloc(inode->i_sb, &retries)))
goto retry_journal;
folio_put(folio);
return ret;
@@ -2321,6 +2344,11 @@ static int mpage_map_one_extent(handle_t *handle, struct mpage_da_data *mpd)
int get_blocks_flags;
int err, dioread_nolock;
/* Make sure transaction has enough credits for this extent */
err = ext4_journal_ensure_extent_credits(handle, inode);
if (err < 0)
return err;
trace_ext4_da_write_pages_extent(inode, map);
/*
* Call ext4_map_blocks() to allocate any delayed allocation blocks, or
@@ -2448,7 +2476,7 @@ static int mpage_map_and_submit_extent(handle_t *handle,
* In the case of ENOSPC, if ext4_count_free_blocks()
* is non-zero, a commit should free up blocks.
*/
if ((err == -ENOMEM) ||
if ((err == -ENOMEM) || (err == -EAGAIN) ||
(err == -ENOSPC && ext4_count_free_clusters(sb))) {
/*
* We may have already allocated extents for
@@ -2954,6 +2982,8 @@ retry:
ret = 0;
continue;
}
if (ret == -EAGAIN)
ret = 0;
/* Fatal error - ENOMEM, EIO... */
if (ret)
break;
@@ -6732,7 +6762,8 @@ vm_fault_t ext4_page_mkwrite(struct vm_fault *vmf)
retry_alloc:
/* Start journal and allocate blocks */
err = ext4_block_page_mkwrite(inode, folio, get_block);
if (err == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
if (err == -EAGAIN ||
(err == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)))
goto retry_alloc;
out_ret:
ret = vmf_fs_error(err);