* [PATCH] f2fs: introduce gcless mount option to avoid foreground GC
[not found] <CGME20260706062043epcms2p16928216befdca1242bc2d3cd7cb34afe@epcms2p1>
@ 2026-07-06 6:20 ` Yonggil Song
2026-07-07 8:29 ` kernel test robot
0 siblings, 1 reply; 2+ messages in thread
From: Yonggil Song @ 2026-07-06 6:20 UTC (permalink / raw)
To: jaegeuk@kernel.org, chao@kernel.org, corbet@lwn.net
Cc: Yonggil Song, linux-f2fs-devel@lists.sourceforge.net,
linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org,
Dongjin Kim, Seokhwan Kim, Daejun Park
Under heavy out-of-place overwrite at near-full utilization, foreground
GC picks nearly-fully-valid victims and relocates almost every block,
while the scattered invalid space is not SSR-reusable until a checkpoint
stabilizes it. WAF explodes even though reclaimable space exists.
Add a "gcless" mount option that counts checkpoint-stable invalid blocks
(invalid as of the last checkpoint, hence SSR-reusable) and credits them
as free sections in has_not_enough_free_secs(). The watermark then sees
the slack as free, so f2fs_balance_fs() skips foreground GC and
allocation reclaims the space through SSR instead. The count is
recomputed at mount and after each successful checkpoint under
block_operations(), where it is exact and needs no locking.
The option is limited to adaptive (non-LFS) mode.
8 GiB UFS, 2 GiB random overwrite at 99% utilization:
baseline: WAF 76.7, foreground GC calls 578k
gcless: WAF 1.2, foreground GC calls 504
Signed-off-by: Yonggil Song <yonggil.song@samsung.com>
---
Documentation/filesystems/f2fs.rst | 8 +++++
fs/f2fs/checkpoint.c | 1 +
fs/f2fs/debug.c | 4 +++
fs/f2fs/f2fs.h | 12 ++++++++
fs/f2fs/gc.c | 5 ++--
fs/f2fs/segment.c | 47 ++++++++++++++++++++++++++++++
fs/f2fs/segment.h | 15 ++++++++++
fs/f2fs/super.c | 17 +++++++++++
8 files changed, 107 insertions(+), 2 deletions(-)
diff --git a/Documentation/filesystems/f2fs.rst b/Documentation/filesystems/f2fs.rst
index 7e4031631286..05ac3f76bfba 100644
--- a/Documentation/filesystems/f2fs.rst
+++ b/Documentation/filesystems/f2fs.rst
@@ -409,6 +409,14 @@ lookup_mode=%s Control the directory lookup behavior for casefolded
on-disk `SB_ENC_NO_COMPAT_FALLBACK_FL`
flag.
================== ========================================
+gcless Avoid foreground GC by crediting checkpoint-stable invalid
+ blocks (invalid at the last checkpoint and thus SSR-reusable)
+ as free space in the free section watermark, so allocation
+ recycles that slack via SSR instead of relocating valid
+ blocks. Intended for heavy out-of-place overwrite at
+ near-full utilization, where it reduces write amplification.
+ Not allowed in LFS mode (including zoned block devices),
+ by default it's disabled.
======================== ============================================================
Debugfs Entries
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 01e1ba77263e..0d83e90b583c 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -1932,6 +1932,7 @@ int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
f2fs_release_discard_addrs(sbi);
} else {
f2fs_clear_prefree_segments(sbi, cpc);
+ f2fs_update_cib(sbi);
}
f2fs_restore_inmem_curseg(sbi);
diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index af88db8fdb71..b1435e01447d 100644
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -285,6 +285,8 @@ static void update_general_status(struct f2fs_sb_info *sbi)
for (i = 0; i < MAX_CALL_TYPE; i++)
si->cp_call_count[i] = atomic_read(&sbi->cp_call_count[i]);
+ si->cib_total_blocks = READ_ONCE(sbi->cib_total_blocks);
+
for (i = 0; i < 2; i++) {
si->segment_count[i] = sbi->segment_count[i];
si->block_count[i] = sbi->block_count[i];
@@ -623,6 +625,8 @@ static int stat_show(struct seq_file *s, void *v)
seq_printf(s, " - Total : %4d\n", si->nr_total_ckpt);
seq_printf(s, " - Cur time : %4d(ms)\n", si->cur_ckpt_time);
seq_printf(s, " - Peak time : %4d(ms)\n", si->peak_ckpt_time);
+ seq_printf(s, "GCless CIB budget : %u blocks\n",
+ si->cib_total_blocks);
seq_printf(s, "GC calls: %d (gc_thread: %d)\n",
si->gc_call_count[BACKGROUND] +
si->gc_call_count[FOREGROUND],
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index e40b6b2784ee..51c615724cf5 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -137,6 +137,7 @@ enum f2fs_mount_opt {
* string rather than using the MS_LAZYTIME flag, so this must remain.
*/
F2FS_MOUNT_LAZYTIME,
+ F2FS_MOUNT_GCLESS,
F2FS_MOUNT_RESERVE_NODE,
};
@@ -1870,6 +1871,15 @@ struct f2fs_sb_info {
struct f2fs_mount_info mount_opt; /* mount options */
+ /*
+ * Checkpoint-stable invalid blocks: sum of blocks that were invalid at
+ * the last checkpoint and are thus SSR-eligible while their section stays
+ * dirty. Written only by f2fs_update_cib() (mount and after each
+ * successful checkpoint, under block_operations()), read locklessly, so a
+ * plain block_t with READ_ONCE()/WRITE_ONCE() suffices -- no atomic.
+ */
+ block_t cib_total_blocks;
+
/* for cleaning operations */
struct f2fs_rwsem gc_lock; /*
* semaphore for GC, avoid
@@ -4000,6 +4010,7 @@ bool f2fs_issue_discard_timeout(struct f2fs_sb_info *sbi, bool need_check);
void f2fs_clear_prefree_segments(struct f2fs_sb_info *sbi,
struct cp_control *cpc);
void f2fs_dirty_to_prefree(struct f2fs_sb_info *sbi);
+void f2fs_update_cib(struct f2fs_sb_info *sbi);
block_t f2fs_get_unusable_blocks(struct f2fs_sb_info *sbi);
int f2fs_disable_cp_again(struct f2fs_sb_info *sbi, block_t unusable);
void f2fs_release_discard_addrs(struct f2fs_sb_info *sbi);
@@ -4289,6 +4300,7 @@ struct f2fs_stat_info {
int dirty_count, node_pages, meta_pages, compress_pages;
int compress_page_hit;
int prefree_count, free_segs, free_secs;
+ block_t cib_total_blocks;
int cp_call_count[MAX_CALL_TYPE], cp_count;
int gc_call_count[MAX_CALL_TYPE];
int gc_segs[2][2];
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index e60c1106f70b..ebf47ef5fff0 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1964,10 +1964,11 @@ int f2fs_gc(struct f2fs_sb_info *sbi, struct f2fs_gc_control *gc_control)
* threshold, we can make them free by checkpoint. Then, we
* secure free segments which doesn't need fggc any more.
*/
- if (prefree_segments(sbi)) {
+ if (prefree_segments(sbi) || test_opt(sbi, GCLESS)) {
stat_inc_cp_call_count(sbi, TOTAL_CALL);
ret = f2fs_write_checkpoint(sbi, &cpc);
- if (ret)
+ if (ret ||
+ (test_opt(sbi, GCLESS) && has_enough_free_secs(sbi, 0, 0)))
goto stop;
/* Reset due to checkpoint */
sec_freed = 0;
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 788f8b050249..e020714261ff 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -305,6 +305,53 @@ static void __complete_revoke_list(struct inode *inode, struct list_head *head,
f2fs_do_truncate_blocks(inode, start_index * PAGE_SIZE, false);
}
+static inline u32 cib_contrib_of_se(struct f2fs_sb_info *sbi, unsigned long seg)
+{
+ struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
+ struct free_segmap_info *free_i = SM_I(sbi)->free_info;
+ struct seg_entry *se = get_seg_entry(sbi, seg);
+ u32 usable = f2fs_usable_blks_in_seg(sbi, seg);
+ u32 ckpt_v = se->ckpt_valid_blocks;
+
+ /* free, prefree and current segments hold no reusable SSR slack */
+ if (test_bit(seg, free_i->free_segmap))
+ return 0;
+ if (test_bit(seg, dirty_i->dirty_segmap[PRE]))
+ return 0;
+ if (is_curseg(sbi, seg))
+ return 0;
+ if (ckpt_v >= usable)
+ return 0;
+
+ return usable - ckpt_v;
+}
+
+/*
+ * Recompute the checkpoint-stable invalid-block budget by scanning all main
+ * segments via ckpt_valid_blocks (free/prefree/current segments contribute
+ * nothing). Called at mount and after every successful checkpoint, both under
+ * block_operations(), so it is the only writer and needs no atomic; readers use
+ * READ_ONCE(). ckpt_valid_blocks is fixed between checkpoints, so the value is
+ * exact at each checkpoint -- gcless checkpoints often enough to keep it fresh,
+ * which is why no per-allocation delta hooks are needed.
+ */
+void f2fs_update_cib(struct f2fs_sb_info *sbi)
+{
+ unsigned long nsegs = MAIN_SEGS(sbi);
+ unsigned long seg;
+ block_t total = 0;
+
+ if (!test_opt(sbi, GCLESS)) {
+ WRITE_ONCE(sbi->cib_total_blocks, 0);
+ return;
+ }
+
+ for (seg = 0; seg < nsegs; seg++)
+ total += cib_contrib_of_se(sbi, seg);
+
+ WRITE_ONCE(sbi->cib_total_blocks, total);
+}
+
static int __f2fs_commit_atomic_write(struct inode *inode)
{
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 068845660b0f..3226930d759a 100644
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -702,6 +702,21 @@ static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi,
free_secs = free_sections(sbi) + freed;
required_secs = needed + reserved_sections(sbi) +
__get_secs_required(sbi);
+ /*
+ * Credit the checkpoint-stable invalid-block budget (SSR-reusable slack)
+ * to free_secs, so the watermark lets allocation recycle that slack via
+ * SSR instead of running foreground GC. cib_total_blocks is a section/
+ * block count (always non-negative), so the math stays in unsigned int and
+ * is capped at the sections still unaccounted for.
+ */
+ if (test_opt(sbi, GCLESS)) {
+ unsigned int sec_blks = CAP_BLKS_PER_SEC(sbi);
+ unsigned int add_secs = READ_ONCE(sbi->cib_total_blocks) / sec_blks;
+ unsigned int room = free_secs < MAIN_SECS(sbi) ?
+ MAIN_SECS(sbi) - free_secs : 0;
+
+ free_secs += min(add_secs, room);
+ }
return free_secs < required_secs;
}
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index ccf806b676f5..8cb2eb2ce836 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -234,6 +234,7 @@ enum {
Opt_jqfmt,
Opt_checkpoint,
Opt_lookup_mode,
+ Opt_gcless,
Opt_err,
};
@@ -336,6 +337,7 @@ static const struct fs_parameter_spec f2fs_param_specs[] = {
fsparam_flag("usrquota", Opt_usrquota),
fsparam_flag("grpquota", Opt_grpquota),
fsparam_flag("prjquota", Opt_prjquota),
+ fsparam_flag("gcless", Opt_gcless),
fsparam_string("usrjquota", Opt_usrjquota),
fsparam_flag("usrjquota", Opt_usrjquota),
fsparam_string("grpjquota", Opt_grpjquota),
@@ -1230,6 +1232,9 @@ static int f2fs_parse_param(struct fs_context *fc, struct fs_parameter *param)
case Opt_nat_bits:
ctx_set_opt(ctx, F2FS_MOUNT_NAT_BITS);
break;
+ case Opt_gcless:
+ ctx_set_opt(ctx, F2FS_MOUNT_GCLESS);
+ break;
case Opt_lookup_mode:
F2FS_CTX_INFO(ctx).lookup_mode = result.uint_32;
ctx->spec_mask |= F2FS_SPEC_lookup_mode;
@@ -1603,6 +1608,13 @@ static int f2fs_check_opt_consistency(struct fs_context *fc,
f2fs_err(sbi, "Allow to mount readonly mode only");
return -EROFS;
}
+
+ /* Only for adaptive mode */
+ if (test_opt(sbi, GCLESS) && f2fs_lfs_mode(sbi)) {
+ f2fs_err(sbi, "gcless is not allowed in LFS mode");
+ return -EINVAL;
+ }
+
return 0;
}
@@ -2542,6 +2554,9 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
else if (F2FS_OPTION(sbi).lookup_mode == LOOKUP_AUTO)
seq_show_option(seq, "lookup_mode", "auto");
+ if (test_opt(sbi, GCLESS))
+ seq_puts(seq, ",gcless");
+
return 0;
}
@@ -5344,6 +5359,8 @@ static int f2fs_fill_super(struct super_block *sb, struct fs_context *fc)
if (err)
goto sync_free_meta;
+ f2fs_update_cib(sbi);
+
/*
* If filesystem is not mounted as read-only then
* do start the gc_thread.
base-commit: cb8ff3ead9a3fc43727980be58c7099506f65261
--
2.43.0
^ permalink raw reply related [flat|nested] 2+ messages in thread
* Re: [PATCH] f2fs: introduce gcless mount option to avoid foreground GC
2026-07-06 6:20 ` [PATCH] f2fs: introduce gcless mount option to avoid foreground GC Yonggil Song
@ 2026-07-07 8:29 ` kernel test robot
0 siblings, 0 replies; 2+ messages in thread
From: kernel test robot @ 2026-07-07 8:29 UTC (permalink / raw)
To: Yonggil Song, jaegeuk@kernel.org, chao@kernel.org, corbet@lwn.net
Cc: llvm, oe-kbuild-all, Yonggil Song,
linux-f2fs-devel@lists.sourceforge.net, linux-doc@vger.kernel.org,
linux-kernel@vger.kernel.org, Dongjin Kim, Seokhwan Kim,
Daejun Park
Hi Yonggil,
kernel test robot noticed the following build warnings:
[auto build test WARNING on cb8ff3ead9a3fc43727980be58c7099506f65261]
url: https://github.com/intel-lab-lkp/linux/commits/Yonggil-Song/f2fs-introduce-gcless-mount-option-to-avoid-foreground-GC/20260706-154229
base: cb8ff3ead9a3fc43727980be58c7099506f65261
patch link: https://lore.kernel.org/r/20260706062043epcms2p16928216befdca1242bc2d3cd7cb34afe%40epcms2p1
patch subject: [PATCH] f2fs: introduce gcless mount option to avoid foreground GC
config: hexagon-allmodconfig (https://download.01.org/0day-ci/archive/20260707/202607071623.ZxOpKv3S-lkp@intel.com/config)
compiler: clang version 23.0.0git (https://github.com/llvm/llvm-project 0a2fb2a2269da0e2a3e230beb6cad39ca314db33)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260707/202607071623.ZxOpKv3S-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202607071623.ZxOpKv3S-lkp@intel.com/
All warnings (new ones prefixed by >>):
In file included from fs/f2fs/dir.c:14:
>> fs/f2fs/f2fs.h:2945:4: warning: shift count >= width of type [-Wshift-count-overflow]
2945 | test_opt(sbi, RESERVE_NODE));
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:150:26: note: expanded from macro 'test_opt'
150 | (F2FS_OPTION(sbi).opt & BIT(F2FS_MOUNT_##option))
| ^~~~~~~~~~~~~~~~~~~~~~~~
include/vdso/bits.h:7:26: note: expanded from macro 'BIT'
7 | #define BIT(nr) (UL(1) << (nr))
| ^ ~~~~
In file included from fs/f2fs/dir.c:14:
fs/f2fs/f2fs.h:2953:6: warning: shift count >= width of type [-Wshift-count-overflow]
2953 | if (test_opt(sbi, RESERVE_NODE) &&
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:150:26: note: expanded from macro 'test_opt'
150 | (F2FS_OPTION(sbi).opt & BIT(F2FS_MOUNT_##option))
| ^~~~~~~~~~~~~~~~~~~~~~~~
include/vdso/bits.h:7:26: note: expanded from macro 'BIT'
7 | #define BIT(nr) (UL(1) << (nr))
| ^ ~~~~
2 warnings generated.
--
In file included from fs/f2fs/super.c:33:
>> fs/f2fs/f2fs.h:2945:4: warning: shift count >= width of type [-Wshift-count-overflow]
2945 | test_opt(sbi, RESERVE_NODE));
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:150:26: note: expanded from macro 'test_opt'
150 | (F2FS_OPTION(sbi).opt & BIT(F2FS_MOUNT_##option))
| ^~~~~~~~~~~~~~~~~~~~~~~~
include/vdso/bits.h:7:26: note: expanded from macro 'BIT'
7 | #define BIT(nr) (UL(1) << (nr))
| ^ ~~~~
In file included from fs/f2fs/super.c:33:
fs/f2fs/f2fs.h:2953:6: warning: shift count >= width of type [-Wshift-count-overflow]
2953 | if (test_opt(sbi, RESERVE_NODE) &&
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:150:26: note: expanded from macro 'test_opt'
150 | (F2FS_OPTION(sbi).opt & BIT(F2FS_MOUNT_##option))
| ^~~~~~~~~~~~~~~~~~~~~~~~
include/vdso/bits.h:7:26: note: expanded from macro 'BIT'
7 | #define BIT(nr) (UL(1) << (nr))
| ^ ~~~~
>> fs/f2fs/super.c:520:6: warning: shift count >= width of type [-Wshift-count-overflow]
520 | if (test_opt(sbi, RESERVE_NODE) &&
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:150:26: note: expanded from macro 'test_opt'
150 | (F2FS_OPTION(sbi).opt & BIT(F2FS_MOUNT_##option))
| ^~~~~~~~~~~~~~~~~~~~~~~~
include/vdso/bits.h:7:26: note: expanded from macro 'BIT'
7 | #define BIT(nr) (UL(1) << (nr))
| ^ ~~~~
fs/f2fs/super.c:526:39: warning: shift count >= width of type [-Wshift-count-overflow]
526 | if (!test_opt(sbi, RESERVE_ROOT) && !test_opt(sbi, RESERVE_NODE) &&
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:150:26: note: expanded from macro 'test_opt'
150 | (F2FS_OPTION(sbi).opt & BIT(F2FS_MOUNT_##option))
| ^~~~~~~~~~~~~~~~~~~~~~~~
include/vdso/bits.h:7:26: note: expanded from macro 'BIT'
7 | #define BIT(nr) (UL(1) << (nr))
| ^ ~~~~
fs/f2fs/super.c:1528:6: warning: shift count >= width of type [-Wshift-count-overflow]
1528 | if (test_opt(sbi, RESERVE_NODE) &&
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:150:26: note: expanded from macro 'test_opt'
150 | (F2FS_OPTION(sbi).opt & BIT(F2FS_MOUNT_##option))
| ^~~~~~~~~~~~~~~~~~~~~~~~
include/vdso/bits.h:7:26: note: expanded from macro 'BIT'
7 | #define BIT(nr) (UL(1) << (nr))
| ^ ~~~~
fs/f2fs/super.c:1529:21: warning: shift count >= width of type [-Wshift-count-overflow]
1529 | (ctx->opt_mask & BIT(F2FS_MOUNT_RESERVE_NODE)) &&
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/vdso/bits.h:7:26: note: expanded from macro 'BIT'
7 | #define BIT(nr) (UL(1) << (nr))
| ^ ~~~~
fs/f2fs/super.c:1534:21: warning: shift count >= width of type [-Wshift-count-overflow]
1534 | ctx->opt_mask &= ~BIT(F2FS_MOUNT_RESERVE_NODE);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/vdso/bits.h:7:26: note: expanded from macro 'BIT'
7 | #define BIT(nr) (UL(1) << (nr))
| ^ ~~~~
fs/f2fs/super.c:2475:37: warning: shift count >= width of type [-Wshift-count-overflow]
2475 | if (test_opt(sbi, RESERVE_ROOT) || test_opt(sbi, RESERVE_NODE))
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:150:26: note: expanded from macro 'test_opt'
150 | (F2FS_OPTION(sbi).opt & BIT(F2FS_MOUNT_##option))
| ^~~~~~~~~~~~~~~~~~~~~~~~
include/vdso/bits.h:7:26: note: expanded from macro 'BIT'
7 | #define BIT(nr) (UL(1) << (nr))
| ^ ~~~~
8 warnings generated.
vim +2945 fs/f2fs/f2fs.h
e48e16f3e37fac Daeho Jeong 2026-01-10 2916
3bac20a8f011b8 Jaegeuk Kim 2022-11-30 2917 extern void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync);
0abd675e97e60d Chao Yu 2017-07-09 2918 static inline int inc_valid_node_count(struct f2fs_sb_info *sbi,
000519f27866af Chao Yu 2017-07-06 2919 struct inode *inode, bool is_inode)
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2920 {
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2921 block_t valid_block_count;
2141879369681f Chunhai Guo 2025-08-07 2922 unsigned int valid_node_count, avail_user_node_count;
0f1c6ede6da9f7 Chao Yu 2024-02-20 2923 unsigned int avail_user_block_count;
af033b2aa8a874 Chao Yu 2018-09-20 2924 int err;
0abd675e97e60d Chao Yu 2017-07-09 2925
af033b2aa8a874 Chao Yu 2018-09-20 2926 if (is_inode) {
af033b2aa8a874 Chao Yu 2018-09-20 2927 if (inode) {
af033b2aa8a874 Chao Yu 2018-09-20 2928 err = dquot_alloc_inode(inode);
af033b2aa8a874 Chao Yu 2018-09-20 2929 if (err)
af033b2aa8a874 Chao Yu 2018-09-20 2930 return err;
af033b2aa8a874 Chao Yu 2018-09-20 2931 }
af033b2aa8a874 Chao Yu 2018-09-20 2932 } else {
af033b2aa8a874 Chao Yu 2018-09-20 2933 err = dquot_reserve_block(inode, 1);
af033b2aa8a874 Chao Yu 2018-09-20 2934 if (err)
af033b2aa8a874 Chao Yu 2018-09-20 2935 return err;
0abd675e97e60d Chao Yu 2017-07-09 2936 }
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2937
c40e15a9a59f79 Yangtao Li 2022-12-21 2938 if (time_to_inject(sbi, FAULT_BLOCK))
812c60564ca721 Chao Yu 2017-11-13 2939 goto enospc;
812c60564ca721 Chao Yu 2017-11-13 2940
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2941 spin_lock(&sbi->stat_lock);
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2942
0f1c6ede6da9f7 Chao Yu 2024-02-20 2943 valid_block_count = sbi->total_valid_block_count + 1;
2141879369681f Chunhai Guo 2025-08-07 2944 avail_user_block_count = get_available_block_count(sbi, inode,
2141879369681f Chunhai Guo 2025-08-07 @2945 test_opt(sbi, RESERVE_NODE));
300a842937fbcf Chao Yu 2021-12-11 2946
0f1c6ede6da9f7 Chao Yu 2024-02-20 2947 if (unlikely(valid_block_count > avail_user_block_count)) {
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2948 spin_unlock(&sbi->stat_lock);
0abd675e97e60d Chao Yu 2017-07-09 2949 goto enospc;
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2950 }
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2951
2141879369681f Chunhai Guo 2025-08-07 2952 avail_user_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
2141879369681f Chunhai Guo 2025-08-07 2953 if (test_opt(sbi, RESERVE_NODE) &&
2141879369681f Chunhai Guo 2025-08-07 2954 !__allow_reserved_root(sbi, inode, true))
2141879369681f Chunhai Guo 2025-08-07 2955 avail_user_node_count -= F2FS_OPTION(sbi).root_reserved_nodes;
ef86d70994b57c Gu Zheng 2013-11-19 2956 valid_node_count = sbi->total_valid_node_count + 1;
2141879369681f Chunhai Guo 2025-08-07 2957 if (unlikely(valid_node_count > avail_user_node_count)) {
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2958 spin_unlock(&sbi->stat_lock);
0abd675e97e60d Chao Yu 2017-07-09 2959 goto enospc;
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2960 }
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2961
ef86d70994b57c Gu Zheng 2013-11-19 2962 sbi->total_valid_node_count++;
ef86d70994b57c Gu Zheng 2013-11-19 2963 sbi->total_valid_block_count++;
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2964 spin_unlock(&sbi->stat_lock);
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2965
000519f27866af Chao Yu 2017-07-06 2966 if (inode) {
000519f27866af Chao Yu 2017-07-06 2967 if (is_inode)
000519f27866af Chao Yu 2017-07-06 2968 f2fs_mark_inode_dirty_sync(inode, true);
000519f27866af Chao Yu 2017-07-06 2969 else
0abd675e97e60d Chao Yu 2017-07-09 2970 f2fs_i_blocks_write(inode, 1, true, true);
000519f27866af Chao Yu 2017-07-06 2971 }
ef86d70994b57c Gu Zheng 2013-11-19 2972
41382ec43255b5 Jaegeuk Kim 2016-05-16 2973 percpu_counter_inc(&sbi->alloc_valid_block_count);
0abd675e97e60d Chao Yu 2017-07-09 2974 return 0;
0abd675e97e60d Chao Yu 2017-07-09 2975
0abd675e97e60d Chao Yu 2017-07-09 2976 enospc:
af033b2aa8a874 Chao Yu 2018-09-20 2977 if (is_inode) {
af033b2aa8a874 Chao Yu 2018-09-20 2978 if (inode)
af033b2aa8a874 Chao Yu 2018-09-20 2979 dquot_free_inode(inode);
af033b2aa8a874 Chao Yu 2018-09-20 2980 } else {
0abd675e97e60d Chao Yu 2017-07-09 2981 dquot_release_reservation_block(inode, 1);
af033b2aa8a874 Chao Yu 2018-09-20 2982 }
0abd675e97e60d Chao Yu 2017-07-09 2983 return -ENOSPC;
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2984 }
39a53e0ce0df01 Jaegeuk Kim 2012-11-28 2985
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-07-07 8:30 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
[not found] <CGME20260706062043epcms2p16928216befdca1242bc2d3cd7cb34afe@epcms2p1>
2026-07-06 6:20 ` [PATCH] f2fs: introduce gcless mount option to avoid foreground GC Yonggil Song
2026-07-07 8:29 ` kernel test robot
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox