[f2fs-dev] [PATCH v8 00/15] f2fs: support & optimize large folios for writable files

[Nanzhe Zhao <nzzhao.sigma@gmail.com>]

From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>

This series supports large folios for most readable/writable files
in buffered I/O paths, including normal files, block-layer encrypted
files, and atomic files except for inline-data files, compressed files,
and quota files.

It also extends f2fs_folio_state to coexist with f2fs page-private
flags and to handle large folio write path and partial truncate of
large folios correctly.  A valid large folio always carries a
f2fs_folio_state at its folio->private in the current implementation.

Benchmark details can be found in the RFC v2 cover letter:
https://lore.kernel.org/r/20260622160830.324455-1-zhaonanzhe@xiaomi.com

Changes in v8:
- 01/15: add a sanity check in f2fs_folio_has_ffs(): if a large folio
  carries non-pointer private data (PAGE_PRIVATE_NOT_POINTER), report
  it with f2fs_bug_on() and return false instead of casting the value
  to a struct f2fs_folio_state pointer.
- 03/15: cache sbi before dropping read_pages_pending, so
  f2fs_finish_read_bio() no longer uses F2FS_F_SB(folio) after a sync
  reader has been woken up and may have released the folio.
- 05/15: clear the dirty bits of the whole folio on success, otherwise
  post-EOF subpages (e.g. fill_zero() with FALLOC_FL_KEEP_SIZE, or a
  block migration beyond EOF) keep the folio redirtied forever;
  - recheck cp_error after f2fs_balance_fs() or the trylock_op() backoff
    dropped the folio lock, and drop the folio instead of writing on a
    filesystem which can no longer checkpoint;
  - reset the per-folio submitted counter for each dirty range.
- 07/15: since the whole valid range below will be marked dirty, a large
  folio whose subpage was invalidated by a racing collapse/insert/punch
  hole is not usable; after folio_lock(), unlock it and return
  VM_FAULT_NOPAGE (-EFAULT) so the faulting access is retried instead
  of dirtying the stale subpages.
- 08/15: keep PAGE_PRIVATE_GCING on a failed GC write which redirties
  the folio, and clear it only when no dirty subpage is left; mark the
  target subpage dirty in f2fs_defragment_range() and
  f2fs_migrate_blocks(); and submit the cached bio before unlocking a
  large folio in move_data_page() to avoid an AB-BA deadlock with
  WB_SYNC_ALL.
- 15/15: make redirty_blocks() large-folio aware: allocate the
  f2fs_folio_state and mark the cluster range dirty.  This is mainly
  for the chattr +c (FS_IOC_SETFLAGS) case, where the compression flag
  is set on an inode that keeps using large folios until it is evicted;
  since F2FS_IOC_COMPRESS_FILE is already rejected for large-folio
  mappings, this hint state is only reachable through chattr +c.
  Without this, F2FS_IOC_DECOMPRESS_FILE and
  F2FS_IOC_RELEASE_COMPRESS_BLOCKS would find no dirty range and
  silently skip the rewrite.

Many thanks to Chao for the detailed v7 review; several of the fixes
above are folded in from his suggestions.

Changes in v7:
- 01/15: realloc the f2fs_folio_state in f2fs_get_lock_data_folio() if
  it was released while the folio was unlocked.
- 04/15: on an atomic buffered write repeat if folio was unlocked, check the 
COW block before reserving it again, so inc_atomic_write_cnt() is not called twice.
- 08/15: clear PAGE_PRIVATE_GCING if large folio has no dirty sub pages
 when f2fs_trylock_op() fails before any write is submitted in f2fs_do_write_data_page().

No other functional changes.

Changes in v6:
- Rebased onto the f2fs dev branch (fd106ada4dee).
- v5 12/16 ("f2fs: wait for folio writeback before ffs_detach_free")
  is dropped, because the lkp warning reported by [1] was caused by a
  write_pages_pending leak on the GC truncate path.

- Improve large-folio support in the f2fs_do_write_data_page() path used
  by GC:
  - 05/15: use __folio_start_writeback(folio, folio_test_dirty(folio))
    in both the IPU and OPU paths, so a single-subpage GC write does not
    clear PAGECACHE_TAG_TOWRITE while other subpages are still dirty [3].
  - 05/15: add f2fs_ffs_put_write_pending() as the common writeback
    completion helper; do_write_block() only ends writeback for order-0
    folios.
  - 08/15: move the write_pages_pending increment from move_data_page()
    into f2fs_do_write_data_page(), take it only after
    __folio_start_writeback(), and drop it on every error path.
    move_data_page() no longer adjusts write_pages_pending or clears
    gcing on error [1].

- 02/15: compute bio_offset/bio_len against the folio actually added to
  the bio [5].

- 05/15, 06/15: fix the order-0 dirty accounting leak in the cp_error
  path [2].

- 10/15: allocate ffs before f2fs_truncate_read_extent() [4].

- 11/15: move the existing truncated-page handling into
  f2fs_clear_truncated_page_state() and reuse it for the subpage-aware
  large-folio writeback path, including the -ENOENT/NULL_ADDR case [2].

Link to v5: [6]

Many thanks to Chao, Daeho and Jaegeuk for the reviews, and to the
kernel test robot for the report.

[1] https://lore.kernel.org/oe-lkp/202610081027.b13dcf10-lkp@intel.com
[2] https://lore.kernel.org/r/6be679d1-d8ab-41b3-9975-1f1bcd552579@kernel.org
[3] https://lore.kernel.org/r/fc101bc7-6ece-4a30-9e19-9b32376489a8@kernel.org
[4] https://lore.kernel.org/r/36220ef3-5b00-4aa1-ad11-60b10857a886@kernel.org
[5] https://lore.kernel.org/r/atA8dsZ35E6wTMD6@google.com
[6] https://lore.kernel.org/r/20261014064445.2835813-1-zhaonanzhe@xiaomi.com/

Nanzhe Zhao (15):
  f2fs: extend folio state for large folio write path
  f2fs: carry subpage offset and count in write IO
  f2fs: support regular file buffered writes on large folios
  f2fs: support atomic file large folios buffered write
  f2fs: support large folio writeback
  f2fs: account large folio dirty data at block granularity
  f2fs: prepare mmap write faults for large folios
  f2fs: make GC migration large-folio aware
  f2fs: optimize small block size large folio read
  f2fs: support partial uptodate large folio read
  f2fs: handle partial truncate of large folio dirty subpages
  f2fs: fix zeroing paths for large folios
  f2fs: handle block cloning within the same large folio
  f2fs: allow large folio support to writeable files
  f2fs: make compressed files compatible with large folio

 Documentation/filesystems/f2fs.rst |   10 +
 fs/f2fs/checkpoint.c               |   40 +-
 fs/f2fs/compress.c                 |    7 +-
 fs/f2fs/data.c                     | 1550 +++++++++++++++++++++++++---
 fs/f2fs/dir.c                      |    2 +-
 fs/f2fs/f2fs.h                     |  182 +++-
 fs/f2fs/file.c                     |  269 +++--
 fs/f2fs/gc.c                       |   51 +-
 fs/f2fs/inline.c                   |    3 +-
 fs/f2fs/inode.c                    |    4 +-
 fs/f2fs/namei.c                    |    1 +
 fs/f2fs/node.c                     |    2 +-
 fs/f2fs/segment.c                  |   13 +-
 13 files changed, 1869 insertions(+), 265 deletions(-)

-- 
2.43.0



_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel