f2fs: support resizable tail section and unify pinned allocation

Currently, zoned block devices restrict pinned file allocations to
conventional zones at the beginning of the storage (before
first_seq_zone_segno), triggering range GC when conventional space is
exhausted.

On regular block devices, when preparing for future online filesystem
resizing (e.g. partition shrinking), pinned files must not be allocated
in the tail area that will be truncated, as pinned files cannot be
relocated by GC. Specifying the resizable tail area size (in sections)
allows uniform mount configuration across devices of different storage
capacities.

To support this, introduce a unified `pinned_area_max_secno` boundary
abstraction in `f2fs_sb_info`:
1. Add `-o resizable_tail_secno=%u` mount option to specify the number
   of sections at the tail of the filesystem reserved for resizing.
2. In `f2fs_fill_super()`, initialize `sbi->pinned_area_max_secno` as:
   min(MAIN_SECS(sbi) - resizable_tail_sec, zoned_max_sec).
3. In `get_new_segment()`, restrict segment allocation for pinned files
   (`pinning == true`) to `0 .. sbi->pinned_area_max_secno - 1`. If no
   free section is available in the pinned area, return -EAGAIN.
4. In `f2fs_allocate_pinning_section()`, unify the range GC trigger to
   run `f2fs_gc_range()` up to `sbi->pinned_area_max_secno` whenever
   `sbi->pinned_area_max_secno < MAIN_SECS(sbi)` and allocation
   returns -EAGAIN.
5. Expose `/sys/fs/f2fs/<dev>/pinned_area_max_secno` as a read-only
   sysfs node.

Signed-off-by: Daeho Jeong <daehojeong@google.com>
Signed-off-by: Sunmin Jeong <s_min.jeong@samsung.com>
Reviewed-by: Wenjie Qi <qiwenjie@xiaomi.com>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
index 85194e4c7f018b99f18b59bb5b32e2fed1a5d204..0cebc89799dd17ee59c21ecee248156449f2c0e3 100644 (file)
--- a/Documentation/ABI/testing/sysfs-fs-f2fs
+++ b/Documentation/ABI/testing/sysfs-fs-f2fs
@@ -1013,3 +1013,10 @@ Description:     Every time a write operation completes f2fs_write_end_io() is
                the maximum size of a write bio that is completed in atomic
                (atc) context. The default value for this attribute is UINT_MAX
                which means that this functionality is disabled by default.
+
+What:          /sys/fs/f2fs/<disk>/pinned_area_max_secno
+Date:          August 2026
+Contact:       "Daeho Jeong" <daehojeong@google.com>
+Description:   This is a read-only entry to show the upper bound section number
+               for pinned files. Pinned files will only be allocated within
+               sections 0 to pinned_area_max_secno - 1.

diff --git a/Documentation/filesystems/f2fs.rst b/Documentation/filesystems/f2fs.rst
index 1a5fd4afe60902710efb80bc00c9bb2f16ed8e31..a3c3b6948734372a3f3b4b473f65975fe32ffda8 100644 (file)
--- a/Documentation/filesystems/f2fs.rst
+++ b/Documentation/filesystems/f2fs.rst
@@ -417,7 +417,13 @@ lookup_mode=%s              Control the directory lookup behavior for casefolded
                             auto               F2FS determines the mode based on the
                                                on-disk `SB_ENC_NO_COMPAT_FALLBACK_FL`
                                                flag.
