ext4: get discard out of jbd2 commit kthread
v4 cover ext4: get discard out of jbd2 commit kthread
Hi all
This is the version 4 patch set that attempts to get discard out of the jbd2 commit kthread. When the user delete a lot data and cause discard flooding, the jbd2 commit kthread can be blocked for very long time and then all of the metadata operations are blocked due to no journal space.
The xfstest with following parameters,
MODULAR=0
TEST_DIR=/mnt/test
TEST_DEV=/dev/nbd37p1
SCRATCH_MNT=/mnt/scratch
SCRATCH_DEV=/dev/nbd37p2
MOUNT_OPTIONS="-o discard"
has passed. The result is consistent w/ or w/o this patch set.
There are 5 patches,
Patch 1 ~ 3, there are no functional changes in them, but just some preparation for following patches
Patch 4 introduces a async kworker to do discard in fstrim fation which implements the core idea of this patch set.
Patch 5 flush discard background work in ext4_should_retry_alloc, This fix the generic/371
Any comments are welcome ;)
V3 -> V4:
- In patch 1, avoid modify two lines in patch 1 when remove 'grou'p parameter
- In patch 4, remove redunbant queue_work() in ext4_mb_release(). And queue background discard work to system_unbound_wq as it is not a urgent task.
- In patch 5, flush discard kwork in ext4_should_retry_alloc(), instead of invoke ext4_should_retry_alloc in fallocate again.
V2 -> V3
- Get rid of the per block group rb tree which carries freed entry. It is not neccesary because we have done aggregation when wait for journal commit. Just use a list to carry the free entries.
V1 -> V2
- free the blocks back to mb buddy after commit and then do ftrim fashion discard
fs/ext4/balloc.c | 8 ++- fs/ext4/ext4.h | 3 ++ fs/ext4/mballoc.c | 216 +++++++++++++++++++++++++++++++++++++++++++++++++++----------------------------- 3 files changed, 148 insertions(+), 79 deletions(-)
PATCH v4 1/5 ext4: remove the 'group' parameter of ext4_trim_extent
From: Wang Jianchao <[email protected]>
Get rid of the 'group' parameter of ext4_trim_extent as we can get it from the 'e4b'.
--- fs/ext4/mballoc.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
fs/ext4/mballoc.c +3 -4
@@ -6183,7 +6183,6 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,* @sb: super block for the file system * @start: starting block of the free extent in the alloc. group * @count: number of blocks to TRIM -* @group: alloc. group we are working with * @e4b: ext4 buddy for the group * * Trim "count" blocks starting at "start" in the "group". To assure that no
@@ -6191,11 +6190,12 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,* be called with under the group lock. */ static int ext4_trim_extent (struct super_block *sb,int start,int count, -ext4_group_t group,struct ext4_buddy *e4b) +struct ext4_buddy *e4b)__releases (bitlock)__acquires (bitlock) {struct ext4_free_extent ex; +ext4_group_t group = e4b->bd_group;int ret =0 ;trace_ext4_trim_extent (sb, group, start, count);
@@ -6271,8 +6271,7 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group, next =mb_find_next_bit (bitmap, max +1 , start);if ((next - start) >= minblocks) { - ret =ext4_trim_extent (sb, start, - next - start, group, &e4b); + ret =ext4_trim_extent (sb, start, next - start, &e4b);if (ret && ret != -EOPNOTSUPP )break ; ret =0 ;
Signature · 1 line
2.17.1
PATCH v4 2/5 ext4: add new helper interface ext4_try_to_trim_range()
In reply to Wang JianchaoFrom: Wang Jianchao <[email protected]>
There is no functional change in this patch but just split the codes, which serachs free block and does trim, into a new function ext4_try_to_trim_range. This is preparing for the following async backgroup discard.
--- fs/ext4/mballoc.c | 102 ++++++++++++++++++++++++++-------------------- 1 file changed, 57 insertions(+), 45 deletions(-)
fs/ext4/mballoc.c +57 -45
@@ -6218,6 +6218,54 @@ __acquires(bitlock)return ret; } +static int ext4_try_to_trim_range (struct super_block *sb, +struct ext4_buddy *e4b,ext4_grpblk_t start, +ext4_grpblk_t max,ext4_grpblk_t minblocks) +{ +ext4_grpblk_t next, count, free_count; +void *bitmap; +int ret =0 ; + + bitmap = e4b->bd_bitmap; + start = (e4b->bd_info->bb_first_free > start) ? + e4b->bd_info->bb_first_free : start; + count =0 ; + free_count =0 ; + +while (start <= max) { + start =mb_find_next_zero_bit (bitmap, max +1 , start); +if (start > max) +break ; + next =mb_find_next_bit (bitmap, max +1 , start); + +if ((next - start) >= minblocks) { + ret =ext4_trim_extent (sb, start, next - start, e4b); +if (ret && ret != -EOPNOTSUPP ) +break ; + ret =0 ; + count += next - start; + } + free_count += next - start; + start = next +1 ; + +if (fatal_signal_pending (current)) { + count = -ERESTARTSYS ; +break ; + } + +if (need_resched ()) { +ext4_unlock_group (sb, e4b->bd_group); +cond_resched (); +ext4_lock_group (sb, e4b->bd_group); + } + +if ((e4b->bd_info->bb_free - free_count) < minblocks) +break ; + } + +return count; +} +/** * ext4_trim_all_free -- function to trim all free space in alloc. group * @sb: super block for file system
@@ -6241,10 +6289,8 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group, ext4_grpblk_t start, ext4_grpblk_t max, ext4_grpblk_t minblocks) { - void *bitmap; -ext4_grpblk_t next, count =0 , free_count =0 ; struct ext4_buddy e4b; -int ret =0 ; +int ret;trace_ext4_trim_all_free (sb, group, start, max);
@@ -6254,57 +6300,23 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group, ret, group);return ret; } - bitmap = e4b.bd_bitmap;ext4_lock_group (sb, group); -if (EXT4_MB_GRP_WAS_TRIMMED (e4b.bd_info) && - minblocks >=atomic_read (&EXT4_SB (sb)->s_last_trim_minblks)) - goto out; - - start = (e4b.bd_info->bb_first_free > start) ? - e4b.bd_info->bb_first_free : start; -while (start <= max) { - start =mb_find_next_zero_bit (bitmap, max +1 , start); -if (start > max) -break ; - next =mb_find_next_bit (bitmap, max +1 , start); - -if ((next - start) >= minblocks) { - ret =ext4_trim_extent (sb, start, next - start, &e4b); -if (ret && ret != -EOPNOTSUPP ) -break ; - ret =0 ; - count += next - start; - } - free_count += next - start; - start = next +1 ; - -if (fatal_signal_pending (current)) { - count = -ERESTARTSYS ; -break ; - } - -if (need_resched ()) { -ext4_unlock_group (sb, group); -cond_resched (); -ext4_lock_group (sb, group); - } - -if ((e4b.bd_info->bb_free - free_count) < minblocks) -break ; +if (!EXT4_MB_GRP_WAS_TRIMMED (e4b.bd_info) || + minblocks <atomic_read (&EXT4_SB (sb)->s_last_trim_minblks)) { + ret =ext4_try_to_trim_range (sb, &e4b, start, max, minblocks); +if (ret >=0 ) +EXT4_MB_GRP_SET_TRIMMED (e4b.bd_info); + }else { + ret =0 ; } -if (!ret) { - ret = count; -EXT4_MB_GRP_SET_TRIMMED (e4b.bd_info); - } -out:ext4_unlock_group (sb, group);ext4_mb_unload_buddy (&e4b);ext4_debug ("trimmed %d blocks in the group %d\n" , - count, group); + ret, group);return ret; }
Signature · 1 line
2.17.1
PATCH v4 3/5 ext4: remove the repeated comment of ext4_trim_all_free
In reply to Wang JianchaoFrom: Wang Jianchao <[email protected]>
--- fs/ext4/mballoc.c | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-)
fs/ext4/mballoc.c +1 -6
@@ -6274,15 +6274,10 @@ static int ext4_try_to_trim_range(struct super_block *sb,* @max: last group block to examine * @minblocks: minimum extent block count * -* ext4_trim_all_free walks through group's buddy bitmap searching for free -* extents. When the free block is found, ext4_trim_extent is called to TRIM -* the extent. -* -* * ext4_trim_all_free walks through group's block bitmap searching for free * extents. When the free extent is found, mark it as used in group buddy * bitmap. Then issue a TRIM command on this extent and free the extent in -* the group buddy bitmap. This is done until whole group is scanned. +* the group buddy bitmap. */ static ext4_grpblk_t ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
Signature · 1 line
2.17.1
PATCH v4 4/5 ext4: get discard out of jbd2 commit kthread contex
In reply to Wang JianchaoFrom: Wang Jianchao <[email protected]>
Right now, discard is issued and waited to be completed in jbd2 commit kthread context after the logs are committed. When large amount of files are deleted and discard is flooding, jbd2 commit kthread can be blocked for long time. Then all of the metadata operations can be blocked to wait the log space.
One case is the page fault path with read mm->mmap_sem held, which wants to update the file time but has to wait for the log space. When other threads in the task wants to do mmap, then write mmap_sem is blocked. Finally all of the following read mmap_sem requirements are blocked, even the ps command which need to read the /proc/pid/ -cmdline. Our monitor service which needs to read /proc/pid/cmdline used to be blocked for 5 mins.
This patch frees the blocks back to buddy after commit and then do discard in a async kworker context in fstrim fashion, namely,
- mark blocks to be discarded as used if they have not been allocated
- do discard
- mark them free
After this, jbd2 commit kthread won't be blocked any more by discard and we won't get NOSPC even if the discard is slow or throttled.
--- fs/ext4/ext4.h | 2 + fs/ext4/mballoc.c | 101 ++++++++++++++++++++++++++++++++++------------ 2 files changed, 78 insertions(+), 25 deletions(-)
fs/ext4/ext4.h +2 -0
@@ -1536,6 +1536,8 @@ struct ext4_sb_info {unsigned int s_mb_free_pending;struct list_head s_freed_data_list;/* List of blocks to be freed after commit completed */ +struct list_head s_discard_list; +struct work_struct s_discard_work;struct rb_root s_mb_avg_fragment_size_root;rwlock_t s_mb_rb_lock;struct list_head *s_mb_largest_free_orders;
fs/ext4/mballoc.c +76 -25
147 lines not on this page · raw message
Signature · 1 line
2.17.1
Theodore Ts'o
maintainerRe: [PATCH V4 4/5] ext4: get discard out of jbd2 commit kthread contex
Quoted 24 lines · Wang Jianchao
From: Wang Jianchao <[email protected]>
Right now, discard is issued and waited to be completed in jbd2 commit kthread context after the logs are committed. When large amount of files are deleted and discard is flooding, jbd2 commit kthread can be blocked for long time. Then all of the metadata operations can be blocked to wait the log space.
One case is the page fault path with read
mm->mmap_semheld, which wants to update the file time but has to wait for the log space. When other threads in the task wants to do mmap, then writemmap_semis blocked. Finally all of the following readmmap_semrequirements are blocked, even the ps command which need to read the/proc/pid/-cmdline. Our monitor service which needs to read/proc/pid/cmdlineused to be blocked for 5 mins.This patch frees the blocks back to buddy after commit and then do discard in a async kworker context in fstrim fashion, namely,
- mark blocks to be discarded as used if they have not been allocated
- do discard
- mark them free
After this, jbd2 commit kthread won't be blocked any more by discard and we won't get NOSPC even if the discard is slow or throttled.
Quoted 4 lines
Suggested-by Theodore Ts'o <[email protected]>Reviewed-by Jan Kara <[email protected]>Signed-off-by Wang Jianchao <[email protected]>
I had applied the V3 version of this patch series for testing purposes, and then accidentally included in the dev branch. So an earlier version of this patch series has been in the ext4 git tree for a while. I've done a comparison between the V3 and V4 patches, and aside from a minor whitespace change in patch #1, the only patch that had any real changes was this one (#4). Patch #5 was also added in the V4 series.
So I've edited the ext4 git tree using rebase magic, replacing patch #4 and adding patch #5.
In other words, this is a slightly more complicated, "Thanks, applied". :-)
- Ted
PATCH v4 5/5 ext4: flush background discard kwork when retry allocation
In reply to Wang JianchaoFrom: Wang Jianchao <[email protected]>
The background discard kwork tries to mark blocks used and issue discard. This can make filesystem suffer from NOSPC error, xfstest generic/371 can fail due to it. Fix it by flushing discard kwork in ext4_should_retry_alloc. At the same time, give up discard at the moment.
--- fs/ext4/balloc.c | 8 +++++++- fs/ext4/ext4.h | 1 + fs/ext4/mballoc.c | 7 +++++-- 3 files changed, 13 insertions(+), 3 deletions(-)
fs/ext4/balloc.c +7 -1
@@ -652,8 +652,14 @@ int ext4_should_retry_alloc(struct super_block *sb, int *retries)* possible we just missed a transaction commit that did so */ smp_mb (); -if (sbi->s_mb_free_pending ==0 ) +if (sbi->s_mb_free_pending ==0 ) { +if (test_opt (sb,DISCARD )) { +atomic_inc (&sbi->s_retry_alloc_pending); +flush_work (&sbi->s_discard_work); +atomic_dec (&sbi->s_retry_alloc_pending); + }return ext4_has_free_clusters (sbi,1 ,0 ); + }/* * it's possible we've just missed a transaction commit here,
fs/ext4/ext4.h +1 -0
@@ -1538,6 +1538,7 @@ struct ext4_sb_info {after commit completed */ struct list_head s_discard_list;struct work_struct s_discard_work; +atomic_t s_retry_alloc_pending;struct rb_root s_mb_avg_fragment_size_root;rwlock_t s_mb_rb_lock;struct list_head *s_mb_largest_free_orders;
fs/ext4/mballoc.c +5 -2
@@ -3331,9 +3331,11 @@ static void ext4_discard_work(struct work_struct *work) load_grp =UINT_MAX ;list_for_each_entry_safe (fd, nfd, &discard_list, efd_list) {/* -* If filesystem is umounting or no memory, give up the discard +* If filesystem is umounting or no memory or suffering +* from no space, give up the discard */ -if ((sb->s_flags &SB_ACTIVE ) && !err) { +if ((sb->s_flags &SB_ACTIVE ) && !err && + !atomic_read (&sbi->s_retry_alloc_pending)) { grp = fd->efd_group;if (grp != load_grp) {if (load_grp !=UINT_MAX )
@@ -3431,6 +3433,7 @@ int ext4_mb_init(struct super_block *sb)INIT_LIST_HEAD (&sbi->s_freed_data_list);INIT_LIST_HEAD (&sbi->s_discard_list);INIT_WORK (&sbi->s_discard_work, ext4_discard_work); +atomic_set (&sbi->s_retry_alloc_pending,0 ); sbi->s_mb_max_to_scan =MB_DEFAULT_MAX_TO_SCAN ; sbi->s_mb_min_to_scan =MB_DEFAULT_MIN_TO_SCAN ;
Signature · 1 line
2.17.1