Re: [f2fs-dev] [PATCH v3 12/17] f2fs: handle partial truncate of large folio dirty subpages

[Daeho Jeong]

On Fri, Oct 9, 2026 at 9:31 AM Nanzhe Zhao via Linux-f2fs-devel
<linux-f2fs-devel@xxxxxxxxxxxxxxxxxxxxx> wrote:
>
> A large folio can be partial truncated and stays in folio mapping, we
> need to clear the subrange dirty bits and uptodate bits that the partial
> truncate covers. If this partial truncate happens to clear the last
> subrange dirty bits, then cancel the whole folio dirty state.
>
> Also add a guard in f2fs_write_single_data_folio() so a large folio
> subpage whose disk block was already truncated (NULL_ADDR) is skipped
>
> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xxxxxxxxxx>
> ---
>  fs/f2fs/data.c | 115 ++++++++++++++++++++++++++++++++++++++++++++++---
>  1 file changed, 109 insertions(+), 6 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 21c43019167a..138a77044e95 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -329,6 +329,27 @@ static void f2fs_read_end_io(struct bio *bio)
>         f2fs_verify_and_finish_bio(bio, intask);
>  }
>
> +static bool f2fs_ffs_has_dirty_subpage(struct folio *folio)
> +{
> +       struct f2fs_folio_state *ffs;
> +       unsigned long flags;
> +       unsigned int nr_subpages;
> +       bool dirty;
> +
> +       if (!f2fs_folio_has_ffs(folio))
> +               return false;
> +
> +       ffs = (struct f2fs_folio_state *)folio->private;
> +       nr_subpages = folio_nr_pages(folio);
> +
> +       spin_lock_irqsave(&ffs->state_lock, flags);
> +       dirty = find_next_bit(ffs->state, 2 * nr_subpages,
> +                               nr_subpages) < 2 * nr_subpages;
> +       spin_unlock_irqrestore(&ffs->state_lock, flags);
> +
> +       return dirty;
> +}
> +
>  static void f2fs_write_end_bio(struct bio *bio)
>  {
>         struct f2fs_sb_info *sbi = bio->bi_private;
> @@ -380,7 +401,8 @@ static void f2fs_write_end_bio(struct bio *bio)
>                         wake_up(&sbi->cp_wait);
>
>                 if (finished) {
> -                       folio_clear_f2fs_gcing(folio);
> +                       if (!f2fs_ffs_has_dirty_subpage(folio))
> +                               folio_clear_f2fs_gcing(folio);
>                         folio_end_writeback(folio);
>                 }
>         }
> @@ -2893,6 +2915,29 @@ static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
>                 folio_mark_uptodate(folio);
>  }
>
> +static void ffs_clear_subrange_uptodate(struct folio *folio,
> +                                       size_t offset, size_t len)
> +{
> +       struct f2fs_folio_state *ffs;
> +       unsigned int nr_subpages, start, end;
> +       unsigned long flags;
> +
> +       f2fs_bug_on(F2FS_F_SB(folio), offset + len > folio_size(folio));
> +
> +       if (!f2fs_folio_has_ffs(folio))
> +               return;
> +
> +       ffs = (struct f2fs_folio_state *)folio->private;
> +       nr_subpages = folio_nr_pages(folio);
> +       start = offset >> PAGE_SHIFT;
> +       end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
> +       end = min(end, nr_subpages);
> +
> +       spin_lock_irqsave(&ffs->state_lock, flags);
> +       bitmap_clear(ffs->state, start, end - start);
> +       spin_unlock_irqrestore(&ffs->state_lock, flags);
> +}
> +
>  bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
>  {
>         struct f2fs_folio_state *ffs;
> @@ -3771,12 +3816,35 @@ static int f2fs_write_folio_dirty_range(struct folio *folio, int *submitted,
>
>                 err = f2fs_get_dnode_of_data(&dn, data_idx, LOOKUP_NODE);
>
> +               /*
> +                * If a subpage of folio for a cow file is dirtied but not
> +                * reserve a cow block, fallback to original inode to lookup
> +                * block address
> +                */
> +               if (atomic_commit && (err == -ENOENT ||
> +                   (!err && dn.data_blkaddr == NULL_ADDR))) {
> +                       f2fs_put_dnode(&dn);
> +                       set_new_dnode(&dn, inode, NULL, NULL, 0);
> +                       err = f2fs_get_dnode_of_data(&dn, data_idx,
> +                                                    LOOKUP_NODE);
> +                       /* Original inode has no block, handled as truncated below */
> +                       if (err == -ENOENT)
> +                               err = 0;
> +               }
>                 if (err)
>                         goto block_done;

Hi Nanzhe,

For non-atomic files, -ENOENT from the first f2fs_get_dnode_of_data()
still comes here as an error, so f2fs_write_cache_folios() redirties
the rest of the folio and returns the error.
f2fs_write_single_data_page() does not fail the writeback on -ENOENT.

I asked the same on v2 05/14. Could non-atomic files also handle it
like NULL_ADDR (already truncated)? Something like:

if (err == -ENOENT) {
    ffs_clear_subrange_uptodate(folio,
        (unsigned long long)i << PAGE_SHIFT,
        PAGE_SIZE);
    err = 0;
    goto block_done;
}
if (err)
    goto block_done;

Thanks,
Daeho

>                 dn_held = true;
>
>                 fio.old_blkaddr = dn.data_blkaddr;
>
> +               /* This page is already truncated */
> +               if (fio.old_blkaddr == NULL_ADDR) {
> +                       ffs_clear_subrange_uptodate(folio,
> +                                       (unsigned long long)i << PAGE_SHIFT,
> +                                       PAGE_SIZE);
> +                       goto block_done;
> +               }
> +
>  got_it:
>                 if (__is_valid_data_blkaddr(fio.old_blkaddr) &&
>                     !f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr,
> @@ -4325,6 +4393,7 @@ static int f2fs_write_cache_folios(struct address_space *mapping,
>                 bool verity_in_progress;
>                 int folio_submitted = 0;
>                 bool bias_added = false;
> +               bool dirty;
>
>                 submitted = 0;
>                 next = true;
> @@ -4432,15 +4501,19 @@ static int f2fs_write_cache_folios(struct address_space *mapping,
>                  * partially written back), the folio must stay dirty so that
>                  * the remaining subranges are written back later.
>                  */
> -               if (f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
> -                                       (err ? pos : end_pos) - folio_pos(folio)))
> +               dirty = f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
> +                                       (err ? pos : end_pos) - folio_pos(folio));
> +               if (dirty)
>                         folio_redirty_for_writepage(wbc, folio);
>                 else if (!f2fs_folio_has_ffs(folio))
>                         inode_dec_dirty_pages(inode);
>
>                 if (bias_added) {
> -                       if (atomic_dec_and_test(&ffs->write_pages_pending))
> +                       if (atomic_dec_and_test(&ffs->write_pages_pending)) {
> +                               if (!dirty)
> +                                       folio_clear_f2fs_gcing(folio);
>                                 folio_end_writeback(folio);
> +                       }
>                 } else if (!folio_submitted && folio_test_writeback(folio)) {
>                         folio_end_writeback(folio);
>                 }
> @@ -5243,10 +5316,40 @@ void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length)
>         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
>
>         if (inode->i_ino >= F2FS_ROOT_INO(sbi) &&
> -                               (offset || length != folio_size(folio)))
> +                               (offset || length != folio_size(folio))) {
> +               size_t clear_start = round_up(offset, PAGE_SIZE);
> +               size_t clear_end = round_down(offset + length, PAGE_SIZE);
> +               size_t clear_length;
> +               bool dirty;
> +
> +               /*
> +                * If the truncated range falls within a single subpage, no
> +                * subpage state needs to be cleared.
> +                */
> +               if (clear_start >= clear_end || !f2fs_folio_has_ffs(folio))
> +                       return;
> +
> +               clear_length = clear_end - clear_start;
> +               dirty = f2fs_ffs_clear_subrange_dirty_and_test(folio,
> +                                               clear_start, clear_length);
> +               ffs_clear_subrange_uptodate(folio, clear_start, clear_length);
> +
> +               /*
> +                * If the truncated subrange happens to clear the remaining
> +                * dirty bitmap of the whole folio, cancel the folio-level
> +                * dirty state.
> +                */
> +               if (!dirty && folio_test_dirty(folio))
> +                       folio_cancel_dirty(folio);
> +               if (!dirty && !folio_test_writeback(folio))
> +                       folio_clear_f2fs_gcing(folio);
>                 return;
> +       }
>
> -       if (folio_test_dirty(folio)) {
> +       if (f2fs_folio_has_ffs(folio)) {
> +               f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
> +                                                       folio_size(folio));
> +       } else if (folio_test_dirty(folio)) {
>                 inode_dec_dirty_pages(inode);
>                 f2fs_remove_dirty_inode(inode);
>         }
> --
> 2.43.0
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@xxxxxxxxxxxxxxxxxxxxx
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel