From: Greg Kroah-Hartman Date: Sun, 16 Oct 2022 12:44:19 +0000 (+0200) Subject: 6.0-stable patches X-Git-Tag: v5.4.219~127 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=c88c5a4998207245678678b3eef9b61747e457c3;p=thirdparty%2Fkernel%2Fstable-queue.git 6.0-stable patches added patches: f2fs-allow-direct-read-for-zoned-device.patch f2fs-complete-checkpoints-during-remount.patch f2fs-fix-to-do-sanity-check-on-destination-blkaddr-during-recovery.patch f2fs-fix-to-do-sanity-check-on-summary-info.patch f2fs-fix-wrong-continue-condition-in-gc.patch f2fs-flush-pending-checkpoints-when-freezing-super.patch f2fs-increase-the-limit-for-reserve_root.patch --- diff --git a/queue-6.0/f2fs-allow-direct-read-for-zoned-device.patch b/queue-6.0/f2fs-allow-direct-read-for-zoned-device.patch new file mode 100644 index 00000000000..0a7b8df4748 --- /dev/null +++ b/queue-6.0/f2fs-allow-direct-read-for-zoned-device.patch @@ -0,0 +1,42 @@ +From 689fe57e7ecefd2eeba76c32aa569bb3e1e790d9 Mon Sep 17 00:00:00 2001 +From: Jaegeuk Kim +Date: Fri, 30 Sep 2022 15:48:24 -0700 +Subject: f2fs: allow direct read for zoned device + +From: Jaegeuk Kim + +commit 689fe57e7ecefd2eeba76c32aa569bb3e1e790d9 upstream. + +This reverts dbf8e63f48af ("f2fs: remove device type check for direct IO"), +and apply the below first version, since it contributed out-of-order DIO writes. + +For zoned devices, f2fs forbids direct IO and forces buffered IO +to serialize write IOs. However, the constraint does not apply to +read IOs. + +Cc: stable@vger.kernel.org +Fixes: dbf8e63f48af ("f2fs: remove device type check for direct IO") +Signed-off-by: Eunhee Rho +Reviewed-by: Chao Yu +Signed-off-by: Jaegeuk Kim +Signed-off-by: Greg Kroah-Hartman +--- + fs/f2fs/f2fs.h | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +--- a/fs/f2fs/f2fs.h ++++ b/fs/f2fs/f2fs.h +@@ -4513,7 +4513,12 @@ static inline bool f2fs_force_buffered_i + /* disallow direct IO if any of devices has unaligned blksize */ + if (f2fs_is_multi_device(sbi) && !sbi->aligned_blksize) + return true; +- ++ /* ++ * for blkzoned device, fallback direct IO to buffered IO, so ++ * all IOs can be serialized by log-structured write. ++ */ ++ if (f2fs_sb_has_blkzoned(sbi) && (rw == WRITE)) ++ return true; + if (f2fs_lfs_mode(sbi) && (rw == WRITE)) { + if (block_unaligned_IO(inode, iocb, iter)) + return true; diff --git a/queue-6.0/f2fs-complete-checkpoints-during-remount.patch b/queue-6.0/f2fs-complete-checkpoints-during-remount.patch new file mode 100644 index 00000000000..7c274f843e9 --- /dev/null +++ b/queue-6.0/f2fs-complete-checkpoints-during-remount.patch @@ -0,0 +1,70 @@ +From 4f99484d27961cb194cebcd917176fa038a5025f Mon Sep 17 00:00:00 2001 +From: Jaegeuk Kim +Date: Thu, 18 Aug 2022 22:40:09 -0700 +Subject: f2fs: complete checkpoints during remount + +From: Jaegeuk Kim + +commit 4f99484d27961cb194cebcd917176fa038a5025f upstream. + +Otherwise, pending checkpoints can contribute a race condition to give a +quota warning. + +- Thread - checkpoint thread + add checkpoints to the list +do_remount() + down_write(&sb->s_umount); + f2fs_remount() + block_operations() + down_read_trylock(&sb->s_umount) = 0 + up_write(&sb->s_umount); + f2fs_quota_sync() + dquot_writeback_dquots() + WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount)); + +Or, + +do_remount() + down_write(&sb->s_umount); + f2fs_remount() + create a ckpt thread + f2fs_enable_checkpoint() adds checkpoints + wait for f2fs_sync_fs() + trigger another pending checkpoint + block_operations() + down_read_trylock(&sb->s_umount) = 0 + up_write(&sb->s_umount); + f2fs_quota_sync() + dquot_writeback_dquots() + WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount)); + +Cc: stable@vger.kernel.org +Reviewed-by: Chao Yu +Signed-off-by: Jaegeuk Kim +Signed-off-by: Greg Kroah-Hartman +--- + fs/f2fs/super.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +--- a/fs/f2fs/super.c ++++ b/fs/f2fs/super.c +@@ -2181,6 +2181,9 @@ static void f2fs_enable_checkpoint(struc + f2fs_up_write(&sbi->gc_lock); + + f2fs_sync_fs(sbi->sb, 1); ++ ++ /* Let's ensure there's no pending checkpoint anymore */ ++ f2fs_flush_ckpt_thread(sbi); + } + + static int f2fs_remount(struct super_block *sb, int *flags, char *data) +@@ -2346,6 +2349,9 @@ static int f2fs_remount(struct super_blo + f2fs_stop_ckpt_thread(sbi); + need_restart_ckpt = true; + } else { ++ /* Flush if the prevous checkpoint, if exists. */ ++ f2fs_flush_ckpt_thread(sbi); ++ + err = f2fs_start_ckpt_thread(sbi); + if (err) { + f2fs_err(sbi, diff --git a/queue-6.0/f2fs-fix-to-do-sanity-check-on-destination-blkaddr-during-recovery.patch b/queue-6.0/f2fs-fix-to-do-sanity-check-on-destination-blkaddr-during-recovery.patch new file mode 100644 index 00000000000..4ccf5002acc --- /dev/null +++ b/queue-6.0/f2fs-fix-to-do-sanity-check-on-destination-blkaddr-during-recovery.patch @@ -0,0 +1,124 @@ +From 0ef4ca04a3f9223ff8bc440041c524b2123e09a3 Mon Sep 17 00:00:00 2001 +From: Chao Yu +Date: Tue, 13 Sep 2022 10:08:41 +0800 +Subject: f2fs: fix to do sanity check on destination blkaddr during recovery + +From: Chao Yu + +commit 0ef4ca04a3f9223ff8bc440041c524b2123e09a3 upstream. + +As Wenqing Liu reported in bugzilla: + +https://bugzilla.kernel.org/show_bug.cgi?id=216456 + +loop5: detected capacity change from 0 to 131072 +F2FS-fs (loop5): recover_inode: ino = 6, name = hln, inline = 1 +F2FS-fs (loop5): recover_data: ino = 6 (i_size: recover) err = 0 +F2FS-fs (loop5): recover_inode: ino = 6, name = hln, inline = 1 +F2FS-fs (loop5): recover_data: ino = 6 (i_size: recover) err = 0 +F2FS-fs (loop5): recover_inode: ino = 6, name = hln, inline = 1 +F2FS-fs (loop5): recover_data: ino = 6 (i_size: recover) err = 0 +F2FS-fs (loop5): Bitmap was wrongly set, blk:5634 +------------[ cut here ]------------ +WARNING: CPU: 3 PID: 1013 at fs/f2fs/segment.c:2198 +RIP: 0010:update_sit_entry+0xa55/0x10b0 [f2fs] +Call Trace: + + f2fs_do_replace_block+0xa98/0x1890 [f2fs] + f2fs_replace_block+0xeb/0x180 [f2fs] + recover_data+0x1a69/0x6ae0 [f2fs] + f2fs_recover_fsync_data+0x120d/0x1fc0 [f2fs] + f2fs_fill_super+0x4665/0x61e0 [f2fs] + mount_bdev+0x2cf/0x3b0 + legacy_get_tree+0xed/0x1d0 + vfs_get_tree+0x81/0x2b0 + path_mount+0x47e/0x19d0 + do_mount+0xce/0xf0 + __x64_sys_mount+0x12c/0x1a0 + do_syscall_64+0x38/0x90 + entry_SYSCALL_64_after_hwframe+0x63/0xcd + +If we enable CONFIG_F2FS_CHECK_FS config, it will trigger a kernel panic +instead of warning. + +The root cause is: in fuzzed image, SIT table is inconsistent with inode +mapping table, result in triggering such warning during SIT table update. + +This patch introduces a new flag DATA_GENERIC_ENHANCE_UPDATE, w/ this +flag, data block recovery flow can check destination blkaddr's validation +in SIT table, and skip f2fs_replace_block() to avoid inconsistent status. + +Cc: stable@vger.kernel.org +Reported-by: Wenqing Liu +Signed-off-by: Chao Yu +Signed-off-by: Jaegeuk Kim +Signed-off-by: Greg Kroah-Hartman +--- + fs/f2fs/checkpoint.c | 10 +++++++++- + fs/f2fs/f2fs.h | 4 ++++ + fs/f2fs/recovery.c | 8 ++++++++ + 3 files changed, 21 insertions(+), 1 deletion(-) + +--- a/fs/f2fs/checkpoint.c ++++ b/fs/f2fs/checkpoint.c +@@ -140,7 +140,7 @@ static bool __is_bitmap_valid(struct f2f + unsigned int segno, offset; + bool exist; + +- if (type != DATA_GENERIC_ENHANCE && type != DATA_GENERIC_ENHANCE_READ) ++ if (type == DATA_GENERIC) + return true; + + segno = GET_SEGNO(sbi, blkaddr); +@@ -148,6 +148,13 @@ static bool __is_bitmap_valid(struct f2f + se = get_seg_entry(sbi, segno); + + exist = f2fs_test_bit(offset, se->cur_valid_map); ++ if (exist && type == DATA_GENERIC_ENHANCE_UPDATE) { ++ f2fs_err(sbi, "Inconsistent error blkaddr:%u, sit bitmap:%d", ++ blkaddr, exist); ++ set_sbi_flag(sbi, SBI_NEED_FSCK); ++ return exist; ++ } ++ + if (!exist && type == DATA_GENERIC_ENHANCE) { + f2fs_err(sbi, "Inconsistent error blkaddr:%u, sit bitmap:%d", + blkaddr, exist); +@@ -185,6 +192,7 @@ bool f2fs_is_valid_blkaddr(struct f2fs_s + case DATA_GENERIC: + case DATA_GENERIC_ENHANCE: + case DATA_GENERIC_ENHANCE_READ: ++ case DATA_GENERIC_ENHANCE_UPDATE: + if (unlikely(blkaddr >= MAX_BLKADDR(sbi) || + blkaddr < MAIN_BLKADDR(sbi))) { + f2fs_warn(sbi, "access invalid blkaddr:%u", +--- a/fs/f2fs/f2fs.h ++++ b/fs/f2fs/f2fs.h +@@ -266,6 +266,10 @@ enum { + * condition of read on truncated area + * by extent_cache + */ ++ DATA_GENERIC_ENHANCE_UPDATE, /* ++ * strong check on range and segment ++ * bitmap for update case ++ */ + META_GENERIC, + }; + +--- a/fs/f2fs/recovery.c ++++ b/fs/f2fs/recovery.c +@@ -698,6 +698,14 @@ retry_prev: + goto err; + } + ++ if (f2fs_is_valid_blkaddr(sbi, dest, ++ DATA_GENERIC_ENHANCE_UPDATE)) { ++ f2fs_err(sbi, "Inconsistent dest blkaddr:%u, ino:%lu, ofs:%u", ++ dest, inode->i_ino, dn.ofs_in_node); ++ err = -EFSCORRUPTED; ++ goto err; ++ } ++ + /* write dummy data page */ + f2fs_replace_block(sbi, &dn, src, dest, + ni.version, false, false); diff --git a/queue-6.0/f2fs-fix-to-do-sanity-check-on-summary-info.patch b/queue-6.0/f2fs-fix-to-do-sanity-check-on-summary-info.patch new file mode 100644 index 00000000000..fb122fcce0c --- /dev/null +++ b/queue-6.0/f2fs-fix-to-do-sanity-check-on-summary-info.patch @@ -0,0 +1,123 @@ +From c6ad7fd16657ebd34a87a97d9588195aae87597d Mon Sep 17 00:00:00 2001 +From: Chao Yu +Date: Wed, 14 Sep 2022 19:51:51 +0800 +Subject: f2fs: fix to do sanity check on summary info + +From: Chao Yu + +commit c6ad7fd16657ebd34a87a97d9588195aae87597d upstream. + +As Wenqing Liu reported in bugzilla: + +https://bugzilla.kernel.org/show_bug.cgi?id=216456 + +BUG: KASAN: use-after-free in recover_data+0x63ae/0x6ae0 [f2fs] +Read of size 4 at addr ffff8881464dcd80 by task mount/1013 + +CPU: 3 PID: 1013 Comm: mount Tainted: G W 6.0.0-rc4 #1 +Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.15.0-1 04/01/2014 +Call Trace: + dump_stack_lvl+0x45/0x5e + print_report.cold+0xf3/0x68d + kasan_report+0xa8/0x130 + recover_data+0x63ae/0x6ae0 [f2fs] + f2fs_recover_fsync_data+0x120d/0x1fc0 [f2fs] + f2fs_fill_super+0x4665/0x61e0 [f2fs] + mount_bdev+0x2cf/0x3b0 + legacy_get_tree+0xed/0x1d0 + vfs_get_tree+0x81/0x2b0 + path_mount+0x47e/0x19d0 + do_mount+0xce/0xf0 + __x64_sys_mount+0x12c/0x1a0 + do_syscall_64+0x38/0x90 + entry_SYSCALL_64_after_hwframe+0x63/0xcd + +The root cause is: in fuzzed image, SSA table is corrupted: ofs_in_node +is larger than ADDRS_PER_PAGE(), result in out-of-range access on 4k-size +page. + +- recover_data + - do_recover_data + - check_index_in_prev_nodes + - f2fs_data_blkaddr + +This patch adds sanity check on summary info in recovery and GC flow +in where the flows rely on them. + +After patch: +[ 29.310883] F2FS-fs (loop0): Inconsistent ofs_in_node:65286 in summary, ino:0, nid:6, max:1018 + +Cc: stable@vger.kernel.org +Reported-by: Wenqing Liu +Signed-off-by: Chao Yu +Signed-off-by: Jaegeuk Kim +Signed-off-by: Greg Kroah-Hartman +--- + fs/f2fs/gc.c | 10 +++++++++- + fs/f2fs/recovery.c | 15 ++++++++++++--- + 2 files changed, 21 insertions(+), 4 deletions(-) + +--- a/fs/f2fs/gc.c ++++ b/fs/f2fs/gc.c +@@ -1078,7 +1078,7 @@ static bool is_alive(struct f2fs_sb_info + { + struct page *node_page; + nid_t nid; +- unsigned int ofs_in_node; ++ unsigned int ofs_in_node, max_addrs; + block_t source_blkaddr; + + nid = le32_to_cpu(sum->nid); +@@ -1104,6 +1104,14 @@ static bool is_alive(struct f2fs_sb_info + return false; + } + ++ max_addrs = IS_INODE(node_page) ? DEF_ADDRS_PER_INODE : ++ DEF_ADDRS_PER_BLOCK; ++ if (ofs_in_node >= max_addrs) { ++ f2fs_err(sbi, "Inconsistent ofs_in_node:%u in summary, ino:%u, nid:%u, max:%u", ++ ofs_in_node, dni->ino, dni->nid, max_addrs); ++ return false; ++ } ++ + *nofs = ofs_of_node(node_page); + source_blkaddr = data_blkaddr(NULL, node_page, ofs_in_node); + f2fs_put_page(node_page, 1); +--- a/fs/f2fs/recovery.c ++++ b/fs/f2fs/recovery.c +@@ -474,7 +474,7 @@ static int check_index_in_prev_nodes(str + struct dnode_of_data tdn = *dn; + nid_t ino, nid; + struct inode *inode; +- unsigned int offset; ++ unsigned int offset, ofs_in_node, max_addrs; + block_t bidx; + int i; + +@@ -501,15 +501,24 @@ static int check_index_in_prev_nodes(str + got_it: + /* Use the locked dnode page and inode */ + nid = le32_to_cpu(sum.nid); ++ ofs_in_node = le16_to_cpu(sum.ofs_in_node); ++ ++ max_addrs = ADDRS_PER_PAGE(dn->node_page, dn->inode); ++ if (ofs_in_node >= max_addrs) { ++ f2fs_err(sbi, "Inconsistent ofs_in_node:%u in summary, ino:%lu, nid:%u, max:%u", ++ ofs_in_node, dn->inode->i_ino, nid, max_addrs); ++ return -EFSCORRUPTED; ++ } ++ + if (dn->inode->i_ino == nid) { + tdn.nid = nid; + if (!dn->inode_page_locked) + lock_page(dn->inode_page); + tdn.node_page = dn->inode_page; +- tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node); ++ tdn.ofs_in_node = ofs_in_node; + goto truncate_out; + } else if (dn->nid == nid) { +- tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node); ++ tdn.ofs_in_node = ofs_in_node; + goto truncate_out; + } + diff --git a/queue-6.0/f2fs-fix-wrong-continue-condition-in-gc.patch b/queue-6.0/f2fs-fix-wrong-continue-condition-in-gc.patch new file mode 100644 index 00000000000..bc92caefa44 --- /dev/null +++ b/queue-6.0/f2fs-fix-wrong-continue-condition-in-gc.patch @@ -0,0 +1,41 @@ +From 605b0a778aa2599aa902ae639b8e9937c74b869b Mon Sep 17 00:00:00 2001 +From: Jaegeuk Kim +Date: Fri, 12 Aug 2022 22:49:50 -0700 +Subject: f2fs: fix wrong continue condition in GC + +From: Jaegeuk Kim + +commit 605b0a778aa2599aa902ae639b8e9937c74b869b upstream. + +We should decrease the frozen counter. + +Cc: stable@vger.kernel.org +Fixes: 325163e9892b ("f2fs: add gc_urgent_high_remaining sysfs node") +Reviewed-by: Chao Yu +Signed-off-by: Jaegeuk Kim +Signed-off-by: Greg Kroah-Hartman +--- + fs/f2fs/gc.c | 12 ++++-------- + 1 file changed, 4 insertions(+), 8 deletions(-) + +--- a/fs/f2fs/gc.c ++++ b/fs/f2fs/gc.c +@@ -97,14 +97,10 @@ static int gc_thread_func(void *data) + */ + if (sbi->gc_mode == GC_URGENT_HIGH) { + spin_lock(&sbi->gc_urgent_high_lock); +- if (sbi->gc_urgent_high_limited) { +- if (!sbi->gc_urgent_high_remaining) { +- sbi->gc_urgent_high_limited = false; +- spin_unlock(&sbi->gc_urgent_high_lock); +- sbi->gc_mode = GC_NORMAL; +- continue; +- } +- sbi->gc_urgent_high_remaining--; ++ if (sbi->gc_urgent_high_limited && ++ !sbi->gc_urgent_high_remaining--) { ++ sbi->gc_urgent_high_limited = false; ++ sbi->gc_mode = GC_NORMAL; + } + spin_unlock(&sbi->gc_urgent_high_lock); + } diff --git a/queue-6.0/f2fs-flush-pending-checkpoints-when-freezing-super.patch b/queue-6.0/f2fs-flush-pending-checkpoints-when-freezing-super.patch new file mode 100644 index 00000000000..bf767a47b56 --- /dev/null +++ b/queue-6.0/f2fs-flush-pending-checkpoints-when-freezing-super.patch @@ -0,0 +1,81 @@ +From c7b58576370147833999fd4cc874d0f918bdf9ca Mon Sep 17 00:00:00 2001 +From: Jaegeuk Kim +Date: Fri, 19 Aug 2022 15:52:02 -0700 +Subject: f2fs: flush pending checkpoints when freezing super + +From: Jaegeuk Kim + +commit c7b58576370147833999fd4cc874d0f918bdf9ca upstream. + +This avoids -EINVAL when trying to freeze f2fs. + +Cc: stable@vger.kernel.org +Reviewed-by: Chao Yu +Signed-off-by: Jaegeuk Kim +Signed-off-by: Greg Kroah-Hartman +--- + fs/f2fs/checkpoint.c | 24 ++++++++++++++++++------ + fs/f2fs/f2fs.h | 1 + + fs/f2fs/super.c | 5 ++--- + 3 files changed, 21 insertions(+), 9 deletions(-) + +--- a/fs/f2fs/checkpoint.c ++++ b/fs/f2fs/checkpoint.c +@@ -1892,15 +1892,27 @@ int f2fs_start_ckpt_thread(struct f2fs_s + void f2fs_stop_ckpt_thread(struct f2fs_sb_info *sbi) + { + struct ckpt_req_control *cprc = &sbi->cprc_info; ++ struct task_struct *ckpt_task; + +- if (cprc->f2fs_issue_ckpt) { +- struct task_struct *ckpt_task = cprc->f2fs_issue_ckpt; ++ if (!cprc->f2fs_issue_ckpt) ++ return; + +- cprc->f2fs_issue_ckpt = NULL; +- kthread_stop(ckpt_task); ++ ckpt_task = cprc->f2fs_issue_ckpt; ++ cprc->f2fs_issue_ckpt = NULL; ++ kthread_stop(ckpt_task); + +- flush_remained_ckpt_reqs(sbi, NULL); +- } ++ f2fs_flush_ckpt_thread(sbi); ++} ++ ++void f2fs_flush_ckpt_thread(struct f2fs_sb_info *sbi) ++{ ++ struct ckpt_req_control *cprc = &sbi->cprc_info; ++ ++ flush_remained_ckpt_reqs(sbi, NULL); ++ ++ /* Let's wait for the previous dispatched checkpoint. */ ++ while (atomic_read(&cprc->queued_ckpt)) ++ io_schedule_timeout(DEFAULT_IO_TIMEOUT); + } + + void f2fs_init_ckpt_req_control(struct f2fs_sb_info *sbi) +--- a/fs/f2fs/f2fs.h ++++ b/fs/f2fs/f2fs.h +@@ -3707,6 +3707,7 @@ static inline bool f2fs_need_rand_seg(st + * checkpoint.c + */ + void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io); ++void f2fs_flush_ckpt_thread(struct f2fs_sb_info *sbi); + struct page *f2fs_grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index); + struct page *f2fs_get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index); + struct page *f2fs_get_meta_page_retry(struct f2fs_sb_info *sbi, pgoff_t index); +--- a/fs/f2fs/super.c ++++ b/fs/f2fs/super.c +@@ -1666,9 +1666,8 @@ static int f2fs_freeze(struct super_bloc + if (is_sbi_flag_set(F2FS_SB(sb), SBI_IS_DIRTY)) + return -EINVAL; + +- /* ensure no checkpoint required */ +- if (!llist_empty(&F2FS_SB(sb)->cprc_info.issue_list)) +- return -EINVAL; ++ /* Let's flush checkpoints and stop the thread. */ ++ f2fs_flush_ckpt_thread(F2FS_SB(sb)); + + /* to avoid deadlock on f2fs_evict_inode->SB_FREEZE_FS */ + set_sbi_flag(F2FS_SB(sb), SBI_IS_FREEZING); diff --git a/queue-6.0/f2fs-increase-the-limit-for-reserve_root.patch b/queue-6.0/f2fs-increase-the-limit-for-reserve_root.patch new file mode 100644 index 00000000000..cd237c02c56 --- /dev/null +++ b/queue-6.0/f2fs-increase-the-limit-for-reserve_root.patch @@ -0,0 +1,39 @@ +From da35fe96d12d15779f3cb74929b7ed03941cf983 Mon Sep 17 00:00:00 2001 +From: Jaegeuk Kim +Date: Tue, 23 Aug 2022 10:18:42 -0700 +Subject: f2fs: increase the limit for reserve_root + +From: Jaegeuk Kim + +commit da35fe96d12d15779f3cb74929b7ed03941cf983 upstream. + +This patch increases the threshold that limits the reserved root space from 0.2% +to 12.5% by using simple shift operation. + +Typically Android sets 128MB, but if the storage capacity is 32GB, 0.2% which is +around 64MB becomes too small. Let's relax it. + +Cc: stable@vger.kernel.org +Reported-by: Aran Dalton +Reviewed-by: Chao Yu +Signed-off-by: Jaegeuk Kim +Signed-off-by: Greg Kroah-Hartman +--- + fs/f2fs/super.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/fs/f2fs/super.c ++++ b/fs/f2fs/super.c +@@ -301,10 +301,10 @@ static void f2fs_destroy_casefold_cache( + + static inline void limit_reserve_root(struct f2fs_sb_info *sbi) + { +- block_t limit = min((sbi->user_block_count << 1) / 1000, ++ block_t limit = min((sbi->user_block_count >> 3), + sbi->user_block_count - sbi->reserved_blocks); + +- /* limit is 0.2% */ ++ /* limit is 12.5% */ + if (test_opt(sbi, RESERVE_ROOT) && + F2FS_OPTION(sbi).root_reserved_blocks > limit) { + F2FS_OPTION(sbi).root_reserved_blocks = limit; diff --git a/queue-6.0/series b/queue-6.0/series index 76346a5e879..08b65893662 100644 --- a/queue-6.0/series +++ b/queue-6.0/series @@ -120,3 +120,10 @@ btrfs-enhance-unsupported-compat-ro-flags-handling.patch btrfs-fix-race-between-quota-enable-and-quota-rescan-ioctl.patch btrfs-fix-missed-extent-on-fsync-after-dropping-extent-maps.patch btrfs-set-generation-before-calling-btrfs_clean_tree_block-in-btrfs_init_new_buffer.patch +f2fs-fix-wrong-continue-condition-in-gc.patch +f2fs-complete-checkpoints-during-remount.patch +f2fs-flush-pending-checkpoints-when-freezing-super.patch +f2fs-increase-the-limit-for-reserve_root.patch +f2fs-fix-to-do-sanity-check-on-destination-blkaddr-during-recovery.patch +f2fs-fix-to-do-sanity-check-on-summary-info.patch +f2fs-allow-direct-read-for-zoned-device.patch