* [PATCH] f2fs: introduce reserve_shrink mount option for filesystem shrinkage
@ 2026-09-10 18:10 Daeho Jeong
2026-09-11 8:10 ` kernel test robot
0 siblings, 1 reply; 2+ messages in thread
From: Daeho Jeong @ 2026-09-10 18:10 UTC (permalink / raw)
To: linux-kernel, linux-f2fs-devel, kernel-team; +Cc: Daeho Jeong
From: Daeho Jeong <daehojeong@google.com>
When preparing for subsequent online filesystem shrinkage (e.g., during
partition resizing or FOTA updates), sufficient free space must be
preserved so that valid data blocks can be evacuated and the filesystem
can safely shrink.
Existing reserve_root cannot prevent space exhaustion by privileged root
processes (such as OTA updaters, package managers, and system daemons
running with CAP_SYS_RESOURCE), which can allocate blocks from the root
reserve and lead to resize failures due to lack of space. Moreover,
runtime configurable reserved_blocks represents permanent GC and metadata
headroom that must persist after resize, which would cause double-counting
if inflated for shrinkage.
To resolve this, introduce a dedicated reserve_shrink=<blocks>
mount option:
1. Symmetrically mirrors reserve_root=<blocks> in block units to
pre-reserve space specifically for subsequent filesystem shrinkage.
2. In get_available_block_count(), unconditionally deducts
reserve_shrink_blocks for all callers, strictly rejecting all
allocations (including root / CAP_SYS_RESOURCE) once available blocks
are exhausted.
3. In f2fs_statfs(), deducts reserve_shrink_blocks from f_bfree (and
f_bavail) so that filesystem statistics accurately reflect usable space.
4. In f2fs_resize_fs(), automatically resets reserve_shrink_blocks to 0
and clears F2FS_MOUNT_RESERVE_SHRINK upon successful shrink completion,
releasing any remaining reservation.
5. In sysfs: reserved_blocks, subtracts reserve_shrink_blocks when
validating the upper limit of configurable reserved blocks.
Signed-off-by: Daeho Jeong <daehojeong@google.com>
---
Documentation/filesystems/f2fs.rst | 7 +++++
fs/f2fs/f2fs.h | 9 ++++++
fs/f2fs/gc.c | 5 ++++
fs/f2fs/super.c | 47 ++++++++++++++++++++++++++++++
fs/f2fs/sysfs.c | 13 +++++++--
5 files changed, 79 insertions(+), 2 deletions(-)
diff --git a/Documentation/filesystems/f2fs.rst b/Documentation/filesystems/f2fs.rst
index 771216f45207..dbdc5d5a83ad 100644
--- a/Documentation/filesystems/f2fs.rst
+++ b/Documentation/filesystems/f2fs.rst
@@ -191,6 +191,13 @@ reserve_node=%d Support configuring reserved nodes which are used for
gid, the default limit is 12.5% of all nodes.
resuid=%d The user ID which may use the reserved blocks and nodes.
resgid=%d The group ID which may use the reserved blocks and nodes.
+reserve_shrink=%d Support pre-reserving space for subsequent filesystem
+ shrinkage (e.g. during partition resizing or FOTA),
+ unit: blocks. Unlike reserve_root, allocations from
+ this reserved space strictly reject all callers
+ (including root / CAP_SYS_RESOURCE). Once the
+ filesystem is successfully shrunk via resize, this
+ value is automatically reset to 0.
fault_injection=%d Enable fault injection in all supported types with
specified injection rate.
fault_type=%d Support configuring fault injection type, should be
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 62efc25cd107..c21ed3eacc6f 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -145,6 +145,7 @@ enum f2fs_mount_opt {
*/
F2FS_MOUNT_LAZYTIME,
F2FS_MOUNT_RESERVE_NODE,
+ F2FS_MOUNT_RESERVE_SHRINK,
};
#define F2FS_OPTION(sbi) ((sbi)->mount_opt)
@@ -226,6 +227,7 @@ struct f2fs_mount_info {
unsigned long long opt;
block_t root_reserved_blocks; /* root reserved blocks */
block_t root_reserved_nodes; /* root reserved nodes */
+ block_t reserve_shrink_blocks; /* reserve blocks for shrink */
kuid_t s_resuid; /* reserved blocks for uid */
kgid_t s_resgid; /* reserved blocks for gid */
int active_logs; /* # of active logs */
@@ -2658,6 +2660,13 @@ static inline unsigned int get_available_block_count(struct f2fs_sb_info *sbi,
if (test_opt(sbi, RESERVE_ROOT) && !__allow_reserved_root(sbi, inode, cap))
avail_user_block_count -= F2FS_OPTION(sbi).root_reserved_blocks;
+ if (test_opt(sbi, RESERVE_SHRINK)) {
+ if (avail_user_block_count > F2FS_OPTION(sbi).reserve_shrink_blocks)
+ avail_user_block_count -= F2FS_OPTION(sbi).reserve_shrink_blocks;
+ else
+ avail_user_block_count = 0;
+ }
+
if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
if (avail_user_block_count > sbi->unusable_block_count)
avail_user_block_count -= sbi->unusable_block_count;
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index bc22dde1cb30..556c4793478d 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -2492,6 +2492,11 @@ int f2fs_resize_fs(struct file *filp, __u64 block_count)
spin_lock(&sbi->stat_lock);
sbi->user_block_count += shrunk_blocks;
spin_unlock(&sbi->stat_lock);
+ } else if (test_opt(sbi, RESERVE_SHRINK)) {
+ spin_lock(&sbi->stat_lock);
+ F2FS_OPTION(sbi).reserve_shrink_blocks = 0;
+ clear_opt(sbi, RESERVE_SHRINK);
+ spin_unlock(&sbi->stat_lock);
}
out_err:
f2fs_up_write_trace(&sbi->cp_global_sem, &clc);
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index f96abecb3c55..f7f82a32f99f 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -196,6 +196,7 @@ enum {
Opt_data_flush,
Opt_reserve_root,
Opt_reserve_node,
+ Opt_reserve_shrink,
Opt_resgid,
Opt_resuid,
Opt_mode,
@@ -328,6 +329,7 @@ static const struct fs_parameter_spec f2fs_param_specs[] = {
fsparam_flag("data_flush", Opt_data_flush),
fsparam_u32("reserve_root", Opt_reserve_root),
fsparam_u32("reserve_node", Opt_reserve_node),
+ fsparam_u32("reserve_shrink", Opt_reserve_shrink),
fsparam_gid("resgid", Opt_resgid),
fsparam_uid("resuid", Opt_resuid),
fsparam_enum("mode", Opt_mode, f2fs_param_mode),
@@ -407,6 +409,7 @@ static match_table_t f2fs_checkpoint_tokens = {
#define F2FS_SPEC_lookup_mode (1 << 24)
#define F2FS_SPEC_reserve_node (1 << 25)
#define F2FS_SPEC_resizable_tail_secno (1 << 26)
+#define F2FS_SPEC_reserve_shrink (1 << 27)
struct f2fs_fs_context {
struct f2fs_mount_info info;
@@ -538,6 +541,27 @@ static inline void limit_reserve_root(struct f2fs_sb_info *sbi)
F2FS_OPTION(sbi).s_resgid));
}
+static inline void limit_reserve_shrink(struct f2fs_sb_info *sbi)
+{
+ block_t block_limit;
+
+ if (!test_opt(sbi, RESERVE_SHRINK))
+ return;
+
+ block_limit = sbi->user_block_count - sbi->reserved_blocks;
+ if (test_opt(sbi, RESERVE_ROOT)) {
+ if (block_limit > F2FS_OPTION(sbi).root_reserved_blocks)
+ block_limit -= F2FS_OPTION(sbi).root_reserved_blocks;
+ else
+ block_limit = 0;
+ }
+ if (F2FS_OPTION(sbi).reserve_shrink_blocks > block_limit) {
+ F2FS_OPTION(sbi).reserve_shrink_blocks = block_limit;
+ f2fs_info(sbi, "Reduce reserved blocks for shrink = %u",
+ F2FS_OPTION(sbi).reserve_shrink_blocks);
+ }
+}
+
static inline void adjust_unusable_cap_perc(struct f2fs_sb_info *sbi)
{
if (!F2FS_OPTION(sbi).unusable_cap_perc)
@@ -941,6 +965,14 @@ static int f2fs_parse_param(struct fs_context *fc, struct fs_parameter *param)
F2FS_CTX_INFO(ctx).root_reserved_nodes = result.uint_32;
ctx->spec_mask |= F2FS_SPEC_reserve_node;
break;
+ case Opt_reserve_shrink:
+ if (result.uint_32)
+ ctx_set_opt(ctx, F2FS_MOUNT_RESERVE_SHRINK);
+ else
+ ctx_clear_opt(ctx, F2FS_MOUNT_RESERVE_SHRINK);
+ F2FS_CTX_INFO(ctx).reserve_shrink_blocks = result.uint_32;
+ ctx->spec_mask |= F2FS_SPEC_reserve_shrink;
+ break;
case Opt_resuid:
F2FS_CTX_INFO(ctx).s_resuid = result.uid;
ctx->spec_mask |= F2FS_SPEC_resuid;
@@ -1763,6 +1795,9 @@ static void f2fs_apply_options(struct fs_context *fc, struct super_block *sb)
if (ctx->spec_mask & F2FS_SPEC_reserve_node)
F2FS_OPTION(sbi).root_reserved_nodes =
F2FS_CTX_INFO(ctx).root_reserved_nodes;
+ if (ctx->spec_mask & F2FS_SPEC_reserve_shrink)
+ F2FS_OPTION(sbi).reserve_shrink_blocks =
+ F2FS_CTX_INFO(ctx).reserve_shrink_blocks;
if (ctx->spec_mask & F2FS_SPEC_resgid)
F2FS_OPTION(sbi).s_resgid = F2FS_CTX_INFO(ctx).s_resgid;
if (ctx->spec_mask & F2FS_SPEC_resuid)
@@ -2288,6 +2323,13 @@ static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
buf->f_bfree = user_block_count - valid_user_blocks(sbi) -
sbi->current_reserved_blocks;
+ if (test_opt(sbi, RESERVE_SHRINK)) {
+ if (buf->f_bfree > F2FS_OPTION(sbi).reserve_shrink_blocks)
+ buf->f_bfree -= F2FS_OPTION(sbi).reserve_shrink_blocks;
+ else
+ buf->f_bfree = 0;
+ }
+
if (unlikely(buf->f_bfree <= sbi->unusable_block_count))
buf->f_bfree = 0;
else
@@ -2512,6 +2554,9 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
F2FS_OPTION(sbi).s_resuid),
from_kgid_munged(&init_user_ns,
F2FS_OPTION(sbi).s_resgid));
+ if (test_opt(sbi, RESERVE_SHRINK))
+ seq_printf(seq, ",reserve_shrink=%u",
+ F2FS_OPTION(sbi).reserve_shrink_blocks);
#ifdef CONFIG_F2FS_FAULT_INJECTION
if (test_opt(sbi, FAULT_INJECTION)) {
seq_printf(seq, ",fault_injection=%u",
@@ -3093,6 +3138,7 @@ static int __f2fs_remount(struct fs_context *fc, struct super_block *sb)
adjust_pinned_area_boundary(sbi);
limit_reserve_root(sbi);
+ limit_reserve_shrink(sbi);
fc->sb_flags = (flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
sbi->umount_lock_holder = NULL;
@@ -5310,6 +5356,7 @@ static int f2fs_fill_super(struct super_block *sb, struct fs_context *fc)
sbi->current_reserved_blocks = 0;
sbi->alias_reserved_blocks = 0;
limit_reserve_root(sbi);
+ limit_reserve_shrink(sbi);
adjust_unusable_cap_perc(sbi);
f2fs_init_extent_cache_info(sbi);
diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index aaca9ed9b169..d61940d095b4 100644
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -591,9 +591,18 @@ static ssize_t __sbi_store(struct f2fs_attr *a,
}
#endif
if (a->struct_type == RESERVED_BLOCKS) {
+ unsigned long limit;
+
spin_lock(&sbi->stat_lock);
- if (t > (unsigned long)(sbi->user_block_count -
- F2FS_OPTION(sbi).root_reserved_blocks)) {
+ limit = sbi->user_block_count -
+ F2FS_OPTION(sbi).root_reserved_blocks;
+ if (test_opt(sbi, RESERVE_SHRINK)) {
+ if (limit > F2FS_OPTION(sbi).reserve_shrink_blocks)
+ limit -= F2FS_OPTION(sbi).reserve_shrink_blocks;
+ else
+ limit = 0;
+ }
+ if (t > limit) {
spin_unlock(&sbi->stat_lock);
return -EINVAL;
}
--
2.55.0.1007.g17ff1f9808-goog
^ permalink raw reply [flat|nested] 2+ messages in thread* Re: [PATCH] f2fs: introduce reserve_shrink mount option for filesystem shrinkage
2026-09-10 18:10 [PATCH] f2fs: introduce reserve_shrink mount option for filesystem shrinkage Daeho Jeong
@ 2026-09-11 8:10 ` kernel test robot
0 siblings, 0 replies; 2+ messages in thread
From: kernel test robot @ 2026-09-11 8:10 UTC (permalink / raw)
To: Daeho Jeong, linux-kernel, linux-f2fs-devel, kernel-team
Cc: llvm, oe-kbuild-all, Daeho Jeong
Hi Daeho,
kernel test robot noticed the following build warnings:
[auto build test WARNING on jaegeuk-f2fs/dev-test]
[also build test WARNING on jaegeuk-f2fs/dev linus/master v7.3-rc2 next-20260909]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Daeho-Jeong/f2fs-introduce-reserve_shrink-mount-option-for-filesystem-shrinkage/20260910-111056
base: https://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git dev-test
patch link: https://lore.kernel.org/r/20260910181057.640203-1-daeho43%40gmail.com
patch subject: [PATCH] f2fs: introduce reserve_shrink mount option for filesystem shrinkage
config: powerpc-randconfig-001-20260911 (https://download.01.org/0day-ci/archive/20260911/202609111633.uyRbsEUB-lkp@intel.com/config)
compiler: clang version 21.1.8 (https://github.com/llvm/llvm-project 2078da43e25a4623cab2d0d60decddf709aaea28)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260911/202609111633.uyRbsEUB-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/202609111633.uyRbsEUB-lkp@intel.com/
All warnings (new ones prefixed by >>):
In file included from fs/f2fs/debug.c:18:
>> fs/f2fs/f2fs.h:2663:6: warning: shift count >= width of type [-Wshift-count-overflow]
2663 | if (test_opt(sbi, RESERVE_SHRINK)) {
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:157:26: note: expanded from macro 'test_opt'
157 | (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))
| ^ ~~~~
1 warning generated.
--
In file included from fs/f2fs/gc.c:19:
>> fs/f2fs/f2fs.h:2663:6: warning: shift count >= width of type [-Wshift-count-overflow]
2663 | if (test_opt(sbi, RESERVE_SHRINK)) {
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:157:26: note: expanded from macro 'test_opt'
157 | (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/gc.c:2495:13: warning: shift count >= width of type [-Wshift-count-overflow]
2495 | } else if (test_opt(sbi, RESERVE_SHRINK)) {
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:157:26: note: expanded from macro 'test_opt'
157 | (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/gc.c:2498:3: warning: shift count >= width of type [-Wshift-count-overflow]
2498 | clear_opt(sbi, RESERVE_SHRINK);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:153:28: note: expanded from macro 'clear_opt'
153 | (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))
| ^ ~~~~
3 warnings generated.
--
In file included from fs/f2fs/super.c:34:
>> fs/f2fs/f2fs.h:2663:6: warning: shift count >= width of type [-Wshift-count-overflow]
2663 | if (test_opt(sbi, RESERVE_SHRINK)) {
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:157:26: note: expanded from macro 'test_opt'
157 | (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:548:7: warning: shift count >= width of type [-Wshift-count-overflow]
548 | if (!test_opt(sbi, RESERVE_SHRINK))
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:157:26: note: expanded from macro 'test_opt'
157 | (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:2326:6: warning: shift count >= width of type [-Wshift-count-overflow]
2326 | if (test_opt(sbi, RESERVE_SHRINK)) {
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:157:26: note: expanded from macro 'test_opt'
157 | (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:2557:6: warning: shift count >= width of type [-Wshift-count-overflow]
2557 | if (test_opt(sbi, RESERVE_SHRINK))
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:157:26: note: expanded from macro 'test_opt'
157 | (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))
| ^ ~~~~
4 warnings generated.
--
In file included from fs/f2fs/sysfs.c:17:
>> fs/f2fs/f2fs.h:2663:6: warning: shift count >= width of type [-Wshift-count-overflow]
2663 | if (test_opt(sbi, RESERVE_SHRINK)) {
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:157:26: note: expanded from macro 'test_opt'
157 | (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/sysfs.c:599:7: warning: shift count >= width of type [-Wshift-count-overflow]
599 | if (test_opt(sbi, RESERVE_SHRINK)) {
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/f2fs/f2fs.h:157:26: note: expanded from macro 'test_opt'
157 | (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.
Kconfig warnings: (for reference only)
WARNING: unmet direct dependencies detected for HOTPLUG_CPU
Depends on [n]: SMP [=y] && (PPC_PSERIES [=n] || PPC_PMAC [=n] || PPC_POWERNV [=n] || FSL_SOC_BOOKE [=n])
Selected by [y]:
- PM_SLEEP_SMP [=y] && SMP [=y] && (ARCH_SUSPEND_POSSIBLE [=n] || ARCH_HIBERNATION_POSSIBLE [=y]) && PM_SLEEP [=y]
vim +2663 fs/f2fs/f2fs.h
2650
2651 static inline unsigned int get_available_block_count(struct f2fs_sb_info *sbi,
2652 struct inode *inode, bool cap)
2653 {
2654 block_t avail_user_block_count;
2655
2656 avail_user_block_count = sbi->user_block_count -
2657 sbi->current_reserved_blocks -
2658 sbi->alias_reserved_blocks;
2659
2660 if (test_opt(sbi, RESERVE_ROOT) && !__allow_reserved_root(sbi, inode, cap))
2661 avail_user_block_count -= F2FS_OPTION(sbi).root_reserved_blocks;
2662
> 2663 if (test_opt(sbi, RESERVE_SHRINK)) {
2664 if (avail_user_block_count > F2FS_OPTION(sbi).reserve_shrink_blocks)
2665 avail_user_block_count -= F2FS_OPTION(sbi).reserve_shrink_blocks;
2666 else
2667 avail_user_block_count = 0;
2668 }
2669
2670 if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
2671 if (avail_user_block_count > sbi->unusable_block_count)
2672 avail_user_block_count -= sbi->unusable_block_count;
2673 else
2674 avail_user_block_count = 0;
2675 }
2676
2677 return avail_user_block_count;
2678 }
2679
--
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-09-11 8:12 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-09-10 18:10 [PATCH] f2fs: introduce reserve_shrink mount option for filesystem shrinkage Daeho Jeong
2026-09-11 8:10 ` 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
all inboxes | Powered by JetHome®