Re: [PATCH v4 2/2] f2fs: refresh pinned allocation boundary after resize

[Daeho Jeong]

On Thu, Oct 15, 2026 at 10:44 PM Wenjie Qi <qwjhust@xxxxxxxxx> wrote:
>
> Online shrink updates MAIN_SECS() but leaves resizable_tail_secno and
> pinned_area_max_secno unchanged. The pinned allocation limit can exceed
> the new main area when shrinking beyond the reserved tail.
>
> Consume the reserved tail by the number of removed sections, clamping
> it to zero, before refreshing the shared pinned allocation boundary.
> This preserves the boundary while shrinking within the reservation and
> limits it to the new main area otherwise, retaining the zoned limit.
>
> Save the old tail count and restore it before rolling back the geometry
> if the final checkpoint fails.
>
> Also bound pinned section allocation by the current MAIN_SECS(). Range
> evacuation temporarily reduces it before moving cursegs, while the
> cached pinned boundary still describes the old geometry. Otherwise, a
> pinned curseg can be reallocated into the range being removed.
>
> Fixes: c966d29e01bb ("f2fs: support resizable tail section and unify pinned allocation")
> Suggested-by: Daeho Jeong <daehojeong@xxxxxxxxxx>
> Signed-off-by: Wenjie Qi <qiwenjie@xxxxxxxxxx>
> ---
> Changes in v4 (since v3):
> - Bound pinned section allocation by the current MAIN_SECS().
>
> Changes in v3 (since v2):
> - Consume the tail reservation instead of keeping its old size.
> - Restore the saved tail before geometry and boundary rollback.
> - Document the remaining-reservation semantics.
>
> Changes in v2 (since v1):
> - Simplify tail validation and improve rejection diagnostics.
> - Validate before taking the mount write reference and recheck
>   after freeze for concurrent remounts.
>
> v1:
> - Refresh the pinned boundary on geometry changes and rollback.
> - Check the tail against the requested shrink geometry.
>
>  Documentation/filesystems/f2fs.rst |  3 ++-
>  fs/f2fs/gc.c                       |  6 +++++-
>  fs/f2fs/segment.c                  |  2 +-
>  fs/f2fs/segment.h                  | 11 +++++++++++
>  fs/f2fs/super.c                    | 15 ++-------------
>  5 files changed, 21 insertions(+), 16 deletions(-)
>
> diff --git a/Documentation/filesystems/f2fs.rst b/Documentation/filesystems/f2fs.rst
> index 771216f45207a..55798421f2c45 100644
> --- a/Documentation/filesystems/f2fs.rst
> +++ b/Documentation/filesystems/f2fs.rst
> @@ -421,7 +421,8 @@ resizable_tail_secno=%u  Control the number of sections at the tail of the
>                          (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.
> +                        used. Online shrink consumes this reservation, reducing
> +                        the value by the number of removed sections, down to zero.
>  ======================== ============================================================
>
>  Debugfs Entries
> diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
> index 926e6976bc22a..540769ad58acc 100644
> --- a/fs/f2fs/gc.c
> +++ b/fs/f2fs/gc.c
> @@ -2342,6 +2342,7 @@ static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)
>         SM_I(sbi)->segment_count = (int)SM_I(sbi)->segment_count + segs;
>         MAIN_SEGS(sbi) = (int)MAIN_SEGS(sbi) + segs;
>         MAIN_SECS(sbi) += secs;
> +       f2fs_adjust_pinned_area_boundary(sbi);
>         if (sbi->allocate_section_hint > MAIN_SECS(sbi))
>                 sbi->allocate_section_hint = MAIN_SECS(sbi);
>         FREE_I(sbi)->free_sections = (int)FREE_I(sbi)->free_sections + secs;
> @@ -2373,7 +2374,7 @@ int f2fs_resize_fs(struct file *filp, __u64 block_count)
>         struct f2fs_lock_context lc;
>         struct f2fs_lock_context glc;
>         struct f2fs_lock_context clc;
> -       unsigned int secs;
> +       unsigned int secs, old_tail;
>         int err = 0;
>         __u32 rem;
>
> @@ -2482,6 +2483,8 @@ int f2fs_resize_fs(struct file *filp, __u64 block_count)
>                 goto recover_out;
>         }
>
> +       old_tail = F2FS_OPTION(sbi).resizable_tail_secno;
> +       F2FS_OPTION(sbi).resizable_tail_secno -= min(old_tail, secs);
>         update_fs_metadata(sbi, -secs);
>         clear_sbi_flag(sbi, SBI_IS_RESIZEFS);
>         set_sbi_flag(sbi, SBI_IS_DIRTY);
> @@ -2489,6 +2492,7 @@ int f2fs_resize_fs(struct file *filp, __u64 block_count)
>         stat_inc_cp_call_count(sbi, TOTAL_CALL);
>         err = f2fs_write_checkpoint(sbi, &cpc);
>         if (err) {
> +               F2FS_OPTION(sbi).resizable_tail_secno = old_tail;
>                 update_fs_metadata(sbi, secs);
>                 update_sb_metadata(sbi, secs);
>                 f2fs_commit_super(sbi, false);
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index bf8d07fcce331..f6e1cb1c0b71d 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -2983,7 +2983,7 @@ static int get_new_segment(struct f2fs_sb_info *sbi,
>                 alloc_hint = MAIN_SECS(sbi);
>
>         if (pinning) {
> -               max_secno = sbi->pinned_area_max_secno;
> +               max_secno = min(sbi->pinned_area_max_secno, MAIN_SECS(sbi));
>                 hint = 0;
>         } else if (alloc_policy == ALLOCATE_FORWARD_FROM_HINT &&
>                 hint < alloc_hint) {
> diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
> index 526764ba31ae5..918bc4452ad09 100644
> --- a/fs/f2fs/segment.h
> +++ b/fs/f2fs/segment.h
> @@ -91,6 +91,17 @@ static inline void sanity_check_seg_type(struct f2fs_sb_info *sbi,
>  #define GET_ZONE_FROM_SEG(sbi, segno)                          \
>         GET_ZONE_FROM_SEC(sbi, GET_SEC_FROM_SEG(sbi, segno))
>
> +static inline void f2fs_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);
> +}
> +
>  #define GET_SUM_BLOCK(sbi, segno)      \
>         (SM_I(sbi)->ssa_blkaddr + (segno / (sbi)->sums_per_block))
>  #define GET_SUM_BLKOFF(sbi, segno) (segno % (sbi)->sums_per_block)
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index 773b12ea29c0c..f323d9705aebe 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -554,17 +554,6 @@ 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;
> @@ -3103,7 +3092,7 @@ static int __f2fs_remount(struct fs_context *fc, struct super_block *sb)
>         sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
>                 (test_opt(sbi, POSIX_ACL) ? SB_POSIXACL : 0);
>
> -       adjust_pinned_area_boundary(sbi);
> +       f2fs_adjust_pinned_area_boundary(sbi);
>         limit_reserve_root(sbi);
>         fc->sb_flags = (flags & ~SB_LAZYTIME) | (sb->s_flags & SB_LAZYTIME);
>
> @@ -5440,7 +5429,7 @@ static int f2fs_fill_super(struct super_block *sb, struct fs_context *fc)
>         /* get segno of first zoned block device */
>         sbi->first_seq_zone_segno = get_first_seq_zone_segno(sbi);
>
> -       adjust_pinned_area_boundary(sbi);
> +       f2fs_adjust_pinned_area_boundary(sbi);
>
>         sbi->reserved_pin_section = f2fs_sb_has_blkzoned(sbi) ?
>                         ZONED_PIN_SEC_REQUIRED_COUNT :
> --
> 2.43.0
>

Reviewed-by: Daeho Jeong <daehojeong@xxxxxxxxxx>

Thanks,