-                            ================== ========================================
+resizable_tail_secno=%u  Control the number of sections at the tail of the
+                        filesystem reserved for online resizing. Pinned files
+                        will only be allocated within sections 0 to
+                        (MAIN_SECS - resizable_tail_secno) - 1. If set to 0
+                        (default), there is no tail restriction unless running
+                        on a zoned block device where conventional zones are
+                        used.
 ======================== ============================================================
 
 Debugfs Entries

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index b0a9c14de595517180c095ff3215d2f6c814ae1f..16720f1f0a9ca9c2f6e89d2df08a58e2f506b8d6 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -255,6 +255,7 @@ struct f2fs_mount_info {
        block_t unusable_cap;           /* Amount of space allowed to be
                                         * unusable when disabling checkpoint
                                         */
+       unsigned int resizable_tail_secno;      /* number of resizable tail sections */
 
        /* For compression */
        unsigned char compress_algorithm;       /* algorithm type */
@@ -2005,6 +2006,7 @@ struct f2fs_sb_info {
        spinlock_t dev_lock;                    /* protect dirty_device */
        bool aligned_blksize;                   /* all devices has the same logical blksize */
        unsigned int first_seq_zone_segno;      /* first segno in sequential zone */
+       unsigned int pinned_area_max_secno;     /* upper bound section for pinned files */
        unsigned int bggc_io_aware;             /* For adjust the BG_GC priority when pending IO */
        unsigned int allocate_section_hint;     /* the boundary position between devices */
        unsigned int allocate_section_policy;   /* determine the section writing priority */

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 56decf9c691c45ff80106241a3711ac8f08dabad..1e7e745be71d4b48936f1511abd48b657388c4a9 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -2877,6 +2877,7 @@ static int get_new_segment(struct f2fs_sb_info *sbi,
        unsigned int old_zoneno = GET_ZONE_FROM_SEG(sbi, *newseg);
        unsigned int alloc_policy = sbi->allocate_section_policy;
        unsigned int alloc_hint = sbi->allocate_section_hint;
+       unsigned int max_secno = MAIN_SECS(sbi);
        bool init = true;
        bool looped = false;
        int i, devi;
@@ -2908,7 +2909,7 @@ static int get_new_segment(struct f2fs_sb_info *sbi,
         */
        if (f2fs_sb_has_blkzoned(sbi)) {
                /* Prioritize writing to conventional zones */
-               if (sbi->blkzone_alloc_policy == BLKZONE_ALLOC_PRIOR_CONV || pinning)
+               if (sbi->blkzone_alloc_policy == BLKZONE_ALLOC_PRIOR_CONV)
                        segno = 0;
                else
                        segno = max(sbi->first_seq_zone_segno, *newseg);
@@ -2924,19 +2925,24 @@ static int get_new_segment(struct f2fs_sb_info *sbi,
                alloc_hint > MAIN_SECS(sbi))
                alloc_hint = MAIN_SECS(sbi);
 
-       if (alloc_policy == ALLOCATE_FORWARD_FROM_HINT &&
-               hint < alloc_hint)
+       if (pinning) {
+               max_secno = sbi->pinned_area_max_secno;
+               hint = 0;
+       } else if (alloc_policy == ALLOCATE_FORWARD_FROM_HINT &&
+               hint < alloc_hint) {
                hint = alloc_hint;
-       else if (alloc_policy == ALLOCATE_FORWARD_WITHIN_HINT &&
-                       hint >= alloc_hint)
+       } else if (alloc_policy == ALLOCATE_FORWARD_WITHIN_HINT &&
+                       hint >= alloc_hint) {
                hint = 0;
+       }
 
 find_other_zone:
-       secno = find_next_zero_bit(free_i->free_secmap, MAIN_SECS(sbi), hint);
+       secno = find_next_zero_bit(free_i->free_secmap, max_secno, hint);
 
-       if (secno >= MAIN_SECS(sbi)) {
+       if (secno >= max_secno) {
                if (looped) {
-                       ret = -ENOSPC;
+                       ret = (pinning && has_unpinned_area(sbi)) ?
+                                       -EAGAIN : -ENOSPC;
                        f2fs_bug_on(sbi, !pinning);
                        goto out_unlock;
                }
@@ -3001,12 +3007,6 @@ got_it:
                goto out_unlock;
        }
 
-       /* no free section in conventional device or conventional zone */
-       if (new_sec && pinning &&
-               f2fs_is_sequential_zone_area(sbi, START_BLOCK(sbi, segno))) {
-               ret = -EAGAIN;
-               goto out_unlock;
-       }
        __set_inuse(sbi, segno);
        *newseg = segno;
 out_unlock:
@@ -3472,8 +3472,9 @@ retry:
        err = f2fs_allocate_new_section(sbi, CURSEG_COLD_DATA_PINNED, false);
        f2fs_unlock_op(sbi, &lc);
 
-       if (f2fs_sb_has_blkzoned(sbi) && err == -EAGAIN && gc_required) {
-               err = f2fs_gc_range(sbi, 0, sbi->first_seq_zone_segno - 1,
+       if (has_unpinned_area(sbi) && err == -EAGAIN && gc_required) {
+               err = f2fs_gc_range(sbi, 0,
+                               sbi->pinned_area_max_secno * SEGS_PER_SEC(sbi) - 1,
                                true, ZONED_PIN_SEC_REQUIRED_COUNT, true);
                if (err)
                        return err;

diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index db1079169a23ea74cbd05f58fc7210f491b46c62..5949aa5200ac160e2841944ee40169f6c6def3ea 100644 (file)
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -43,6 +43,7 @@ static inline void sanity_check_seg_type(struct f2fs_sb_info *sbi,
 
 #define MAIN_SEGS(sbi) (SM_I(sbi)->main_segments)
 #define MAIN_SECS(sbi) ((sbi)->total_sections)
+#define has_unpinned_area(sbi) ((sbi)->pinned_area_max_secno < MAIN_SECS(sbi))
 
 #define TOTAL_SEGS(sbi)                                                        \
        (SM_I(sbi) ? SM_I(sbi)->segment_count :                                 \

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 3bdb0f891c359a3995506dd562a75d49fd04b45e..253a579e9d5b63dcd39e3b55f3a38aa5f20d2070 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -235,6 +235,7 @@ enum {
        Opt_jqfmt,
        Opt_checkpoint,
        Opt_lookup_mode,
+       Opt_resizable_tail_secno,
        Opt_err,
 };
 
@@ -366,6 +367,7 @@ static const struct fs_parameter_spec f2fs_param_specs[] = {
        fsparam_flag("age_extent_cache", Opt_age_extent_cache),
        fsparam_enum("errors", Opt_errors, f2fs_param_errors),
        fsparam_enum("lookup_mode", Opt_lookup_mode, f2fs_param_lookup_mode),
+       fsparam_u32("resizable_tail_secno", Opt_resizable_tail_secno),
        {}
 };
 
@@ -404,6 +406,7 @@ static match_table_t f2fs_checkpoint_tokens = {
 #define F2FS_SPEC_errors                       (1 << 23)
 #define F2FS_SPEC_lookup_mode                  (1 << 24)
 #define F2FS_SPEC_reserve_node                 (1 << 25)
+#define F2FS_SPEC_resizable_tail_secno         (1 << 26)
 
 struct f2fs_fs_context {
        struct f2fs_mount_info info;
@@ -551,6 +554,17 @@ static inline void adjust_unusable_cap_perc(struct f2fs_sb_info *sbi)
                        F2FS_OPTION(sbi).unusable_cap_perc);
 }
 
+static inline void adjust_pinned_area_boundary(struct f2fs_sb_info *sbi)
+{
+       sbi->pinned_area_max_secno = MAIN_SECS(sbi);
+       if (f2fs_sb_has_blkzoned(sbi) && sbi->first_seq_zone_segno != NULL_SEGNO)
+               sbi->pinned_area_max_secno = min(sbi->pinned_area_max_secno,
+                               GET_SEC_FROM_SEG(sbi, sbi->first_seq_zone_segno));
+       if (F2FS_OPTION(sbi).resizable_tail_secno)
+               sbi->pinned_area_max_secno = min(sbi->pinned_area_max_secno,
+                               MAIN_SECS(sbi) - F2FS_OPTION(sbi).resizable_tail_secno);
+}
+
 static void init_once(void *foo)
 {
        struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;
@@ -1235,6 +1249,10 @@ static int f2fs_parse_param(struct fs_context *fc, struct fs_parameter *param)
                F2FS_CTX_INFO(ctx).lookup_mode = result.uint_32;
                ctx->spec_mask |= F2FS_SPEC_lookup_mode;
                break;
+       case Opt_resizable_tail_secno:
+               F2FS_CTX_INFO(ctx).resizable_tail_secno = result.uint_32;
+               ctx->spec_mask |= F2FS_SPEC_resizable_tail_secno;
+               break;
        }
        return 0;
 }
@@ -1763,6 +1781,9 @@ static void f2fs_apply_options(struct fs_context *fc, struct super_block *sb)
                F2FS_OPTION(sbi).errors = F2FS_CTX_INFO(ctx).errors;
        if (ctx->spec_mask & F2FS_SPEC_lookup_mode)
                F2FS_OPTION(sbi).lookup_mode = F2FS_CTX_INFO(ctx).lookup_mode;
+       if (ctx->spec_mask & F2FS_SPEC_resizable_tail_secno)
+               F2FS_OPTION(sbi).resizable_tail_secno =
+                                       F2FS_CTX_INFO(ctx).resizable_tail_secno;
 
        f2fs_apply_compression(fc, sb);
        f2fs_apply_test_dummy_encryption(fc, sb);
@@ -1771,6 +1792,13 @@ static void f2fs_apply_options(struct fs_context *fc, struct super_block *sb)
 
 static int f2fs_sanity_check_options(struct f2fs_sb_info *sbi, bool remount)
 {
+       unsigned int total_sections = le32_to_cpu(sbi->raw_super->section_count);
+
+       if (F2FS_OPTION(sbi).resizable_tail_secno >= total_sections) {
+               f2fs_err(sbi, "Option resizable_tail_secno is larger than or equal to total sections (%u >= %u)",
+                               F2FS_OPTION(sbi).resizable_tail_secno, total_sections);
+               return -EINVAL;
+       }
        if (f2fs_sb_has_device_alias(sbi) &&
            !test_opt(sbi, READ_EXTENT_CACHE)) {
                f2fs_err(sbi, "device aliasing requires extent cache");
@@ -2544,6 +2572,10 @@ 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 (F2FS_OPTION(sbi).resizable_tail_secno)
+               seq_printf(seq, ",resizable_tail_secno=%u",
+                               F2FS_OPTION(sbi).resizable_tail_secno);
+
        return 0;
 }
 
@@ -2586,6 +2618,7 @@ static void default_options(struct f2fs_sb_info *sbi, bool remount)
        F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON;
        F2FS_OPTION(sbi).memory_mode = MEMORY_MODE_NORMAL;
        F2FS_OPTION(sbi).errors = MOUNT_ERRORS_CONTINUE;
+       F2FS_OPTION(sbi).resizable_tail_secno = 0;
 
        set_opt(sbi, INLINE_XATTR);
        set_opt(sbi, INLINE_DATA);
@@ -3045,6 +3078,7 @@ skip:
        sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
                (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
 
+       adjust_pinned_area_boundary(sbi);
        limit_reserve_root(sbi);
        fc->sb_flags = (flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
 
@@ -5287,6 +5321,8 @@ try_onemore:
        /* get segno of first zoned block device */
        sbi->first_seq_zone_segno = get_first_seq_zone_segno(sbi);
 
+       adjust_pinned_area_boundary(sbi);
+
        sbi->reserved_pin_section = f2fs_sb_has_blkzoned(sbi) ?
                        ZONED_PIN_SEC_REQUIRED_COUNT :
                        GET_SEC_FROM_SEG(sbi, overprovision_segments(sbi));

diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index 3201e2185feabc8940b8fea3c5d03d227ad03839..811e350a14302008a8122f61e0f2abfcee29e65b 100644 (file)
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -1313,6 +1313,7 @@ F2FS_SBI_GENERAL_RW_ATTR(blkzone_alloc_policy);
 #endif
 F2FS_SBI_GENERAL_RW_ATTR(carve_out);
 F2FS_SBI_GENERAL_RW_ATTR(reserved_pin_section);
+F2FS_SBI_GENERAL_RO_ATTR(pinned_area_max_secno);
 F2FS_SBI_GENERAL_RW_ATTR(bggc_io_aware);
 F2FS_SBI_GENERAL_RW_ATTR(max_lock_elapsed_time);
 F2FS_SBI_GENERAL_RW_ATTR(lock_duration_priority);
@@ -1525,6 +1526,7 @@ static struct attribute *f2fs_attrs[] = {
        ATTR_LIST(max_read_extent_count),
        ATTR_LIST(carve_out),
        ATTR_LIST(reserved_pin_section),
+       ATTR_LIST(pinned_area_max_secno),
        ATTR_LIST(allocate_section_hint),
        ATTR_LIST(allocate_section_policy),
        ATTR_LIST(max_lock_elapsed_time),