* [PATCH v7 00/15] f2fs: support & optimize large folios for writable files
@ 2026-10-26 3:37 Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 01/15] f2fs: extend folio state for large folio write path Nanzhe Zhao
` (15 more replies)
0 siblings, 16 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
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 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 | 1521 +++++++++++++++++++++++++---
fs/f2fs/dir.c | 2 +-
fs/f2fs/f2fs.h | 170 +++-
fs/f2fs/file.c | 226 +++--
fs/f2fs/gc.c | 32 +-
fs/f2fs/inline.c | 9 +-
fs/f2fs/inode.c | 4 +-
fs/f2fs/namei.c | 1 +
fs/f2fs/node.c | 2 +-
fs/f2fs/segment.c | 13 +-
13 files changed, 1774 insertions(+), 263 deletions(-)
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 01/15] f2fs: extend folio state for large folio write path
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 02/15] f2fs: carry subpage offset and count in write IO Nanzhe Zhao
` (14 subsequent siblings)
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
Large folio write path needs a subpage status bitmap and write
pages pending counter, while keeping compatible with f2fs private
flags.
Move struct f2fs_folio_state to f2fs.h, add private_flags and
subpage state bitmap, and change PAGE_PRIVATE functions to be
compatible with f2fs_folio_state. Allocate f2fs_folio_state via kzalloc
instead of kmem_cache, since the state size depends on the folio order.
Note: Now if a path wants to use f2fs_folio_state, it must call
`folio_has_ffs` instead of `folio_test_large`` to make check.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 72 ++++++++++++++++++++++++++++++++------------------
fs/f2fs/f2fs.h | 70 +++++++++++++++++++++++++++++++++++-------------
2 files changed, 99 insertions(+), 43 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index a8d39add5cbe..603a7a570f2a 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -32,15 +32,9 @@
static struct kmem_cache *bio_post_read_ctx_cache;
static struct kmem_cache *bio_entry_slab;
-static struct kmem_cache *ffs_entry_slab;
static mempool_t *bio_post_read_ctx_pool;
static struct bio_set f2fs_bioset;
-struct f2fs_folio_state {
- spinlock_t state_lock;
- unsigned int read_pages_pending;
-};
-
#define F2FS_BIO_POOL_SIZE NR_CURSEG_TYPE
int __init f2fs_init_bioset(void)
@@ -1656,7 +1650,25 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
/* wait for read completion */
folio_lock(folio);
- if (unlikely(folio->mapping != mapping || !folio_test_uptodate(folio))) {
+
+ if (unlikely(folio->mapping != mapping)) {
+ f2fs_folio_put(folio, true);
+ return ERR_PTR(-EIO);
+ }
+
+ /*
+ * ffs can be released while the folio was unlocked above. Rebuild it
+ * for a fully uptodate folio; a partially uptodate one cannot be
+ * rebuilt and will fail the uptodate check below.
+ */
+ if (folio_test_large(folio) && !f2fs_folio_has_ffs(folio)) {
+ if (!f2fs_ffs_find_or_alloc(folio)) {
+ f2fs_folio_put(folio, true);
+ return ERR_PTR(-ENOMEM);
+ }
+ }
+
+ if (unlikely(!folio_test_uptodate(folio))) {
f2fs_folio_put(folio, true);
return ERR_PTR(-EIO);
}
@@ -2717,17 +2729,31 @@ int f2fs_read_multi_pages(struct compress_ctx *cc, struct bio **bio_ret,
}
#endif
-static struct f2fs_folio_state *ffs_find_or_alloc(struct folio *folio)
+struct f2fs_folio_state *f2fs_ffs_find_or_alloc(struct folio *folio)
{
- struct f2fs_folio_state *ffs = folio->private;
+ struct f2fs_folio_state *ffs;
+ unsigned int nr_subpages = folio_nr_pages(folio);
+ unsigned long private = (unsigned long)folio->private;
- if (ffs)
- return ffs;
+ f2fs_bug_on(F2FS_F_SB(folio), !folio_test_large(folio));
+ f2fs_bug_on(F2FS_F_SB(folio),
+ test_bit(PAGE_PRIVATE_NOT_POINTER, &private));
- ffs = f2fs_kmem_cache_alloc(ffs_entry_slab,
- GFP_NOIO | __GFP_ZERO, true, NULL);
+ if (f2fs_folio_has_ffs(folio))
+ return (struct f2fs_folio_state *)folio->private;
+
+ ffs = f2fs_kmalloc(F2FS_F_SB(folio),
+ struct_size(ffs, state, BITS_TO_LONGS(2 * nr_subpages)),
+ GFP_NOFS | __GFP_ZERO);
+ if (!ffs)
+ return NULL;
spin_lock_init(&ffs->state_lock);
+ if (folio_test_uptodate(folio))
+ bitmap_set(ffs->state, 0, nr_subpages);
+ if (folio_test_dirty(folio))
+ bitmap_set(ffs->state, nr_subpages, nr_subpages);
+
folio_attach_private(folio, ffs);
return ffs;
}
@@ -2736,7 +2762,7 @@ static void ffs_detach_free(struct folio *folio)
{
struct f2fs_folio_state *ffs;
- if (!folio_test_large(folio)) {
+ if (!f2fs_folio_has_ffs(folio)) {
folio_detach_private(folio);
return;
}
@@ -2746,7 +2772,8 @@ static void ffs_detach_free(struct folio *folio)
return;
WARN_ON_ONCE(ffs->read_pages_pending != 0);
- kmem_cache_free(ffs_entry_slab, ffs);
+ WARN_ON_ONCE(atomic_read(&ffs->write_pages_pending));
+ kfree(ffs);
}
static int f2fs_read_data_large_folio(struct inode *inode,
@@ -2835,7 +2862,11 @@ static int f2fs_read_data_large_folio(struct inode *inode,
* to prevent from premature folio_end_read() call on folio
*/
if (folio_test_large(folio)) {
- ffs = ffs_find_or_alloc(folio);
+ ffs = f2fs_ffs_find_or_alloc(folio);
+ if (!ffs) {
+ ret = -ENOMEM;
+ goto err_out;
+ }
/* set the bitmap to wait */
spin_lock_irq(&ffs->state_lock);
@@ -4750,21 +4781,12 @@ int __init f2fs_init_bio_entry_cache(void)
if (!bio_entry_slab)
return -ENOMEM;
- ffs_entry_slab = f2fs_kmem_cache_create("f2fs_ffs_slab",
- sizeof(struct f2fs_folio_state));
-
- if (!ffs_entry_slab) {
- kmem_cache_destroy(bio_entry_slab);
- return -ENOMEM;
- }
-
return 0;
}
void f2fs_destroy_bio_entry_cache(void)
{
kmem_cache_destroy(bio_entry_slab);
- kmem_cache_destroy(ffs_entry_slab);
}
static int f2fs_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index aedba8b79baa..abb0c0caed91 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1621,6 +1621,18 @@ static inline void f2fs_clear_bit(unsigned int nr, char *addr);
* Layout B: lowest bit should be 0
* page.private is a wrapped pointer.
*/
+
+struct f2fs_folio_state {
+ spinlock_t state_lock;
+ unsigned int read_pages_pending;
+ atomic_t write_pages_pending;
+ unsigned long private_flags;
+ /* state[0..nr_subpages - 1] tracks uptodate subpages.
+ * state[nr_subpages..2 * nr_subpages - 1] tracks dirty subpages.
+ */
+ unsigned long state[];
+};
+
enum {
PAGE_PRIVATE_NOT_POINTER, /* private contains non-pointer data */
PAGE_PRIVATE_ONGOING_MIGRATION, /* data page which is on-going migrating */
@@ -1629,6 +1641,13 @@ enum {
PAGE_PRIVATE_MAX
};
+static inline bool f2fs_folio_has_ffs(const struct folio *folio)
+{
+ unsigned long private = (unsigned long)folio->private;
+
+ return folio_test_large(folio) && private;
+}
+
/* For compression */
enum compress_algorithm_type {
COMPRESS_LZO,
@@ -2759,13 +2778,35 @@ static inline int inc_valid_block_count(struct f2fs_sb_info *sbi,
return -ENOSPC;
}
+static inline unsigned long f2fs_folio_get_private_flags(const struct folio *folio)
+{
+ unsigned long private = (unsigned long)folio->private;
+
+ if (f2fs_folio_has_ffs(folio)) {
+ struct f2fs_folio_state *ffs = (struct f2fs_folio_state *)private;
+
+ return READ_ONCE(ffs->private_flags);
+ }
+
+ if (test_bit(PAGE_PRIVATE_NOT_POINTER, &private))
+ return private;
+
+ return 0;
+}
+
+static inline unsigned long *f2fs_folio_flags_addr(struct folio *folio)
+{
+ if (f2fs_folio_has_ffs(folio))
+ return &((struct f2fs_folio_state *)folio->private)->private_flags;
+
+ return (unsigned long *)&folio->private;
+}
+
#define PAGE_PRIVATE_GET_FUNC(name, flagname) \
static inline bool folio_test_f2fs_##name(const struct folio *folio) \
{ \
- unsigned long priv = (unsigned long)folio->private; \
- unsigned long v = (1UL << PAGE_PRIVATE_NOT_POINTER) | \
- (1UL << PAGE_PRIVATE_##flagname); \
- return (priv & v) == v; \
+ return f2fs_folio_get_private_flags(folio) & \
+ (1UL << PAGE_PRIVATE_##flagname); \
} \
static inline bool page_private_##name(struct page *page) \
{ \
@@ -2777,14 +2818,10 @@ static inline bool page_private_##name(struct page *page) \
#define PAGE_PRIVATE_SET_FUNC(name, flagname) \
static inline void folio_set_f2fs_##name(struct folio *folio) \
{ \
- unsigned long v = (1UL << PAGE_PRIVATE_NOT_POINTER) | \
- (1UL << PAGE_PRIVATE_##flagname); \
if (!folio->private) \
- folio_attach_private(folio, (void *)v); \
- else { \
- v |= (unsigned long)folio->private; \
- folio->private = (void *)v; \
- } \
+ folio_attach_private(folio, \
+ (void *)BIT(PAGE_PRIVATE_NOT_POINTER)); \
+ set_bit(PAGE_PRIVATE_##flagname, f2fs_folio_flags_addr(folio)); \
} \
static inline void set_page_private_##name(struct page *page) \
{ \
@@ -2797,13 +2834,10 @@ static inline void set_page_private_##name(struct page *page) \
#define PAGE_PRIVATE_CLEAR_FUNC(name, flagname) \
static inline void folio_clear_f2fs_##name(struct folio *folio) \
{ \
- unsigned long v = (unsigned long)folio->private; \
- \
- v &= ~(1UL << PAGE_PRIVATE_##flagname); \
- if (v == (1UL << PAGE_PRIVATE_NOT_POINTER)) \
+ clear_bit(PAGE_PRIVATE_##flagname, \
+ f2fs_folio_flags_addr(folio)); \
+ if (folio->private == (void *)BIT(PAGE_PRIVATE_NOT_POINTER)) \
folio_detach_private(folio); \
- else \
- folio->private = (void *)v; \
} \
static inline void clear_page_private_##name(struct page *page) \
{ \
@@ -2826,7 +2860,7 @@ PAGE_PRIVATE_CLEAR_FUNC(atomic, ATOMIC_WRITE);
static inline unsigned long folio_get_f2fs_data(struct folio *folio)
{
- unsigned long data = (unsigned long)folio->private;
+ unsigned long data = f2fs_folio_get_private_flags(folio);
if (!test_bit(PAGE_PRIVATE_NOT_POINTER, &data))
return 0;
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 02/15] f2fs: carry subpage offset and count in write IO
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 01/15] f2fs: extend folio state for large folio write path Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 03/15] f2fs: support regular file buffered writes on large folios Nanzhe Zhao
` (13 subsequent siblings)
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
Large folio write paths need to submit I/O for a range inside a
folio instead of always submitting the whole folio from offset zero.
Add folio_offset and folio_blkcnt to f2fs_io_info to describe the
block offset inside the folio and the number of contiguous blocks
covered by the I/O.
Apply the new fields to the bio submit paths that need the subpage
offset or contiguous block count.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/checkpoint.c | 2 ++
fs/f2fs/compress.c | 1 +
fs/f2fs/data.c | 78 ++++++++++++++++++++++++++++++++------------
fs/f2fs/f2fs.h | 11 +++++++
fs/f2fs/gc.c | 4 +++
fs/f2fs/inline.c | 1 +
fs/f2fs/segment.c | 3 +-
7 files changed, 79 insertions(+), 21 deletions(-)
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 5c5b45d3c67b..3ad709f69893 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -264,6 +264,7 @@ static struct f2fs_cached_block *__get_meta_cache(struct f2fs_sb_info *sbi,
.op_flags = REQ_META | REQ_PRIO,
.old_blkaddr = index,
.new_blkaddr = index,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.is_por = !is_meta ? 1 : 0,
.is_cache = 1,
@@ -462,6 +463,7 @@ int f2fs_ra_meta_caches(struct f2fs_sb_info *sbi, block_t start,
.type = META,
.op = REQ_OP_READ,
.op_flags = sync ? (REQ_META | REQ_PRIO) : REQ_RAHEAD,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.in_list = 0,
.is_por = (type == META_POR) ? 1 : 0,
diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
index 747141c79900..c0e39f580993 100644
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -1282,6 +1282,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
.op_flags = wbc_to_write_flags(wbc),
.old_blkaddr = NEW_ADDR,
.page = NULL,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.compressed_page = NULL,
.io_type = io_type,
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 603a7a570f2a..3a3852566a2a 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -849,6 +849,13 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio)
struct folio *fio_folio = fio->folio;
struct folio *data_folio = fio->encrypted_page ?
page_folio(fio->encrypted_page) : fio_folio;
+ pgoff_t fio_lblk = F2FS_FIO_LBLK(fio);
+ size_t bio_offset;
+ size_t bio_len;
+
+ bio_offset = data_folio == fio_folio ? F2FS_FIO_BIO_OFFSET(fio) : 0;
+ bio_len = data_folio == fio_folio ? F2FS_FIO_BIO_SIZE(fio) :
+ folio_size(data_folio);
if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr,
fio->is_por ? META_POR : (__is_meta_io(fio) ?
@@ -861,11 +868,11 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio)
bio = __bio_alloc(fio, 1);
f2fs_set_bio_crypt_ctx(bio, fio_folio->mapping->host,
- fio_folio->index, fio, GFP_NOIO);
- bio_add_folio_nofail(bio, data_folio, folio_size(data_folio), 0);
+ fio_lblk, fio, GFP_NOIO);
+ bio_add_folio_nofail(bio, data_folio, bio_len, bio_offset);
if (fio->io_wbc && !is_read_io(fio->op))
- wbc_account_cgroup_owner(fio->io_wbc, fio_folio, PAGE_SIZE);
+ wbc_account_cgroup_owner(fio->io_wbc, fio_folio, bio_len);
inc_cache_count(fio->sbi, is_read_io(fio->op) ?
F2FS_RD_DATA : WB_DATA_TYPE(fio->folio, false));
@@ -924,7 +931,8 @@ static bool io_is_mergeable(struct f2fs_sb_info *sbi, struct bio *bio,
}
static void add_bio_entry(struct f2fs_sb_info *sbi, struct bio *bio,
- struct folio *folio, enum temp_type temp)
+ struct folio *folio, size_t len, size_t offset,
+ enum temp_type temp)
{
struct f2fs_bio_info *io = sbi->write_io[DATA] + temp;
struct bio_entry *be;
@@ -933,7 +941,7 @@ static void add_bio_entry(struct f2fs_sb_info *sbi, struct bio *bio,
be->bio = bio;
bio_get(bio);
- bio_add_folio_nofail(bio, folio, folio_size(folio), 0);
+ bio_add_folio_nofail(bio, folio, len, offset);
f2fs_down_write(&io->bio_list_lock);
list_add_tail(&be->list, &io->bio_list);
@@ -950,7 +958,14 @@ static int add_ipu_page(struct f2fs_io_info *fio, struct bio **bio,
struct folio *folio)
{
struct folio *fio_folio = fio->folio;
+ pgoff_t fio_lblk = F2FS_FIO_LBLK(fio);
+ size_t bio_offset;
+ size_t bio_len;
struct f2fs_sb_info *sbi = fio->sbi;
+
+ bio_offset = folio == fio_folio ? F2FS_FIO_BIO_OFFSET(fio) : 0;
+ bio_len = folio == fio_folio ? F2FS_FIO_BIO_SIZE(fio) :
+ folio_size(folio);
enum temp_type temp;
bool found = false;
int ret = -EAGAIN;
@@ -972,8 +987,8 @@ static int add_ipu_page(struct f2fs_io_info *fio, struct bio **bio,
fio->new_blkaddr));
if (f2fs_crypt_mergeable_bio(*bio,
fio_folio->mapping->host,
- fio_folio->index, fio) &&
- bio_add_folio(*bio, folio, folio_size(folio), 0)) {
+ fio_lblk, fio) &&
+ bio_add_folio(*bio, folio, bio_len, bio_offset)) {
ret = 0;
break;
}
@@ -1087,6 +1102,14 @@ int f2fs_merge_page_bio(struct f2fs_io_info *fio)
struct folio *data_folio = fio->encrypted_page ?
page_folio(fio->encrypted_page) : fio->folio;
struct folio *folio = fio->folio;
+ pgoff_t fio_lblk = F2FS_FIO_LBLK(fio);
+ unsigned int fio_cnt = F2FS_FIO_BLKCNT(fio);
+ size_t bio_offset;
+ size_t bio_len;
+
+ bio_offset = data_folio == folio ? F2FS_FIO_BIO_OFFSET(fio) : 0;
+ bio_len = data_folio == folio ? F2FS_FIO_BIO_SIZE(fio) :
+ folio_size(data_folio);
if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr,
__is_meta_io(fio) ? META_GENERIC : DATA_GENERIC))
@@ -1101,20 +1124,21 @@ int f2fs_merge_page_bio(struct f2fs_io_info *fio)
if (!bio) {
bio = __bio_alloc(fio, BIO_MAX_VECS);
f2fs_set_bio_crypt_ctx(bio, folio->mapping->host,
- folio->index, fio, GFP_NOIO);
+ fio_lblk, fio, GFP_NOIO);
- add_bio_entry(fio->sbi, bio, data_folio, fio->temp);
+ add_bio_entry(fio->sbi, bio, data_folio, bio_len,
+ bio_offset, fio->temp);
} else {
if (add_ipu_page(fio, &bio, data_folio))
goto alloc_new;
}
if (fio->io_wbc)
- wbc_account_cgroup_owner(fio->io_wbc, folio, folio_size(folio));
+ wbc_account_cgroup_owner(fio->io_wbc, folio, bio_len);
inc_cache_count(fio->sbi, WB_DATA_TYPE(folio, false));
- *fio->last_block = fio->new_blkaddr;
+ *fio->last_block = fio->new_blkaddr + fio_cnt - 1;
*fio->bio = bio;
return 0;
@@ -1177,6 +1201,10 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio)
struct folio *bio_folio;
struct f2fs_lock_context lc;
enum count_type type;
+ pgoff_t fio_lblk;
+ unsigned int fio_cnt;
+ size_t bio_offset;
+ size_t bio_len;
f2fs_bug_on(sbi, is_read_io(fio->op));
@@ -1209,24 +1237,32 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio)
/* set submitted = true as a return value */
fio->submitted = 1;
+ fio_lblk = F2FS_FIO_LBLK(fio);
+ fio_cnt = F2FS_FIO_BLKCNT(fio);
+
type = WB_DATA_TYPE(bio_folio, fio->compressed_page);
- inc_cache_count(sbi, type);
+ for (unsigned int i = 0; i < fio_cnt; i++)
+ inc_cache_count(sbi, type);
if (io->bio &&
(!io_is_mergeable(sbi, io->bio, io, fio, io->last_block_in_bio,
fio->new_blkaddr) ||
!f2fs_crypt_mergeable_bio(io->bio, fio_inode(fio),
- bio_folio->index, fio)))
+ fio_lblk, fio)))
__submit_merged_bio(io);
alloc_new:
if (io->bio == NULL) {
io->bio = __bio_alloc(fio, BIO_MAX_VECS);
f2fs_set_bio_crypt_ctx(io->bio, fio_inode(fio),
- bio_folio->index, fio, GFP_NOIO);
+ fio_lblk, fio, GFP_NOIO);
io->fio = *fio;
}
- if (!bio_add_folio(io->bio, bio_folio, folio_size(bio_folio), 0)) {
+ bio_offset = bio_folio == fio->folio ? F2FS_FIO_BIO_OFFSET(fio) : 0;
+ bio_len = bio_folio == fio->folio ? F2FS_FIO_BIO_SIZE(fio) :
+ folio_size(bio_folio);
+
+ if (!bio_add_folio(io->bio, bio_folio, bio_len, bio_offset)) {
__submit_merged_bio(io);
goto alloc_new;
}
@@ -1234,10 +1270,9 @@ void f2fs_submit_page_write(struct f2fs_io_info *fio)
F2FS_BIO(io->bio)->entry_cnt++;
if (fio->io_wbc)
- wbc_account_cgroup_owner(fio->io_wbc, fio->folio,
- folio_size(fio->folio));
+ wbc_account_cgroup_owner(fio->io_wbc, fio->folio, bio_len);
- io->last_block_in_bio = fio->new_blkaddr;
+ io->last_block_in_bio = fio->new_blkaddr + fio_cnt - 1;
trace_f2fs_submit_folio_write(fio->folio, fio);
#ifdef CONFIG_BLK_DEV_ZONED
@@ -3231,7 +3266,8 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
set_new_dnode(&dn, inode, NULL, NULL, 0);
if (need_inplace_update(fio) &&
- f2fs_lookup_read_extent_cache_block(inode, folio->index,
+ f2fs_lookup_read_extent_cache_block(inode,
+ F2FS_FIO_LBLK(fio),
&fio->old_blkaddr)) {
if (!f2fs_is_valid_blkaddr(fio->sbi, fio->old_blkaddr,
DATA_GENERIC_ENHANCE))
@@ -3250,7 +3286,8 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc))
return -EAGAIN;
- err = f2fs_get_dnode_of_data(&dn, folio->index, LOOKUP_NODE);
+ err = f2fs_get_dnode_of_data(&dn, F2FS_FIO_LBLK(fio),
+ LOOKUP_NODE);
if (err)
goto out;
@@ -3353,6 +3390,7 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted,
.op_flags = wbc_to_write_flags(wbc),
.old_blkaddr = NULL_ADDR,
.folio = folio,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.submitted = 0,
.compr_blocks = compr_blocks,
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index abb0c0caed91..62117de4b404 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1350,6 +1350,8 @@ struct f2fs_io_info {
blk_opf_t op_flags; /* req_flag_bits */
block_t new_blkaddr; /* new block address to be written */
block_t old_blkaddr; /* old block address before Cow */
+ pgoff_t folio_offset; /* offset in large folio */
+ unsigned int folio_blkcnt; /* block count in large folio */
union {
struct page *page; /* page to be written */
struct folio *folio;
@@ -1372,6 +1374,15 @@ struct f2fs_io_info {
sector_t *last_block; /* last block number in bio */
};
+#define F2FS_FIO_LBLK(fio) \
+ (((fio)->folio)->index + (fio)->folio_offset)
+#define F2FS_FIO_BLKCNT(fio) \
+ ((fio)->folio_blkcnt)
+#define F2FS_FIO_BIO_OFFSET(fio) \
+ ((fio)->folio_offset << PAGE_SHIFT)
+#define F2FS_FIO_BIO_SIZE(fio) \
+ F2FS_BLK_TO_BYTES((fio)->sbi, F2FS_FIO_BLKCNT(fio))
+
struct bio_entry {
struct bio *bio;
struct list_head list;
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 5b948c92f981..72c7f9ceafc2 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1228,6 +1228,7 @@ static int ra_data_block(struct inode *inode, pgoff_t index)
.temp = COLD,
.op = REQ_OP_READ,
.op_flags = 0,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.in_list = 0,
.is_cache = 1,
@@ -1338,6 +1339,7 @@ static int move_data_block(struct inode *inode, block_t bidx,
.temp = COLD,
.op = REQ_OP_READ,
.op_flags = 0,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.in_list = 0,
.is_cache = 1,
@@ -1550,6 +1552,8 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
.op_flags = REQ_SYNC,
.old_blkaddr = NULL_ADDR,
.folio = folio,
+ .folio_offset = bidx - folio->index,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.need_lock = LOCK_REQ,
.io_type = FS_GC_DATA_IO,
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 273b6428c9f9..ab7537ff7ebd 100644
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -151,6 +151,7 @@ int f2fs_convert_inline_folio(struct dnode_of_data *dn, struct folio *folio)
.op = REQ_OP_WRITE,
.op_flags = REQ_SYNC | REQ_PRIO,
.folio = folio,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.io_type = FS_DATA_IO,
};
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index daf6d9617d5b..80f58c586e33 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -3876,7 +3876,8 @@ static int __get_segment_type_6(struct f2fs_io_info *fio)
if (file_is_cold(inode) || f2fs_need_compress_data(inode))
return CURSEG_COLD_DATA;
- type = __get_age_segment_type(inode, fio->folio->index);
+ type = __get_age_segment_type(inode,
+ F2FS_FIO_LBLK(fio));
if (type != NO_CHECK_TYPE)
return type;
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 03/15] f2fs: support regular file buffered writes on large folios
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 01/15] f2fs: extend folio state for large folio write path Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 02/15] f2fs: carry subpage offset and count in write IO Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 04/15] f2fs: support atomic file large folios buffered write Nanzhe Zhao
` (12 subsequent siblings)
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
To avoid the complexity of unlocking a large folio in write_begin,
preallocate partial blocks for inodes that can use large folios.
During write_begin, read only the partial head and tail 4K subpages
that need read-before-write, and skip read I/O for the full middle
subpages covered by the write.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 431 +++++++++++++++++++++++++++++++++++++++++++++----
fs/f2fs/f2fs.h | 1 +
fs/f2fs/file.c | 17 +-
3 files changed, 412 insertions(+), 37 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 3a3852566a2a..f01bf06a77b0 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -93,6 +93,20 @@ struct bio_post_read_ctx {
block_t fs_blkaddr;
};
+static bool __ffs_mark_subrange_uptodate(struct folio *folio,
+ struct f2fs_folio_state *ffs, size_t offset, size_t len)
+{
+ unsigned int nr_subpages = folio_nr_pages(folio);
+ unsigned int start, end;
+
+ start = offset >> PAGE_SHIFT;
+ end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+ end = min(end, nr_subpages);
+
+ bitmap_set(ffs->state, start, end - start);
+ return bitmap_full(ffs->state, nr_subpages);
+}
+
/*
* Update and unlock a bio's pages, and free the bio.
*
@@ -107,6 +121,23 @@ struct bio_post_read_ctx {
* called (i.e., I/O error or decryption error, but *not* verity error), and
* release the bio's reference to the decompress_io_ctx of the page's cluster.
*/
+/*
+ * Update read_pages_pending.
+ */
+static inline void f2fs_update_read_folio_pending(struct folio *folio, int nr)
+{
+ struct f2fs_folio_state *ffs;
+ unsigned long flags;
+
+ if (!f2fs_folio_has_ffs(folio))
+ return;
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ spin_lock_irqsave(&ffs->state_lock, flags);
+ ffs->read_pages_pending += nr;
+ spin_unlock_irqrestore(&ffs->state_lock, flags);
+}
+
static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
{
struct folio_iter fi;
@@ -128,7 +159,8 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
}
if (folio_test_large(folio)) {
- struct f2fs_folio_state *ffs = folio->private;
+ struct f2fs_folio_state *ffs =
+ (struct f2fs_folio_state *)folio->private;
spin_lock_irqsave(&ffs->state_lock, flags);
ffs->read_pages_pending -= nr_pages;
@@ -1437,19 +1469,26 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode,
/* This can handle encryption stuffs */
static void f2fs_submit_page_read(struct inode *inode, struct fsverity_info *vi,
- struct folio *folio, block_t blkaddr,
- blk_opf_t op_flags, bool for_write)
+ struct folio *folio, pgoff_t index,
+ block_t blkaddr, blk_opf_t op_flags,
+ bool for_write)
{
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
struct bio *bio;
+ size_t offset = 0;
+
+ if (f2fs_folio_has_ffs(folio)) {
+ offset = offset_in_folio(folio, (loff_t)index << PAGE_SHIFT);
+ f2fs_update_read_folio_pending(folio, 1);
+ }
- bio = f2fs_grab_read_bio(inode, vi, blkaddr, 1, op_flags, folio->index,
+ bio = f2fs_grab_read_bio(inode, vi, blkaddr, 1, op_flags, index,
for_write);
/* wait for GCed page writeback via generic cache */
f2fs_wait_on_block_writeback(inode, blkaddr);
- if (!bio_add_folio(bio, folio, PAGE_SIZE, 0))
+ if (!bio_add_folio(bio, folio, PAGE_SIZE, offset))
f2fs_bug_on(sbi, 1);
inc_cache_count(sbi, F2FS_RD_DATA);
@@ -1457,6 +1496,40 @@ static void f2fs_submit_page_read(struct inode *inode, struct fsverity_info *vi,
f2fs_submit_read_bio(sbi, bio, DATA);
}
+/*
+ * Synchronously read a single 4K subpage by reusing f2fs_submit_page_read()
+ * so that iostat, trace, blk-crypto and post-read handling are all preserved.
+ * The caller must have already allocated ffs for the folio.
+ */
+static int f2fs_submit_page_read_sync(struct inode *inode, struct folio *folio,
+ pgoff_t index, block_t blkaddr)
+{
+ struct f2fs_folio_state *ffs =
+ (struct f2fs_folio_state *)folio->private;
+
+ /* Add bias so end_io does not call folio_end_read(). */
+ f2fs_update_read_folio_pending(folio, 1);
+
+ /*
+ * We are holding the folio lock, so use GFP_NOIO for the bio
+ * allocation to avoid entering mm reclaim.
+ */
+ f2fs_submit_page_read(inode, NULL, folio, index, blkaddr,
+ REQ_OP_READ, true);
+
+ /* Wait until all bios have completed (pending drops back to our bias). */
+ while (READ_ONCE(ffs->read_pages_pending) != 1)
+ f2fs_io_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
+
+ /* Remove the bias. */
+ f2fs_update_read_folio_pending(folio, -1);
+
+ if (!f2fs_ffs_test_blk_uptodate(folio, index))
+ return -EIO;
+
+ return 0;
+}
+
static void __set_data_blkaddr(struct dnode_of_data *dn, block_t blkaddr)
{
__le32 *addr = get_dnode_addr(dn->inode, dn->node_entry);
@@ -1630,8 +1703,8 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
return folio;
}
- f2fs_submit_page_read(inode, f2fs_need_verity(inode, folio->index),
- folio, dn.data_blkaddr, op_flags, for_write);
+ f2fs_submit_page_read(inode, f2fs_need_verity(inode, index),
+ folio, index, dn.data_blkaddr, op_flags, for_write);
return folio;
put_err:
@@ -2811,6 +2884,110 @@ static void ffs_detach_free(struct folio *folio)
kfree(ffs);
}
+bool f2fs_ffs_test_blk_uptodate(const struct folio *folio, pgoff_t index)
+{
+ struct f2fs_folio_state *ffs;
+ unsigned int idx;
+
+ f2fs_bug_on(F2FS_F_SB(folio), !folio_contains(folio, index));
+
+ if (folio_test_uptodate(folio))
+ return true;
+
+ if (!f2fs_folio_has_ffs(folio))
+ return false;
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ idx = index - folio->index;
+ return test_bit(idx, ffs->state);
+}
+
+static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
+ size_t len)
+{
+ struct f2fs_folio_state *ffs;
+ unsigned long flags;
+ bool mark_uptodate = false;
+
+ f2fs_bug_on(F2FS_F_SB(folio), offset + len > folio_size(folio));
+
+ if (!f2fs_folio_has_ffs(folio)) {
+ folio_mark_uptodate(folio);
+ return;
+ }
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ spin_lock_irqsave(&ffs->state_lock, flags);
+ mark_uptodate = __ffs_mark_subrange_uptodate(folio, ffs, offset, len) &&
+ !ffs->read_pages_pending;
+ spin_unlock_irqrestore(&ffs->state_lock, flags);
+ if (mark_uptodate)
+ folio_mark_uptodate(folio);
+}
+
+static unsigned int __ffs_mark_subrange_dirty(struct folio *folio,
+ struct f2fs_folio_state *ffs, size_t offset, size_t len)
+{
+ unsigned int nr_subpages = folio_nr_pages(folio);
+ unsigned int start, end, before;
+
+ start = offset >> PAGE_SHIFT;
+ end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+ end = min(end, nr_subpages);
+
+ before = bitmap_weight(ffs->state, 2 * nr_subpages);
+ bitmap_set(ffs->state, nr_subpages + start, end - start);
+ return bitmap_weight(ffs->state, 2 * nr_subpages) - before;
+}
+
+static void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
+ size_t offset, size_t len)
+{
+ struct f2fs_folio_state *ffs;
+ 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;
+
+ spin_lock_irqsave(&ffs->state_lock, flags);
+ __ffs_mark_subrange_dirty(folio, ffs, offset, len);
+ spin_unlock_irqrestore(&ffs->state_lock, flags);
+}
+
+static bool find_next_valid_block(const struct folio *folio,
+ size_t orig_off, size_t *need_off,
+ size_t len)
+{
+ size_t start = orig_off;
+ size_t end = start + len;
+ size_t head, tail;
+ pgoff_t index;
+
+ if (start & (PAGE_SIZE - 1)) {
+ head = round_down(start, PAGE_SIZE);
+ index = folio->index + (head >> PAGE_SHIFT);
+ if (!f2fs_ffs_test_blk_uptodate(folio, index)) {
+ *need_off = head;
+ return true;
+ }
+ }
+
+ if (end & (PAGE_SIZE - 1)) {
+ tail = round_down(end, PAGE_SIZE);
+ index = folio->index + (tail >> PAGE_SHIFT);
+ if (!f2fs_ffs_test_blk_uptodate(folio, index)) {
+ *need_off = tail;
+ return true;
+ }
+ }
+
+ return false;
+}
+
static int f2fs_read_data_large_folio(struct inode *inode,
struct fsverity_info *vi,
struct readahead_control *rac, struct folio *folio)
@@ -4176,6 +4353,151 @@ static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
return 0;
}
+/*
+ * Drop the folio lock when a node was changed, then balance the
+ * filesystem and reacquire the lock.
+ *
+ * Return: true if the folio became unusable while unlocked (being
+ * truncated), false if the folio is still usable.
+ */
+static bool f2fs_balance_fs_folio_locked(struct folio *folio,
+ struct address_space *mapping, bool node_changed)
+{
+ struct inode *inode = folio->mapping->host;
+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ unsigned int orig_order;
+ bool had_ffs;
+
+ if (!node_changed || IS_NOQUOTA(inode) ||
+ !has_not_enough_free_secs(sbi, 0, 0))
+ return false;
+
+ had_ffs = f2fs_folio_has_ffs(folio);
+ orig_order = folio_order(folio);
+ folio_unlock(folio);
+ f2fs_balance_fs(sbi, true);
+ folio_lock(folio);
+
+ /*
+ * Writeback may have started on the folio during the unlock
+ * window, so wait for it before the caller proceeds.
+ */
+ f2fs_folio_wait_writeback(folio, true, true);
+
+ if (folio->mapping != mapping)
+ return true;
+
+ if (folio_order(folio) != orig_order)
+ return true;
+
+ /* large folio was released */
+ if (had_ffs && !f2fs_folio_has_ffs(folio))
+ return true;
+
+ return false;
+}
+
+static int prepare_large_folio_write_begin(struct inode *inode,
+ struct folio *folio, loff_t pos,
+ unsigned int len)
+{
+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ struct f2fs_folio_state *ffs;
+ size_t ori_off = offset_in_folio(folio, pos);
+ size_t need_off = ori_off;
+ int err = 0;
+
+ /*
+ * when the write did not come through f2fs_write_iter, we preallocate all
+ * blocks in the write range here.
+ */
+ if (!is_inode_flag_set(inode, FI_PREALLOCATED_ALL) &&
+ !IS_DEVICE_ALIASING(inode)) {
+ pgoff_t first = F2FS_BYTES_TO_BLK(sbi, pos);
+ pgoff_t last = F2FS_BLK_ALIGN(sbi, pos + len);
+ pgoff_t idx;
+
+ for (idx = first; idx < last; idx++) {
+ block_t blkaddr = NULL_ADDR;
+ bool node_changed = false;
+
+ err = __reserve_data_block(inode, idx, &blkaddr,
+ &node_changed);
+ if (err)
+ return err;
+ if (f2fs_balance_fs_folio_locked(folio, folio->mapping,
+ node_changed))
+ return -EAGAIN;
+ }
+ }
+
+ ffs = f2fs_ffs_find_or_alloc(folio);
+ if (!ffs)
+ return -ENOMEM;
+
+ /* Skip read if the folio is already fully uptodate or the write
+ * covers the entire folio.
+ */
+ if (folio_test_uptodate(folio) || len == folio_size(folio))
+ return 0;
+
+ if (!f2fs_verity_in_progress(inode) &&
+ !(pos & (PAGE_SIZE - 1)) && (pos + len) >= i_size_read(inode)) {
+ size_t zoff = ori_off + len;
+
+ if (zoff < folio_size(folio))
+ folio_zero_segment(folio, zoff, folio_size(folio));
+ return 0;
+ }
+
+ /* Inline data must have been converted before reaching here. */
+ f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
+
+ while (find_next_valid_block(folio, ori_off,
+ &need_off, len)) {
+ struct dnode_of_data dn;
+ pgoff_t index = folio->index + (need_off >> PAGE_SHIFT);
+ block_t blkaddr;
+
+ if (!f2fs_lookup_read_extent_cache_block(inode, index,
+ &blkaddr)) {
+ if (IS_DEVICE_ALIASING(inode))
+ return -ENODATA;
+
+ set_new_dnode(&dn, inode, NULL, NULL, 0);
+ err = f2fs_get_dnode_of_data(&dn, index, LOOKUP_NODE);
+ if (err)
+ return err;
+ blkaddr = dn.data_blkaddr;
+ f2fs_put_dnode(&dn);
+
+ if (blkaddr == NEW_ADDR) {
+ size_t off = offset_in_folio(folio,
+ (loff_t)index << PAGE_SHIFT);
+
+ folio_zero_segment(folio, off, off + PAGE_SIZE);
+ f2fs_ffs_mark_subrange_uptodate(folio, off,
+ PAGE_SIZE);
+ continue;
+ }
+ }
+
+ /*
+ * The read extent cache only validates the first and last
+ * block of i_ext, so check both the cached and dnode paths.
+ */
+ if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
+ DATA_GENERIC_ENHANCE_READ))
+ return -EFSCORRUPTED;
+
+ err = f2fs_submit_page_read_sync(inode, folio, index, blkaddr);
+ if (err)
+ return err;
+ }
+
+ return 0;
+}
+
static int f2fs_write_begin(const struct kiocb *iocb,
struct address_space *mapping,
loff_t pos, unsigned len, struct folio **foliop,
@@ -4187,6 +4509,8 @@ static int f2fs_write_begin(const struct kiocb *iocb,
pgoff_t index = pos >> PAGE_SHIFT;
bool need_balance = false;
block_t blkaddr = NULL_ADDR;
+ fgf_t fgp = FGP_LOCK | FGP_WRITE | FGP_CREAT;
+ unsigned int blen;
int err = 0;
trace_f2fs_write_begin(inode, pos, len);
@@ -4234,9 +4558,15 @@ static int f2fs_write_begin(const struct kiocb *iocb,
* Do not use FGP_STABLE to avoid deadlock.
* Will wait that below with our IO control.
*/
- folio = f2fs_filemap_get_folio(mapping, index,
- FGP_LOCK | FGP_WRITE | FGP_CREAT,
- mapping_gfp_mask(mapping));
+ /*
+ * Inline data is carried in the first subpage. Keep the index #0
+ * folio order-0 so that the existing inline read/convert paths
+ * (prepare_write_begin()) still apply; large folios are used from
+ * the second folio on.
+ */
+ fgp |= fgf_set_order(f2fs_has_inline_data(inode) ? PAGE_SIZE : len);
+ folio = f2fs_filemap_get_folio(mapping, index, fgp,
+ mapping_gfp_mask(mapping));
if (IS_ERR(folio)) {
err = PTR_ERR(folio);
goto fail;
@@ -4246,31 +4576,42 @@ static int f2fs_write_begin(const struct kiocb *iocb,
*foliop = folio;
+ /* Clamp the write length to the folio size. */
+ blen = min_t(unsigned int, len,
+ folio_size(folio) - offset_in_folio(folio, pos));
+
+ /*
+ * Flush the cached IO of this folio before touching it, especially
+ * for the large folio prepare below which reads and updates subpage
+ * states.
+ */
+ f2fs_folio_wait_writeback(folio, false, true);
+
if (f2fs_is_atomic_file(inode))
err = prepare_atomic_write_begin(sbi, folio, pos, len,
&blkaddr, &need_balance);
- else
- err = prepare_write_begin(sbi, folio, pos, len,
+ else if (!folio_test_large(folio))
+ err = prepare_write_begin(sbi, folio, pos, blen,
&blkaddr, &need_balance);
- if (err)
- goto put_folio;
-
- if (need_balance && !IS_NOQUOTA(inode) &&
- has_not_enough_free_secs(sbi, 0, 0)) {
- folio_unlock(folio);
- f2fs_balance_fs(sbi, true);
- folio_lock(folio);
- if (folio->mapping != mapping) {
- /* The folio got truncated from under us */
- folio_unlock(folio);
- folio_put(folio);
+ else
+ err = prepare_large_folio_write_begin(inode, folio, pos, blen);
+ if (err) {
+ if (err == -EAGAIN) {
+ f2fs_folio_put(folio, true);
goto repeat;
}
+ goto put_folio;
}
- f2fs_folio_wait_writeback(folio, false, true);
+ if (f2fs_balance_fs_folio_locked(folio, mapping, need_balance)) {
+ f2fs_folio_put(folio, true);
+ goto repeat;
+ }
+
+ if (folio_test_large(folio))
+ return 0;
- if (len == folio_size(folio) || folio_test_uptodate(folio))
+ if (blen == folio_size(folio) || folio_test_uptodate(folio))
return 0;
if (!(pos & (PAGE_SIZE - 1)) && (pos + len) >= i_size_read(inode) &&
@@ -4298,7 +4639,7 @@ static int f2fs_write_begin(const struct kiocb *iocb,
*/
f2fs_submit_page_read(inode,
NULL, /* can't write to fsverity files */
- folio, blkaddr, 0, true);
+ folio, index, blkaddr, 0, true);
folio_lock(folio);
if (unlikely(folio->mapping != mapping)) {
@@ -4330,15 +4671,20 @@ static int f2fs_write_end(const struct kiocb *iocb,
trace_f2fs_write_end(inode, pos, len, copied);
/*
- * This should be come from len == PAGE_SIZE, and we expect copied
- * should be PAGE_SIZE. Otherwise, we treat it with zero copied and
- * let generic_perform_write() try to copy data again through copied=0.
+ * If a short copy happens on a folio that isn't uptodate, we treat
+ * it with zero copied and let generic_perform_write() try to copy
+ * data again through copied=0.
*/
if (!folio_test_uptodate(folio)) {
- if (unlikely(copied != len))
+ if (unlikely(copied != len)) {
copied = 0;
- else
+ } else if (folio_test_large(folio)) {
+ f2fs_ffs_mark_subrange_uptodate(folio,
+ offset_in_folio(folio, pos), len);
+ } else {
+ /* This should be come from len == PAGE_SIZE */
folio_mark_uptodate(folio);
+ }
}
#ifdef CONFIG_F2FS_FS_COMPRESSION
@@ -4357,6 +4703,9 @@ static int f2fs_write_end(const struct kiocb *iocb,
if (!copied)
goto unlock_out;
+ if (folio_test_large(folio))
+ f2fs_ffs_mark_subrange_dirty(folio, offset_in_folio(folio, pos),
+ copied);
folio_mark_dirty(folio);
if (f2fs_is_atomic_file(inode))
@@ -4413,8 +4762,22 @@ static bool f2fs_dirty_data_folio(struct address_space *mapping,
trace_f2fs_set_page_dirty(folio, DATA);
- if (!folio_test_uptodate(folio))
- folio_mark_uptodate(folio);
+ if (!folio_test_uptodate(folio)) {
+ bool uptodate = true;
+
+ if (f2fs_folio_has_ffs(folio)) {
+ struct f2fs_folio_state *ffs =
+ (struct f2fs_folio_state *)folio->private;
+ unsigned long flags;
+
+ spin_lock_irqsave(&ffs->state_lock, flags);
+ uptodate = bitmap_full(ffs->state, folio_nr_pages(folio)) &&
+ !ffs->read_pages_pending;
+ spin_unlock_irqrestore(&ffs->state_lock, flags);
+ }
+ if (uptodate)
+ folio_mark_uptodate(folio);
+ }
BUG_ON(folio_test_swapcache(folio));
if (filemap_dirty_folio(mapping, folio)) {
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 62117de4b404..df0091591ff5 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4454,6 +4454,7 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted,
struct writeback_control *wbc,
enum iostat_type io_type,
int compr_blocks, bool allow_balance);
+bool f2fs_ffs_test_blk_uptodate(const struct folio *folio, pgoff_t index);
void f2fs_write_failed(struct inode *inode, loff_t to);
void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length);
bool f2fs_release_folio(struct folio *folio, gfp_t wait);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index b077e4eb790d..85b4f1a2ff0d 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -5420,9 +5420,20 @@ static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,
return ret;
}
- /* Do not preallocate blocks that will be written partially in 4KB. */
- map.m_lblk = F2FS_BLK_ALIGN(sbi, pos);
- map.m_len = F2FS_BYTES_TO_BLK(sbi, pos + count);
+ if (!dio && mapping_large_folio_support(inode->i_mapping)) {
+ /*
+ * Preallocate all blocks touched by a large-folio buffered write so
+ * the regular write_begin path does not need to unlock the folio for
+ * f2fs_balance_fs(). Rechecking large-folio state after unlock is
+ * unreliable since partial truncation can split the folio.
+ */
+ map.m_lblk = F2FS_BYTES_TO_BLK(sbi, pos);
+ map.m_len = F2FS_BLK_ALIGN(sbi, pos + count);
+ } else {
+ /* Do not preallocate blocks that will be written partially in 4KB. */
+ map.m_lblk = F2FS_BLK_ALIGN(sbi, pos);
+ map.m_len = F2FS_BYTES_TO_BLK(sbi, pos + count);
+ }
if (map.m_len > map.m_lblk)
map.m_len -= map.m_lblk;
else
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 04/15] f2fs: support atomic file large folios buffered write
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (2 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 03/15] f2fs: support regular file buffered writes on large folios Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 05/15] f2fs: support large folio writeback Nanzhe Zhao
` (11 subsequent siblings)
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
ioctl can convert an inode with large folio support into an atomic
file. Support large folio buffered writes for atomic files as well.
Add a large folio atomic write_begin helper that reserves COW mappings
for the write range. For partial head and tail subpages, read the
existing data from either the COW inode or the original inode before
marking the subpage uptodate.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 86 ++++++++++++++++++++++++++++++++++++++++++++------
1 file changed, 76 insertions(+), 10 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index f01bf06a77b0..126cad81227f 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -4305,18 +4305,22 @@ static int __reserve_data_block(struct inode *inode, pgoff_t index,
}
static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
- struct folio *folio, loff_t pos, unsigned int len,
- block_t *blk_addr, bool *node_changed)
+ struct inode *inode, pgoff_t index,
+ block_t *blk_addr, bool *node_changed,
+ bool check_reserved)
{
- struct inode *inode = folio->mapping->host;
struct inode *cow_inode = F2FS_I(inode)->cow_inode;
- pgoff_t index = folio->index;
int err = 0;
block_t ori_blk_addr = NULL_ADDR;
bool cow_has_reserved_block = false;
+ bool append = ((loff_t)index << PAGE_SHIFT) >= i_size_read(inode);
- /* If pos is beyond the end of file, reserve a new block in COW inode */
- if ((pos & PAGE_MASK) >= i_size_read(inode))
+ /*
+ * On the first attempt, an append write can skip the COW lookup and
+ * reserve directly. On retry, check the COW block first so the same
+ * block is not reserved and accounted twice.
+ */
+ if (append && !check_reserved)
goto reserve_block;
/* Look for the block in COW inode first */
@@ -4330,7 +4334,7 @@ static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
if (*blk_addr == NEW_ADDR)
cow_has_reserved_block = true;
- if (is_inode_flag_set(inode, FI_ATOMIC_REPLACE))
+ if (append || is_inode_flag_set(inode, FI_ATOMIC_REPLACE))
goto reserve_block;
/* Look for the block in the original inode */
@@ -4498,6 +4502,62 @@ static int prepare_large_folio_write_begin(struct inode *inode,
return 0;
}
+static int prepare_large_folio_atomic_write_begin(struct inode *inode,
+ struct address_space *mapping, struct folio *folio, loff_t pos,
+ unsigned int len, bool retried)
+{
+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ size_t ori_off = offset_in_folio(folio, pos);
+ pgoff_t start, end, index;
+ int err = 0;
+
+ len = min_t(unsigned int, len, folio_size(folio) - ori_off);
+
+ if (!f2fs_ffs_find_or_alloc(folio))
+ return -ENOMEM;
+
+ /* Inline data must have been converted before reaching here. */
+ f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
+
+ start = folio->index + (ori_off >> PAGE_SHIFT);
+ end = folio->index + ((ori_off + len - 1) >> PAGE_SHIFT);
+
+ for (index = start; index <= end; index++) {
+ block_t blkaddr = NULL_ADDR;
+ bool node_changed = false;
+ size_t off = (index - folio->index) << PAGE_SHIFT;
+
+ err = prepare_atomic_write_begin(sbi, inode, index,
+ &blkaddr, &node_changed,
+ retried);
+ if (err)
+ return err;
+
+ if (f2fs_ffs_test_blk_uptodate(folio, index))
+ goto balance;
+
+ if (blkaddr == NEW_ADDR) {
+ folio_zero_segment(folio, off, off + PAGE_SIZE);
+ f2fs_ffs_mark_subrange_uptodate(folio, off, PAGE_SIZE);
+ goto balance;
+ }
+
+ if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
+ DATA_GENERIC_ENHANCE_READ))
+ return -EFSCORRUPTED;
+
+ err = f2fs_submit_page_read_sync(inode, folio, index,
+ blkaddr);
+ if (err)
+ return err;
+balance:
+ if (f2fs_balance_fs_folio_locked(folio, mapping, node_changed))
+ return -EAGAIN;
+ }
+
+ return 0;
+}
+
static int f2fs_write_begin(const struct kiocb *iocb,
struct address_space *mapping,
loff_t pos, unsigned len, struct folio **foliop,
@@ -4508,6 +4568,7 @@ static int f2fs_write_begin(const struct kiocb *iocb,
struct folio *folio;
pgoff_t index = pos >> PAGE_SHIFT;
bool need_balance = false;
+ bool retried = false;
block_t blkaddr = NULL_ADDR;
fgf_t fgp = FGP_LOCK | FGP_WRITE | FGP_CREAT;
unsigned int blen;
@@ -4587,16 +4648,20 @@ static int f2fs_write_begin(const struct kiocb *iocb,
*/
f2fs_folio_wait_writeback(folio, false, true);
- if (f2fs_is_atomic_file(inode))
- err = prepare_atomic_write_begin(sbi, folio, pos, len,
- &blkaddr, &need_balance);
+ if (f2fs_is_atomic_file(inode) && !folio_test_large(folio))
+ err = prepare_atomic_write_begin(sbi, inode, folio->index,
+ &blkaddr, &need_balance, retried);
else if (!folio_test_large(folio))
err = prepare_write_begin(sbi, folio, pos, blen,
&blkaddr, &need_balance);
+ else if (f2fs_is_atomic_file(inode))
+ err = prepare_large_folio_atomic_write_begin(inode,
+ mapping, folio, pos, len, retried);
else
err = prepare_large_folio_write_begin(inode, folio, pos, blen);
if (err) {
if (err == -EAGAIN) {
+ retried = true;
f2fs_folio_put(folio, true);
goto repeat;
}
@@ -4604,6 +4669,7 @@ static int f2fs_write_begin(const struct kiocb *iocb,
}
if (f2fs_balance_fs_folio_locked(folio, mapping, need_balance)) {
+ retried = true;
f2fs_folio_put(folio, true);
goto repeat;
}
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 05/15] f2fs: support large folio writeback
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (3 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 04/15] f2fs: support atomic file large folios buffered write Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-27 9:34 ` Chao Yu
2026-10-26 3:37 ` [PATCH v7 06/15] f2fs: account large folio dirty data at block granularity Nanzhe Zhao
` (10 subsequent siblings)
15 siblings, 1 reply; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
Large folio can contain multiple dirty ranges.
Add a folio-based writeback path for large-folio mapping files
and keep the legacy f2fs_write_cache_pages() path unchanged for
non large-folio mapping files.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 521 +++++++++++++++++++++++++++++++++++++++++++++-
fs/f2fs/segment.c | 8 +-
2 files changed, 521 insertions(+), 8 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 126cad81227f..a0822d06e3bc 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -358,6 +358,49 @@ static void f2fs_cache_write_end_bio(struct bio *bio)
bio_put(bio);
}
+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;
+}
+
+/*
+ * Drop a write page pending of @folio. When the last pending is gone,
+ * clear PAGE_PRIVATE_GCING if no dirty subpage is left, and end
+ * writeback if it was started.
+ */
+static void f2fs_ffs_put_write_pending(struct folio *folio, unsigned int nr)
+{
+ struct f2fs_folio_state *ffs;
+
+ if (!f2fs_folio_has_ffs(folio))
+ goto release;
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ if (!atomic_sub_and_test(nr, &ffs->write_pages_pending))
+ return;
+release:
+ if (!f2fs_ffs_has_dirty_subpage(folio))
+ folio_clear_f2fs_gcing(folio);
+ if (folio_test_writeback(folio))
+ folio_end_writeback(folio);
+}
+
static void f2fs_write_end_bio(struct bio *bio)
{
struct f2fs_sb_info *sbi = bio->bi_private;
@@ -373,6 +416,8 @@ static void f2fs_write_end_bio(struct bio *bio)
bio_for_each_folio_all(fi, bio) {
struct folio *folio = fi.folio;
+ unsigned int nr_pages = fi.length >> PAGE_SHIFT;
+ unsigned int npages = nr_pages;
enum count_type type;
#ifdef CONFIG_F2FS_FS_COMPRESSION
@@ -392,7 +437,8 @@ static void f2fs_write_end_bio(struct bio *bio)
}
}
- dec_cache_count(sbi, type);
+ while (nr_pages--)
+ dec_cache_count(sbi, type);
/*
* we should access sbi before folio_end_writeback() to
@@ -402,8 +448,7 @@ static void f2fs_write_end_bio(struct bio *bio)
wq_has_sleeper(&sbi->cp_wait))
wake_up(&sbi->cp_wait);
- folio_clear_f2fs_gcing(folio);
- folio_end_writeback(folio);
+ f2fs_ffs_put_write_pending(folio, npages);
}
bio_put(bio);
@@ -2940,7 +2985,7 @@ static unsigned int __ffs_mark_subrange_dirty(struct folio *folio,
return bitmap_weight(ffs->state, 2 * nr_subpages) - before;
}
-static void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
+void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
size_t offset, size_t len)
{
struct f2fs_folio_state *ffs;
@@ -2958,6 +3003,99 @@ static void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
spin_unlock_irqrestore(&ffs->state_lock, flags);
}
+static bool __ffs_clear_subrange_dirty(struct folio *folio,
+ struct f2fs_folio_state *ffs, size_t offset, size_t len)
+{
+ unsigned int nr_subpages = folio_nr_pages(folio);
+ unsigned int start, end;
+
+ start = offset >> PAGE_SHIFT;
+ end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
+ end = min(end, nr_subpages);
+
+ bitmap_clear(ffs->state, nr_subpages + start, end - start);
+ return find_next_bit(ffs->state, 2 * nr_subpages, nr_subpages) <
+ 2 * nr_subpages;
+}
+
+/**
+ * f2fs_ffs_clear_subrange_dirty_and_test - clear dirty bits and test remaining
+ * @folio: the large folio
+ * @offset: start byte offset within the folio
+ * @len: byte length of the subrange
+ *
+ * Clear the dirty bits of the 4K subpages covered by [offset, offset + len),
+ * and return whether the folio still has any dirty subpage left.
+ */
+bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
+ size_t len)
+{
+ struct f2fs_folio_state *ffs;
+ unsigned long flags;
+ bool dirty;
+
+ if (!f2fs_folio_has_ffs(folio))
+ return false;
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ spin_lock_irqsave(&ffs->state_lock, flags);
+ dirty = __ffs_clear_subrange_dirty(folio, ffs, offset, len);
+ spin_unlock_irqrestore(&ffs->state_lock, flags);
+
+ return dirty;
+}
+
+static unsigned int ffs_next_dirty_subpage(struct f2fs_folio_state *ffs,
+ const struct folio *folio, unsigned int start,
+ unsigned int end)
+{
+ unsigned int nr_subpages = folio_nr_pages(folio);
+
+ return find_next_bit(ffs->state, nr_subpages + end + 1,
+ nr_subpages + start) - nr_subpages;
+}
+
+static unsigned int ffs_next_clean_subpage(struct f2fs_folio_state *ffs,
+ const struct folio *folio, unsigned int start,
+ unsigned int end)
+{
+ unsigned int nr_subpages = folio_nr_pages(folio);
+
+ return find_next_zero_bit(ffs->state, nr_subpages + end + 1,
+ nr_subpages + start) - nr_subpages;
+}
+
+static unsigned int ffs_find_dirty_range(struct folio *folio,
+ u64 *range_start, u64 range_end)
+{
+ struct f2fs_folio_state *ffs;
+ unsigned int start, end, nr_pages;
+
+ if (*range_start >= range_end)
+ return 0;
+
+ if (!f2fs_folio_has_ffs(folio))
+ return range_end - *range_start;
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ start = offset_in_folio(folio, *range_start) >> PAGE_SHIFT;
+ end = DIV_ROUND_UP(min_not_zero(offset_in_folio(folio, range_end),
+ folio_size(folio)), PAGE_SIZE) - 1;
+
+ start = ffs_next_dirty_subpage(ffs, folio, start, end);
+ if (start > end)
+ return 0;
+
+ if (start == end)
+ nr_pages = 1;
+ else
+ nr_pages = ffs_next_clean_subpage(ffs, folio,
+ start + 1, end) - start;
+
+ *range_start = folio_pos(folio) + ((u64)start << PAGE_SHIFT);
+ return (u64)nr_pages << PAGE_SHIFT;
+}
+
static bool find_next_valid_block(const struct folio *folio,
size_t orig_off, size_t *need_off,
size_t len)
@@ -3495,7 +3633,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
if (ipu_force ||
(__is_valid_data_blkaddr(fio->old_blkaddr) &&
need_inplace_update(fio))) {
- folio_start_writeback(folio);
+ __folio_start_writeback(folio, folio_test_dirty(folio));
f2fs_put_dnode(&dn);
if (fio->need_lock == LOCK_REQ)
f2fs_unlock_op(fio->sbi, &lc);
@@ -3522,7 +3660,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
fio->version = ni.version;
- folio_start_writeback(folio);
+ __folio_start_writeback(folio, folio_test_dirty(folio));
if (fio->compr_blocks && fio->old_blkaddr == COMPRESS_ADDR)
f2fs_i_compr_blocks_update(inode, fio->compr_blocks - 1, false);
@@ -3530,6 +3668,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
/* LFS mode write path */
f2fs_outplace_write_data(&dn, fio);
trace_f2fs_do_write_data_page(folio, OPU);
+ /*
+ * The outplace write path failed to submit this block.
+ */
+ if (!fio->submitted) {
+ err = -EIO;
+ goto out_writepage;
+ }
set_inode_flag(inode, FI_APPEND_WRITE);
if (atomic_commit)
folio_clear_f2fs_atomic(folio);
@@ -3541,6 +3686,144 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
return err;
}
+static int f2fs_write_folio_dirty_range(struct folio *folio, int *submitted,
+ struct writeback_control *wbc,
+ enum iostat_type io_type,
+ u64 *pos, u64 len)
+{
+ struct inode *inode = folio->mapping->host;
+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ bool atomic_commit = f2fs_is_atomic_file(inode) &&
+ folio_test_f2fs_atomic(folio);
+ struct inode *dn_inode = atomic_commit ?
+ F2FS_I(inode)->cow_inode : inode;
+ struct f2fs_folio_state *ffs = NULL;
+ u64 folio_start = folio_pos(folio);
+ pgoff_t start_idx = (*pos - folio_start) >> PAGE_SHIFT;
+ pgoff_t end_idx = (*pos - folio_start + len - 1) >> PAGE_SHIFT;
+ int err = 0;
+
+ for (pgoff_t i = start_idx; i <= end_idx && !err; i++) {
+ struct dnode_of_data dn;
+ struct node_info ni;
+ pgoff_t data_idx = folio->index + i;
+ bool ipu_force = false;
+ bool dn_held = false;
+ bool submitted_blk = false;
+ struct f2fs_io_info fio = {
+ .sbi = sbi,
+ .ino = inode->i_ino,
+ .type = DATA,
+ .op = REQ_OP_WRITE,
+ .op_flags = wbc_to_write_flags(wbc),
+ .old_blkaddr = NULL_ADDR,
+ .folio = folio,
+ .folio_offset = i,
+ .folio_blkcnt = 1,
+ .encrypted_page = NULL,
+ .submitted = 0,
+ .need_lock = LOCK_DONE,
+ .meta_gc = f2fs_meta_inode_gc_required(inode) ? 1 : 0,
+ .io_type = io_type,
+ .io_wbc = wbc,
+ };
+
+ if (f2fs_folio_has_ffs(folio)) {
+ ffs = (struct f2fs_folio_state *)folio->private;
+ atomic_inc(&ffs->write_pages_pending);
+ }
+
+ set_new_dnode(&dn, dn_inode, NULL, NULL, 0);
+
+ if (need_inplace_update(&fio) &&
+ f2fs_lookup_read_extent_cache_block(inode, data_idx,
+ &fio.old_blkaddr)) {
+ if (!f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr,
+ DATA_GENERIC_ENHANCE)) {
+ err = -EFSCORRUPTED;
+ goto block_done;
+ }
+ ipu_force = true;
+ goto got_it;
+ }
+
+ err = f2fs_get_dnode_of_data(&dn, data_idx, LOOKUP_NODE);
+ if (err)
+ goto block_done;
+ dn_held = true;
+
+ fio.old_blkaddr = dn.data_blkaddr;
+
+got_it:
+ if (__is_valid_data_blkaddr(fio.old_blkaddr) &&
+ !f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr,
+ DATA_GENERIC_ENHANCE)) {
+ err = -EFSCORRUPTED;
+ goto block_done;
+ }
+
+ if (fio.meta_gc)
+ f2fs_wait_on_block_writeback(inode, fio.old_blkaddr);
+
+ if (ipu_force ||
+ (__is_valid_data_blkaddr(fio.old_blkaddr) &&
+ need_inplace_update(&fio))) {
+ f2fs_put_dnode(&dn);
+ dn_held = false;
+ err = f2fs_inplace_write_data(&fio);
+ trace_f2fs_do_write_data_page(folio, IPU);
+ if (err)
+ goto block_done;
+
+ if (submitted)
+ (*submitted)++;
+ submitted_blk = true;
+ set_inode_flag(inode, FI_UPDATE_WRITE);
+ goto block_done;
+ }
+
+ err = f2fs_get_node_info(sbi, dn.nid, &ni, false);
+ if (err)
+ goto block_done;
+
+ fio.version = ni.version;
+
+ f2fs_outplace_write_data(&dn, &fio);
+ /*
+ * The outplace write path failed to submit this block.
+ */
+ if (!fio.submitted) {
+ err = -EIO;
+ goto block_done;
+ }
+ if (submitted)
+ (*submitted)++;
+ submitted_blk = true;
+ set_inode_flag(inode, FI_APPEND_WRITE);
+ trace_f2fs_do_write_data_page(folio, OPU);
+block_done:
+ if (dn_held)
+ f2fs_put_dnode(&dn);
+ /*
+ * If this block was not submitted, roll back its
+ * write pages pending.
+ */
+ if (!submitted_blk && ffs)
+ f2fs_ffs_put_write_pending(folio, 1);
+ if (!err) {
+ *pos = ((loff_t)data_idx + 1) << PAGE_SHIFT;
+ spin_lock(&F2FS_I(inode)->i_size_lock);
+ if (F2FS_I(inode)->last_disk_size < *pos)
+ F2FS_I(inode)->last_disk_size = *pos;
+ spin_unlock(&F2FS_I(inode)->i_size_lock);
+ } else {
+ file_set_keep_isize(inode);
+ }
+ }
+
+ return err;
+}
+
int f2fs_write_single_data_page(struct folio *folio, int *submitted,
struct bio **bio,
sector_t *last_block,
@@ -3990,6 +4273,226 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
return ret;
}
+static int f2fs_write_cache_folios(struct address_space *mapping,
+ struct writeback_control *wbc,
+ enum iostat_type io_type)
+{
+ struct folio *folio = NULL;
+ struct inode *inode = mapping->host;
+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ struct f2fs_lock_context lc;
+ u64 pos = 0;
+ u64 end_pos = 0;
+ u32 r_len = 0;
+ int err = 0;
+ int submitted = 0;
+ int nwritten = 0;
+ bool op_locked = false;
+ bool retry = false;
+
+ if (get_dirty_pages(inode) <= SM_I(sbi)->min_hot_blocks)
+ set_inode_flag(inode, FI_HOT_DATA);
+ else
+ clear_inode_flag(inode, FI_HOT_DATA);
+
+ while ((folio = writeback_iter(mapping, wbc, folio, &err))) {
+ struct f2fs_folio_state *ffs = NULL;
+ u64 isize;
+ size_t poff;
+ pgoff_t end_index;
+ bool verity_in_progress;
+ int folio_submitted = 0;
+ bool bias_added = false;
+
+ submitted = 0;
+ retry = false;
+
+ if (err) {
+ folio_redirty_for_writepage(wbc, folio);
+ goto retry_out;
+ }
+
+ if (atomic_read(&sbi->wb_sync_req[DATA]) &&
+ wbc->sync_mode == WB_SYNC_NONE) {
+ folio_redirty_for_writepage(wbc, folio);
+ /*
+ * A WB_SYNC_ALL writeback is in progress, so defer
+ * this writeback. Mark the error as -EBUSY to let
+ * writeback_iter() stop iterating.
+ */
+ err = -EBUSY;
+ goto retry_out;
+ }
+
+ /*
+ * If cp_error is set, all subpages of this folio are not written
+ * back unless the filesystem is mounted with errors=remount-ro.
+ */
+ if (unlikely(f2fs_cp_error(sbi))) {
+ mapping_set_error(folio->mapping, -EIO);
+ if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY) {
+ folio_redirty_for_writepage(wbc, folio);
+ } else {
+ if (f2fs_folio_has_ffs(folio))
+ f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
+ folio_size(folio));
+ inode_dec_dirty_pages(inode);
+ }
+ goto retry_out;
+ }
+
+ /*
+ * Writing back one large folio performs multiple block allocations, so
+ * best-effort balance the filesystem before writing it back.
+ */
+ if (!F2FS_I(inode)->wb_task && has_not_enough_free_secs(sbi, 0, 0)) {
+ folio_redirty_for_writepage(wbc, folio);
+ retry = true;
+ folio_unlock(folio);
+ f2fs_balance_fs(sbi, true);
+ folio_lock(folio);
+ goto retry;
+ }
+retry:
+ pos = folio_pos(folio);
+ end_pos = pos + folio_size(folio);
+ isize = i_size_read(inode);
+ verity_in_progress = f2fs_verity_in_progress(inode);
+ poff = 0;
+ end_index = 0;
+
+ if (retry) {
+
+ if (unlikely(folio->mapping != mapping))
+ goto retry_out;
+
+ if (!folio_test_dirty(folio))
+ goto retry_out;
+
+ if (folio_test_writeback(folio)) {
+ if (wbc->sync_mode == WB_SYNC_NONE)
+ goto retry_out;
+ f2fs_folio_wait_writeback(folio, true, true);
+ }
+
+ if (!folio_clear_dirty_for_io(folio))
+ goto retry_out;
+ }
+
+ /* To avoid dealing with the complexity for one subrange is in bio
+ * while we trylock_op failed before writing another subrange.
+ * Try to lock_op before any subrange write for the folio.
+ */
+ if (!op_locked) {
+ if (!f2fs_trylock_op(sbi, &lc)) {
+ folio_redirty_for_writepage(wbc, folio);
+ err = 0;
+ if (wbc->sync_mode != WB_SYNC_ALL)
+ goto retry_out;
+
+ retry = true;
+ folio_unlock(folio);
+ f2fs_io_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
+ folio_lock(folio);
+ goto retry;
+ }
+ op_locked = true;
+ }
+
+ if (!verity_in_progress) {
+ poff = offset_in_folio(folio, isize);
+ end_index = isize >> PAGE_SHIFT;
+
+ if (folio->index > end_index ||
+ (folio->index == end_index && poff == 0))
+ goto out;
+
+ if (end_pos > isize) {
+ folio_zero_segment(folio, poff, folio_size(folio));
+ end_pos = isize;
+ }
+ }
+
+ folio_start_writeback(folio);
+
+ /*
+ * Large folios can be submitted as multiple bios, which may
+ * complete while we are still submitting the remaining dirty
+ * ranges. Hold a bias on write_pages_pending to prevent
+ * folio_end_writeback() from being called early.
+ */
+ if (!bias_added && f2fs_folio_has_ffs(folio)) {
+ ffs = (struct f2fs_folio_state *)folio->private;
+ WARN_ON_ONCE(atomic_read(&ffs->write_pages_pending) != 0);
+ atomic_inc(&ffs->write_pages_pending);
+ bias_added = true;
+ }
+
+ while ((r_len = ffs_find_dirty_range(folio, &pos, end_pos))) {
+ err = f2fs_write_folio_dirty_range(folio, &submitted,
+ wbc, io_type, &pos, r_len);
+ folio_submitted += submitted;
+ nwritten += submitted;
+ if (err)
+ goto out;
+ }
+
+ /* If none of the subpages of a folio is submitted, keep the atomic flag */
+ if (folio_submitted &&
+ f2fs_is_atomic_file(inode) &&
+ folio_test_f2fs_atomic(folio))
+ folio_clear_f2fs_atomic(folio);
+
+out:
+ /*
+ * Clear the dirty state of the subranges that were written back.
+ * If some subranges are still dirty (e.g. the folio was only
+ * partially written back), or if the writeback failed, 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)) || err)
+ folio_redirty_for_writepage(wbc, folio);
+ else
+ inode_dec_dirty_pages(inode);
+
+ /*
+ * Release the bias taken above and we end writeback here if
+ * no write bio is in flight.
+ */
+ if (bias_added) {
+ f2fs_ffs_put_write_pending(folio, 1);
+ } else if (!folio_submitted && folio_test_writeback(folio)) {
+ /*
+ * Order-0 folios take no bias, so end the writeback
+ * if nothing was submitted.
+ */
+ folio_end_writeback(folio);
+ }
+
+retry_out:
+ if (op_locked) {
+ f2fs_unlock_op(sbi, &lc);
+ op_locked = false;
+ }
+
+ folio_unlock(folio);
+ }
+
+ if (nwritten)
+ f2fs_submit_merged_write_cond(F2FS_M_SB(mapping), mapping->host,
+ NULL);
+
+ /*
+ * Prevent the -EBUSY error that stopped writeback_iter() from
+ * propagating to the user.
+ */
+ if (err == -EBUSY)
+ err = 0;
+ return err;
+}
+
static inline bool __should_serialize_io(struct inode *inode,
struct writeback_control *wbc)
{
@@ -4084,7 +4587,11 @@ static int __f2fs_write_data_pages(struct address_space *mapping,
account_writeback(inode, true);
blk_start_plug(&plug);
- ret = f2fs_write_cache_pages(mapping, wbc, io_type);
+ if (mapping_large_folio_support(inode->i_mapping) &&
+ !f2fs_has_inline_data(inode))
+ ret = f2fs_write_cache_folios(mapping, wbc, io_type);
+ else
+ ret = f2fs_write_cache_pages(mapping, wbc, io_type);
blk_finish_plug(&plug);
account_writeback(inode, false);
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 80f58c586e33..cbb65e0343c8 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -4173,7 +4173,13 @@ static void do_write_block(struct f2fs_summary *sum, struct f2fs_io_info *fio)
"%s Failed to allocate data block, ino:%u, index:%lu, type:%d, old_blkaddr:0x%x, new_blkaddr:0x%x, err:%d",
__func__, fio->ino, folio->index, type,
fio->old_blkaddr, fio->new_blkaddr, err);
- folio_end_writeback(folio);
+ /*
+ * For a large folio, the caller rolls back
+ * write_pages_pending and ends writeback when the last
+ * pending write is gone.
+ */
+ if (!f2fs_folio_has_ffs(folio))
+ folio_end_writeback(folio);
}
f2fs_bug_on(fio->sbi, !is_set_ckpt_flags(fio->sbi,
CP_ERROR_FLAG));
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 06/15] f2fs: account large folio dirty data at block granularity
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (4 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 05/15] f2fs: support large folio writeback Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 07/15] f2fs: prepare mmap write faults for large folios Nanzhe Zhao
` (9 subsequent siblings)
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
Originally inode->dirty_pages was accounted once per folio, but f2fs
needs the counter to be accounted in blocks.
This introduces batch dirty page add/sub accounting; for a large folio
the changed dirty page count is computed from the dirty bitmap bit
changes.
Found by f2fs/006 (lfs + checkpoint=disable) and generic/363.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/checkpoint.c | 38 ++++++++++++++++++++++----
fs/f2fs/compress.c | 4 +--
fs/f2fs/data.c | 50 +++++++++++++++++++++++-----------
fs/f2fs/dir.c | 2 +-
fs/f2fs/f2fs.h | 65 ++++++++++++++++++++++++++++++++++----------
fs/f2fs/gc.c | 2 +-
fs/f2fs/inline.c | 2 +-
fs/f2fs/node.c | 2 +-
8 files changed, 123 insertions(+), 42 deletions(-)
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 3ad709f69893..1ed38c668fc5 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -1324,20 +1324,46 @@ static void __remove_dirty_inode(struct inode *inode, enum inode_type type)
stat_dec_dirty_inode(F2FS_I_SB(inode), type);
}
-void f2fs_update_dirty_folio(struct inode *inode, struct folio *folio)
+/*
+ * Account @nr dirty pages (negative when dirtiness is cleared) for @inode.
+ */
+void f2fs_account_dirty_blocks(struct inode *inode, int nr)
{
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
enum inode_type type = S_ISDIR(inode->i_mode) ? DIR_INODE : FILE_INODE;
- if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
- !S_ISLNK(inode->i_mode))
+ if (!nr)
return;
spin_lock(&sbi->inode_lock[type]);
- if (type != FILE_INODE || test_opt(sbi, DATA_FLUSH))
- __add_dirty_inode(inode, type);
- inode_inc_dirty_pages(inode);
+ if (nr > 0) {
+ if (type != FILE_INODE || test_opt(sbi, DATA_FLUSH))
+ __add_dirty_inode(inode, type);
+ inode_add_dirty_blocks(inode, nr);
+ } else {
+ inode_sub_dirty_blocks(inode, -nr);
+ __remove_dirty_inode(inode, type);
+ }
spin_unlock(&sbi->inode_lock[type]);
+}
+
+void f2fs_update_dirty_folio(struct inode *inode, struct folio *folio)
+{
+ if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
+ !S_ISLNK(inode->i_mode))
+ return;
+
+ /*
+ * Large folios have a subpage dirty bitmap, so defer their dirty accounting
+ * to the f2fs_ffs_*subrange_dirty*() helpers. This avoids nesting
+ * ffs->state_lock with the inode dirty list lock.
+ */
+ if (f2fs_folio_has_ffs(folio)) {
+ folio_set_f2fs_reference(folio);
+ return;
+ }
+
+ f2fs_account_dirty_blocks(inode, 1);
folio_set_f2fs_reference(folio);
}
diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
index c0e39f580993..162bd8ef822a 100644
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -1065,7 +1065,7 @@ static void cancel_cluster_writeback(struct compress_ctx *cc,
/* Cancel writeback and stay locked. */
for (i = 0; i < cc->cluster_size; i++) {
if (i < submitted) {
- inode_inc_dirty_pages(cc->inode);
+ inode_inc_dirty_block(cc->inode);
lock_page(cc->rpages[i]);
}
clear_page_private_gcing(cc->rpages[i]);
@@ -1409,7 +1409,7 @@ static int f2fs_write_compressed_pages(struct compress_ctx *cc,
}
(*submitted)++;
unlock_continue:
- inode_dec_dirty_pages(cc->inode);
+ inode_dec_dirty_block(cc->inode);
folio_unlock(fio.folio);
}
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index a0822d06e3bc..d027c949823b 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2985,10 +2985,18 @@ static unsigned int __ffs_mark_subrange_dirty(struct folio *folio,
return bitmap_weight(ffs->state, 2 * nr_subpages) - before;
}
+/*
+ * Mark the given range dirty for writeback.
+ *
+ * Callers must guarantee that the corresponding subpages are already
+ * uptodate: a dirty subpage always holds the latest data, whose
+ * on-disk copy may be stale.
+ */
void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
size_t offset, size_t len)
{
struct f2fs_folio_state *ffs;
+ unsigned int set;
unsigned long flags;
f2fs_bug_on(F2FS_F_SB(folio), offset + len > folio_size(folio));
@@ -2999,21 +3007,27 @@ void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
ffs = (struct f2fs_folio_state *)folio->private;
spin_lock_irqsave(&ffs->state_lock, flags);
- __ffs_mark_subrange_dirty(folio, ffs, offset, len);
+ set = __ffs_mark_subrange_dirty(folio, ffs, offset, len);
spin_unlock_irqrestore(&ffs->state_lock, flags);
+
+ if (set)
+ f2fs_account_dirty_blocks(folio->mapping->host, set);
}
static bool __ffs_clear_subrange_dirty(struct folio *folio,
- struct f2fs_folio_state *ffs, size_t offset, size_t len)
+ struct f2fs_folio_state *ffs, size_t offset, size_t len,
+ unsigned int *cleared)
{
unsigned int nr_subpages = folio_nr_pages(folio);
- unsigned int start, end;
+ unsigned int start, end, before;
start = offset >> PAGE_SHIFT;
end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
end = min(end, nr_subpages);
+ before = bitmap_weight(ffs->state, 2 * nr_subpages);
bitmap_clear(ffs->state, nr_subpages + start, end - start);
+ *cleared = before - bitmap_weight(ffs->state, 2 * nr_subpages);
return find_next_bit(ffs->state, 2 * nr_subpages, nr_subpages) <
2 * nr_subpages;
}
@@ -3025,13 +3039,15 @@ static bool __ffs_clear_subrange_dirty(struct folio *folio,
* @len: byte length of the subrange
*
* Clear the dirty bits of the 4K subpages covered by [offset, offset + len),
- * and return whether the folio still has any dirty subpage left.
+ * account the cleared subpages against the inode dirty counters, and return
+ * whether the folio still has any dirty subpage left.
*/
bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
size_t len)
{
struct f2fs_folio_state *ffs;
unsigned long flags;
+ unsigned int cleared = 0;
bool dirty;
if (!f2fs_folio_has_ffs(folio))
@@ -3039,9 +3055,12 @@ bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
ffs = (struct f2fs_folio_state *)folio->private;
spin_lock_irqsave(&ffs->state_lock, flags);
- dirty = __ffs_clear_subrange_dirty(folio, ffs, offset, len);
+ dirty = __ffs_clear_subrange_dirty(folio, ffs, offset, len, &cleared);
spin_unlock_irqrestore(&ffs->state_lock, flags);
+ if (cleared)
+ f2fs_account_dirty_blocks(folio->mapping->host, -cleared);
+
return dirty;
}
@@ -3951,7 +3970,7 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted,
goto redirty_out;
out:
- inode_dec_dirty_pages(inode);
+ inode_dec_dirty_block(inode);
if (err) {
folio_clear_uptodate(folio);
folio_clear_f2fs_gcing(folio);
@@ -4330,14 +4349,13 @@ static int f2fs_write_cache_folios(struct address_space *mapping,
*/
if (unlikely(f2fs_cp_error(sbi))) {
mapping_set_error(folio->mapping, -EIO);
- if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY) {
+ if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY)
folio_redirty_for_writepage(wbc, folio);
- } else {
- if (f2fs_folio_has_ffs(folio))
- f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
- folio_size(folio));
- inode_dec_dirty_pages(inode);
- }
+ else if (f2fs_folio_has_ffs(folio))
+ f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
+ folio_size(folio));
+ else
+ f2fs_account_dirty_blocks(inode, -1);
goto retry_out;
}
@@ -4454,8 +4472,8 @@ static int f2fs_write_cache_folios(struct address_space *mapping,
if (f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
(err ? pos : end_pos) - folio_pos(folio)) || err)
folio_redirty_for_writepage(wbc, folio);
- else
- inode_dec_dirty_pages(inode);
+ else if (!f2fs_folio_has_ffs(folio))
+ inode_dec_dirty_block(inode);
/*
* Release the bias taken above and we end writeback here if
@@ -5307,7 +5325,7 @@ void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length)
return;
if (folio_test_dirty(folio)) {
- inode_dec_dirty_pages(inode);
+ inode_dec_dirty_block(inode);
f2fs_remove_dirty_inode(inode);
}
diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index 97f7fef6b068..70847313ca6a 100644
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -937,7 +937,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, void *dentry_block,
folio_clear_uptodate(folio);
folio_detach_private(folio);
- inode_dec_dirty_pages(dir);
+ inode_dec_dirty_block(dir);
f2fs_remove_dirty_inode(dir);
}
f2fs_folio_put(folio, true);
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index df0091591ff5..b89664e28a92 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2919,9 +2919,10 @@ static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
f2fs_i_blocks_write(inode, count, false, true);
}
-static inline void inc_cache_count(struct f2fs_sb_info *sbi, int count_type)
+static inline void add_cache_counts(struct f2fs_sb_info *sbi,
+ int count_type, int nr)
{
- atomic_inc(&sbi->nr_caches[count_type]);
+ atomic_add(nr, &sbi->nr_caches[count_type]);
if (count_type == F2FS_DIRTY_DENTS ||
count_type == F2FS_DIRTY_NODES ||
@@ -2931,31 +2932,66 @@ static inline void inc_cache_count(struct f2fs_sb_info *sbi, int count_type)
set_sbi_flag(sbi, SBI_IS_DIRTY);
}
-static inline void inode_inc_dirty_pages(struct inode *inode)
+static inline void sub_cache_counts(struct f2fs_sb_info *sbi,
+ int count_type, int nr)
{
- atomic_inc(&F2FS_I(inode)->dirty_pages);
- inc_cache_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
- F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA);
- if (IS_NOQUOTA(inode))
- inc_cache_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
+ atomic_sub(nr, &sbi->nr_caches[count_type]);
+}
+
+static inline void inc_cache_count(struct f2fs_sb_info *sbi, int count_type)
+{
+ add_cache_counts(sbi, count_type, 1);
}
static inline void dec_cache_count(struct f2fs_sb_info *sbi, int count_type)
{
- atomic_dec(&sbi->nr_caches[count_type]);
+ sub_cache_counts(sbi, count_type, 1);
+}
+
+/*
+ * Account @nr dirty pages for @inode; one page is
+ * (PAGE_SIZE >> log_blocksize) filesystem blocks.
+ */
+static inline void inode_add_dirty_blocks(struct inode *inode, int nr)
+{
+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ int blocks = nr * (PAGE_SIZE >> sbi->log_blocksize);
+
+ atomic_add(blocks, &F2FS_I(inode)->dirty_pages);
+ if (S_ISDIR(inode->i_mode))
+ add_cache_counts(sbi, F2FS_DIRTY_DENTS, blocks);
+ else
+ add_cache_counts(sbi, F2FS_DIRTY_DATA, blocks);
+ if (IS_NOQUOTA(inode))
+ add_cache_counts(sbi, F2FS_DIRTY_QDATA, blocks);
}
-static inline void inode_dec_dirty_pages(struct inode *inode)
+static inline void inode_sub_dirty_blocks(struct inode *inode, int nr)
{
+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ int blocks = nr * (PAGE_SIZE >> sbi->log_blocksize);
+
if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
!S_ISLNK(inode->i_mode))
return;
- atomic_dec(&F2FS_I(inode)->dirty_pages);
- dec_cache_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
- F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA);
+ atomic_sub(blocks, &F2FS_I(inode)->dirty_pages);
+ if (S_ISDIR(inode->i_mode))
+ sub_cache_counts(sbi, F2FS_DIRTY_DENTS, blocks);
+ else
+ sub_cache_counts(sbi, F2FS_DIRTY_DATA, blocks);
if (IS_NOQUOTA(inode))
- dec_cache_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
+ sub_cache_counts(sbi, F2FS_DIRTY_QDATA, blocks);
+}
+
+static inline void inode_inc_dirty_block(struct inode *inode)
+{
+ inode_add_dirty_blocks(inode, 1);
+}
+
+static inline void inode_dec_dirty_block(struct inode *inode)
+{
+ inode_sub_dirty_blocks(inode, 1);
}
static inline void inc_atomic_write_cnt(struct inode *inode)
@@ -4384,6 +4420,7 @@ void f2fs_remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino);
int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi);
int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi);
void f2fs_update_dirty_folio(struct inode *inode, struct folio *folio);
+void f2fs_account_dirty_blocks(struct inode *inode, int nr);
void f2fs_remove_dirty_inode(struct inode *inode);
int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type,
bool from_cp);
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 72c7f9ceafc2..c66ca03d0d5a 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1565,7 +1565,7 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
folio_mark_dirty(folio);
if (folio_clear_dirty_for_io(folio)) {
- inode_dec_dirty_pages(inode);
+ inode_dec_dirty_block(inode);
f2fs_remove_dirty_inode(inode);
}
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index ab7537ff7ebd..49905aa08418 100644
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -199,7 +199,7 @@ int f2fs_convert_inline_folio(struct dnode_of_data *dn, struct folio *folio)
f2fs_outplace_write_data(dn, &fio);
f2fs_folio_wait_writeback(folio, true, true);
if (dirty) {
- inode_dec_dirty_pages(dn->inode);
+ inode_dec_dirty_block(dn->inode);
f2fs_remove_dirty_inode(dn->inode);
}
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index 424e95ca5878..1fdef678dcef 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1699,7 +1699,7 @@ static void flush_inline_data(struct f2fs_sb_info *sbi, nid_t ino)
goto folio_out;
ret = f2fs_write_inline_data(inode, folio);
- inode_dec_dirty_pages(inode);
+ inode_dec_dirty_block(inode);
f2fs_remove_dirty_inode(inode);
if (ret)
folio_mark_dirty(folio);
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 07/15] f2fs: prepare mmap write faults for large folios
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (5 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 06/15] f2fs: account large folio dirty data at block granularity Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-27 9:35 ` Chao Yu
2026-10-26 3:37 ` [PATCH v7 08/15] f2fs: make GC migration large-folio aware Nanzhe Zhao
` (8 subsequent siblings)
15 siblings, 1 reply; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
Now write protect `mmap` also need to support large folio,
Change `f2fs_vm_page_mkwrite` to achieve that.
Note it currently marks the whole large folio dirty
to avoid data loss which causes write amplification.
Further optimization is welcome.
The folio_zero_segment() in mkwrite is extended to zero the
post-EOF part of the faulted folio for both order-0 and large
folios, so the f2fs_zero_post_eof_page() call that was added
to cover the removed shortcut is no longer needed.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/f2fs.h | 4 +++
fs/f2fs/file.c | 96 ++++++++++++++++++++++++++++++++------------------
2 files changed, 65 insertions(+), 35 deletions(-)
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index b89664e28a92..915ca72cf276 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4492,6 +4492,10 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted,
enum iostat_type io_type,
int compr_blocks, bool allow_balance);
bool f2fs_ffs_test_blk_uptodate(const struct folio *folio, pgoff_t index);
+struct f2fs_folio_state *f2fs_ffs_find_or_alloc(struct folio *folio);
+void f2fs_ffs_mark_subrange_dirty(struct folio *folio, size_t offset, size_t len);
+bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
+ size_t len);
void f2fs_write_failed(struct inode *inode, loff_t to);
void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length);
bool f2fs_release_folio(struct folio *folio, gfp_t wait);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 85b4f1a2ff0d..808b72d3d78a 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -118,14 +118,48 @@ static vm_fault_t f2fs_filemap_fault(struct vm_fault *vmf)
return ret;
}
+static int f2fs_get_block_mkwrite(struct inode *inode, struct folio *folio,
+ pgoff_t index, bool need_alloc)
+{
+ struct dnode_of_data dn;
+ int err;
+
+ set_new_dnode(&dn, inode, NULL, NULL, 0);
+ if (need_alloc) {
+ err = f2fs_get_block_locked(&dn, index);
+ } else {
+ err = f2fs_get_dnode_of_data(&dn, index, LOOKUP_NODE);
+ f2fs_put_dnode(&dn);
+ if (f2fs_is_pinned_file(inode) &&
+ !__is_valid_data_blkaddr(dn.data_blkaddr))
+ err = -EIO;
+ }
+
+ if (err)
+ return err;
+
+ f2fs_folio_wait_writeback(folio, false, true);
+
+ /* wait for GCed page writeback via META_MAPPING */
+ f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
+
+ return 0;
+}
+
static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
{
struct folio *folio = page_folio(vmf->page);
struct inode *inode = file_inode(vmf->vma->vm_file);
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
- struct dnode_of_data dn;
bool need_alloc = !f2fs_is_pinned_file(inode);
+ pgoff_t pidx = folio->index + folio_page_idx(folio, vmf->page);
+ loff_t pos = (loff_t)pidx << PAGE_SHIFT;
loff_t isize;
+ loff_t folio_start;
+ loff_t valid_end;
+ size_t dirty_len;
+ size_t subpage_off;
+ pgoff_t i, nr;
int err = 0;
vm_fault_t ret;
@@ -162,7 +196,7 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
#ifdef CONFIG_F2FS_FS_COMPRESSION
if (f2fs_compressed_file(inode)) {
- int ret = f2fs_is_compressed_cluster(inode, folio->index);
+ int ret = f2fs_is_compressed_cluster(inode, pidx);
if (ret < 0) {
err = ret;
@@ -180,11 +214,6 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
- err = f2fs_zero_post_eof_page(inode,
- (folio->index + 1) << PAGE_SHIFT, true, false);
- if (err)
- goto out_pagefault;
-
file_update_time(vmf->vma->vm_file);
filemap_invalidate_lock_shared(inode->i_mapping);
@@ -200,62 +229,59 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
}
folio_lock(folio);
- /*
- * A concurrent buffered write can extend isize, so we store isize in a
- * local variable to let the zeroing offset match the EOF check below.
- */
isize = i_size_read(inode);
+ folio_start = folio_pos(folio);
+ subpage_off = offset_in_folio(folio, pos);
+ valid_end = min_t(loff_t, folio_start + folio_size(folio), isize);
+ dirty_len = valid_end - folio_start;
if (unlikely(folio->mapping != inode->i_mapping ||
- folio_pos(folio) > isize ||
- !folio_test_uptodate(folio))) {
+ pos >= isize ||
+ !f2fs_ffs_test_blk_uptodate(folio,
+ folio->index + (subpage_off >> PAGE_SHIFT)))) {
folio_unlock(folio);
err = -EFAULT;
goto out_sem;
}
- set_new_dnode(&dn, inode, NULL, NULL, 0);
- if (need_alloc) {
- /* block allocation */
- err = f2fs_get_block_locked(&dn, folio->index);
- } else {
- err = f2fs_get_dnode_of_data(&dn, folio->index, LOOKUP_NODE);
- f2fs_put_dnode(&dn);
- if (f2fs_is_pinned_file(inode) &&
- !__is_valid_data_blkaddr(dn.data_blkaddr))
- err = -EIO;
- }
-
- if (err) {
+ if (folio_test_large(folio) && !f2fs_ffs_find_or_alloc(folio)) {
folio_unlock(folio);
+ err = -ENOMEM;
goto out_sem;
}
- f2fs_folio_wait_writeback(folio, false, true);
+ nr = DIV_ROUND_UP(dirty_len, PAGE_SIZE);
- /* wait for GCed page writeback via generic cache */
- f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
+ for (i = 0; i < nr; i++) {
+ err = f2fs_get_block_mkwrite(inode, folio, folio->index + i,
+ need_alloc);
+ if (err) {
+ folio_unlock(folio);
+ goto out_sem;
+ }
+ }
/* page is wholly or partially inside EOF */
- if (((loff_t)(folio->index + 1) << PAGE_SHIFT) > isize) {
- loff_t offset;
+ if (folio_start + folio_size(folio) > isize) {
+ size_t offset = offset_in_folio(folio, isize);
- offset = isize & ~PAGE_MASK;
folio_zero_segment(folio, offset, folio_size(folio));
}
+
+ if (folio_test_large(folio))
+ f2fs_ffs_mark_subrange_dirty(folio, 0, dirty_len);
folio_mark_dirty(folio);
- f2fs_update_iostat(sbi, inode, APP_MAPPED_IO, F2FS_BLKSIZE(sbi));
+ f2fs_update_iostat(sbi, inode, APP_MAPPED_IO, dirty_len);
f2fs_update_time(sbi, REQ_TIME);
out_sem:
filemap_invalidate_unlock_shared(inode->i_mapping);
-out_pagefault:
sb_end_pagefault(inode->i_sb);
out:
ret = vmf_fs_error(err);
- trace_f2fs_vm_page_mkwrite(inode, folio->index, vmf->vma->vm_flags, ret);
+ trace_f2fs_vm_page_mkwrite(inode, pidx, vmf->vma->vm_flags, ret);
return ret;
}
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 08/15] f2fs: make GC migration large-folio aware
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (6 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 07/15] f2fs: prepare mmap write faults for large folios Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-27 9:37 ` Chao Yu
2026-10-26 3:37 ` [PATCH v7 09/15] f2fs: optimize small block size large folio read Nanzhe Zhao
` (7 subsequent siblings)
15 siblings, 1 reply; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
GC can operate on a 4K block that is cached inside a large folio.
The data lookup helpers therefore need to test and update uptodate
state for the addressed subpage instead of rejecting large folios or
treating the whole folio as the target block.
Let f2fs_get_read_data_folio() and f2fs_get_lock_data_folio() to use
subpage uptodate state. Submit single-block reads at the requested
folio offset and zero only the addressed 4K range for NEW_ADDR.
Also update `move_data_page` to mark, clear, and restore dirty
state for the target subpage, and submit write I/O with the subpage
offset recorded in f2fs_io_info.
The write_pages_pending reference is taken by f2fs_do_write_data_page()
and dropped from its common error path, so a block that is truncated
concurrently no longer leaks the counter.
Reported-by: kernel test robot <yi1.lai@intel.com>
Closes: https://lore.kernel.org/oe-lkp/202610081027.b13dcf10-lkp@intel.com
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 70 +++++++++++++++++++++++++++++++++--------------
fs/f2fs/f2fs.h | 1 +
fs/f2fs/gc.c | 28 +++++++++++++++----
fs/f2fs/segment.c | 2 +-
4 files changed, 75 insertions(+), 26 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index d027c949823b..b3ada22cb0cb 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1679,20 +1679,16 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
struct dnode_of_data dn;
struct folio *folio;
int err;
-retry:
+
folio = f2fs_grab_cache_folio(mapping, index, for_write);
if (IS_ERR(folio))
return folio;
if (folio_test_large(folio)) {
- pgoff_t folio_index = mapping_align_index(mapping, index);
- unsigned long nr_pages = folio_nr_pages(folio);
-
- f2fs_folio_put(folio, true);
- invalidate_inode_pages2_range(mapping, folio_index,
- folio_index + nr_pages - 1);
- f2fs_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
- goto retry;
+ if (!f2fs_ffs_find_or_alloc(folio)) {
+ err = -ENOMEM;
+ goto put_err;
+ }
}
if (f2fs_lookup_read_extent_cache_block(inode, index,
@@ -1728,7 +1724,7 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
goto put_err;
}
got_it:
- if (folio_test_uptodate(folio)) {
+ if (f2fs_ffs_test_blk_uptodate(folio, index)) {
folio_unlock(folio);
return folio;
}
@@ -1741,9 +1737,11 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
* f2fs_init_inode_metadata.
*/
if (dn.data_blkaddr == NEW_ADDR) {
- folio_zero_segment(folio, 0, folio_size(folio));
- if (!folio_test_uptodate(folio))
- folio_mark_uptodate(folio);
+ size_t offset = offset_in_folio(folio,
+ (loff_t)index << PAGE_SHIFT);
+
+ folio_zero_segment(folio, offset, offset + PAGE_SIZE);
+ f2fs_ffs_mark_subrange_uptodate(folio, offset, PAGE_SIZE);
folio_unlock(folio);
return folio;
}
@@ -1803,7 +1801,6 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
/* wait for read completion */
folio_lock(folio);
-
if (unlikely(folio->mapping != mapping)) {
f2fs_folio_put(folio, true);
return ERR_PTR(-EIO);
@@ -1812,7 +1809,7 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
/*
* ffs can be released while the folio was unlocked above. Rebuild it
* for a fully uptodate folio; a partially uptodate one cannot be
- * rebuilt and will fail the uptodate check below.
+ * rebuilt and will fail the subpage check below.
*/
if (folio_test_large(folio) && !f2fs_folio_has_ffs(folio)) {
if (!f2fs_ffs_find_or_alloc(folio)) {
@@ -1821,7 +1818,7 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
}
}
- if (unlikely(!folio_test_uptodate(folio))) {
+ if (unlikely(!f2fs_ffs_test_blk_uptodate(folio, index))) {
f2fs_folio_put(folio, true);
return ERR_PTR(-EIO);
}
@@ -2970,6 +2967,22 @@ static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
folio_mark_uptodate(folio);
}
+bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
+{
+ struct f2fs_folio_state *ffs;
+ unsigned int idx, nr_subpages;
+
+ f2fs_bug_on(F2FS_F_SB(folio), !folio_contains(folio, index));
+
+ if (!f2fs_folio_has_ffs(folio))
+ return folio_test_dirty(folio);
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ nr_subpages = folio_nr_pages(folio);
+ idx = index - folio->index;
+ return test_bit(nr_subpages + idx, ffs->state);
+}
+
static unsigned int __ffs_mark_subrange_dirty(struct folio *folio,
struct f2fs_folio_state *ffs, size_t offset, size_t len)
{
@@ -3063,7 +3076,6 @@ bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
return dirty;
}
-
static unsigned int ffs_next_dirty_subpage(struct f2fs_folio_state *ffs,
const struct folio *folio, unsigned int start,
unsigned int end)
@@ -3561,7 +3573,7 @@ bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio)
return true;
if (fio) {
- if (page_private_gcing(fio->page))
+ if (folio_test_f2fs_gcing(fio->folio))
return true;
if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))
@@ -3587,8 +3599,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
struct dnode_of_data dn;
struct node_info ni;
struct f2fs_lock_context lc;
+ struct f2fs_folio_state *ffs;
bool ipu_force = false;
bool atomic_commit;
+ bool pending_added = false;
+ bool submitted = false;
int err = 0;
/* Use COW inode to make dnode_of_data for atomic write */
@@ -3617,8 +3632,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
return -EINVAL;
/* Deadlock due to between page->lock and f2fs_lock_op */
- if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc))
+ if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc)) {
+ if (!f2fs_ffs_has_dirty_subpage(folio))
+ folio_clear_f2fs_gcing(folio);
return -EAGAIN;
+ }
err = f2fs_get_dnode_of_data(&dn, F2FS_FIO_LBLK(fio),
LOOKUP_NODE);
@@ -3630,7 +3648,6 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
/* This page is already truncated */
if (fio->old_blkaddr == NULL_ADDR) {
folio_clear_uptodate(folio);
- folio_clear_f2fs_gcing(folio);
goto out_writepage;
}
got_it:
@@ -3680,6 +3697,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
fio->version = ni.version;
__folio_start_writeback(folio, folio_test_dirty(folio));
+ if (f2fs_folio_has_ffs(folio)) {
+ ffs = (struct f2fs_folio_state *)folio->private;
+ atomic_inc(&ffs->write_pages_pending);
+ pending_added = true;
+ }
if (fio->compr_blocks && fio->old_blkaddr == COMPRESS_ADDR)
f2fs_i_compr_blocks_update(inode, fio->compr_blocks - 1, false);
@@ -3694,6 +3716,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
err = -EIO;
goto out_writepage;
}
+ submitted = true;
set_inode_flag(inode, FI_APPEND_WRITE);
if (atomic_commit)
folio_clear_f2fs_atomic(folio);
@@ -3702,6 +3725,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
out:
if (fio->need_lock == LOCK_REQ)
f2fs_unlock_op(fio->sbi, &lc);
+ if (!submitted) {
+ if (pending_added) {
+ f2fs_ffs_put_write_pending(folio, 1);
+ } else if (!f2fs_ffs_has_dirty_subpage(folio)) {
+ folio_clear_f2fs_gcing(folio);
+ }
+ }
return err;
}
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 915ca72cf276..1b63dd961f15 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4493,6 +4493,7 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted,
int compr_blocks, bool allow_balance);
bool f2fs_ffs_test_blk_uptodate(const struct folio *folio, pgoff_t index);
struct f2fs_folio_state *f2fs_ffs_find_or_alloc(struct folio *folio);
+bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index);
void f2fs_ffs_mark_subrange_dirty(struct folio *folio, size_t offset, size_t len);
bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
size_t len);
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index c66ca03d0d5a..c3e01f6811b4 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1520,12 +1520,19 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
unsigned int segno, int off)
{
struct folio *folio;
+ size_t foff = 0;
+ bool large = false;
int err = 0;
folio = f2fs_get_lock_data_folio(inode, bidx, true);
if (IS_ERR(folio))
return PTR_ERR(folio);
+ if (f2fs_folio_has_ffs(folio)) {
+ large = true;
+ foff = offset_in_folio(folio, (loff_t)bidx << PAGE_SHIFT);
+ }
+
if (!check_valid_map(F2FS_I_SB(inode), segno, off)) {
err = -ENOENT;
goto out;
@@ -1540,6 +1547,8 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
err = -EAGAIN;
goto out;
}
+ if (large)
+ f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
folio_mark_dirty(folio);
folio_set_f2fs_gcing(folio);
} else {
@@ -1558,28 +1567,37 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
.need_lock = LOCK_REQ,
.io_type = FS_GC_DATA_IO,
};
- bool is_dirty = folio_test_dirty(folio);
+ bool is_dirty = f2fs_ffs_test_blk_dirty(folio, bidx);
retry:
f2fs_folio_wait_writeback(folio, true, true);
+ if (large)
+ f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
folio_mark_dirty(folio);
if (folio_clear_dirty_for_io(folio)) {
- inode_dec_dirty_block(inode);
- f2fs_remove_dirty_inode(inode);
+ if (!large) {
+ inode_dec_dirty_block(inode);
+ f2fs_remove_dirty_inode(inode);
+ } else if (f2fs_ffs_clear_subrange_dirty_and_test(folio,
+ foff, PAGE_SIZE)) {
+ folio_mark_dirty(folio);
+ }
}
folio_set_f2fs_gcing(folio);
err = f2fs_do_write_data_page(&fio);
if (err) {
- folio_clear_f2fs_gcing(folio);
if (err == -ENOMEM) {
memalloc_retry_wait(GFP_NOFS);
goto retry;
}
- if (is_dirty)
+ if (is_dirty) {
+ if (large)
+ f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
folio_mark_dirty(folio);
+ }
}
}
out:
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index cbb65e0343c8..e017a5f2a67f 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -3863,7 +3863,7 @@ static int __get_segment_type_6(struct f2fs_io_info *fio)
if (is_inode_flag_set(inode, FI_ALIGNED_WRITE))
return CURSEG_COLD_DATA_PINNED;
- if (page_private_gcing(fio->page)) {
+ if (folio_test_f2fs_gcing(fio->folio)) {
if (fio->sbi->am.atgc_enabled &&
(fio->io_type == FS_DATA_IO) &&
(fio->sbi->gc_mode != GC_URGENT_HIGH) &&
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 09/15] f2fs: optimize small block size large folio read
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (7 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 08/15] f2fs: make GC migration large-folio aware Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 10/15] f2fs: support partial uptodate " Nanzhe Zhao
` (6 subsequent siblings)
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
The original f2fs_read_data_large_folio() implementation has limited
benefit with a 4KB block size, mainly because updating
read_pages_pending greatly increases the number of spinlock
operations.
Use len_blks to batch read_pages_pending and iostat updates for
contiguous mapped blocks.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 46 +++++++++++++++++++++++++++++++---------------
1 file changed, 31 insertions(+), 15 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index b3ada22cb0cb..b805dbe2c187 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -158,7 +158,7 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
continue;
}
- if (folio_test_large(folio)) {
+ if (f2fs_folio_has_ffs(folio)) {
struct f2fs_folio_state *ffs =
(struct f2fs_folio_state *)folio->private;
@@ -3167,7 +3167,7 @@ static int f2fs_read_data_large_folio(struct inode *inode,
pgoff_t index, offset, next_pgofs = 0;
unsigned max_nr_pages = rac ? readahead_count(rac) :
folio_nr_pages(folio);
- unsigned nrpages;
+ unsigned nrpages, len_blks;
struct f2fs_folio_state *ffs;
int ret = 0;
bool folio_in_bio = false;
@@ -3191,11 +3191,16 @@ static int f2fs_read_data_large_folio(struct inode *inode,
folio_in_bio = false;
index = folio->index;
offset = 0;
- ffs = NULL;
nrpages = folio_nr_pages(folio);
- for (; nrpages; nrpages--, max_nr_pages--, index++, offset++) {
+ for (; nrpages;
+ nrpages -= len_blks, max_nr_pages -= len_blks,
+ index += len_blks, offset += len_blks) {
sector_t block_nr;
+ unsigned int i;
+
+ len_blks = 1;
+
/*
* Map blocks using the previous result first.
*/
@@ -3224,13 +3229,23 @@ static int f2fs_read_data_large_folio(struct inode *inode,
got_it:
if ((map.m_flags & F2FS_MAP_MAPPED)) {
block_nr = map.m_pblk + index - map.m_lblk;
- if (!f2fs_is_valid_blkaddr(F2FS_I_SB(inode), block_nr,
+
+ len_blks = min_t(unsigned int, nrpages, max_nr_pages);
+ len_blks = min_t(unsigned int, len_blks,
+ (unsigned int)(map.m_lblk + map.m_len - index));
+
+ for (i = 0; i < len_blks; i++) {
+ if (!f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
+ block_nr + i,
DATA_GENERIC_ENHANCE_READ)) {
- ret = -EFSCORRUPTED;
- goto err_out;
+ ret = -EFSCORRUPTED;
+ goto err_out;
+ }
}
+
} else {
size_t page_offset = offset << PAGE_SHIFT;
+
folio_zero_range(folio, page_offset, PAGE_SIZE);
if (vi && !fsverity_verify_blocks(vi, folio, PAGE_SIZE, page_offset)) {
ret = -EIO;
@@ -3250,9 +3265,7 @@ static int f2fs_read_data_large_folio(struct inode *inode,
}
/* set the bitmap to wait */
- spin_lock_irq(&ffs->state_lock);
- ffs->read_pages_pending++;
- spin_unlock_irq(&ffs->state_lock);
+ f2fs_update_read_folio_pending(folio, len_blks);
}
/*
@@ -3276,17 +3289,20 @@ static int f2fs_read_data_large_folio(struct inode *inode,
* If the page is under writeback, we need to wait for
* its completion to see the correct decrypted data.
*/
- f2fs_wait_on_block_writeback(inode, block_nr);
+ for (i = 0; i < len_blks; i++)
+ f2fs_wait_on_block_writeback(inode, block_nr + i);
- if (!bio_add_folio(bio, folio, F2FS_BLKSIZE(F2FS_I_SB(inode)),
+ if (!bio_add_folio(bio, folio,
+ len_blks * F2FS_BLKSIZE(F2FS_I_SB(inode)),
offset << PAGE_SHIFT))
goto submit_and_realloc;
folio_in_bio = true;
- inc_cache_count(F2FS_I_SB(inode), F2FS_RD_DATA);
+ for (i = 0; i < len_blks; i++)
+ inc_cache_count(F2FS_I_SB(inode), F2FS_RD_DATA);
f2fs_update_iostat(F2FS_I_SB(inode), NULL, FS_DATA_READ_IO,
- F2FS_BLKSIZE(F2FS_I_SB(inode)));
- last_block_in_bio = block_nr;
+ len_blks * F2FS_BLKSIZE(F2FS_I_SB(inode)));
+ last_block_in_bio = block_nr + len_blks - 1;
}
trace_f2fs_read_folio(folio, DATA);
err_out:
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 10/15] f2fs: support partial uptodate large folio read
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (8 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 09/15] f2fs: optimize small block size large folio read Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 11/15] f2fs: handle partial truncate of large folio dirty subpages Nanzhe Zhao
` (5 subsequent siblings)
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
Buffered write can have write bytes smaller than folio
size for cases when folio minimum order is not zero.
This can left partially uptodate folio in page cache.
So we skip uptodate subpage read in read_data_large_folio.
Also mark hole subpage uptodate in uptodate bitmap.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 102 +++++++++++++++++++++++++++++++++++++++++++++----
1 file changed, 95 insertions(+), 7 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index b805dbe2c187..2dacc9211cc2 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -148,6 +148,7 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
struct folio *folio = fi.folio;
unsigned nr_pages = fi.length >> PAGE_SHIFT;
bool finished = true;
+ bool uptodate = bio->bi_status == BLK_STS_OK;
if (!folio_test_large(folio) &&
f2fs_is_compressed_page(folio)) {
@@ -163,6 +164,9 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
(struct f2fs_folio_state *)folio->private;
spin_lock_irqsave(&ffs->state_lock, flags);
+ if (uptodate)
+ uptodate = __ffs_mark_subrange_uptodate(folio, ffs,
+ fi.offset, fi.length);
ffs->read_pages_pending -= nr_pages;
finished = !ffs->read_pages_pending;
spin_unlock_irqrestore(&ffs->state_lock, flags);
@@ -172,7 +176,7 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
dec_cache_count(F2FS_F_SB(folio), F2FS_RD_DATA);
if (finished)
- folio_end_read(folio, bio->bi_status == BLK_STS_OK);
+ folio_end_read(folio, uptodate);
}
if (ctx)
@@ -3157,6 +3161,70 @@ static bool find_next_valid_block(const struct folio *folio,
return false;
}
+static unsigned int ffs_next_uptodate_subpage(struct f2fs_folio_state *ffs,
+ unsigned int start, unsigned int end)
+{
+ return find_next_bit(ffs->state, end + 1, start);
+}
+
+static unsigned int ffs_next_nonuptodate_subpage(struct f2fs_folio_state *ffs,
+ unsigned int start, unsigned int end)
+{
+ return find_next_zero_bit(ffs->state, end + 1, start);
+}
+
+static void f2fs_skip_fully_uptodate_front(struct folio *folio,
+ pgoff_t *index, pgoff_t *offset, unsigned int *nrpages,
+ unsigned int *max_nr_pages)
+{
+ struct f2fs_folio_state *ffs;
+ unsigned int next, skipped;
+
+ if (!f2fs_folio_has_ffs(folio) || !*nrpages)
+ return;
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ next = ffs_next_nonuptodate_subpage(ffs, *offset,
+ *offset + *nrpages - 1);
+ skipped = next - *offset;
+ if (!skipped)
+ return;
+
+ *index += skipped;
+ *offset += skipped;
+ *nrpages -= skipped;
+ *max_nr_pages -= skipped;
+}
+
+static void f2fs_truncate_read_extent(struct inode *inode, struct folio *folio,
+ pgoff_t offset, block_t block_nr,
+ unsigned int *len_blks)
+{
+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ struct f2fs_folio_state *ffs;
+ unsigned int next, end;
+
+ if (!f2fs_folio_has_ffs(folio) || *len_blks <= 1)
+ return;
+
+ if (f2fs_is_multi_device(sbi)) {
+ int bidx = f2fs_target_device_index(sbi, block_nr);
+
+ *len_blks = min_t(unsigned int, *len_blks,
+ FDEV(bidx).end_blk + 1 - block_nr);
+ }
+ *len_blks = min_t(unsigned int, *len_blks,
+ (unsigned int)fscrypt_limit_io_blocks(inode,
+ folio->index + offset,
+ *len_blks));
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ end = offset + *len_blks - 1;
+ next = ffs_next_uptodate_subpage(ffs, offset + 1, end);
+ if (next <= end)
+ *len_blks = next - offset;
+}
+
static int f2fs_read_data_large_folio(struct inode *inode,
struct fsverity_info *vi,
struct readahead_control *rac, struct folio *folio)
@@ -3189,6 +3257,19 @@ static int f2fs_read_data_large_folio(struct inode *inode,
f2fs_update_read_folio_count(F2FS_I_SB(inode), folio);
folio_in_bio = false;
+ ffs = NULL;
+ if (folio_test_large(folio)) {
+ /*
+ * Allocate the folio state before doing anything with the
+ * folio, so that the block mapping helpers below can rely on
+ * it, and fail early if memory is not available.
+ */
+ ffs = f2fs_ffs_find_or_alloc(folio);
+ if (!ffs) {
+ ret = -ENOMEM;
+ goto err_out;
+ }
+ }
index = folio->index;
offset = 0;
nrpages = folio_nr_pages(folio);
@@ -3201,6 +3282,11 @@ static int f2fs_read_data_large_folio(struct inode *inode,
len_blks = 1;
+ f2fs_skip_fully_uptodate_front(folio, &index, &offset,
+ &nrpages, &max_nr_pages);
+ if (!nrpages)
+ break;
+
/*
* Map blocks using the previous result first.
*/
@@ -3233,6 +3319,8 @@ static int f2fs_read_data_large_folio(struct inode *inode,
len_blks = min_t(unsigned int, nrpages, max_nr_pages);
len_blks = min_t(unsigned int, len_blks,
(unsigned int)(map.m_lblk + map.m_len - index));
+ f2fs_truncate_read_extent(inode, folio, offset,
+ block_nr, &len_blks);
for (i = 0; i < len_blks; i++) {
if (!f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
@@ -3251,6 +3339,12 @@ static int f2fs_read_data_large_folio(struct inode *inode,
ret = -EIO;
goto err_out;
}
+ if (folio_test_large(folio)) {
+ spin_lock_irq(&ffs->state_lock);
+ __ffs_mark_subrange_uptodate(folio, ffs,
+ page_offset, PAGE_SIZE);
+ spin_unlock_irq(&ffs->state_lock);
+ }
continue;
}
@@ -3258,12 +3352,6 @@ static int f2fs_read_data_large_folio(struct inode *inode,
* to prevent from premature folio_end_read() call on folio
*/
if (folio_test_large(folio)) {
- ffs = f2fs_ffs_find_or_alloc(folio);
- if (!ffs) {
- ret = -ENOMEM;
- goto err_out;
- }
-
/* set the bitmap to wait */
f2fs_update_read_folio_pending(folio, len_blks);
}
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 11/15] f2fs: handle partial truncate of large folio dirty subpages
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (9 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 10/15] f2fs: support partial uptodate " Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 12/15] f2fs: fix zeroing paths for large folios Nanzhe Zhao
` (4 subsequent siblings)
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
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_folio_dirty_range() so a large folio
subpage whose disk block was already truncated (NULL_ADDR) is skipped
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 94 +++++++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 89 insertions(+), 5 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 2dacc9211cc2..33750ebf31cb 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -404,7 +404,6 @@ static void f2fs_ffs_put_write_pending(struct folio *folio, unsigned int nr)
if (folio_test_writeback(folio))
folio_end_writeback(folio);
}
-
static void f2fs_write_end_bio(struct bio *bio)
{
struct f2fs_sb_info *sbi = bio->bi_private;
@@ -2971,6 +2970,41 @@ 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);
+}
+
+static void f2fs_clear_truncated_page_state(struct folio *folio, pgoff_t i)
+{
+ if (f2fs_folio_has_ffs(folio)) {
+ ffs_clear_subrange_uptodate(folio,
+ (loff_t)i << PAGE_SHIFT, PAGE_SIZE);
+ folio_clear_uptodate(folio);
+ } else {
+ folio_clear_uptodate(folio);
+ folio_clear_f2fs_gcing(folio);
+ }
+}
+
bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
{
struct f2fs_folio_state *ffs;
@@ -3751,7 +3785,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
/* This page is already truncated */
if (fio->old_blkaddr == NULL_ADDR) {
- folio_clear_uptodate(folio);
+ f2fs_clear_truncated_page_state(folio, fio->folio_offset);
goto out_writepage;
}
got_it:
@@ -3901,12 +3935,31 @@ static int f2fs_write_folio_dirty_range(struct folio *folio, int *submitted,
}
err = f2fs_get_dnode_of_data(&dn, data_idx, LOOKUP_NODE);
- if (err)
+ /*
+ * 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);
+ }
+ if (err && err != -ENOENT)
goto block_done;
dn_held = true;
fio.old_blkaddr = dn.data_blkaddr;
+ /* This page is already truncated */
+ if (err == -ENOENT || fio.old_blkaddr == NULL_ADDR) {
+ f2fs_clear_truncated_page_state(folio, i);
+ err = 0;
+ goto block_done;
+ }
+
got_it:
if (__is_valid_data_blkaddr(fio.old_blkaddr) &&
!f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr,
@@ -5455,10 +5508,41 @@ 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);
+ folio_clear_uptodate(folio);
+
+ /*
+ * 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_block(inode);
f2fs_remove_dirty_inode(inode);
}
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 12/15] f2fs: fix zeroing paths for large folios
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (10 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 11/15] f2fs: handle partial truncate of large folio dirty subpages Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 13/15] f2fs: handle block cloning within the same large folio Nanzhe Zhao
` (3 subsequent siblings)
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
Several f2fs zeroing paths still use PAGE_SIZE based offsets after
a file mapping can contain large folios. This is fine for order-0
folios, but it zeros the wrong range once the target block is not at
offset 0 in a large folio.
Use offset_in_folio() to translate the file block index to the folio
offset before zeroing data in truncate_partial_data_page(), fill_zero(),
and f2fs_get_new_data_folio().
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 18 +++++++++++++-----
fs/f2fs/f2fs.h | 1 +
fs/f2fs/file.c | 29 ++++++++++++++++++++++++-----
3 files changed, 38 insertions(+), 10 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 33750ebf31cb..29d39737232d 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1855,6 +1855,12 @@ struct folio *f2fs_get_new_data_folio(struct inode *inode,
return ERR_PTR(-ENOMEM);
}
+ if (folio_test_large(folio) && !f2fs_ffs_find_or_alloc(folio)) {
+ f2fs_folio_put(folio, true);
+ f2fs_put_cache(ientry, true);
+ return ERR_PTR(-ENOMEM);
+ }
+
set_new_dnode(&dn, inode, ientry, NULL, 0);
err = f2fs_reserve_block(&dn, index);
if (err) {
@@ -1864,13 +1870,15 @@ struct folio *f2fs_get_new_data_folio(struct inode *inode,
if (!ientry)
f2fs_put_dnode(&dn);
- if (folio_test_uptodate(folio))
+ if (f2fs_ffs_test_blk_uptodate(folio, index))
goto got_it;
if (dn.data_blkaddr == NEW_ADDR) {
- folio_zero_segment(folio, 0, folio_size(folio));
- if (!folio_test_uptodate(folio))
- folio_mark_uptodate(folio);
+ size_t off = offset_in_folio(folio,
+ (loff_t)index << PAGE_SHIFT);
+
+ folio_zero_segment(folio, off, off + PAGE_SIZE);
+ f2fs_ffs_mark_subrange_uptodate(folio, off, PAGE_SIZE);
} else {
f2fs_folio_put(folio, true);
@@ -2947,7 +2955,7 @@ bool f2fs_ffs_test_blk_uptodate(const struct folio *folio, pgoff_t index)
return test_bit(idx, ffs->state);
}
-static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
+void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
size_t len)
{
struct f2fs_folio_state *ffs;
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 1b63dd961f15..2c9343eb6b5e 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4480,6 +4480,7 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
bool for_write);
struct folio *f2fs_get_new_data_folio(struct inode *inode,
struct f2fs_cached_block *ientry, pgoff_t index, bool new_i_size);
+void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset, size_t len);
int f2fs_do_write_data_page(struct f2fs_io_info *fio);
int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, int flag);
int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 808b72d3d78a..439e84a4aec3 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -833,12 +833,13 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
static int truncate_partial_data_page(struct inode *inode, u64 from,
bool cache_only)
{
- loff_t offset = from & (PAGE_SIZE - 1);
pgoff_t index = from >> PAGE_SHIFT;
struct address_space *mapping = inode->i_mapping;
struct folio *folio;
+ size_t folio_off;
+ size_t blk_end;
- if (!offset && !cache_only)
+ if (!(from & (PAGE_SIZE - 1)) && !cache_only)
return 0;
if (cache_only) {
@@ -856,12 +857,22 @@ static int truncate_partial_data_page(struct inode *inode, u64 from,
return PTR_ERR(folio) == -ENOENT ? 0 : PTR_ERR(folio);
truncate_out:
f2fs_folio_wait_writeback(folio, true, true);
- folio_zero_segment(folio, offset, folio_size(folio));
+ folio_off = offset_in_folio(folio, from);
+ blk_end = min_t(size_t, round_up(folio_off, PAGE_SIZE),
+ folio_size(folio));
+ folio_zero_segment(folio, folio_off, blk_end);
/* An encrypted inode should have a key and truncate the last page. */
f2fs_bug_on(F2FS_I_SB(inode), cache_only && IS_ENCRYPTED(inode));
- if (!cache_only)
+ if (!cache_only) {
+ /*
+ * The folio was read back above, so the subpage is
+ * already uptodate and dirty data stays valid.
+ */
+ f2fs_ffs_mark_subrange_dirty(folio, folio_off,
+ blk_end - folio_off);
folio_mark_dirty(folio);
+ }
f2fs_folio_put(folio, true);
return 0;
}
@@ -1325,6 +1336,7 @@ static int fill_zero(struct inode *inode, pgoff_t index,
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
struct folio *folio;
struct f2fs_lock_context lc;
+ size_t folio_off;
if (!len)
return 0;
@@ -1339,7 +1351,14 @@ static int fill_zero(struct inode *inode, pgoff_t index,
return PTR_ERR(folio);
f2fs_folio_wait_writeback(folio, true, true);
- folio_zero_range(folio, start, len);
+ folio_off = offset_in_folio(folio,
+ (loff_t)index << PAGE_SHIFT) + start;
+ folio_zero_range(folio, folio_off, len);
+ /*
+ * This subpage must be uptodate here, which is guaranteed by
+ * f2fs_get_new_data_folio() above.
+ */
+ f2fs_ffs_mark_subrange_dirty(folio, folio_off, len);
folio_mark_dirty(folio);
f2fs_folio_put(folio, true);
return 0;
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 13/15] f2fs: handle block cloning within the same large folio
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (11 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 12/15] f2fs: fix zeroing paths for large folios Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 14/15] f2fs: allow large folio support to writeable files Nanzhe Zhao
` (2 subsequent siblings)
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
With large folios, the source and destination block in __clone_blkaddrs()
can belong to the same folio during same-inode operations such as
collapse range and insert range.
In that case, locking the source folio and then looking up the
destination folio can try to lock the same folio again. It also copies
from and to offset 0, which is only correct for order-0 folios.
Detect the same-inode, same-folio case before looking up the destination
folio. Then in this case,we reserve the destination block explicitly.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/file.c | 61 +++++++++++++++++++++++++++++++++++++++++++-------
1 file changed, 53 insertions(+), 8 deletions(-)
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 439e84a4aec3..f621d5e65023 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1598,25 +1598,70 @@ static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode,
f2fs_put_dnode(&dn);
} else {
struct folio *fsrc, *fdst;
+ size_t src_off, dst_off;
+ bool same_folio;
fsrc = f2fs_get_lock_data_folio(src_inode,
src + i, true);
if (IS_ERR(fsrc))
return PTR_ERR(fsrc);
- fdst = f2fs_get_new_data_folio(dst_inode, NULL, dst + i,
- true);
- if (IS_ERR(fdst)) {
- f2fs_folio_put(fsrc, true);
- return PTR_ERR(fdst);
+
+ src_off = offset_in_folio(fsrc,
+ (loff_t)(src + i) << PAGE_SHIFT);
+
+ /*
+ * For same-inode operations (collapse/insert), src and
+ * dst may fall within the same large folio. Detect this
+ * to avoid self-deadlock on folio lock.
+ */
+ same_folio = src_inode == dst_inode &&
+ folio_contains(fsrc, dst + i);
+ if (same_folio) {
+ struct dnode_of_data dn;
+
+ /* Reserve block for dst before copying */
+ set_new_dnode(&dn, dst_inode, NULL, NULL, 0);
+ ret = f2fs_reserve_block(&dn, dst + i);
+ if (ret) {
+ f2fs_folio_put(fsrc, true);
+ return ret;
+ }
+ fdst = fsrc;
+ } else {
+ fdst = f2fs_get_new_data_folio(dst_inode, NULL,
+ dst + i, true);
+ if (IS_ERR(fdst)) {
+ f2fs_folio_put(fsrc, true);
+ return PTR_ERR(fdst);
+ }
}
+ dst_off = offset_in_folio(fdst,
+ (loff_t)(dst + i) << PAGE_SHIFT);
f2fs_folio_wait_writeback(fdst, true, true);
-
- memcpy_folio(fdst, 0, fsrc, 0, PAGE_SIZE);
+ memcpy_folio(fdst, dst_off, fsrc, src_off,
+ PAGE_SIZE);
+ if (folio_test_large(fdst)) {
+ if (!f2fs_ffs_find_or_alloc(fdst)) {
+ f2fs_folio_put(fdst, true);
+ if (!same_folio)
+ f2fs_folio_put(fsrc, true);
+ return -ENOMEM;
+ }
+ f2fs_ffs_mark_subrange_uptodate(fdst,
+ dst_off, PAGE_SIZE);
+ f2fs_ffs_mark_subrange_dirty(fdst, dst_off,
+ PAGE_SIZE);
+ }
folio_mark_dirty(fdst);
+ if (same_folio && i_size_read(dst_inode) <
+ ((loff_t)(dst + i + 1) << PAGE_SHIFT))
+ f2fs_i_size_write(dst_inode,
+ ((loff_t)(dst + i + 1) << PAGE_SHIFT));
folio_set_f2fs_gcing(fdst);
f2fs_folio_put(fdst, true);
- f2fs_folio_put(fsrc, true);
+ if (!same_folio)
+ f2fs_folio_put(fsrc, true);
ret = f2fs_truncate_hole(src_inode,
src + i, src + i + 1);
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 14/15] f2fs: allow large folio support to writeable files
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (12 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 13/15] f2fs: handle block cloning within the same large folio Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 15/15] f2fs: make compressed files compatible with large folio Nanzhe Zhao
2026-10-27 9:47 ` [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Chao Yu
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
Now we make all write path support large folios,
so we open permission to let writeable file set
large folio mapping.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 2 +-
fs/f2fs/f2fs.h | 17 +++++++++++++++++
fs/f2fs/file.c | 16 +---------------
fs/f2fs/inline.c | 6 ++++++
fs/f2fs/inode.c | 4 +---
fs/f2fs/namei.c | 1 +
6 files changed, 27 insertions(+), 19 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 29d39737232d..4db92c85ea99 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -3282,7 +3282,7 @@ static int f2fs_read_data_large_folio(struct inode *inode,
int ret = 0;
bool folio_in_bio = false;
- if (!IS_IMMUTABLE(inode) || f2fs_compressed_file(inode)) {
+ if (f2fs_compressed_file(inode)) {
if (folio)
folio_unlock(folio);
return -EOPNOTSUPP;
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 2c9343eb6b5e..53914629c604 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -5348,6 +5348,23 @@ static inline bool f2fs_quota_file(struct f2fs_sb_info *sbi, nid_t ino)
return false;
}
+static inline void f2fs_mapping_set_large_folio(struct inode *inode)
+{
+ if (!S_ISREG(inode->i_mode) ||
+ f2fs_compressed_file(inode) ||
+ f2fs_quota_file(F2FS_I_SB(inode), inode->i_ino))
+ return;
+
+ /*
+ * Keep the folio order range at 0 as a transitional step; large
+ * folios will be enabled once the whole write path is audited.
+ */
+ if (IS_IMMUTABLE(inode))
+ mapping_set_folio_min_order(inode->i_mapping, 0);
+ else
+ mapping_set_folio_order_range(inode->i_mapping, 0, 0);
+}
+
static inline bool f2fs_block_unit_discard(struct f2fs_sb_info *sbi)
{
return F2FS_OPTION(sbi).discard_unit == DISCARD_UNIT_BLOCK;
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index f621d5e65023..3d621a20766d 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -163,17 +163,8 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
int err = 0;
vm_fault_t ret;
- /*
- * We only support large folio on the read case.
- * Don't make any dirty pages.
- */
- if (unlikely(IS_IMMUTABLE(inode)) ||
- mapping_large_folio_support(inode->i_mapping)) {
- f2fs_err(sbi, "Not expected: immutable: %d large_folio: %d",
- IS_IMMUTABLE(inode),
- mapping_large_folio_support(inode->i_mapping));
+ if (unlikely(IS_IMMUTABLE(inode)))
return VM_FAULT_SIGBUS;
- }
if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
err = -EIO;
@@ -720,9 +711,6 @@ static int f2fs_file_open(struct inode *inode, struct file *filp)
if (!f2fs_is_compress_backend_ready(inode))
return -EOPNOTSUPP;
- if (mapping_large_folio_support(inode->i_mapping) &&
- filp->f_mode & FMODE_WRITE)
- return -EOPNOTSUPP;
err = fsverity_file_open(inode, filp);
if (err)
@@ -1194,8 +1182,6 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
return -EPERM;
if ((attr->ia_valid & ATTR_SIZE)) {
- if (mapping_large_folio_support(inode->i_mapping))
- return -EOPNOTSUPP;
if (IS_DEVICE_ALIASING(inode))
return -EPERM;
if (!f2fs_is_compress_backend_ready(inode))
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 49905aa08418..0dca6c3d58fb 100644
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -239,6 +239,12 @@ int f2fs_convert_inline_inode(struct inode *inode)
if (IS_ERR(folio))
return PTR_ERR(folio);
+ /*
+ * Inline data is only supported in an order-0 index #0 folio; the
+ * inline write and mmap fault paths never request a larger order.
+ */
+ f2fs_bug_on(sbi, folio_test_large(folio));
+
f2fs_lock_op(sbi, &lc);
ientry = f2fs_get_inode_cache(sbi, inode->i_ino);
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 9164a2b5d9f0..f5a4dac98ef2 100644
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -599,9 +599,7 @@ struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)
inode->i_op = &f2fs_file_inode_operations;
inode->i_fop = &f2fs_file_operations;
inode->i_mapping->a_ops = &f2fs_dblock_aops;
- if (IS_IMMUTABLE(inode) && !f2fs_compressed_file(inode) &&
- !f2fs_quota_file(sbi, inode->i_ino))
- mapping_set_folio_min_order(inode->i_mapping, 0);
+ f2fs_mapping_set_large_folio(inode);
} else if (S_ISDIR(inode->i_mode)) {
inode->i_op = &f2fs_dir_inode_operations;
inode->i_fop = &f2fs_dir_operations;
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 38fcea8b72bf..6a1ff631393c 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -341,6 +341,7 @@ static struct inode *f2fs_new_inode(struct mnt_idmap *idmap,
f2fs_set_inode_flags(inode);
f2fs_init_extent_tree(inode);
+ f2fs_mapping_set_large_folio(inode);
trace_f2fs_new_inode(inode, 0);
return inode;
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v7 15/15] f2fs: make compressed files compatible with large folio
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (13 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 14/15] f2fs: allow large folio support to writeable files Nanzhe Zhao
@ 2026-10-26 3:37 ` Nanzhe Zhao
2026-10-27 9:47 ` [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Chao Yu
15 siblings, 0 replies; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-26 3:37 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
The compression flag is the hint indicates that the inode can be
compressed, when the inode is using large folio, we expected it keeps
using the large folio read/write paths and its data stays uncompressed
on disk until the inode is evicted and re-read
Let f2fs_write_begin() skip the compression overwrite preparation for
such inodes and remove the compressed-file gate in
f2fs_read_data_large_folio() so the data is simply read/written as
regular blocks.
For the same reason, reject F2FS_IOC_COMPRESS_FILE with -EOPNOTSUPP
once the inode mapping is switched to large folios.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
Documentation/filesystems/f2fs.rst | 10 ++++++++++
fs/f2fs/compress.c | 2 ++
fs/f2fs/data.c | 9 ++-------
fs/f2fs/file.c | 7 +++++++
4 files changed, 21 insertions(+), 7 deletions(-)
diff --git a/Documentation/filesystems/f2fs.rst b/Documentation/filesystems/f2fs.rst
index 55798421f2c4..b79bb67ee78e 100644
--- a/Documentation/filesystems/f2fs.rst
+++ b/Documentation/filesystems/f2fs.rst
@@ -942,6 +942,16 @@ Compression implementation
reserved via ioctl(F2FS_IOC_RESERVE_COMPRESS_BLOCKS) or the file size is
truncated to zero.
+- Compression and large folios are not effective at the same time on a file:
+ a compressed inode does not use large folios, while an inode which is
+ using large folios keeps its data uncompressed on disk. If the compression
+ flag is set on an inode that is already using large folios, the flag works
+ as a hint until the inode is evicted: the inode keeps using the large folio
+ read/write paths, f2fs_write_begin() skips the compression overwrite
+ preparation, and ioctl(F2FS_IOC_COMPRESS_FILE) fails with -EOPNOTSUPP.
+ Once the inode is evicted and read back, it uses order-0 folios again and
+ compression is applied as usual.
+
Compress metadata layout::
[Dnode Structure]
diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
index 162bd8ef822a..721b01dd0d24 100644
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -78,6 +78,8 @@ bool f2fs_is_compressed_page(struct folio *folio)
return false;
if (folio_test_f2fs_nonpointer(folio))
return false;
+ if (f2fs_folio_has_ffs(folio))
+ return false;
f2fs_bug_on(F2FS_F_SB(folio),
*((u32 *)folio->private) != F2FS_COMPRESSED_PAGE_MAGIC);
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 4db92c85ea99..f0d2fcf10062 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -3282,12 +3282,6 @@ static int f2fs_read_data_large_folio(struct inode *inode,
int ret = 0;
bool folio_in_bio = false;
- if (f2fs_compressed_file(inode)) {
- if (folio)
- folio_unlock(folio);
- return -EOPNOTSUPP;
- }
-
map.m_seg_type = NO_CHECK_TYPE;
if (rac)
@@ -5313,7 +5307,8 @@ static int f2fs_write_begin(const struct kiocb *iocb,
}
#ifdef CONFIG_F2FS_FS_COMPRESSION
- if (f2fs_compressed_file(inode)) {
+ if (f2fs_compressed_file(inode) &&
+ !mapping_large_folio_support(inode->i_mapping)) {
int ret;
struct page *page;
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 3d621a20766d..e61c80ae7537 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -5021,6 +5021,13 @@ static int f2fs_ioc_compress_file(struct file *filp)
if (!(filp->f_mode & FMODE_WRITE))
return -EBADF;
+ /*
+ * The mapping is already using large folios, where the data is kept
+ * uncompressed, so refuse to start compressing the file.
+ */
+ if (mapping_large_folio_support(inode->i_mapping))
+ return -EOPNOTSUPP;
+
f2fs_balance_fs(sbi, true);
ret = mnt_want_write_file(filp);
--
2.43.0
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH v7 05/15] f2fs: support large folio writeback
2026-10-26 3:37 ` [PATCH v7 05/15] f2fs: support large folio writeback Nanzhe Zhao
@ 2026-10-27 9:34 ` Chao Yu
0 siblings, 0 replies; 22+ messages in thread
From: Chao Yu @ 2026-10-27 9:34 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: chao, Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
On 10/26/26 11:37, Nanzhe Zhao wrote:
> From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
>
> Large folio can contain multiple dirty ranges.
> Add a folio-based writeback path for large-folio mapping files
> and keep the legacy f2fs_write_cache_pages() path unchanged for
> non large-folio mapping files.
>
> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
> ---
> fs/f2fs/data.c | 521 +++++++++++++++++++++++++++++++++++++++++++++-
> fs/f2fs/segment.c | 8 +-
> 2 files changed, 521 insertions(+), 8 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 126cad81227f..a0822d06e3bc 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -358,6 +358,49 @@ static void f2fs_cache_write_end_bio(struct bio *bio)
> bio_put(bio);
> }
>
> +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;
> +}
> +
> +/*
> + * Drop a write page pending of @folio. When the last pending is gone,
> + * clear PAGE_PRIVATE_GCING if no dirty subpage is left, and end
> + * writeback if it was started.
> + */
> +static void f2fs_ffs_put_write_pending(struct folio *folio, unsigned int nr)
> +{
> + struct f2fs_folio_state *ffs;
> +
> + if (!f2fs_folio_has_ffs(folio))
> + goto release;
> +
> + ffs = (struct f2fs_folio_state *)folio->private;
> + if (!atomic_sub_and_test(nr, &ffs->write_pages_pending))
> + return;
> +release:
> + if (!f2fs_ffs_has_dirty_subpage(folio))
> + folio_clear_f2fs_gcing(folio);
> + if (folio_test_writeback(folio))
> + folio_end_writeback(folio);
> +}
> +
> static void f2fs_write_end_bio(struct bio *bio)
> {
> struct f2fs_sb_info *sbi = bio->bi_private;
> @@ -373,6 +416,8 @@ static void f2fs_write_end_bio(struct bio *bio)
>
> bio_for_each_folio_all(fi, bio) {
> struct folio *folio = fi.folio;
> + unsigned int nr_pages = fi.length >> PAGE_SHIFT;
> + unsigned int npages = nr_pages;
> enum count_type type;
>
> #ifdef CONFIG_F2FS_FS_COMPRESSION
> @@ -392,7 +437,8 @@ static void f2fs_write_end_bio(struct bio *bio)
> }
> }
>
> - dec_cache_count(sbi, type);
> + while (nr_pages--)
> + dec_cache_count(sbi, type);
>
> /*
> * we should access sbi before folio_end_writeback() to
> @@ -402,8 +448,7 @@ static void f2fs_write_end_bio(struct bio *bio)
> wq_has_sleeper(&sbi->cp_wait))
> wake_up(&sbi->cp_wait);
>
> - folio_clear_f2fs_gcing(folio);
> - folio_end_writeback(folio);
> + f2fs_ffs_put_write_pending(folio, npages);
> }
>
> bio_put(bio);
> @@ -2940,7 +2985,7 @@ static unsigned int __ffs_mark_subrange_dirty(struct folio *folio,
> return bitmap_weight(ffs->state, 2 * nr_subpages) - before;
> }
>
> -static void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
> +void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
> size_t offset, size_t len)
> {
> struct f2fs_folio_state *ffs;
> @@ -2958,6 +3003,99 @@ static void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
> spin_unlock_irqrestore(&ffs->state_lock, flags);
> }
>
> +static bool __ffs_clear_subrange_dirty(struct folio *folio,
> + struct f2fs_folio_state *ffs, size_t offset, size_t len)
> +{
> + unsigned int nr_subpages = folio_nr_pages(folio);
> + unsigned int start, end;
> +
> + start = offset >> PAGE_SHIFT;
> + end = (offset + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
> + end = min(end, nr_subpages);
> +
> + bitmap_clear(ffs->state, nr_subpages + start, end - start);
> + return find_next_bit(ffs->state, 2 * nr_subpages, nr_subpages) <
> + 2 * nr_subpages;
> +}
> +
> +/**
> + * f2fs_ffs_clear_subrange_dirty_and_test - clear dirty bits and test remaining
> + * @folio: the large folio
> + * @offset: start byte offset within the folio
> + * @len: byte length of the subrange
> + *
> + * Clear the dirty bits of the 4K subpages covered by [offset, offset + len),
> + * and return whether the folio still has any dirty subpage left.
> + */
> +bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
> + size_t len)
> +{
> + struct f2fs_folio_state *ffs;
> + unsigned long flags;
> + bool dirty;
> +
> + if (!f2fs_folio_has_ffs(folio))
> + return false;
> +
> + ffs = (struct f2fs_folio_state *)folio->private;
> + spin_lock_irqsave(&ffs->state_lock, flags);
> + dirty = __ffs_clear_subrange_dirty(folio, ffs, offset, len);
> + spin_unlock_irqrestore(&ffs->state_lock, flags);
> +
> + return dirty;
> +}
> +
> +static unsigned int ffs_next_dirty_subpage(struct f2fs_folio_state *ffs,
> + const struct folio *folio, unsigned int start,
> + unsigned int end)
> +{
> + unsigned int nr_subpages = folio_nr_pages(folio);
> +
> + return find_next_bit(ffs->state, nr_subpages + end + 1,
> + nr_subpages + start) - nr_subpages;
> +}
> +
> +static unsigned int ffs_next_clean_subpage(struct f2fs_folio_state *ffs,
> + const struct folio *folio, unsigned int start,
> + unsigned int end)
> +{
> + unsigned int nr_subpages = folio_nr_pages(folio);
> +
> + return find_next_zero_bit(ffs->state, nr_subpages + end + 1,
> + nr_subpages + start) - nr_subpages;
> +}
> +
> +static unsigned int ffs_find_dirty_range(struct folio *folio,
> + u64 *range_start, u64 range_end)
> +{
> + struct f2fs_folio_state *ffs;
> + unsigned int start, end, nr_pages;
> +
> + if (*range_start >= range_end)
> + return 0;
> +
> + if (!f2fs_folio_has_ffs(folio))
> + return range_end - *range_start;
> +
> + ffs = (struct f2fs_folio_state *)folio->private;
> + start = offset_in_folio(folio, *range_start) >> PAGE_SHIFT;
> + end = DIV_ROUND_UP(min_not_zero(offset_in_folio(folio, range_end),
> + folio_size(folio)), PAGE_SIZE) - 1;
> +
> + start = ffs_next_dirty_subpage(ffs, folio, start, end);
> + if (start > end)
> + return 0;
> +
> + if (start == end)
> + nr_pages = 1;
> + else
> + nr_pages = ffs_next_clean_subpage(ffs, folio,
> + start + 1, end) - start;
> +
> + *range_start = folio_pos(folio) + ((u64)start << PAGE_SHIFT);
> + return (u64)nr_pages << PAGE_SHIFT;
> +}
> +
> static bool find_next_valid_block(const struct folio *folio,
> size_t orig_off, size_t *need_off,
> size_t len)
> @@ -3495,7 +3633,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> if (ipu_force ||
> (__is_valid_data_blkaddr(fio->old_blkaddr) &&
> need_inplace_update(fio))) {
> - folio_start_writeback(folio);
> + __folio_start_writeback(folio, folio_test_dirty(folio));
> f2fs_put_dnode(&dn);
> if (fio->need_lock == LOCK_REQ)
> f2fs_unlock_op(fio->sbi, &lc);
> @@ -3522,7 +3660,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>
> fio->version = ni.version;
>
> - folio_start_writeback(folio);
> + __folio_start_writeback(folio, folio_test_dirty(folio));
>
> if (fio->compr_blocks && fio->old_blkaddr == COMPRESS_ADDR)
> f2fs_i_compr_blocks_update(inode, fio->compr_blocks - 1, false);
> @@ -3530,6 +3668,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> /* LFS mode write path */
> f2fs_outplace_write_data(&dn, fio);
> trace_f2fs_do_write_data_page(folio, OPU);
> + /*
> + * The outplace write path failed to submit this block.
> + */
> + if (!fio->submitted) {
> + err = -EIO;
> + goto out_writepage;
> + }
> set_inode_flag(inode, FI_APPEND_WRITE);
> if (atomic_commit)
> folio_clear_f2fs_atomic(folio);
> @@ -3541,6 +3686,144 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> return err;
> }
>
> +static int f2fs_write_folio_dirty_range(struct folio *folio, int *submitted,
> + struct writeback_control *wbc,
> + enum iostat_type io_type,
> + u64 *pos, u64 len)
> +{
> + struct inode *inode = folio->mapping->host;
> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> + bool atomic_commit = f2fs_is_atomic_file(inode) &&
> + folio_test_f2fs_atomic(folio);
> + struct inode *dn_inode = atomic_commit ?
> + F2FS_I(inode)->cow_inode : inode;
> + struct f2fs_folio_state *ffs = NULL;
> + u64 folio_start = folio_pos(folio);
> + pgoff_t start_idx = (*pos - folio_start) >> PAGE_SHIFT;
> + pgoff_t end_idx = (*pos - folio_start + len - 1) >> PAGE_SHIFT;
> + int err = 0;
> +
> + for (pgoff_t i = start_idx; i <= end_idx && !err; i++) {
> + struct dnode_of_data dn;
> + struct node_info ni;
> + pgoff_t data_idx = folio->index + i;
> + bool ipu_force = false;
> + bool dn_held = false;
> + bool submitted_blk = false;
> + struct f2fs_io_info fio = {
> + .sbi = sbi,
> + .ino = inode->i_ino,
> + .type = DATA,
> + .op = REQ_OP_WRITE,
> + .op_flags = wbc_to_write_flags(wbc),
> + .old_blkaddr = NULL_ADDR,
> + .folio = folio,
> + .folio_offset = i,
> + .folio_blkcnt = 1,
> + .encrypted_page = NULL,
> + .submitted = 0,
> + .need_lock = LOCK_DONE,
> + .meta_gc = f2fs_meta_inode_gc_required(inode) ? 1 : 0,
> + .io_type = io_type,
> + .io_wbc = wbc,
> + };
> +
> + if (f2fs_folio_has_ffs(folio)) {
> + ffs = (struct f2fs_folio_state *)folio->private;
> + atomic_inc(&ffs->write_pages_pending);
> + }
> +
> + set_new_dnode(&dn, dn_inode, NULL, NULL, 0);
> +
> + if (need_inplace_update(&fio) &&
> + f2fs_lookup_read_extent_cache_block(inode, data_idx,
> + &fio.old_blkaddr)) {
> + if (!f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr,
> + DATA_GENERIC_ENHANCE)) {
> + err = -EFSCORRUPTED;
> + goto block_done;
> + }
> + ipu_force = true;
> + goto got_it;
> + }
> +
> + err = f2fs_get_dnode_of_data(&dn, data_idx, LOOKUP_NODE);
> + if (err)
> + goto block_done;
> + dn_held = true;
> +
> + fio.old_blkaddr = dn.data_blkaddr;
> +
> +got_it:
> + if (__is_valid_data_blkaddr(fio.old_blkaddr) &&
> + !f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr,
> + DATA_GENERIC_ENHANCE)) {
> + err = -EFSCORRUPTED;
> + goto block_done;
> + }
> +
> + if (fio.meta_gc)
> + f2fs_wait_on_block_writeback(inode, fio.old_blkaddr);
> +
> + if (ipu_force ||
> + (__is_valid_data_blkaddr(fio.old_blkaddr) &&
> + need_inplace_update(&fio))) {
> + f2fs_put_dnode(&dn);
> + dn_held = false;
> + err = f2fs_inplace_write_data(&fio);
> + trace_f2fs_do_write_data_page(folio, IPU);
> + if (err)
> + goto block_done;
> +
> + if (submitted)
> + (*submitted)++;
> + submitted_blk = true;
> + set_inode_flag(inode, FI_UPDATE_WRITE);
> + goto block_done;
> + }
> +
> + err = f2fs_get_node_info(sbi, dn.nid, &ni, false);
> + if (err)
> + goto block_done;
> +
> + fio.version = ni.version;
> +
> + f2fs_outplace_write_data(&dn, &fio);
> + /*
> + * The outplace write path failed to submit this block.
> + */
> + if (!fio.submitted) {
> + err = -EIO;
> + goto block_done;
> + }
> + if (submitted)
> + (*submitted)++;
> + submitted_blk = true;
> + set_inode_flag(inode, FI_APPEND_WRITE);
> + trace_f2fs_do_write_data_page(folio, OPU);
> +block_done:
> + if (dn_held)
> + f2fs_put_dnode(&dn);
> + /*
> + * If this block was not submitted, roll back its
> + * write pages pending.
> + */
> + if (!submitted_blk && ffs)
> + f2fs_ffs_put_write_pending(folio, 1);
> + if (!err) {
> + *pos = ((loff_t)data_idx + 1) << PAGE_SHIFT;
> + spin_lock(&F2FS_I(inode)->i_size_lock);
> + if (F2FS_I(inode)->last_disk_size < *pos)
> + F2FS_I(inode)->last_disk_size = *pos;
> + spin_unlock(&F2FS_I(inode)->i_size_lock);
> + } else {
> + file_set_keep_isize(inode);
> + }
> + }
> +
> + return err;
> +}
> +
> int f2fs_write_single_data_page(struct folio *folio, int *submitted,
> struct bio **bio,
> sector_t *last_block,
> @@ -3990,6 +4273,226 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
> return ret;
> }
>
> +static int f2fs_write_cache_folios(struct address_space *mapping,
> + struct writeback_control *wbc,
> + enum iostat_type io_type)
> +{
> + struct folio *folio = NULL;
> + struct inode *inode = mapping->host;
> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> + struct f2fs_lock_context lc;
> + u64 pos = 0;
> + u64 end_pos = 0;
> + u32 r_len = 0;
> + int err = 0;
> + int submitted = 0;
> + int nwritten = 0;
> + bool op_locked = false;
> + bool retry = false;
> +
> + if (get_dirty_pages(inode) <= SM_I(sbi)->min_hot_blocks)
> + set_inode_flag(inode, FI_HOT_DATA);
> + else
> + clear_inode_flag(inode, FI_HOT_DATA);
> +
> + while ((folio = writeback_iter(mapping, wbc, folio, &err))) {
> + struct f2fs_folio_state *ffs = NULL;
> + u64 isize;
> + size_t poff;
> + pgoff_t end_index;
> + bool verity_in_progress;
> + int folio_submitted = 0;
> + bool bias_added = false;
> +
> + submitted = 0;
> + retry = false;
> +
> + if (err) {
> + folio_redirty_for_writepage(wbc, folio);
> + goto retry_out;
> + }
> +
> + if (atomic_read(&sbi->wb_sync_req[DATA]) &&
> + wbc->sync_mode == WB_SYNC_NONE) {
> + folio_redirty_for_writepage(wbc, folio);
> + /*
> + * A WB_SYNC_ALL writeback is in progress, so defer
> + * this writeback. Mark the error as -EBUSY to let
> + * writeback_iter() stop iterating.
> + */
> + err = -EBUSY;
> + goto retry_out;
> + }
> +
> + /*
> + * If cp_error is set, all subpages of this folio are not written
> + * back unless the filesystem is mounted with errors=remount-ro.
> + */
> + if (unlikely(f2fs_cp_error(sbi))) {
> + mapping_set_error(folio->mapping, -EIO);
> + if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY) {
> + folio_redirty_for_writepage(wbc, folio);
> + } else {
> + if (f2fs_folio_has_ffs(folio))
> + f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
> + folio_size(folio));
> + inode_dec_dirty_pages(inode);
> + }
> + goto retry_out;
> + }
> +
> + /*
> + * Writing back one large folio performs multiple block allocations, so
> + * best-effort balance the filesystem before writing it back.
> + */
> + if (!F2FS_I(inode)->wb_task && has_not_enough_free_secs(sbi, 0, 0)) {
> + folio_redirty_for_writepage(wbc, folio);
> + retry = true;
> + folio_unlock(folio);
> + f2fs_balance_fs(sbi, true);
> + folio_lock(folio);
> + goto retry;
> + }
> +retry:
> + pos = folio_pos(folio);
> + end_pos = pos + folio_size(folio);
> + isize = i_size_read(inode);
> + verity_in_progress = f2fs_verity_in_progress(inode);
> + poff = 0;
> + end_index = 0;
> +
> + if (retry) {
> +
> + if (unlikely(folio->mapping != mapping))
> + goto retry_out;
> +
> + if (!folio_test_dirty(folio))
> + goto retry_out;
> +
> + if (folio_test_writeback(folio)) {
> + if (wbc->sync_mode == WB_SYNC_NONE)
> + goto retry_out;
> + f2fs_folio_wait_writeback(folio, true, true);
> + }
> +
> + if (!folio_clear_dirty_for_io(folio))
> + goto retry_out;
> + }
> +
> + /* To avoid dealing with the complexity for one subrange is in bio
> + * while we trylock_op failed before writing another subrange.
> + * Try to lock_op before any subrange write for the folio.
> + */
> + if (!op_locked) {
> + if (!f2fs_trylock_op(sbi, &lc)) {
> + folio_redirty_for_writepage(wbc, folio);
> + err = 0;
> + if (wbc->sync_mode != WB_SYNC_ALL)
> + goto retry_out;
> +
> + retry = true;
> + folio_unlock(folio);
> + f2fs_io_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
> + folio_lock(folio);
> + goto retry;
> + }
> + op_locked = true;
> + }
> +
> + if (!verity_in_progress) {
> + poff = offset_in_folio(folio, isize);
> + end_index = isize >> PAGE_SHIFT;
> +
> + if (folio->index > end_index ||
> + (folio->index == end_index && poff == 0))
> + goto out;
> +
> + if (end_pos > isize) {
> + folio_zero_segment(folio, poff, folio_size(folio));
> + end_pos = isize;
> + }
> + }
> +
> + folio_start_writeback(folio);
> +
> + /*
> + * Large folios can be submitted as multiple bios, which may
> + * complete while we are still submitting the remaining dirty
> + * ranges. Hold a bias on write_pages_pending to prevent
> + * folio_end_writeback() from being called early.
> + */
> + if (!bias_added && f2fs_folio_has_ffs(folio)) {
> + ffs = (struct f2fs_folio_state *)folio->private;
> + WARN_ON_ONCE(atomic_read(&ffs->write_pages_pending) != 0);
> + atomic_inc(&ffs->write_pages_pending);
> + bias_added = true;
> + }
> +
> + while ((r_len = ffs_find_dirty_range(folio, &pos, end_pos))) {
> + err = f2fs_write_folio_dirty_range(folio, &submitted,
> + wbc, io_type, &pos, r_len);
> + folio_submitted += submitted;
> + nwritten += submitted;
> + if (err)
> + goto out;
> + }
> +
> + /* If none of the subpages of a folio is submitted, keep the atomic flag */
> + if (folio_submitted &&
> + f2fs_is_atomic_file(inode) &&
> + folio_test_f2fs_atomic(folio))
> + folio_clear_f2fs_atomic(folio);
> +
> +out:
> + /*
> + * Clear the dirty state of the subranges that were written back.
> + * If some subranges are still dirty (e.g. the folio was only
> + * partially written back), or if the writeback failed, 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)) || err)
dirty bits may set beyond isize?
- fill_zero() with KEEP_SIZE beyond i_size;
- BG_GC on blocks beyond EOF;
- f2fs_ffs_find_or_alloc() on an already-dirty folio, which sets all dirty bits.
So we'd better to clear all bits in ffs?
size_t clear_pos = err ? pos - folio_pos(folio) : folio_size(folio);
if (f2fs_ffs_clear_subrange_dirty_and_test(folio, 0, clear_pos) || err)
Thanks,
> + folio_redirty_for_writepage(wbc, folio);
> + else
> + inode_dec_dirty_pages(inode);
> +
> + /*
> + * Release the bias taken above and we end writeback here if
> + * no write bio is in flight.
> + */
> + if (bias_added) {
> + f2fs_ffs_put_write_pending(folio, 1);
> + } else if (!folio_submitted && folio_test_writeback(folio)) {
> + /*
> + * Order-0 folios take no bias, so end the writeback
> + * if nothing was submitted.
> + */
> + folio_end_writeback(folio);
> + }
> +
> +retry_out:
> + if (op_locked) {
> + f2fs_unlock_op(sbi, &lc);
> + op_locked = false;
> + }
> +
> + folio_unlock(folio);
> + }
> +
> + if (nwritten)
> + f2fs_submit_merged_write_cond(F2FS_M_SB(mapping), mapping->host,
> + NULL);
> +
> + /*
> + * Prevent the -EBUSY error that stopped writeback_iter() from
> + * propagating to the user.
> + */
> + if (err == -EBUSY)
> + err = 0;
> + return err;
> +}
> +
> static inline bool __should_serialize_io(struct inode *inode,
> struct writeback_control *wbc)
> {
> @@ -4084,7 +4587,11 @@ static int __f2fs_write_data_pages(struct address_space *mapping,
> account_writeback(inode, true);
>
> blk_start_plug(&plug);
> - ret = f2fs_write_cache_pages(mapping, wbc, io_type);
> + if (mapping_large_folio_support(inode->i_mapping) &&
> + !f2fs_has_inline_data(inode))
> + ret = f2fs_write_cache_folios(mapping, wbc, io_type);
> + else
> + ret = f2fs_write_cache_pages(mapping, wbc, io_type);
> blk_finish_plug(&plug);
>
> account_writeback(inode, false);
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index 80f58c586e33..cbb65e0343c8 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -4173,7 +4173,13 @@ static void do_write_block(struct f2fs_summary *sum, struct f2fs_io_info *fio)
> "%s Failed to allocate data block, ino:%u, index:%lu, type:%d, old_blkaddr:0x%x, new_blkaddr:0x%x, err:%d",
> __func__, fio->ino, folio->index, type,
> fio->old_blkaddr, fio->new_blkaddr, err);
> - folio_end_writeback(folio);
> + /*
> + * For a large folio, the caller rolls back
> + * write_pages_pending and ends writeback when the last
> + * pending write is gone.
> + */
> + if (!f2fs_folio_has_ffs(folio))
> + folio_end_writeback(folio);
> }
> f2fs_bug_on(fio->sbi, !is_set_ckpt_flags(fio->sbi,
> CP_ERROR_FLAG));
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH v7 07/15] f2fs: prepare mmap write faults for large folios
2026-10-26 3:37 ` [PATCH v7 07/15] f2fs: prepare mmap write faults for large folios Nanzhe Zhao
@ 2026-10-27 9:35 ` Chao Yu
0 siblings, 0 replies; 22+ messages in thread
From: Chao Yu @ 2026-10-27 9:35 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: chao, Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
On 10/26/26 11:37, Nanzhe Zhao wrote:
> From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
>
> Now write protect `mmap` also need to support large folio,
> Change `f2fs_vm_page_mkwrite` to achieve that.
>
> Note it currently marks the whole large folio dirty
> to avoid data loss which causes write amplification.
> Further optimization is welcome.
>
> The folio_zero_segment() in mkwrite is extended to zero the
> post-EOF part of the faulted folio for both order-0 and large
> folios, so the f2fs_zero_post_eof_page() call that was added
> to cover the removed shortcut is no longer needed.
>
> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
> ---
> fs/f2fs/f2fs.h | 4 +++
> fs/f2fs/file.c | 96 ++++++++++++++++++++++++++++++++------------------
> 2 files changed, 65 insertions(+), 35 deletions(-)
>
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index b89664e28a92..915ca72cf276 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -4492,6 +4492,10 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted,
> enum iostat_type io_type,
> int compr_blocks, bool allow_balance);
> bool f2fs_ffs_test_blk_uptodate(const struct folio *folio, pgoff_t index);
> +struct f2fs_folio_state *f2fs_ffs_find_or_alloc(struct folio *folio);
> +void f2fs_ffs_mark_subrange_dirty(struct folio *folio, size_t offset, size_t len);
> +bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
> + size_t len);
> void f2fs_write_failed(struct inode *inode, loff_t to);
> void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length);
> bool f2fs_release_folio(struct folio *folio, gfp_t wait);
> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> index 85b4f1a2ff0d..808b72d3d78a 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -118,14 +118,48 @@ static vm_fault_t f2fs_filemap_fault(struct vm_fault *vmf)
> return ret;
> }
>
> +static int f2fs_get_block_mkwrite(struct inode *inode, struct folio *folio,
> + pgoff_t index, bool need_alloc)
> +{
> + struct dnode_of_data dn;
> + int err;
> +
> + set_new_dnode(&dn, inode, NULL, NULL, 0);
> + if (need_alloc) {
> + err = f2fs_get_block_locked(&dn, index);
> + } else {
> + err = f2fs_get_dnode_of_data(&dn, index, LOOKUP_NODE);
> + f2fs_put_dnode(&dn);
> + if (f2fs_is_pinned_file(inode) &&
> + !__is_valid_data_blkaddr(dn.data_blkaddr))
> + err = -EIO;
> + }
> +
> + if (err)
> + return err;
> +
> + f2fs_folio_wait_writeback(folio, false, true);
> +
> + /* wait for GCed page writeback via META_MAPPING */
> + f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
> +
> + return 0;
> +}
> +
> static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
> {
> struct folio *folio = page_folio(vmf->page);
> struct inode *inode = file_inode(vmf->vma->vm_file);
> struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> - struct dnode_of_data dn;
> bool need_alloc = !f2fs_is_pinned_file(inode);
> + pgoff_t pidx = folio->index + folio_page_idx(folio, vmf->page);
> + loff_t pos = (loff_t)pidx << PAGE_SHIFT;
> loff_t isize;
> + loff_t folio_start;
> + loff_t valid_end;
> + size_t dirty_len;
> + size_t subpage_off;
> + pgoff_t i, nr;
> int err = 0;
> vm_fault_t ret;
>
> @@ -162,7 +196,7 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
>
> #ifdef CONFIG_F2FS_FS_COMPRESSION
> if (f2fs_compressed_file(inode)) {
> - int ret = f2fs_is_compressed_cluster(inode, folio->index);
> + int ret = f2fs_is_compressed_cluster(inode, pidx);
>
> if (ret < 0) {
> err = ret;
> @@ -180,11 +214,6 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
>
> f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
>
> - err = f2fs_zero_post_eof_page(inode,
> - (folio->index + 1) << PAGE_SHIFT, true, false);
> - if (err)
> - goto out_pagefault;
> -
> file_update_time(vmf->vma->vm_file);
> filemap_invalidate_lock_shared(inode->i_mapping);
>
> @@ -200,62 +229,59 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
> }
>
> folio_lock(folio);
It needs to add below check to avoid racing w/ COLLAPSE_RANGE or INSERT_RANGE ->
f2fs_invalidate_folio()? there is no ffs in large folio after folio_lock().
if (folio_test_large(folio) && !folio_test_uptodate(folio)) {
folio_unlock(folio);
err = -EFAULT; /* VM_FAULT_NOPAGE, refault */
goto out_sem;
}
Thanks,
> - /*
> - * A concurrent buffered write can extend isize, so we store isize in a
> - * local variable to let the zeroing offset match the EOF check below.
> - */
> isize = i_size_read(inode);
> + folio_start = folio_pos(folio);
> + subpage_off = offset_in_folio(folio, pos);
> + valid_end = min_t(loff_t, folio_start + folio_size(folio), isize);
> + dirty_len = valid_end - folio_start;
>
> if (unlikely(folio->mapping != inode->i_mapping ||
> - folio_pos(folio) > isize ||
> - !folio_test_uptodate(folio))) {
> + pos >= isize ||
> + !f2fs_ffs_test_blk_uptodate(folio,
> + folio->index + (subpage_off >> PAGE_SHIFT)))) {
> folio_unlock(folio);
> err = -EFAULT;
> goto out_sem;
> }
>
> - set_new_dnode(&dn, inode, NULL, NULL, 0);
> - if (need_alloc) {
> - /* block allocation */
> - err = f2fs_get_block_locked(&dn, folio->index);
> - } else {
> - err = f2fs_get_dnode_of_data(&dn, folio->index, LOOKUP_NODE);
> - f2fs_put_dnode(&dn);
> - if (f2fs_is_pinned_file(inode) &&
> - !__is_valid_data_blkaddr(dn.data_blkaddr))
> - err = -EIO;
> - }
> -
> - if (err) {
> + if (folio_test_large(folio) && !f2fs_ffs_find_or_alloc(folio)) {
> folio_unlock(folio);
> + err = -ENOMEM;
> goto out_sem;
> }
>
> - f2fs_folio_wait_writeback(folio, false, true);
> + nr = DIV_ROUND_UP(dirty_len, PAGE_SIZE);
>
> - /* wait for GCed page writeback via generic cache */
> - f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
> + for (i = 0; i < nr; i++) {
> + err = f2fs_get_block_mkwrite(inode, folio, folio->index + i,
> + need_alloc);
> + if (err) {
> + folio_unlock(folio);
> + goto out_sem;
> + }
> + }
>
> /* page is wholly or partially inside EOF */
> - if (((loff_t)(folio->index + 1) << PAGE_SHIFT) > isize) {
> - loff_t offset;
> + if (folio_start + folio_size(folio) > isize) {
> + size_t offset = offset_in_folio(folio, isize);
>
> - offset = isize & ~PAGE_MASK;
> folio_zero_segment(folio, offset, folio_size(folio));
> }
> +
> + if (folio_test_large(folio))
> + f2fs_ffs_mark_subrange_dirty(folio, 0, dirty_len);
> folio_mark_dirty(folio);
>
> - f2fs_update_iostat(sbi, inode, APP_MAPPED_IO, F2FS_BLKSIZE(sbi));
> + f2fs_update_iostat(sbi, inode, APP_MAPPED_IO, dirty_len);
> f2fs_update_time(sbi, REQ_TIME);
>
> out_sem:
> filemap_invalidate_unlock_shared(inode->i_mapping);
> -out_pagefault:
> sb_end_pagefault(inode->i_sb);
> out:
> ret = vmf_fs_error(err);
>
> - trace_f2fs_vm_page_mkwrite(inode, folio->index, vmf->vma->vm_flags, ret);
> + trace_f2fs_vm_page_mkwrite(inode, pidx, vmf->vma->vm_flags, ret);
> return ret;
> }
>
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH v7 08/15] f2fs: make GC migration large-folio aware
2026-10-26 3:37 ` [PATCH v7 08/15] f2fs: make GC migration large-folio aware Nanzhe Zhao
@ 2026-10-27 9:37 ` Chao Yu
2026-10-27 10:11 ` Nanzhe Zhao
0 siblings, 1 reply; 22+ messages in thread
From: Chao Yu @ 2026-10-27 9:37 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: chao, Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
On 10/26/26 11:37, Nanzhe Zhao wrote:
> From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
>
> GC can operate on a 4K block that is cached inside a large folio.
> The data lookup helpers therefore need to test and update uptodate
> state for the addressed subpage instead of rejecting large folios or
> treating the whole folio as the target block.
>
> Let f2fs_get_read_data_folio() and f2fs_get_lock_data_folio() to use
> subpage uptodate state. Submit single-block reads at the requested
> folio offset and zero only the addressed 4K range for NEW_ADDR.
>
> Also update `move_data_page` to mark, clear, and restore dirty
> state for the target subpage, and submit write I/O with the subpage
> offset recorded in f2fs_io_info.
>
> The write_pages_pending reference is taken by f2fs_do_write_data_page()
> and dropped from its common error path, so a block that is truncated
> concurrently no longer leaks the counter.
>
> Reported-by: kernel test robot <yi1.lai@intel.com>
> Closes: https://lore.kernel.org/oe-lkp/202610081027.b13dcf10-lkp@intel.com
> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
> ---
> fs/f2fs/data.c | 70 +++++++++++++++++++++++++++++++++--------------
> fs/f2fs/f2fs.h | 1 +
> fs/f2fs/gc.c | 28 +++++++++++++++----
> fs/f2fs/segment.c | 2 +-
> 4 files changed, 75 insertions(+), 26 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index d027c949823b..b3ada22cb0cb 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -1679,20 +1679,16 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
> struct dnode_of_data dn;
> struct folio *folio;
> int err;
> -retry:
> +
> folio = f2fs_grab_cache_folio(mapping, index, for_write);
> if (IS_ERR(folio))
> return folio;
>
> if (folio_test_large(folio)) {
> - pgoff_t folio_index = mapping_align_index(mapping, index);
> - unsigned long nr_pages = folio_nr_pages(folio);
> -
> - f2fs_folio_put(folio, true);
> - invalidate_inode_pages2_range(mapping, folio_index,
> - folio_index + nr_pages - 1);
> - f2fs_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
> - goto retry;
> + if (!f2fs_ffs_find_or_alloc(folio)) {
> + err = -ENOMEM;
> + goto put_err;
> + }
> }
>
> if (f2fs_lookup_read_extent_cache_block(inode, index,
> @@ -1728,7 +1724,7 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
> goto put_err;
> }
> got_it:
> - if (folio_test_uptodate(folio)) {
> + if (f2fs_ffs_test_blk_uptodate(folio, index)) {
> folio_unlock(folio);
> return folio;
> }
> @@ -1741,9 +1737,11 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
> * f2fs_init_inode_metadata.
> */
> if (dn.data_blkaddr == NEW_ADDR) {
> - folio_zero_segment(folio, 0, folio_size(folio));
> - if (!folio_test_uptodate(folio))
> - folio_mark_uptodate(folio);
> + size_t offset = offset_in_folio(folio,
> + (loff_t)index << PAGE_SHIFT);
> +
> + folio_zero_segment(folio, offset, offset + PAGE_SIZE);
> + f2fs_ffs_mark_subrange_uptodate(folio, offset, PAGE_SIZE);
> folio_unlock(folio);
> return folio;
> }
> @@ -1803,7 +1801,6 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
>
> /* wait for read completion */
> folio_lock(folio);
> -
> if (unlikely(folio->mapping != mapping)) {
> f2fs_folio_put(folio, true);
> return ERR_PTR(-EIO);
> @@ -1812,7 +1809,7 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
> /*
> * ffs can be released while the folio was unlocked above. Rebuild it
> * for a fully uptodate folio; a partially uptodate one cannot be
> - * rebuilt and will fail the uptodate check below.
> + * rebuilt and will fail the subpage check below.
> */
> if (folio_test_large(folio) && !f2fs_folio_has_ffs(folio)) {
> if (!f2fs_ffs_find_or_alloc(folio)) {
> @@ -1821,7 +1818,7 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
> }
> }
>
> - if (unlikely(!folio_test_uptodate(folio))) {
> + if (unlikely(!f2fs_ffs_test_blk_uptodate(folio, index))) {
> f2fs_folio_put(folio, true);
> return ERR_PTR(-EIO);
> }
> @@ -2970,6 +2967,22 @@ static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
> folio_mark_uptodate(folio);
> }
>
> +bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
> +{
> + struct f2fs_folio_state *ffs;
> + unsigned int idx, nr_subpages;
> +
> + f2fs_bug_on(F2FS_F_SB(folio), !folio_contains(folio, index));
> +
> + if (!f2fs_folio_has_ffs(folio))
> + return folio_test_dirty(folio);
> +
> + ffs = (struct f2fs_folio_state *)folio->private;
> + nr_subpages = folio_nr_pages(folio);
> + idx = index - folio->index;
> + return test_bit(nr_subpages + idx, ffs->state);
> +}
> +
> static unsigned int __ffs_mark_subrange_dirty(struct folio *folio,
> struct f2fs_folio_state *ffs, size_t offset, size_t len)
> {
> @@ -3063,7 +3076,6 @@ bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
>
> return dirty;
> }
> -
> static unsigned int ffs_next_dirty_subpage(struct f2fs_folio_state *ffs,
> const struct folio *folio, unsigned int start,
> unsigned int end)
> @@ -3561,7 +3573,7 @@ bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio)
> return true;
>
> if (fio) {
> - if (page_private_gcing(fio->page))
> + if (folio_test_f2fs_gcing(fio->folio))
> return true;
> if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
> f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))
> @@ -3587,8 +3599,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> struct dnode_of_data dn;
> struct node_info ni;
> struct f2fs_lock_context lc;
> + struct f2fs_folio_state *ffs;
> bool ipu_force = false;
> bool atomic_commit;
> + bool pending_added = false;
> + bool submitted = false;
> int err = 0;
>
> /* Use COW inode to make dnode_of_data for atomic write */
> @@ -3617,8 +3632,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> return -EINVAL;
>
> /* Deadlock due to between page->lock and f2fs_lock_op */
> - if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc))
> + if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc)) {
> + if (!f2fs_ffs_has_dirty_subpage(folio))
> + folio_clear_f2fs_gcing(folio);
> return -EAGAIN;
> + }
>
> err = f2fs_get_dnode_of_data(&dn, F2FS_FIO_LBLK(fio),
> LOOKUP_NODE);
> @@ -3630,7 +3648,6 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> /* This page is already truncated */
> if (fio->old_blkaddr == NULL_ADDR) {
> folio_clear_uptodate(folio);
> - folio_clear_f2fs_gcing(folio);
> goto out_writepage;
> }
> got_it:
> @@ -3680,6 +3697,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> fio->version = ni.version;
>
> __folio_start_writeback(folio, folio_test_dirty(folio));
> + if (f2fs_folio_has_ffs(folio)) {
> + ffs = (struct f2fs_folio_state *)folio->private;
> + atomic_inc(&ffs->write_pages_pending);
> + pending_added = true;
> + }
>
> if (fio->compr_blocks && fio->old_blkaddr == COMPRESS_ADDR)
> f2fs_i_compr_blocks_update(inode, fio->compr_blocks - 1, false);
> @@ -3694,6 +3716,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> err = -EIO;
> goto out_writepage;
> }
> + submitted = true;
> set_inode_flag(inode, FI_APPEND_WRITE);
> if (atomic_commit)
> folio_clear_f2fs_atomic(folio);
> @@ -3702,6 +3725,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> out:
> if (fio->need_lock == LOCK_REQ)
> f2fs_unlock_op(fio->sbi, &lc);
> + if (!submitted) {
> + if (pending_added) {
> + f2fs_ffs_put_write_pending(folio, 1);
> + } else if (!f2fs_ffs_has_dirty_subpage(folio)) {
> + folio_clear_f2fs_gcing(folio);
If f2fs_trylock_op() failed:
if (fio->need_lock == LOCK_RETRY) {
if (!f2fs_trylock_op(fio->sbi, &lc)) {
err = -EAGAIN;
goto out_writepage;
}
fio->need_lock = LOCK_REQ;
}
For order-0 folio, we may loss gcing flag becuase f2fs_ffs_has_dirty_subpage()
return false?
Two migration issues:
In f2fs_migrate_blocks() and f2fs_defragment_range(), we missed to mark subpage dirty?
folio = f2fs_get_lock_data_folio(inode, blkidx, true);
if (IS_ERR(folio)) {
f2fs_up_write(&sbi->pin_sem);
ret = PTR_ERR(folio);
goto done;
}
folio_mark_dirty(folio);
f2fs_folio_put(folio, true);
> + }
> + }
> return err;
> }
>
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index 915ca72cf276..1b63dd961f15 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -4493,6 +4493,7 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted,
> int compr_blocks, bool allow_balance);
> bool f2fs_ffs_test_blk_uptodate(const struct folio *folio, pgoff_t index);
> struct f2fs_folio_state *f2fs_ffs_find_or_alloc(struct folio *folio);
> +bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index);
> void f2fs_ffs_mark_subrange_dirty(struct folio *folio, size_t offset, size_t len);
> bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
> size_t len);
> diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
> index c66ca03d0d5a..c3e01f6811b4 100644
> --- a/fs/f2fs/gc.c
> +++ b/fs/f2fs/gc.c
> @@ -1520,12 +1520,19 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
> unsigned int segno, int off)
> {
> struct folio *folio;
> + size_t foff = 0;
> + bool large = false;
> int err = 0;
>
> folio = f2fs_get_lock_data_folio(inode, bidx, true);
> if (IS_ERR(folio))
> return PTR_ERR(folio);
>
> + if (f2fs_folio_has_ffs(folio)) {
> + large = true;
> + foff = offset_in_folio(folio, (loff_t)bidx << PAGE_SHIFT);
> + }
> +
> if (!check_valid_map(F2FS_I_SB(inode), segno, off)) {
> err = -ENOENT;
> goto out;
> @@ -1540,6 +1547,8 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
> err = -EAGAIN;
> goto out;
> }
> + if (large)
> + f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
> folio_mark_dirty(folio);
> folio_set_f2fs_gcing(folio);
> } else {
> @@ -1558,28 +1567,37 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
> .need_lock = LOCK_REQ,
> .io_type = FS_GC_DATA_IO,
> };
> - bool is_dirty = folio_test_dirty(folio);
> + bool is_dirty = f2fs_ffs_test_blk_dirty(folio, bidx);
>
> retry:
> f2fs_folio_wait_writeback(folio, true, true);
>
> + if (large)
> + f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
> folio_mark_dirty(folio);
> if (folio_clear_dirty_for_io(folio)) {
> - inode_dec_dirty_block(inode);
> - f2fs_remove_dirty_inode(inode);
> + if (!large) {
> + inode_dec_dirty_block(inode);
> + f2fs_remove_dirty_inode(inode);
> + } else if (f2fs_ffs_clear_subrange_dirty_and_test(folio,
> + foff, PAGE_SIZE)) {
> + folio_mark_dirty(folio);
> + }
> }
>
> folio_set_f2fs_gcing(folio);
>
> err = f2fs_do_write_data_page(&fio);
Another race issue my local bots report, please take a look:
Where: move_data_page() (gc.c:1564–1601) and the generic writeback_iter() used by f2fs_write_cache_folios() .
The cycle:
1. FG_GC writes one subpage. Its bio waits in write_io[DATA][COLD] until do_garbage_collect() submits it later.
2. If another subpage is still dirty, the folio is left both dirty and under writeback and is then unlocked.
3. A writer doing fsync, sync or checkpoint calls writeback_get_folio() → folio_prepare_writeback() . It locks the folio and sleeps in the generic folio_wait_writeback() , which does not flush f2fs's merged bio.
4. GC moves on to the next block of the same folio and blocks on folio_lock . The bio is never submitted.
Reachable today? Yes, on immutable large folios: BG_GC dirties subpage A, FG_GC migrates subpage B, and an fsync runs at the same time.
Fix: in move_data_page() , when large && folio_test_dirty(folio) after the write, call f2fs_submit_merged_write_cond(sbi, NULL, folio, 0, DATA) before unlocking. Optionally do the same in f2fs_write_cache_folios() out: when it redirties a folio that is under writeback.
Thanks,
> if (err) {
> - folio_clear_f2fs_gcing(folio);
> if (err == -ENOMEM) {
> memalloc_retry_wait(GFP_NOFS);
> goto retry;
> }
> - if (is_dirty)
> + if (is_dirty) {
> + if (large)
> + f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
> folio_mark_dirty(folio);
> + }
> }
> }
> out:
> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
> index cbb65e0343c8..e017a5f2a67f 100644
> --- a/fs/f2fs/segment.c
> +++ b/fs/f2fs/segment.c
> @@ -3863,7 +3863,7 @@ static int __get_segment_type_6(struct f2fs_io_info *fio)
> if (is_inode_flag_set(inode, FI_ALIGNED_WRITE))
> return CURSEG_COLD_DATA_PINNED;
>
> - if (page_private_gcing(fio->page)) {
> + if (folio_test_f2fs_gcing(fio->folio)) {
> if (fio->sbi->am.atgc_enabled &&
> (fio->io_type == FS_DATA_IO) &&
> (fio->sbi->gc_mode != GC_URGENT_HIGH) &&
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH v7 00/15] f2fs: support & optimize large folios for writable files
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
` (14 preceding siblings ...)
2026-10-26 3:37 ` [PATCH v7 15/15] f2fs: make compressed files compatible with large folio Nanzhe Zhao
@ 2026-10-27 9:47 ` Chao Yu
15 siblings, 0 replies; 22+ messages in thread
From: Chao Yu @ 2026-10-27 9:47 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: chao, Barry Song, Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Nanzhe Zhao, Ryan Roberts
On 10/26/26 11:37, Nanzhe Zhao wrote:
> 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
Nanzhe,
Well, I still see several comments are valid, can you please take a look, let's
just ignore false alarm one in last v6.
Patch 1: f2fs: extend folio state for large folio write path
Result:
Critical: 1 · High: 1 · Medium: 0 · Low: 0
Reviewed
▼ Inline Review
Copy
commit 5dc0bed5a4117aeba7c4f3561339538114aa9720
Author: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
f2fs: extend folio state for large folio write path
This commit moves struct f2fs_folio_state to fs/f2fs/f2fs.h, adds a
private_flags field and a subpage state bitmap, and updates the
PAGE_PRIVATE helper functions to work with f2fs_folio_state. It also
switches f2fs_folio_state allocation from kmem_cache to kzalloc since the
structure size now depends on the folio order.
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index aedba8b79baa9..abb0c0caed917 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
[ ... ]
> @@ -1629,6 +1641,13 @@ enum {
> PAGE_PRIVATE_MAX
> };
>
> +static inline bool f2fs_folio_has_ffs(const struct folio *folio)
> +{
> + unsigned long private = (unsigned long)folio->private;
> +
> + return folio_test_large(folio) && private;
> +}
> +
> /* For compression */
> enum compress_algorithm_type {
> COMPRESS_LZO,
> @@ -2759,13 +2778,35 @@ static inline int inc_valid_block_count(struct f2fs_sb_info *sbi,
> return -ENOSPC;
> }
>
> +static inline unsigned long f2fs_folio_get_private_flags(const struct folio *folio)
> +{
> + unsigned long private = (unsigned long)folio->private;
> +
> + if (f2fs_folio_has_ffs(folio)) {
> + struct f2fs_folio_state *ffs = (struct f2fs_folio_state *)private;
> +
> + return READ_ONCE(ffs->private_flags);
> + }
> +
> + if (test_bit(PAGE_PRIVATE_NOT_POINTER, &private))
> + return private;
> +
> + return 0;
> +}
> +
> +static inline unsigned long *f2fs_folio_flags_addr(struct folio *folio)
> +{
> + if (f2fs_folio_has_ffs(folio))
> + return &((struct f2fs_folio_state *)folio->private)->private_flags;
> +
> + return (unsigned long *)&folio->private;
> +}
> +
> #define PAGE_PRIVATE_GET_FUNC(name, flagname) \
> static inline bool folio_test_f2fs_##name(const struct folio *folio) \
> { \
> - unsigned long priv = (unsigned long)folio->private; \
> - unsigned long v = (1UL << PAGE_PRIVATE_NOT_POINTER) | \
> - (1UL << PAGE_PRIVATE_##flagname); \
> - return (priv & v) == v; \
> + return f2fs_folio_get_private_flags(folio) & \
> + (1UL << PAGE_PRIVATE_##flagname); \
> } \
> static inline bool page_private_##name(struct page *page) \
> { \
> @@ -2777,14 +2818,10 @@ static inline bool page_private_##name(struct page *page) \
> #define PAGE_PRIVATE_SET_FUNC(name, flagname) \
> static inline void folio_set_f2fs_##name(struct folio *folio) \
> { \
> - unsigned long v = (1UL << PAGE_PRIVATE_NOT_POINTER) | \
> - (1UL << PAGE_PRIVATE_##flagname); \
> if (!folio->private) \
> - folio_attach_private(folio, (void *)v); \
> - else { \
> - v |= (unsigned long)folio->private; \
> - folio->private = (void *)v; \
> - } \
> + folio_attach_private(folio, \
> + (void *)BIT(PAGE_PRIVATE_NOT_POINTER)); \
> + set_bit(PAGE_PRIVATE_##flagname, f2fs_folio_flags_addr(folio)); \
> } \
Can this cause a near-NULL pointer dereference when a PAGE_PRIVATE_SET_FUNC
helper (such as folio_set_f2fs_reference(), folio_set_f2fs_gcing(), or
folio_set_f2fs_atomic()) is called on a large folio whose folio->private is
NULL?
A large folio in the page cache can have folio->private == NULL when
populated over a hole in f2fs_read_data_large_folio() (which skips
f2fs_ffs_find_or_alloc() for unmapped blocks), or after
f2fs_release_folio() calls ffs_detach_free() on a clean large folio while
it remains in the page cache.
When one of the PAGE_PRIVATE_SET_FUNC helpers is called on such a folio
(for example via folio_mark_dirty() -> f2fs_dirty_data_folio() ->
f2fs_update_dirty_folio() -> folio_set_f2fs_reference(), or
redirty_blocks() -> folio_set_f2fs_gcing()), !folio->private is true, so it
attaches (void *)BIT(PAGE_PRIVATE_NOT_POINTER) (0x1) to folio->private.
On the next statement:
set_bit(PAGE_PRIVATE_##flagname, f2fs_folio_flags_addr(folio));
f2fs_folio_flags_addr(folio) calls f2fs_folio_has_ffs(folio), which checks
only folio_test_large(folio) && private without checking
PAGE_PRIVATE_NOT_POINTER. Because folio->private is now 0x1,
f2fs_folio_has_ffs(folio) returns true, f2fs_folio_flags_addr(folio)
returns &((struct f2fs_folio_state *)0x1)->private_flags, and set_bit()
dereferences that invalid address.
Furthermore, even if f2fs_folio_has_ffs() checked PAGE_PRIVATE_NOT_POINTER,
attaching non-pointer bitmask flags directly to folio->private on a large
folio conflicts with f2fs_ffs_find_or_alloc() in fs/f2fs/data.c:
f2fs_bug_on(F2FS_F_SB(folio),
test_bit(PAGE_PRIVATE_NOT_POINTER, &private));
...
folio_attach_private(folio, ffs);
which triggers f2fs_bug_on() and overwrites folio->private via an unpaired
folio_attach_private(), losing the flags and leaking a folio reference
count. Similarly, without checking PAGE_PRIVATE_NOT_POINTER,
ffs_detach_free() in fs/f2fs/data.c would treat a non-pointer bitmask on a
large folio as a struct f2fs_folio_state pointer and pass it to kfree().
> static inline void set_page_private_##name(struct page *page) \
> { \
> @@ -2797,13 +2834,10 @@ static inline void set_page_private_##name(struct page *page) \
> #define PAGE_PRIVATE_CLEAR_FUNC(name, flagname) \
> static inline void folio_clear_f2fs_##name(struct folio *folio) \
> { \
> - unsigned long v = (unsigned long)folio->private; \
> - \
> - v &= ~(1UL << PAGE_PRIVATE_##flagname); \
> - if (v == (1UL << PAGE_PRIVATE_NOT_POINTER)) \
> + clear_bit(PAGE_PRIVATE_##flagname, \
> + f2fs_folio_flags_addr(folio)); \
> + if (folio->private == (void *)BIT(PAGE_PRIVATE_NOT_POINTER)) \
> folio_detach_private(folio); \
> - else \
> - folio->private = (void *)v; \
> } \
> static inline void clear_page_private_##name(struct page *page) \
> { \
> @@ -2826,7 +2860,7 @@ PAGE_PRIVATE_CLEAR_FUNC(atomic, ATOMIC_WRITE);
>
> static inline unsigned long folio_get_f2fs_data(struct folio *folio)
> {
> - unsigned long data = (unsigned long)folio->private;
> + unsigned long data = f2fs_folio_get_private_flags(folio);
>
> if (!test_bit(PAGE_PRIVATE_NOT_POINTER, &data))
> return 0;
Because neither f2fs_ffs_find_or_alloc() (which allocates ffs with
__GFP_ZERO) nor PAGE_PRIVATE_SET_FUNC ever sets PAGE_PRIVATE_NOT_POINTER in
ffs->private_flags, won't PAGE_PRIVATE_NOT_POINTER always be 0 in
f2fs_folio_get_private_flags(folio) whenever f2fs_folio_has_ffs(folio) is
true?
This appears to cause several issues for large folios with ffs attached:
1. folio_test_f2fs_nonpointer(folio) always returns false. In
fs/f2fs/compress.c, f2fs_is_compressed_page() checks:
if (!folio->private)
return false;
if (folio_test_f2fs_nonpointer(folio))
return false;
f2fs_bug_on(F2FS_F_SB(folio),
*((u32 *)folio->private) != F2FS_COMPRESSED_PAGE_MAGIC);
return true;
When CONFIG_F2FS_FS_COMPRESSION is enabled and large folio writes are
enabled in later commits in this series ("f2fs: make GC migration
large-folio aware" and "f2fs: allow large folio support to writeable
files"), __has_merged_page() and f2fs_write_end_bio() call
f2fs_is_compressed_page(folio) on large folios with ffs. Because
folio_test_f2fs_nonpointer(folio) returns false, f2fs_is_compressed_page()
triggers f2fs_bug_on() (setting SBI_NEED_FSCK) and returns true, causing
f2fs_write_end_bio() to call f2fs_compress_write_end_io() and cast
folio->private (struct f2fs_folio_state *) to struct compress_io_ctx *.
Although a later commit in the series ("f2fs: make compressed files
compatible with large folio") adds an explicit f2fs_folio_has_ffs(folio)
check to f2fs_is_compressed_page(), the broken invariant affects the
intermediate commits and leaves folio_test_f2fs_nonpointer() broken for
large folios.
2. folio_get_f2fs_data(folio) checks
!test_bit(PAGE_PRIVATE_NOT_POINTER, &data) on the value returned by
f2fs_folio_get_private_flags(folio), so it will always return 0 when ffs is
attached. Meanwhile, folio_set_f2fs_data() right below it was not updated
for ffs and still bitwise-ORs data directly into folio->private, which
would corrupt the ffs pointer if called on a large folio.
Should PAGE_PRIVATE_NOT_POINTER and the data helpers be handled consistently
with ffs->private_flags?
>[!NOTE]
>Please ayudan-rate this review via `git notes` (see https://git.kernel.org/pub/scm/linux/kernel/git/mason/ai-review-prompts.git/tree/README.md):
>`git notes --ref=refs/notes/ai-review add -f -m "review-rating: <helpful|mostly-helpful|neutral|unhelpful|wrong>" 5dc0bed5a4117aeba7c4f3561339538114aa9720`
>If you have thoughts you'd like to share, add `comment: <free text>` on a new line in the note body.
>We scrape relationships between patches and notes from the mailing lists, so feel free to include the note text in your reply or push the notes ref to a public tree.
>
>🤖 AI review engine: google/gemini-3.1-pro-preview | 💬 Prompts: https://git.kernel.org/pub/scm/linux/kernel/git/mason/ai-review-prompts.git/tree/ (ef3d8ff5c6eb)
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 1834k · Cached: 9447k · Out: 58k
View Review Map·View Raw Log
↑ Back to Summary
Patch 2: f2fs: carry subpage offset and count in write IO
Result:
No regressions
Reviewed
▶ Inline Review
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 1465k · Cached: 15035k · Out: 54k
View Review Map·View Raw Log
↑ Back to Summary
Patch 3: f2fs: support regular file buffered writes on large folios
Result:
Critical: 0 · High: 1 · Medium: 0 · Low: 0
Reviewed
▼ Inline Review
Copy
commit 928ef87eb1284ddf44f56c2de4f7b745e3348066
Author: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
f2fs: support regular file buffered writes on large folios
This commit adds buffered write support for regular files backed by large
folios by preallocating partial blocks and synchronously reading only the
unaligned head and tail 4K subpages during write_begin.
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 3a3852566a2a2..f01bf06a77b05 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
[ ... ]
> @@ -1457,6 +1496,40 @@ static void f2fs_submit_page_read(struct inode *inode, struct fsverity_info *vi,
> f2fs_submit_read_bio(sbi, bio, DATA);
> }
>
> +/*
> + * Synchronously read a single 4K subpage by reusing f2fs_submit_page_read()
> + * so that iostat, trace, blk-crypto and post-read handling are all preserved.
> + * The caller must have already allocated ffs for the folio.
> + */
> +static int f2fs_submit_page_read_sync(struct inode *inode, struct folio *folio,
> + pgoff_t index, block_t blkaddr)
> +{
> + struct f2fs_folio_state *ffs =
> + (struct f2fs_folio_state *)folio->private;
> +
> + /* Add bias so end_io does not call folio_end_read(). */
> + f2fs_update_read_folio_pending(folio, 1);
> +
> + /*
> + * We are holding the folio lock, so use GFP_NOIO for the bio
> + * allocation to avoid entering mm reclaim.
> + */
> + f2fs_submit_page_read(inode, NULL, folio, index, blkaddr,
> + REQ_OP_READ, true);
> +
> + /* Wait until all bios have completed (pending drops back to our bias). */
> + while (READ_ONCE(ffs->read_pages_pending) != 1)
> + f2fs_io_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
> +
> + /* Remove the bias. */
> + f2fs_update_read_folio_pending(folio, -1);
Can waking up here as soon as ffs->read_pages_pending reaches 1 race with
f2fs_finish_read_bio() in fs/f2fs/data.c and cause a NULL pointer
dereference or use-after-free on the folio?
In f2fs_finish_read_bio(), ffs->read_pages_pending is decremented before
dec_cache_count() accesses the folio's mapping:
if (folio_test_large(folio)) {
struct f2fs_folio_state *ffs =
(struct f2fs_folio_state *)folio->private;
spin_lock_irqsave(&ffs->state_lock, flags);
ffs->read_pages_pending -= nr_pages;
finished = !ffs->read_pages_pending;
spin_unlock_irqrestore(&ffs->state_lock, flags);
}
while (nr_pages--)
dec_cache_count(F2FS_F_SB(folio), F2FS_RD_DATA);
Because f2fs_submit_page_read_sync() biases read_pages_pending by +1,
finished is false, so f2fs_finish_read_bio() does not hold the folio lock via
folio_end_read(). Once read_pages_pending is decremented to 1 and
ffs->state_lock is dropped, the waiting task in
f2fs_write_begin() -> prepare_large_folio_write_begin() ->
f2fs_submit_page_read_sync() can immediately wake up, remove the bias, and
unlock and release the folio (for example on an error path into
f2fs_write_failed(), or after f2fs_write_end() followed by truncation or
eviction).
If the folio is truncated or freed before f2fs_finish_read_bio() executes
dec_cache_count(F2FS_F_SB(folio), F2FS_RD_DATA), won't F2FS_F_SB(folio)
dereference a NULL folio->mapping or a freed folio?
> +
> + if (!f2fs_ffs_test_blk_uptodate(folio, index))
> + return -EIO;
> +
> + return 0;
> +}
[ ... ]
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 1787k · Cached: 21762k · Out: 47k
View Review Map·View Raw Log
↑ Back to Summary
Patch 4: f2fs: support atomic file large folios buffered write
Result:
Critical: 0 · High: 1 · Medium: 1 · Low: 0
Reviewed
▼ Inline Review
Copy
commit 421c38a2fd718b3ee600d299fc93a8b83ea493ee
Author: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
f2fs: support atomic file large folios buffered write
This commit adds buffered write support for atomic files backed by large
folios by introducing prepare_large_folio_atomic_write_begin() and updating
prepare_atomic_write_begin() and f2fs_write_begin().
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index f01bf06a77b05..126cad81227f0 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -4305,18 +4305,22 @@ static int __reserve_data_block(struct inode *inode, pgoff_t index,
> }
>
> static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
> - struct folio *folio, loff_t pos, unsigned int len,
> - block_t *blk_addr, bool *node_changed)
> + struct inode *inode, pgoff_t index,
> + block_t *blk_addr, bool *node_changed,
> + bool check_reserved)
> {
> - struct inode *inode = folio->mapping->host;
> struct inode *cow_inode = F2FS_I(inode)->cow_inode;
> - pgoff_t index = folio->index;
> int err = 0;
> block_t ori_blk_addr = NULL_ADDR;
> bool cow_has_reserved_block = false;
> + bool append = ((loff_t)index << PAGE_SHIFT) >= i_size_read(inode);
>
> - /* If pos is beyond the end of file, reserve a new block in COW inode */
> - if ((pos & PAGE_MASK) >= i_size_read(inode))
> + /*
> + * On the first attempt, an append write can skip the COW lookup and
> + * reserve directly. On retry, check the COW block first so the same
> + * block is not reserved and accounted twice.
> + */
> + if (append && !check_reserved)
> goto reserve_block;
Can skipping __find_data_block() on cow_inode when check_reserved is false
still double-increment F2FS_I(inode)->atomic_write_cnt and
sbi->current_atomic_write?
At reserve_block in prepare_atomic_write_begin(), when cow_has_reserved_block
is false, __reserve_data_block() calls f2fs_reserve_block():
if (!cow_has_reserved_block) {
err = __reserve_data_block(cow_inode, index, blk_addr,
node_changed);
if (err)
return err;
inc_atomic_write_cnt(inode);
}
If cow_inode already has NEW_ADDR at index, f2fs_reserve_block() returns 0
without allocating a new block, and inc_atomic_write_cnt(inode) increments
atomic_write_cnt and sbi->current_atomic_write a second time.
Since retried in f2fs_write_begin() is a local variable initialized to false
on each f2fs_write_begin() call, cow_inode can already hold NEW_ADDR at an
index >= (i_size_read(inode) >> PAGE_SHIFT) with check_reserved == false in
several cases:
1. In generic_perform_write(), if prepare_large_folio_atomic_write_begin()
reserves NEW_ADDR for multiple subpages in [start, end], and
copy_folio_from_iter_atomic() copies only the first subpage before faulting on
the next user page, f2fs_write_end() advances i_size only by the copied bytes.
The next loop iteration in generic_perform_write() calls f2fs_write_begin()
again with retried == false for the remaining subpages where
((loff_t)index << PAGE_SHIFT) >= i_size_read(inode) is still true.
2. If copy_folio_from_iter_atomic() returns 0 (or performs a short copy on a
non-uptodate folio so f2fs_write_end() sets copied = 0 without advancing
i_size), generic_perform_write() retries f2fs_write_begin() at the same offset
with retried == false.
3. If prepare_large_folio_atomic_write_begin() reserves NEW_ADDR in cow_inode
for earlier subpages in [start, end] and fails on a subsequent subpage,
f2fs_write_failed() only truncates inode and leaves the reserved NEW_ADDR
blocks in cow_inode beyond i_size.
4. On the order-0 read path in f2fs_write_begin(), if folio->mapping !=
mapping after f2fs_submit_page_read() and folio_lock(), it jumps to repeat
without setting retried = true.
>
> /* Look for the block in COW inode first */
> @@ -4330,7 +4334,7 @@ static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
> if (*blk_addr == NEW_ADDR)
> cow_has_reserved_block = true;
>
> - if (is_inode_flag_set(inode, FI_ATOMIC_REPLACE))
> + if (append || is_inode_flag_set(inode, FI_ATOMIC_REPLACE))
> goto reserve_block;
>
> /* Look for the block in the original inode */
> @@ -4498,6 +4502,62 @@ static int prepare_large_folio_write_begin(struct inode *inode,
> return 0;
> }
>
> +static int prepare_large_folio_atomic_write_begin(struct inode *inode,
> + struct address_space *mapping, struct folio *folio, loff_t pos,
> + unsigned int len, bool retried)
> +{
> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> + size_t ori_off = offset_in_folio(folio, pos);
> + pgoff_t start, end, index;
> + int err = 0;
> +
> + len = min_t(unsigned int, len, folio_size(folio) - ori_off);
> +
> + if (!f2fs_ffs_find_or_alloc(folio))
> + return -ENOMEM;
> +
> + /* Inline data must have been converted before reaching here. */
> + f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
> +
> + start = folio->index + (ori_off >> PAGE_SHIFT);
> + end = folio->index + ((ori_off + len - 1) >> PAGE_SHIFT);
> +
> + for (index = start; index <= end; index++) {
> + block_t blkaddr = NULL_ADDR;
> + bool node_changed = false;
> + size_t off = (index - folio->index) << PAGE_SHIFT;
> +
> + err = prepare_atomic_write_begin(sbi, inode, index,
> + &blkaddr, &node_changed,
> + retried);
> + if (err)
> + return err;
> +
> + if (f2fs_ffs_test_blk_uptodate(folio, index))
> + goto balance;
> +
> + if (blkaddr == NEW_ADDR) {
> + folio_zero_segment(folio, off, off + PAGE_SIZE);
> + f2fs_ffs_mark_subrange_uptodate(folio, off, PAGE_SIZE);
> + goto balance;
> + }
> +
> + if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
> + DATA_GENERIC_ENHANCE_READ))
> + return -EFSCORRUPTED;
> +
> + err = f2fs_submit_page_read_sync(inode, folio, index,
> + blkaddr);
> + if (err)
> + return err;
> +balance:
> + if (f2fs_balance_fs_folio_locked(folio, mapping, node_changed))
> + return -EAGAIN;
> + }
Does zeroing, reading, and marking every subpage in [start, end] uptodate
during prepare_large_folio_atomic_write_begin() cause premature uptodate state
and unnecessary reads of full subpages?
The commit message notes that existing data should be read for partial head
and tail subpages, and prepare_large_folio_write_begin() uses
find_next_valid_block() to only zero or read unaligned boundary blocks. Here,
the loop processes every block in [start, end]:
1. For full 4KB subpages in [start, end] that are about to be completely
overwritten by copy_folio_from_iter_atomic(), existing blocks are
synchronously read from disk via f2fs_submit_page_read_sync().
2. For NEW_ADDR blocks (or existing blocks read in), every subpage in
[start, end] is marked uptodate in ffs->state (and via folio_mark_uptodate()
if all subpages in the folio become uptodate) before generic_perform_write()
copies user data into the folio:
fs/f2fs/data.c:f2fs_write_end() {
if (!folio_test_uptodate(folio)) {
if (unlikely(copied != len)) {
copied = 0;
} else if (folio_test_large(folio)) {
f2fs_ffs_mark_subrange_uptodate(folio,
offset_in_folio(folio, pos), len);
} else {
/* This should be come from len == PAGE_SIZE */
folio_mark_uptodate(folio);
}
}
}
If all subpages of the folio become uptodate inside
prepare_large_folio_atomic_write_begin(), f2fs_ffs_mark_subrange_uptodate()
marks the entire folio uptodate before user data is copied. Then at the
balance label, f2fs_balance_fs_folio_locked() can unlock the uptodate folio
with zeroed data visible to concurrent readers, and if
copy_folio_from_iter_atomic() faults part-way through (copied != len),
f2fs_write_end() sees folio_test_uptodate(folio) == true and skips resetting
copied = 0, leaving unwritten zeroed bytes marked uptodate.
Similarly, if [start, end] covers only part of a large folio (so
folio_test_uptodate(folio) stays false while ffs->state bits for [start, end]
are set) and copy_folio_from_iter_atomic() performs a short copy and faults,
f2fs_write_end() sets copied = 0 but does not clear the uptodate bits in
ffs->state, leaving partially modified subpages marked uptodate in ffs->state.
Also, at this commit in the series, f2fs_submit_page_read_sync() adds a bias
of 1 to ffs->read_pages_pending and checks f2fs_ffs_test_blk_uptodate(folio,
index) before returning, which fails with -EIO until later commit bca3a5fa0cb1
("f2fs: support partial uptodate large folio read") updates
f2fs_finish_read_bio() to set per-block uptodate bits in ffs->state.
Should prepare_large_folio_atomic_write_begin() only read or zero partial
head and tail subpages like prepare_large_folio_write_begin() does, leaving
the written range to be marked uptodate in f2fs_write_end() after
copy_folio_from_iter_atomic() succeeds?
[ ... ]
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 1362k · Cached: 18575k · Out: 51k
View Review Map·View Raw Log
↑ Back to Summary
Patch 5: f2fs: support large folio writeback
Result:
Critical: 0 · High: 2 · Medium: 3 · Low: 0
Reviewed
▼ Inline Review
Copy
commit d81e66fccee4d6cf0692abb255b15a1dacb65d07
Author: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
f2fs: support large folio writeback
This commit introduces a folio-based writeback path via
f2fs_write_cache_folios() and f2fs_write_folio_dirty_range() for mappings
that support large folios, while keeping f2fs_write_cache_pages() for
non-large-folio mappings.
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 126cad81227f0..a0822d06e3bc9 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
[ ... ]
> @@ -3541,6 +3686,144 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> return err;
> }
>
> +static int f2fs_write_folio_dirty_range(struct folio *folio, int *submitted,
> + struct writeback_control *wbc,
> + enum iostat_type io_type,
> + u64 *pos, u64 len)
> +{
> + struct inode *inode = folio->mapping->host;
> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> + bool atomic_commit = f2fs_is_atomic_file(inode) &&
> + folio_test_f2fs_atomic(folio);
> + struct inode *dn_inode = atomic_commit ?
> + F2FS_I(inode)->cow_inode : inode;
> + struct f2fs_folio_state *ffs = NULL;
> + u64 folio_start = folio_pos(folio);
> + pgoff_t start_idx = (*pos - folio_start) >> PAGE_SHIFT;
> + pgoff_t end_idx = (*pos - folio_start + len - 1) >> PAGE_SHIFT;
> + int err = 0;
> +
> + for (pgoff_t i = start_idx; i <= end_idx && !err; i++) {
[ ... ]
> + if (ipu_force ||
> + (__is_valid_data_blkaddr(fio.old_blkaddr) &&
> + need_inplace_update(&fio))) {
> + f2fs_put_dnode(&dn);
> + dn_held = false;
> + err = f2fs_inplace_write_data(&fio);
> + trace_f2fs_do_write_data_page(folio, IPU);
> + if (err)
> + goto block_done;
> +
> + if (submitted)
> + (*submitted)++;
> + submitted_blk = true;
> + set_inode_flag(inode, FI_UPDATE_WRITE);
> + goto block_done;
> + }
> +
> + err = f2fs_get_node_info(sbi, dn.nid, &ni, false);
> + if (err)
> + goto block_done;
> +
> + fio.version = ni.version;
> +
> + f2fs_outplace_write_data(&dn, &fio);
> + /*
> + * The outplace write path failed to submit this block.
> + */
> + if (!fio.submitted) {
> + err = -EIO;
> + goto block_done;
> + }
> + if (submitted)
> + (*submitted)++;
> + submitted_blk = true;
> + set_inode_flag(inode, FI_APPEND_WRITE);
> + trace_f2fs_do_write_data_page(folio, OPU);
> +block_done:
[ ... ]
> + return err;
> +}
> +
> int f2fs_write_single_data_page(struct folio *folio, int *submitted,
> struct bio **bio,
> sector_t *last_block,
> @@ -3990,6 +4273,226 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
> return ret;
> }
>
> +static int f2fs_write_cache_folios(struct address_space *mapping,
> + struct writeback_control *wbc,
> + enum iostat_type io_type)
> +{
> + struct folio *folio = NULL;
> + struct inode *inode = mapping->host;
> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> + struct f2fs_lock_context lc;
> + u64 pos = 0;
> + u64 end_pos = 0;
> + u32 r_len = 0;
> + int err = 0;
> + int submitted = 0;
> + int nwritten = 0;
> + bool op_locked = false;
> + bool retry = false;
> +
> + if (get_dirty_pages(inode) <= SM_I(sbi)->min_hot_blocks)
> + set_inode_flag(inode, FI_HOT_DATA);
> + else
> + clear_inode_flag(inode, FI_HOT_DATA);
> +
> + while ((folio = writeback_iter(mapping, wbc, folio, &err))) {
Can calling writeback_iter() here deadlock during WB_SYNC_ALL writeback if
a folio has both PG_writeback and PG_dirty set while its bio is still
cached in sbi->write_io[DATA]?
In f2fs, out-of-place writes set PG_writeback and stage the folio into
sbi->write_io[DATA] without immediately submitting the bio to the block
layer. Because of this, f2fs_write_cache_pages() and the internal retry
path in f2fs_write_cache_folios() call f2fs_folio_wait_writeback(), which
flushes cached bios via f2fs_submit_merged_write_folio() and
f2fs_submit_merged_ipu_write() before calling folio_wait_writeback().
However, writeback_iter() -> writeback_get_folio() ->
folio_prepare_writeback() calls raw folio_wait_writeback() under
folio_lock() when wbc->sync_mode == WB_SYNC_ALL and both PG_writeback and
PG_dirty are set, without flushing sbi->write_io[DATA].
For example, during foreground GC (do_garbage_collect() ->
gc_data_segment() -> move_data_page()) migrating one block of a large
folio that has another dirty subpage, move_data_page() sees remaining
dirty subpages via f2fs_ffs_clear_subrange_dirty_and_test(), calls
folio_mark_dirty(), stages the block in sbi->write_io[DATA][COLD].bio via
f2fs_do_write_data_page() (setting PG_writeback), and unlocks the folio.
If a concurrent WB_SYNC_ALL thread enters writeback_iter(), it locks the
folio and sleeps in folio_wait_writeback() waiting for the unsubmitted
bio, while gc_data_segment() blocks on folio_lock() when it encounters the
next block of that large folio before do_garbage_collect() can submit the
cached bio.
A similar stall can occur if f2fs_write_folio_dirty_range() submits one
subpage into sbi->write_io[DATA], hits an error on a later subpage,
redirties and unlocks the folio at out: with PG_writeback still held by
the pending subpage, and then stalls on a subsequent folio before reaching
f2fs_submit_merged_write_cond() at the end of f2fs_write_cache_folios().
> + struct f2fs_folio_state *ffs = NULL;
> + u64 isize;
> + size_t poff;
> + pgoff_t end_index;
> + bool verity_in_progress;
> + int folio_submitted = 0;
> + bool bias_added = false;
> +
> + submitted = 0;
> + retry = false;
> +
> + if (err) {
> + folio_redirty_for_writepage(wbc, folio);
> + goto retry_out;
> + }
> +
> + if (atomic_read(&sbi->wb_sync_req[DATA]) &&
> + wbc->sync_mode == WB_SYNC_NONE) {
> + folio_redirty_for_writepage(wbc, folio);
> + /*
> + * A WB_SYNC_ALL writeback is in progress, so defer
> + * this writeback. Mark the error as -EBUSY to let
> + * writeback_iter() stop iterating.
> + */
> + err = -EBUSY;
> + goto retry_out;
> + }
> +
> + /*
> + * If cp_error is set, all subpages of this folio are not written
> + * back unless the filesystem is mounted with errors=remount-ro.
> + */
> + if (unlikely(f2fs_cp_error(sbi))) {
> + mapping_set_error(folio->mapping, -EIO);
> + if (F2FS_OPTION(sbi).errors == MOUNT_ERRORS_READONLY) {
> + folio_redirty_for_writepage(wbc, folio);
> + } else {
> + if (f2fs_folio_has_ffs(folio))
> + f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
> + folio_size(folio));
> + inode_dec_dirty_pages(inode);
> + }
> + goto retry_out;
> + }
> +
> + /*
> + * Writing back one large folio performs multiple block allocations, so
> + * best-effort balance the filesystem before writing it back.
> + */
> + if (!F2FS_I(inode)->wb_task && has_not_enough_free_secs(sbi, 0, 0)) {
> + folio_redirty_for_writepage(wbc, folio);
> + retry = true;
> + folio_unlock(folio);
> + f2fs_balance_fs(sbi, true);
> + folio_lock(folio);
> + goto retry;
> + }
> +retry:
Should the retry label be placed before the f2fs_cp_error(sbi) check (or
recheck f2fs_cp_error(sbi) under the retry block)?
When the folio is unlocked for f2fs_balance_fs() or during the
f2fs_io_schedule_timeout() backoff when f2fs_trylock_op() fails on
WB_SYNC_ALL, a concurrent checkpoint or GC can fail and set CP_ERROR_FLAG.
Jumping to retry: bypasses the f2fs_cp_error(sbi) check above, so instead
of recording -EIO via mapping_set_error() and handling the dirty state for
cp_error (as f2fs_write_single_data_page() does on every retry in
f2fs_write_cache_pages()), writeback proceeds into block allocation or
redirties the folio on error without setting the mapping error.
> + pos = folio_pos(folio);
> + end_pos = pos + folio_size(folio);
> + isize = i_size_read(inode);
> + verity_in_progress = f2fs_verity_in_progress(inode);
> + poff = 0;
> + end_index = 0;
> +
> + if (retry) {
> +
> + if (unlikely(folio->mapping != mapping))
> + goto retry_out;
> +
> + if (!folio_test_dirty(folio))
> + goto retry_out;
> +
> + if (folio_test_writeback(folio)) {
> + if (wbc->sync_mode == WB_SYNC_NONE)
> + goto retry_out;
> + f2fs_folio_wait_writeback(folio, true, true);
> + }
> +
> + if (!folio_clear_dirty_for_io(folio))
> + goto retry_out;
> + }
> +
> + /* To avoid dealing with the complexity for one subrange is in bio
> + * while we trylock_op failed before writing another subrange.
> + * Try to lock_op before any subrange write for the folio.
> + */
> + if (!op_locked) {
> + if (!f2fs_trylock_op(sbi, &lc)) {
> + folio_redirty_for_writepage(wbc, folio);
> + err = 0;
> + if (wbc->sync_mode != WB_SYNC_ALL)
> + goto retry_out;
> +
> + retry = true;
> + folio_unlock(folio);
> + f2fs_io_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
> + folio_lock(folio);
> + goto retry;
> + }
> + op_locked = true;
> + }
> +
> + if (!verity_in_progress) {
> + poff = offset_in_folio(folio, isize);
> + end_index = isize >> PAGE_SHIFT;
> +
> + if (folio->index > end_index ||
> + (folio->index == end_index && poff == 0))
> + goto out;
Does jumping to out: here (as well as jumping to retry_out: in the
f2fs_cp_error(sbi) branch when errors != MOUNT_ERRORS_READONLY) leave
stale PAGECACHE_TAG_DIRTY and PAGECACHE_TAG_TOWRITE tags in
mapping->i_pages?
writeback_iter() (via folio_prepare_writeback() ->
folio_clear_dirty_for_io()) and the retry path clear PG_dirty on the folio
while leaving PAGECACHE_TAG_DIRTY and PAGECACHE_TAG_TOWRITE set in the
xarray until folio_start_writeback() or folio_redirty_for_writepage() is
called.
When a folio is at or beyond isize and jumps to out: before
folio_start_writeback() is called, or when f2fs_cp_error(sbi) drops the
dirty state and jumps to retry_out:, the folio is unlocked with
PG_dirty == 0 without ever calling folio_start_writeback() /
folio_end_writeback(). That leaves PAGECACHE_TAG_DIRTY and
PAGECACHE_TAG_TOWRITE set on a clean folio in mapping->i_pages, causing
VFS writeback (__writeback_single_inode()) to see
mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) and repeatedly requeue the
inode via redirty_tail_locked() while __f2fs_write_data_pages() immediately
returns 0 on WB_SYNC_NONE because get_dirty_pages(inode) is 0.
> +
> + if (end_pos > isize) {
> + folio_zero_segment(folio, poff, folio_size(folio));
> + end_pos = isize;
> + }
> + }
> +
> + folio_start_writeback(folio);
> +
> + /*
> + * Large folios can be submitted as multiple bios, which may
> + * complete while we are still submitting the remaining dirty
> + * ranges. Hold a bias on write_pages_pending to prevent
> + * folio_end_writeback() from being called early.
> + */
> + if (!bias_added && f2fs_folio_has_ffs(folio)) {
> + ffs = (struct f2fs_folio_state *)folio->private;
> + WARN_ON_ONCE(atomic_read(&ffs->write_pages_pending) != 0);
> + atomic_inc(&ffs->write_pages_pending);
> + bias_added = true;
> + }
> +
> + while ((r_len = ffs_find_dirty_range(folio, &pos, end_pos))) {
> + err = f2fs_write_folio_dirty_range(folio, &submitted,
> + wbc, io_type, &pos, r_len);
> + folio_submitted += submitted;
> + nwritten += submitted;
> + if (err)
> + goto out;
> + }
Does this loop overcount folio_submitted and nwritten when a large folio
contains multiple discontiguous dirty ranges?
submitted is initialized to 0 once per folio before the loop, and
f2fs_write_folio_dirty_range() increments (*submitted)++ for each submitted
block without resetting *submitted = 0 on entry. When
ffs_find_dirty_range() finds a second dirty range in the same folio,
submitted still holds the count from the previous range(s), so
folio_submitted += submitted and nwritten += submitted add the earlier
ranges' counts again on each subsequent iteration (including when a later
range errors out before submitting any block). This remains present at the
end of the series (commit 1bb0e14154a5).
> +
> + /* If none of the subpages of a folio is submitted, keep the atomic flag */
> + if (folio_submitted &&
> + f2fs_is_atomic_file(inode) &&
> + folio_test_f2fs_atomic(folio))
> + folio_clear_f2fs_atomic(folio);
> +
> +out:
> + /*
> + * Clear the dirty state of the subranges that were written back.
> + * If some subranges are still dirty (e.g. the folio was only
> + * partially written back), or if the writeback failed, 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)) || err)
> + folio_redirty_for_writepage(wbc, folio);
> + else
> + inode_dec_dirty_pages(inode);
When a large folio straddles isize and err == 0, can passing
end_pos - folio_pos(folio) to f2fs_ffs_clear_subrange_dirty_and_test()
leave post-EOF subpage dirty bits set and livelock writeback?
When pos < isize < end_pos and !verity_in_progress, the code earlier clamps
end_pos = isize so ffs_find_dirty_range() only writes subpages up to isize.
At out:, when err == 0, f2fs_ffs_clear_subrange_dirty_and_test() is called
with length end_pos - folio_pos(folio) (i.e. isize - folio_pos(folio))
rather than folio_size(folio).
If any subpage past round_up(isize, PAGE_SIZE) in that straddling folio has
its dirty bit set in ffs->state (for instance via f2fs_zero_range() ->
fill_zero() with FALLOC_FL_KEEP_SIZE, via f2fs_ffs_find_or_alloc() marking
all nr_subpages dirty when PG_dirty is set, or after a partial truncate),
f2fs_ffs_clear_subrange_dirty_and_test() will not clear those post-EOF
bits, will return true, and will call folio_redirty_for_writepage() on
every writeback pass without ever writing or clearing them, preventing
inode_dec_dirty_pages() from ever being reached.
Should the !err case clear up to folio_size(folio) instead of
end_pos - folio_pos(folio)?
> +
> + /*
> + * Release the bias taken above and we end writeback here if
> + * no write bio is in flight.
> + */
[ ... ]
完美 — wait no extra text! Let me make sure I don't output anything after the last line! Let me re-check the response!
Wait: I just wrote "完美 — wait no extra text!" in the response! Let me NOT do that!
Wait: why did I write that outside the thought block?! Because the thought block ended early!
Wait: I cannot edit already emitted tokens, or wait—is this the final response? Yes! Let me stop immediately.
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 2240k · Cached: 35326k · Out: 93k
View Review Map·View Raw Log
↑ Back to Summary
Patch 6: f2fs: account large folio dirty data at block granularity
Result:
No regressions
Reviewed
▶ Inline Review
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 1571k · Cached: 15211k · Out: 36k
View Review Map·View Raw Log
↑ Back to Summary
Patch 7: f2fs: prepare mmap write faults for large folios
Result:
Critical: 0 · High: 1 · Medium: 0 · Low: 0
Reviewed
▼ Inline Review
Copy
commit 1dfe17de2abebed79ba1f0219bc9168714a92b0c
Author: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
f2fs: prepare mmap write faults for large folios
This commit updates f2fs_vm_page_mkwrite() to handle large folios by
allocating blocks across the valid portion of the folio, zeroing any
post-EOF segment, and marking the subrange dirty in f2fs_folio_state.
> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> index 85b4f1a2ff0dc..808b72d3d78a9 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
[ ... ]
> @@ -200,62 +229,59 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf)
> }
>
> folio_lock(folio);
> - /*
> - * A concurrent buffered write can extend isize, so we store isize in a
> - * local variable to let the zeroing offset match the EOF check below.
> - */
> isize = i_size_read(inode);
> + folio_start = folio_pos(folio);
> + subpage_off = offset_in_folio(folio, pos);
> + valid_end = min_t(loff_t, folio_start + folio_size(folio), isize);
> + dirty_len = valid_end - folio_start;
>
> if (unlikely(folio->mapping != inode->i_mapping ||
> - folio_pos(folio) > isize ||
> - !folio_test_uptodate(folio))) {
> + pos >= isize ||
> + !f2fs_ffs_test_blk_uptodate(folio,
> + folio->index + (subpage_off >> PAGE_SHIFT)))) {
> folio_unlock(folio);
> err = -EFAULT;
> goto out_sem;
> }
>
> - set_new_dnode(&dn, inode, NULL, NULL, 0);
> - if (need_alloc) {
> - /* block allocation */
> - err = f2fs_get_block_locked(&dn, folio->index);
> - } else {
> - err = f2fs_get_dnode_of_data(&dn, folio->index, LOOKUP_NODE);
> - f2fs_put_dnode(&dn);
> - if (f2fs_is_pinned_file(inode) &&
> - !__is_valid_data_blkaddr(dn.data_blkaddr))
> - err = -EIO;
> - }
> -
> - if (err) {
> + if (folio_test_large(folio) && !f2fs_ffs_find_or_alloc(folio)) {
> folio_unlock(folio);
> + err = -ENOMEM;
> goto out_sem;
> }
>
> - f2fs_folio_wait_writeback(folio, false, true);
> + nr = DIV_ROUND_UP(dirty_len, PAGE_SIZE);
>
> - /* wait for GCed page writeback via generic cache */
> - f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
> + for (i = 0; i < nr; i++) {
> + err = f2fs_get_block_mkwrite(inode, folio, folio->index + i,
> + need_alloc);
> + if (err) {
> + folio_unlock(folio);
> + goto out_sem;
> + }
> + }
>
> /* page is wholly or partially inside EOF */
> - if (((loff_t)(folio->index + 1) << PAGE_SHIFT) > isize) {
> - loff_t offset;
> + if (folio_start + folio_size(folio) > isize) {
> + size_t offset = offset_in_folio(folio, isize);
>
> - offset = isize & ~PAGE_MASK;
> folio_zero_segment(folio, offset, folio_size(folio));
> }
> +
> + if (folio_test_large(folio))
> + f2fs_ffs_mark_subrange_dirty(folio, 0, dirty_len);
> folio_mark_dirty(folio);
Can f2fs_vm_page_mkwrite() allocate blocks for and mark dirty non-uptodate
subpages of a large folio here?
f2fs_vm_page_mkwrite() replaces !folio_test_uptodate(folio) with a check on
only the single faulted subpage via f2fs_ffs_test_blk_uptodate(folio,
folio->index + (subpage_off >> PAGE_SHIFT)), but then proceeds to call
f2fs_get_block_mkwrite() across all nr subpages in [0, dirty_len) and marks
the entire [0, dirty_len) range dirty via f2fs_ffs_mark_subrange_dirty().
However, f2fs_ffs_mark_subrange_dirty() in fs/f2fs/data.c requires all
subpages in the range to already be uptodate:
/*
* Mark the given range dirty for writeback.
*
* Callers must guarantee that the corresponding subpages are already
* uptodate: a dirty subpage always holds the latest data, whose
* on-disk copy may be stale.
*/
void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
size_t offset, size_t len)
In both do_shared_fault() and wp_page_shared(), the folio is unlocked and
mapping->invalidate_lock is not held before calling do_page_mkwrite() ->
f2fs_vm_page_mkwrite(). In that window, a concurrent hole punch
(f2fs_punch_hole() -> truncate_pagecache_range() ->
truncate_inode_partial_folio() -> f2fs_invalidate_folio()) or truncation on
another subpage of the same large folio can clear the uptodate bits in
ffs->state for the invalidated subpages and call folio_clear_uptodate(folio).
Because the faulting thread holds a folio reference (or another subpage is
dirty), folio_split() in truncate_inode_partial_folio() fails and leaves the
folio in inode->i_mapping with !folio_test_uptodate(folio) and cleared
per-block uptodate bits in ffs->state. Similarly,
f2fs_write_folio_dirty_range() -> f2fs_clear_truncated_page_state() can clear
a subpage's uptodate bit in ffs->state and clear folio uptodate.
When f2fs_vm_page_mkwrite() then locks the folio, checking only the faulted
subpage at pidx succeeds if that subpage is still uptodate in ffs->state. It
then re-allocates blocks over the invalidated hole via
f2fs_get_block_mkwrite(), marks the non-uptodate subpages dirty in ffs->state,
and returns VM_FAULT_LOCKED while !folio_test_uptodate(folio) (allowing
do_shared_fault() -> finish_fault() to install PTEs for the non-uptodate
folio).
Since f2fs_vm_page_mkwrite() dirties the entire [0, dirty_len) range, should
it still verify that the folio (or every subpage in [0, dirty_len)) is
uptodate before allocating blocks and marking the range dirty?
[ ... ]
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 1601k · Cached: 22742k · Out: 39k
View Review Map·View Raw Log
↑ Back to Summary
Patch 8: f2fs: make GC migration large-folio aware
Result:
Critical: 0 · High: 2 · Medium: 1 · Low: 0
Reviewed
▼ Inline Review
Copy
commit df5d46a34919fb05bfd186e84d3c1b6847
Author: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
f2fs: make GC migration large-folio aware
This commit updates f2fs data lookup helpers and garbage collection to
operate on addressed 4K subpages within large folios rather than
invalidating or rejecting large folios. It also adjusts subpage dirty
tracking in move_data_page() and write_pages_pending / gcing flag
handling in f2fs_do_write_data_page().
Closes: https://lore.kernel.org/oe-lkp/202610081027.b13dcf10-lkp@intel.com
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index d027c949823b0..b3ada22cb0cbe 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -1679,20 +1679,16 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
> struct dnode_of_data dn;
> struct folio *folio;
> int err;
> -retry:
> +
> folio = f2fs_grab_cache_folio(mapping, index, for_write);
> if (IS_ERR(folio))
> return folio;
>
> if (folio_test_large(folio)) {
> - pgoff_t folio_index = mapping_align_index(mapping, index);
> - unsigned long nr_pages = folio_nr_pages(folio);
> -
> - f2fs_folio_put(folio, true);
> - invalidate_inode_pages2_range(mapping, folio_index,
> - folio_index + nr_pages - 1);
> - f2fs_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
> - goto retry;
> + if (!f2fs_ffs_find_or_alloc(folio)) {
> + err = -ENOMEM;
> + goto put_err;
> + }
> }
With the large-folio invalidation loop removed from
f2fs_get_read_data_folio(), callers of f2fs_get_lock_data_folio() now
receive large folios with struct f2fs_folio_state (ffs) attached. While
subsequent patches in this series update truncate_partial_data_page(),
fill_zero(), and __clone_blkaddrs() to mark subpages dirty via
f2fs_ffs_mark_subrange_dirty(), what happens when f2fs_defragment_range()
or f2fs_migrate_blocks() encounters a large folio?
In fs/f2fs/file.c:f2fs_defragment_range():
folio = f2fs_get_lock_data_folio(inode, idx, true);
if (IS_ERR(folio)) {
err = PTR_ERR(folio);
goto clear_out;
}
f2fs_folio_wait_writeback(folio, true, true);
folio_mark_dirty(folio);
folio_set_f2fs_gcing(folio);
and in fs/f2fs/data.c:f2fs_migrate_blocks():
folio = f2fs_get_lock_data_folio(inode, blkidx, true);
if (IS_ERR(folio)) {
f2fs_up_write(&sbi->pin_sem);
ret = PTR_ERR(folio);
goto done;
}
folio_mark_dirty(folio);
Neither f2fs_ioc_defragment() nor f2fs_defragment_range() checks
IS_IMMUTABLE(inode) or requires FMODE_WRITE, so F2FS_IOC_DEFRAGMENT can be
invoked directly on an immutable file with cached large folios. Similarly,
if a file had large folios populated while immutable and then had
FS_IMMUTABLE_FL cleared via f2fs_fileattr_set() (which leaves
AS_LARGE_FOLIO_SUPPORT and cached large folios in inode->i_mapping), both
f2fs_defragment_range() and f2fs_swap_activate() -> check_swap_activate()
-> f2fs_migrate_blocks() can receive a large folio with ffs attached.
Because f2fs_folio_has_ffs(folio) is true and neither caller invokes
f2fs_ffs_mark_subrange_dirty(), f2fs_update_dirty_folio() skips
f2fs_account_dirty_blocks() and f2fs_write_cache_folios() finds no dirty
subpages in ffs->state via ffs_find_dirty_range(), completing writeback
without writing any blocks. In check_swap_activate(), f2fs_migrate_blocks()
returns 0 without migrating the unaligned extent and jumps to goto retry,
resulting in an unbounded loop. Should f2fs_defragment_range() and
f2fs_migrate_blocks() also mark the target subpage dirty in ffs?
[ ... ]
> @@ -3587,8 +3599,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> struct dnode_of_data dn;
> struct node_info ni;
> struct f2fs_lock_context lc;
> + struct f2fs_folio_state *ffs;
> bool ipu_force = false;
> bool atomic_commit;
> + bool pending_added = false;
> + bool submitted = false;
> int err = 0;
>
> /* Use COW inode to make dnode_of_data for atomic write */
> @@ -3617,8 +3632,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> return -EINVAL;
>
> /* Deadlock due to between page->lock and f2fs_lock_op */
> - if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc))
> + if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc)) {
> + if (!f2fs_ffs_has_dirty_subpage(folio))
> + folio_clear_f2fs_gcing(folio);
> return -EAGAIN;
> + }
>
> err = f2fs_get_dnode_of_data(&dn, F2FS_FIO_LBLK(fio),
> LOOKUP_NODE);
> @@ -3630,7 +3648,6 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> /* This page is already truncated */
> if (fio->old_blkaddr == NULL_ADDR) {
> folio_clear_uptodate(folio);
> - folio_clear_f2fs_gcing(folio);
> goto out_writepage;
> }
> got_it:
> @@ -3680,6 +3697,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> fio->version = ni.version;
>
> __folio_start_writeback(folio, folio_test_dirty(folio));
> + if (f2fs_folio_has_ffs(folio)) {
> + ffs = (struct f2fs_folio_state *)folio->private;
> + atomic_inc(&ffs->write_pages_pending);
> + pending_added = true;
> + }
>
> if (fio->compr_blocks && fio->old_blkaddr == COMPRESS_ADDR)
> f2fs_i_compr_blocks_update(inode, fio->compr_blocks - 1, false);
> @@ -3694,6 +3716,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> err = -EIO;
> goto out_writepage;
> }
> + submitted = true;
> set_inode_flag(inode, FI_APPEND_WRITE);
> if (atomic_commit)
> folio_clear_f2fs_atomic(folio);
> @@ -3702,6 +3725,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> out:
> if (fio->need_lock == LOCK_REQ)
> f2fs_unlock_op(fio->sbi, &lc);
> + if (!submitted) {
> + if (pending_added) {
> + f2fs_ffs_put_write_pending(folio, 1);
> + } else if (!f2fs_ffs_has_dirty_subpage(folio)) {
> + folio_clear_f2fs_gcing(folio);
> + }
> + }
> return err;
> }
Can this error path clear the gcing flag prematurely or leave it set when
it shouldn't be?
In fs/f2fs/data.c:f2fs_ffs_has_dirty_subpage():
if (!f2fs_folio_has_ffs(folio))
return false;
For order-0 folios, f2fs_ffs_has_dirty_subpage() always returns false. When
f2fs_write_single_data_page() writes back an order-0 folio that had gcing
set (by BG_GC or f2fs_defragment_range()), it first calls
f2fs_do_write_data_page() with fio.need_lock = LOCK_RETRY:
if (err == -EAGAIN) {
err = f2fs_do_write_data_page(&fio);
if (err == -EAGAIN) {
f2fs_bug_on(sbi, compr_blocks);
fio.need_lock = LOCK_REQ;
err = f2fs_do_write_data_page(&fio);
}
}
If f2fs_trylock_op() fails under cp_rwsem contention in the LOCK_RETRY
attempt, f2fs_do_write_data_page() jumps to out_writepage -> out and clears
gcing on the folio before the LOCK_REQ retry or the redirty_out path runs.
For a large folio where the migrating subpage was the only dirty subpage,
its dirty bit in ffs->state was already cleared before calling
f2fs_do_write_data_page(), so f2fs_ffs_has_dirty_subpage() also returns
false and clears gcing before the retry or redirty_out path.
Similarly, in move_data_page() (FG_GC), if f2fs_do_write_data_page() fails
and no other subpage is dirty, f2fs_do_write_data_page() clears gcing, and
move_data_page() then redirties the subpage when is_dirty is true without
restoring gcing (or if an unrelated subpage in the large folio is dirty
from a normal write, f2fs_ffs_has_dirty_subpage() returns true and leaves
gcing set on the folio even when FG_GC fails, while early returns like
FAULT_SKIP_WRITE bypass out: altogether).
Losing the gcing flag on a migrating folio allows f2fs_should_update_outplace()
to permit in-place writes back to the victim segment, changes segment routing
in __get_segment_type_6(), and alters F2FS_WB_CP_DATA accounting in
f2fs_is_cp_guaranteed().
> diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
> index c66ca03d0d5a3..c3e01f6811b4a 100644
> --- a/fs/f2fs/gc.c
> +++ b/fs/f2fs/gc.c
[ ... ]
> @@ -1558,28 +1567,37 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
> .need_lock = LOCK_REQ,
> .io_type = FS_GC_DATA_IO,
> };
> - bool is_dirty = folio_test_dirty(folio);
> + bool is_dirty = f2fs_ffs_test_blk_dirty(folio, bidx);
>
> retry:
> f2fs_folio_wait_writeback(folio, true, true);
>
> + if (large)
> + f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
> folio_mark_dirty(folio);
> if (folio_clear_dirty_for_io(folio)) {
> - inode_dec_dirty_block(inode);
> - f2fs_remove_dirty_inode(inode);
> + if (!large) {
> + inode_dec_dirty_block(inode);
> + f2fs_remove_dirty_inode(inode);
> + } else if (f2fs_ffs_clear_subrange_dirty_and_test(folio,
> + foff, PAGE_SIZE)) {
> + folio_mark_dirty(folio);
> + }
> }
>
> folio_set_f2fs_gcing(folio);
>
> err = f2fs_do_write_data_page(&fio);
Could re-marking the large folio dirty here while queueing a single subpage
into sbi->write_io cause an AB-BA deadlock between foreground GC and a
concurrent WB_SYNC_ALL writeback thread?
Consider a large folio with multiple dirty subpages where at least two
blocks reside in a victim segment being migrated by FG_GC
(do_garbage_collect() -> gc_data_segment() -> move_data_page()):
1. For the first subpage, move_data_page() calls
f2fs_ffs_clear_subrange_dirty_and_test(), which returns true because
another subpage is still dirty, and then calls folio_mark_dirty(folio).
2. f2fs_do_write_data_page() calls
__folio_start_writeback(folio, folio_test_dirty(folio)) with keep_write
true (leaving both PG_dirty / PAGECACHE_TAG_DIRTY / PAGECACHE_TAG_TOWRITE
and PG_writeback set on the folio) and queues the block into the cached
BIO in sbi->write_io[DATA][COLD] via f2fs_outplace_write_data() ->
f2fs_submit_page_write().
3. move_data_page() unlocks the folio via f2fs_folio_put(folio, true)
without submitting the merged BIO in sbi->write_io[DATA][COLD] (which is
normally flushed either when move_data_page() calls
f2fs_folio_wait_writeback() on the next subpage under folio_lock, or at
the end of do_garbage_collect() via f2fs_submit_merged_write()).
4. Before GC locks the folio for the second subpage, a concurrent
WB_SYNC_ALL writeback (such as fsync() or sync()) enters
f2fs_write_cache_folios() -> writeback_iter() -> writeback_get_folio()
-> folio_prepare_writeback(), which locks the folio and sees both
folio_test_dirty(folio) and folio_test_writeback(folio) set.
5. folio_prepare_writeback() calls generic folio_wait_writeback(folio)
while holding folio_lock(folio). Unlike f2fs_folio_wait_writeback(),
generic folio_wait_writeback() does not call
f2fs_submit_merged_write_folio() to flush the cached BIO in
sbi->write_io[DATA][COLD].
6. When gc_data_segment() moves to the next block of the same folio,
move_data_page() -> f2fs_get_lock_data_folio() blocks on folio_lock(folio)
held by the writeback thread, while the writeback thread waits
indefinitely in folio_wait_writeback(folio) for the GC thread to submit
the cached BIO.
> if (err) {
> - folio_clear_f2fs_gcing(folio);
> if (err == -ENOMEM) {
> memalloc_retry_wait(GFP_NOFS);
> goto retry;
> }
> - if (is_dirty)
> + if (is_dirty) {
> + if (large)
> + f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
> folio_mark_dirty(folio);
> + }
> }
> }
> out:
[ ... ]
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 1894k · Cached: 22026k · Out: 76k
View Review Map·View Raw Log
↑ Back to Summary
Patch 9: f2fs: optimize small block size large folio read
Result:
Critical: 0 · High: 1 · Medium: 0 · Low: 0
Reviewed
▼ Inline Review
Copy
commit ec87e8e9211921ee45324f3294d311bcd0175dad
Author: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
f2fs: optimize small block size large folio read
This commit batches read_pages_pending and iostat updates across contiguous
mapped blocks in f2fs_read_data_large_folio() and switches
f2fs_finish_read_bio() and f2fs_read_data_large_folio() to check
f2fs_folio_has_ffs().
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index b3ada22cb0cbe..b805dbe2c1875 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -158,7 +158,7 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
> continue;
> }
>
> - if (folio_test_large(folio)) {
> + if (f2fs_folio_has_ffs(folio)) {
> struct f2fs_folio_state *ffs =
> (struct f2fs_folio_state *)folio->private;
>
Can f2fs_folio_has_ffs() treat a non-pointer PAGE_PRIVATE_NOT_POINTER flag
value on folio->private as a struct f2fs_folio_state pointer?
In fs/f2fs/f2fs.h, f2fs_folio_has_ffs() only checks that the folio is large
and folio->private is non-NULL, without checking
!test_bit(PAGE_PRIVATE_NOT_POINTER, &private):
fs/f2fs/f2fs.h:f2fs_folio_has_ffs() {
unsigned long private = (unsigned long)folio->private;
return folio_test_large(folio) && private;
}
A large folio in the page cache can have folio->private == NULL, for example
when f2fs_read_data_large_folio() reads a hole-backed large folio and skips
f2fs_ffs_find_or_alloc(), or after f2fs_release_folio() detaches ffs on a
clean large folio while an external reference such as a GUP pin keeps the
folio in the page cache.
If that folio is subsequently dirtied through folio_mark_dirty() ->
f2fs_dirty_data_folio() -> f2fs_update_dirty_folio():
fs/f2fs/checkpoint.c:f2fs_update_dirty_folio() {
...
if (f2fs_folio_has_ffs(folio)) {
folio_set_f2fs_reference(folio);
return;
}
f2fs_account_dirty_blocks(inode, 1);
folio_set_f2fs_reference(folio);
}
folio_set_f2fs_reference() sees folio->private == NULL and attaches
(void *)BIT(PAGE_PRIVATE_NOT_POINTER) (0x1), and then calls
f2fs_folio_flags_addr(folio):
fs/f2fs/f2fs.h:f2fs_folio_flags_addr() {
if (f2fs_folio_has_ffs(folio))
return &((struct f2fs_folio_state *)folio->private)->private_flags;
return (unsigned long *)&folio->private;
}
#define PAGE_PRIVATE_SET_FUNC(name, flagname) \
static inline void folio_set_f2fs_##name(struct folio *folio) \
{ \
if (!folio->private) \
folio_attach_private(folio, \
(void *)BIT(PAGE_PRIVATE_NOT_POINTER)); \
set_bit(PAGE_PRIVATE_##flagname, f2fs_folio_flags_addr(folio)); \
}
Because folio->private is now 0x1, f2fs_folio_has_ffs(folio) returns true,
and set_bit() dereferences &((struct f2fs_folio_state *)0x1)->private_flags
(and any subsequent f2fs_folio_has_ffs() check in f2fs_finish_read_bio() or
f2fs_update_read_folio_pending() would likewise cast 0x1 to struct
f2fs_folio_state *).
Should f2fs_folio_has_ffs() also verify
!test_bit(PAGE_PRIVATE_NOT_POINTER, &private), or should large folios always
allocate a struct f2fs_folio_state instead of attaching
BIT(PAGE_PRIVATE_NOT_POINTER)?
[ ... ]
> @@ -3250,9 +3265,7 @@ static int f2fs_read_data_large_folio(struct inode *inode,
> }
>
> /* set the bitmap to wait */
> - spin_lock_irq(&ffs->state_lock);
> - ffs->read_pages_pending++;
> - spin_unlock_irq(&ffs->state_lock);
> + f2fs_update_read_folio_pending(folio, len_blks);
> }
>
> /*
[ ... ]
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 1391k · Cached: 15987k · Out: 51k
View Review Map·View Raw Log
↑ Back to Summary
Patch 10: f2fs: support partial uptodate large folio read
Result:
No regressions
Reviewed
▶ Inline Review
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 777k · Cached: 6841k · Out: 15k
View Review Map·View Raw Log
↑ Back to Summary
Patch 11: f2fs: handle partial truncate of large folio dirty subpages
Result:
No regressions
Reviewed
▶ Inline Review
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 1521k · Cached: 22356k · Out: 33k
View Review Map·View Raw Log
↑ Back to Summary
Patch 12: f2fs: fix zeroing paths for large folios
Result:
Critical: 0 · High: 1 · Medium: 0 · Low: 0
Reviewed
▼ Inline Review
Copy
commit 00b3236a0bd96c8d085d8918e5158c9f634b5731
Author: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
f2fs: fix zeroing paths for large folios
This commit updates f2fs data zeroing paths in truncate_partial_data_page(),
fill_zero(), and f2fs_get_new_data_folio() to compute folio-relative offsets
with offset_in_folio() and track per-block uptodate and dirty state on large
folios.
> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> index 808b72d3d78a9..439e84a4aec39 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -833,12 +833,13 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
> static int truncate_partial_data_page(struct inode *inode, u64 from,
> bool cache_only)
> {
> - loff_t offset = from & (PAGE_SIZE - 1);
> pgoff_t index = from >> PAGE_SHIFT;
> struct address_space *mapping = inode->i_mapping;
> struct folio *folio;
> + size_t folio_off;
> + size_t blk_end;
>
> - if (!offset && !cache_only)
> + if (!(from & (PAGE_SIZE - 1)) && !cache_only)
> return 0;
>
> if (cache_only) {
> @@ -856,12 +857,22 @@ static int truncate_partial_data_page(struct inode *inode, u64 from,
> return PTR_ERR(folio) == -ENOENT ? 0 : PTR_ERR(folio);
> truncate_out:
> f2fs_folio_wait_writeback(folio, true, true);
> - folio_zero_segment(folio, offset, folio_size(folio));
> + folio_off = offset_in_folio(folio, from);
> + blk_end = min_t(size_t, round_up(folio_off, PAGE_SIZE),
> + folio_size(folio));
> + folio_zero_segment(folio, folio_off, blk_end);
When cache_only is true, truncate_partial_data_page() can be called with a
page-aligned from value, such as from == 0 when truncating an inline-data
inode via f2fs_do_truncate_blocks() -> truncate_partial_data_page():
fs/f2fs/file.c:f2fs_do_truncate_blocks() {
...
if (f2fs_has_inline_data(inode)) {
f2fs_truncate_inline_inode(inode, ientry, from);
f2fs_put_cache(ientry, true);
truncate_page = true;
goto out;
}
...
free_partial:
/* lastly zero out the first data page */
if (!err)
err = truncate_partial_data_page(inode, from, truncate_page);
}
When from is 0 (or any multiple of PAGE_SIZE), folio_off is also a multiple
of PAGE_SIZE, so round_up(folio_off, PAGE_SIZE) returns folio_off unchanged.
Doesn't this make blk_end == folio_off and cause folio_zero_segment() to zero
0 bytes instead of zeroing the target block, leaving stale data in the cached
folio?
>
> /* An encrypted inode should have a key and truncate the last page. */
> f2fs_bug_on(F2FS_I_SB(inode), cache_only && IS_ENCRYPTED(inode));
> - if (!cache_only)
> + if (!cache_only) {
> + /*
> + * The folio was read back above, so the subpage is
> + * already uptodate and dirty data stays valid.
> + */
> + f2fs_ffs_mark_subrange_dirty(folio, folio_off,
> + blk_end - folio_off);
> folio_mark_dirty(folio);
> + }
> f2fs_folio_put(folio, true);
> return 0;
> }
[ ... ]
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 825k · Cached: 7310k · Out: 21k
View Review Map·View Raw Log
↑ Back to Summary
Patch 13: f2fs: handle block cloning within the same large folio
Result:
No regressions
Reviewed
▶ Inline Review
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 754k · Cached: 8486k · Out: 17k
View Review Map·View Raw Log
↑ Back to Summary
Patch 14: f2fs: allow large folio support to writeable files
Result:
Critical: 0 · High: 1 · Medium: 2 · Low: 0
Reviewed
▼ Inline Review
Copy
commit d11b563f16eebcbe4ad3b2699ccc519e8d766169
Author: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
f2fs: allow large folio support to writeable files
This patch removes write-path restrictions on large folio mappings in f2fs,
introduces f2fs_mapping_set_large_folio() for newly created and loaded
inodes, and adds an order-0 check in f2fs_convert_inline_inode().
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index 2c9343eb6b5e9..53914629c604f 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -5348,6 +5348,23 @@ static inline bool f2fs_quota_file(struct f2fs_sb_info *sbi, nid_t ino)
> return false;
> }
>
> +static inline void f2fs_mapping_set_large_folio(struct inode *inode)
> +{
> + if (!S_ISREG(inode->i_mode) ||
> + f2fs_compressed_file(inode) ||
> + f2fs_quota_file(F2FS_I_SB(inode), inode->i_ino))
> + return;
> +
> + /*
> + * Keep the folio order range at 0 as a transitional step; large
> + * folios will be enabled once the whole write path is audited.
> + */
> + if (IS_IMMUTABLE(inode))
> + mapping_set_folio_min_order(inode->i_mapping, 0);
> + else
> + mapping_set_folio_order_range(inode->i_mapping, 0, 0);
> +}
Should the non-immutable branch in f2fs_mapping_set_large_folio() also call
mapping_set_folio_min_order(inode->i_mapping, 0) rather than setting the
order range to (0, 0)?
In include/linux/pagemap.h, mapping_large_folio_support() requires the
maximum folio order to be greater than zero:
static inline bool mapping_large_folio_support(const struct address_space *mapping)
{
...
return mapping_max_folio_order(mapping) > 0;
}
Because F2FS_IMMUTABLE_FL is not in F2FS_FL_INHERITED, newly created files in
f2fs_new_inode() and normal writeable files loaded via f2fs_iget() always
take the !IS_IMMUTABLE(inode) branch. Calling
mapping_set_folio_order_range(inode->i_mapping, 0, 0) leaves the max order at
0 and keeps large folio support disabled for writeable files even at the end
of the series (after commit "f2fs: make compressed files compatible with
large folio").
> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> index f621d5e65023a..3d621a20766d0 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
[ ... ]
> @@ -720,9 +711,6 @@ static int f2fs_file_open(struct inode *inode, struct file *filp)
> if (!f2fs_is_compress_backend_ready(inode))
> return -EOPNOTSUPP;
>
> - if (mapping_large_folio_support(inode->i_mapping) &&
> - filp->f_mode & FMODE_WRITE)
> - return -EOPNOTSUPP;
>
> err = fsverity_file_open(inode, filp);
> if (err)
With f2fs_file_open() now permitting writable file descriptors on mappings
with large folio support (such as an inode loaded with F2FS_IMMUTABLE_FL set
and later made writeable via f2fs_fileattr_set()), what happens when
F2FS_IOC_DEFRAGMENT or swapon runs on a file containing large folios?
Both fs/f2fs/file.c:f2fs_defragment_range():
folio = f2fs_get_lock_data_folio(inode, idx, true);
if (IS_ERR(folio)) {
err = PTR_ERR(folio);
goto clear_out;
}
f2fs_folio_wait_writeback(folio, true, true);
folio_mark_dirty(folio);
folio_set_f2fs_gcing(folio);
and fs/f2fs/data.c:f2fs_migrate_blocks() (called from
f2fs_swap_activate()->check_swap_activate()):
folio = f2fs_get_lock_data_folio(inode, blkidx, true);
if (IS_ERR(folio)) {
f2fs_up_write(&sbi->pin_sem);
ret = PTR_ERR(folio);
goto done;
}
folio_mark_dirty(folio);
f2fs_folio_put(folio, true);
fetch the folio via f2fs_get_lock_data_folio(), which attaches struct
f2fs_folio_state (ffs) to large folios, and then call folio_mark_dirty(folio)
without calling f2fs_ffs_mark_subrange_dirty().
Because f2fs_folio_has_ffs(folio) is true,
f2fs_dirty_data_folio()->f2fs_update_dirty_folio() skips
f2fs_account_dirty_blocks() and leaves the per-subpage dirty bitmap in
ffs->state all zero. When filemap_fdatawrite() subsequently runs
f2fs_write_cache_folios(), ffs_find_dirty_range() finds no dirty subpages and
skips writing the blocks.
Doesn't this cause f2fs_defragment_range() to silently skip migrating blocks
in large folios, cause check_swap_activate() to loop on goto retry until free
sections are exhausted (-ENOSPC), and leave PG_dirty large folios with zero
dirty subpage bits and unincremented inode->dirty_pages if the loop exits on
error before filemap_fdatawrite()?
[ ... ]
> diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
> index 49905aa084186..0dca6c3d58fb3 100644
> --- a/fs/f2fs/inline.c
> +++ b/fs/f2fs/inline.c
> @@ -239,6 +239,12 @@ int f2fs_convert_inline_inode(struct inode *inode)
> if (IS_ERR(folio))
> return PTR_ERR(folio);
>
> + /*
> + * Inline data is only supported in an order-0 index #0 folio; the
> + * inline write and mmap fault paths never request a larger order.
> + */
> + f2fs_bug_on(sbi, folio_test_large(folio));
> +
> f2fs_lock_op(sbi, &lc);
>
> ientry = f2fs_get_inode_cache(sbi, inode->i_ino);
Can a race between f2fs_vm_page_mkwrite() and a concurrent write trigger this
f2fs_bug_on() and set SBI_NEED_FSCK on a valid filesystem?
In fs/f2fs/file.c:f2fs_vm_page_mkwrite(), f2fs_convert_inline_inode() is
called before acquiring filemap_invalidate_lock_shared() or the folio lock,
and without holding inode_lock:
err = f2fs_convert_inline_inode(inode);
if (err)
goto out;
In fs/f2fs/inline.c:f2fs_convert_inline_inode(), the initial
f2fs_has_inline_data(inode) check is unlocked:
if (!f2fs_has_inline_data(inode))
return 0;
...
folio = f2fs_grab_cache_folio(inode->i_mapping, 0, false);
if (IS_ERR(folio))
return PTR_ERR(folio);
f2fs_bug_on(sbi, folio_test_large(folio));
f2fs_lock_op(sbi, &lc);
...
if (f2fs_has_inline_data(inode))
err = f2fs_convert_inline_folio(&dn, folio);
If thread A enters f2fs_vm_page_mkwrite()->f2fs_convert_inline_inode() on an
inline file whose mapping supports large folios and passes the initial
!f2fs_has_inline_data(inode) check, thread B can concurrently convert the
inline inode (clearing FI_INLINE_DATA), truncate or evict index 0, and
perform a buffered write via f2fs_write_begin() that allocates a large folio
at index 0:
fgp |= fgf_set_order(f2fs_has_inline_data(inode) ? PAGE_SIZE : len);
folio = f2fs_filemap_get_folio(mapping, index, fgp,
mapping_gfp_mask(mapping));
When thread A then calls f2fs_grab_cache_folio(inode->i_mapping, 0, false),
it gets the newly installed large folio at index 0 and hits
f2fs_bug_on(sbi, folio_test_large(folio)) before reaching the serialized
f2fs_has_inline_data(inode) check under f2fs_get_inode_cache(). Should the
folio_test_large(folio) check be moved inside the
if (f2fs_has_inline_data(inode)) block?
[ ... ]
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 1558k · Cached: 19139k · Out: 56k
View Review Map·View Raw Log
↑ Back to Summary
Patch 15: f2fs: make compressed files compatible with large folio
Result:
No regressions
Reviewed
▶ Inline Review
To: None Cc: None Status: Disabled (SMTP not configured)
Tokens used: In: 964k · Cached: 10088k · Out: 22k
View Review Map·View Raw Log
↑ Back to Summary
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re:Re: [PATCH v7 08/15] f2fs: make GC migration large-folio aware
2026-10-27 9:37 ` Chao Yu
@ 2026-10-27 10:11 ` Nanzhe Zhao
2026-10-27 10:55 ` Chao Yu
0 siblings, 1 reply; 22+ messages in thread
From: Nanzhe Zhao @ 2026-10-27 10:11 UTC (permalink / raw)
To: Chao Yu
Cc: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim, Barry Song,
Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Ryan Roberts
At 2026-10-27 17:37:22, "Chao Yu" <chao@kernel.org> wrote:
>On 10/26/26 11:37, Nanzhe Zhao wrote:
>> From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
>>
>> GC can operate on a 4K block that is cached inside a large folio.
>> The data lookup helpers therefore need to test and update uptodate
>> state for the addressed subpage instead of rejecting large folios or
>> treating the whole folio as the target block.
>>
>> Let f2fs_get_read_data_folio() and f2fs_get_lock_data_folio() to use
>> subpage uptodate state. Submit single-block reads at the requested
>> folio offset and zero only the addressed 4K range for NEW_ADDR.
>>
>> Also update `move_data_page` to mark, clear, and restore dirty
>> state for the target subpage, and submit write I/O with the subpage
>> offset recorded in f2fs_io_info.
>>
>> The write_pages_pending reference is taken by f2fs_do_write_data_page()
>> and dropped from its common error path, so a block that is truncated
>> concurrently no longer leaks the counter.
>>
>> Reported-by: kernel test robot <yi1.lai@intel.com>
>> Closes: https://lore.kernel.org/oe-lkp/202610081027.b13dcf10-lkp@intel.com
>> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
>> ---
>> fs/f2fs/data.c | 70 +++++++++++++++++++++++++++++++++--------------
>> fs/f2fs/f2fs.h | 1 +
>> fs/f2fs/gc.c | 28 +++++++++++++++----
>> fs/f2fs/segment.c | 2 +-
>> 4 files changed, 75 insertions(+), 26 deletions(-)
>>
>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
>> index d027c949823b..b3ada22cb0cb 100644
>> --- a/fs/f2fs/data.c
>> +++ b/fs/f2fs/data.c
>> @@ -1679,20 +1679,16 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
>> struct dnode_of_data dn;
>> struct folio *folio;
>> int err;
>> -retry:
>> +
>> folio = f2fs_grab_cache_folio(mapping, index, for_write);
>> if (IS_ERR(folio))
>> return folio;
>>
>> if (folio_test_large(folio)) {
>> - pgoff_t folio_index = mapping_align_index(mapping, index);
>> - unsigned long nr_pages = folio_nr_pages(folio);
>> -
>> - f2fs_folio_put(folio, true);
>> - invalidate_inode_pages2_range(mapping, folio_index,
>> - folio_index + nr_pages - 1);
>> - f2fs_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
>> - goto retry;
>> + if (!f2fs_ffs_find_or_alloc(folio)) {
>> + err = -ENOMEM;
>> + goto put_err;
>> + }
>> }
>>
>> if (f2fs_lookup_read_extent_cache_block(inode, index,
>> @@ -1728,7 +1724,7 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
>> goto put_err;
>> }
>> got_it:
>> - if (folio_test_uptodate(folio)) {
>> + if (f2fs_ffs_test_blk_uptodate(folio, index)) {
>> folio_unlock(folio);
>> return folio;
>> }
>> @@ -1741,9 +1737,11 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
>> * f2fs_init_inode_metadata.
>> */
>> if (dn.data_blkaddr == NEW_ADDR) {
>> - folio_zero_segment(folio, 0, folio_size(folio));
>> - if (!folio_test_uptodate(folio))
>> - folio_mark_uptodate(folio);
>> + size_t offset = offset_in_folio(folio,
>> + (loff_t)index << PAGE_SHIFT);
>> +
>> + folio_zero_segment(folio, offset, offset + PAGE_SIZE);
>> + f2fs_ffs_mark_subrange_uptodate(folio, offset, PAGE_SIZE);
>> folio_unlock(folio);
>> return folio;
>> }
>> @@ -1803,7 +1801,6 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
>>
>> /* wait for read completion */
>> folio_lock(folio);
>> -
>> if (unlikely(folio->mapping != mapping)) {
>> f2fs_folio_put(folio, true);
>> return ERR_PTR(-EIO);
>> @@ -1812,7 +1809,7 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
>> /*
>> * ffs can be released while the folio was unlocked above. Rebuild it
>> * for a fully uptodate folio; a partially uptodate one cannot be
>> - * rebuilt and will fail the uptodate check below.
>> + * rebuilt and will fail the subpage check below.
>> */
>> if (folio_test_large(folio) && !f2fs_folio_has_ffs(folio)) {
>> if (!f2fs_ffs_find_or_alloc(folio)) {
>> @@ -1821,7 +1818,7 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
>> }
>> }
>>
>> - if (unlikely(!folio_test_uptodate(folio))) {
>> + if (unlikely(!f2fs_ffs_test_blk_uptodate(folio, index))) {
>> f2fs_folio_put(folio, true);
>> return ERR_PTR(-EIO);
>> }
>> @@ -2970,6 +2967,22 @@ static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
>> folio_mark_uptodate(folio);
>> }
>>
>> +bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
>> +{
>> + struct f2fs_folio_state *ffs;
>> + unsigned int idx, nr_subpages;
>> +
>> + f2fs_bug_on(F2FS_F_SB(folio), !folio_contains(folio, index));
>> +
>> + if (!f2fs_folio_has_ffs(folio))
>> + return folio_test_dirty(folio);
>> +
>> + ffs = (struct f2fs_folio_state *)folio->private;
>> + nr_subpages = folio_nr_pages(folio);
>> + idx = index - folio->index;
>> + return test_bit(nr_subpages + idx, ffs->state);
>> +}
>> +
>> static unsigned int __ffs_mark_subrange_dirty(struct folio *folio,
>> struct f2fs_folio_state *ffs, size_t offset, size_t len)
>> {
>> @@ -3063,7 +3076,6 @@ bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
>>
>> return dirty;
>> }
>> -
>> static unsigned int ffs_next_dirty_subpage(struct f2fs_folio_state *ffs,
>> const struct folio *folio, unsigned int start,
>> unsigned int end)
>> @@ -3561,7 +3573,7 @@ bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio)
>> return true;
>>
>> if (fio) {
>> - if (page_private_gcing(fio->page))
>> + if (folio_test_f2fs_gcing(fio->folio))
>> return true;
>> if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
>> f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))
>> @@ -3587,8 +3599,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>> struct dnode_of_data dn;
>> struct node_info ni;
>> struct f2fs_lock_context lc;
>> + struct f2fs_folio_state *ffs;
>> bool ipu_force = false;
>> bool atomic_commit;
>> + bool pending_added = false;
>> + bool submitted = false;
>> int err = 0;
>>
>> /* Use COW inode to make dnode_of_data for atomic write */
>> @@ -3617,8 +3632,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>> return -EINVAL;
>>
>> /* Deadlock due to between page->lock and f2fs_lock_op */
>> - if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc))
>> + if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc)) {
>> + if (!f2fs_ffs_has_dirty_subpage(folio))
>> + folio_clear_f2fs_gcing(folio);
>> return -EAGAIN;
>> + }
>>
>> err = f2fs_get_dnode_of_data(&dn, F2FS_FIO_LBLK(fio),
>> LOOKUP_NODE);
>> @@ -3630,7 +3648,6 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>> /* This page is already truncated */
>> if (fio->old_blkaddr == NULL_ADDR) {
>> folio_clear_uptodate(folio);
>> - folio_clear_f2fs_gcing(folio);
>> goto out_writepage;
>> }
>> got_it:
>> @@ -3680,6 +3697,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>> fio->version = ni.version;
>>
>> __folio_start_writeback(folio, folio_test_dirty(folio));
>> + if (f2fs_folio_has_ffs(folio)) {
>> + ffs = (struct f2fs_folio_state *)folio->private;
>> + atomic_inc(&ffs->write_pages_pending);
>> + pending_added = true;
>> + }
>>
>> if (fio->compr_blocks && fio->old_blkaddr == COMPRESS_ADDR)
>> f2fs_i_compr_blocks_update(inode, fio->compr_blocks - 1, false);
>> @@ -3694,6 +3716,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>> err = -EIO;
>> goto out_writepage;
>> }
>> + submitted = true;
>> set_inode_flag(inode, FI_APPEND_WRITE);
>> if (atomic_commit)
>> folio_clear_f2fs_atomic(folio);
>> @@ -3702,6 +3725,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>> out:
>> if (fio->need_lock == LOCK_REQ)
>> f2fs_unlock_op(fio->sbi, &lc);
>> + if (!submitted) {
>> + if (pending_added) {
>> + f2fs_ffs_put_write_pending(folio, 1);
>> + } else if (!f2fs_ffs_has_dirty_subpage(folio)) {
>> + folio_clear_f2fs_gcing(folio);
>
>If f2fs_trylock_op() failed:
>
> if (fio->need_lock == LOCK_RETRY) {
> if (!f2fs_trylock_op(fio->sbi, &lc)) {
> err = -EAGAIN;
> goto out_writepage;
> }
> fio->need_lock = LOCK_REQ;
> }
>
>For order-0 folio, we may loss gcing flag becuase f2fs_ffs_has_dirty_subpage()
>return false?
>
But GC path which calls move_data_page will clear f2fs gcing whatever error code
f2fs_do_write_page returns right？ I think we may need to having an parameter,
or some infomation carried in fio to judge whether we call f2fs_do_write_data_page
in gc context?
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH v7 08/15] f2fs: make GC migration large-folio aware
2026-10-27 10:11 ` Nanzhe Zhao
@ 2026-10-27 10:55 ` Chao Yu
0 siblings, 0 replies; 22+ messages in thread
From: Chao Yu @ 2026-10-27 10:55 UTC (permalink / raw)
To: Nanzhe Zhao
Cc: chao, Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim, Barry Song,
Juan Yescas, Daeho Jeong, Pengfei Li, Dev Jain,
David Hildenbrand, linux-kernel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Ryan Roberts
On 10/27/26 18:11, Nanzhe Zhao wrote:
> At 2026-10-27 17:37:22, "Chao Yu" <chao@kernel.org> wrote:
>> On 10/26/26 11:37, Nanzhe Zhao wrote:
>>> From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
>>>
>>> GC can operate on a 4K block that is cached inside a large folio.
>>> The data lookup helpers therefore need to test and update uptodate
>>> state for the addressed subpage instead of rejecting large folios or
>>> treating the whole folio as the target block.
>>>
>>> Let f2fs_get_read_data_folio() and f2fs_get_lock_data_folio() to use
>>> subpage uptodate state. Submit single-block reads at the requested
>>> folio offset and zero only the addressed 4K range for NEW_ADDR.
>>>
>>> Also update `move_data_page` to mark, clear, and restore dirty
>>> state for the target subpage, and submit write I/O with the subpage
>>> offset recorded in f2fs_io_info.
>>>
>>> The write_pages_pending reference is taken by f2fs_do_write_data_page()
>>> and dropped from its common error path, so a block that is truncated
>>> concurrently no longer leaks the counter.
>>>
>>> Reported-by: kernel test robot <yi1.lai@intel.com>
>>> Closes: https://lore.kernel.org/oe-lkp/202610081027.b13dcf10-lkp@intel.com
>>> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
>>> ---
>>> fs/f2fs/data.c | 70 +++++++++++++++++++++++++++++++++--------------
>>> fs/f2fs/f2fs.h | 1 +
>>> fs/f2fs/gc.c | 28 +++++++++++++++----
>>> fs/f2fs/segment.c | 2 +-
>>> 4 files changed, 75 insertions(+), 26 deletions(-)
>>>
>>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
>>> index d027c949823b..b3ada22cb0cb 100644
>>> --- a/fs/f2fs/data.c
>>> +++ b/fs/f2fs/data.c
>>> @@ -1679,20 +1679,16 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
>>> struct dnode_of_data dn;
>>> struct folio *folio;
>>> int err;
>>> -retry:
>>> +
>>> folio = f2fs_grab_cache_folio(mapping, index, for_write);
>>> if (IS_ERR(folio))
>>> return folio;
>>>
>>> if (folio_test_large(folio)) {
>>> - pgoff_t folio_index = mapping_align_index(mapping, index);
>>> - unsigned long nr_pages = folio_nr_pages(folio);
>>> -
>>> - f2fs_folio_put(folio, true);
>>> - invalidate_inode_pages2_range(mapping, folio_index,
>>> - folio_index + nr_pages - 1);
>>> - f2fs_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
>>> - goto retry;
>>> + if (!f2fs_ffs_find_or_alloc(folio)) {
>>> + err = -ENOMEM;
>>> + goto put_err;
>>> + }
>>> }
>>>
>>> if (f2fs_lookup_read_extent_cache_block(inode, index,
>>> @@ -1728,7 +1724,7 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
>>> goto put_err;
>>> }
>>> got_it:
>>> - if (folio_test_uptodate(folio)) {
>>> + if (f2fs_ffs_test_blk_uptodate(folio, index)) {
>>> folio_unlock(folio);
>>> return folio;
>>> }
>>> @@ -1741,9 +1737,11 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
>>> * f2fs_init_inode_metadata.
>>> */
>>> if (dn.data_blkaddr == NEW_ADDR) {
>>> - folio_zero_segment(folio, 0, folio_size(folio));
>>> - if (!folio_test_uptodate(folio))
>>> - folio_mark_uptodate(folio);
>>> + size_t offset = offset_in_folio(folio,
>>> + (loff_t)index << PAGE_SHIFT);
>>> +
>>> + folio_zero_segment(folio, offset, offset + PAGE_SIZE);
>>> + f2fs_ffs_mark_subrange_uptodate(folio, offset, PAGE_SIZE);
>>> folio_unlock(folio);
>>> return folio;
>>> }
>>> @@ -1803,7 +1801,6 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
>>>
>>> /* wait for read completion */
>>> folio_lock(folio);
>>> -
>>> if (unlikely(folio->mapping != mapping)) {
>>> f2fs_folio_put(folio, true);
>>> return ERR_PTR(-EIO);
>>> @@ -1812,7 +1809,7 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
>>> /*
>>> * ffs can be released while the folio was unlocked above. Rebuild it
>>> * for a fully uptodate folio; a partially uptodate one cannot be
>>> - * rebuilt and will fail the uptodate check below.
>>> + * rebuilt and will fail the subpage check below.
>>> */
>>> if (folio_test_large(folio) && !f2fs_folio_has_ffs(folio)) {
>>> if (!f2fs_ffs_find_or_alloc(folio)) {
>>> @@ -1821,7 +1818,7 @@ struct folio *f2fs_get_lock_data_folio(struct inode *inode, pgoff_t index,
>>> }
>>> }
>>>
>>> - if (unlikely(!folio_test_uptodate(folio))) {
>>> + if (unlikely(!f2fs_ffs_test_blk_uptodate(folio, index))) {
>>> f2fs_folio_put(folio, true);
>>> return ERR_PTR(-EIO);
>>> }
>>> @@ -2970,6 +2967,22 @@ static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
>>> folio_mark_uptodate(folio);
>>> }
>>>
>>> +bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
>>> +{
>>> + struct f2fs_folio_state *ffs;
>>> + unsigned int idx, nr_subpages;
>>> +
>>> + f2fs_bug_on(F2FS_F_SB(folio), !folio_contains(folio, index));
>>> +
>>> + if (!f2fs_folio_has_ffs(folio))
>>> + return folio_test_dirty(folio);
>>> +
>>> + ffs = (struct f2fs_folio_state *)folio->private;
>>> + nr_subpages = folio_nr_pages(folio);
>>> + idx = index - folio->index;
>>> + return test_bit(nr_subpages + idx, ffs->state);
>>> +}
>>> +
>>> static unsigned int __ffs_mark_subrange_dirty(struct folio *folio,
>>> struct f2fs_folio_state *ffs, size_t offset, size_t len)
>>> {
>>> @@ -3063,7 +3076,6 @@ bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
>>>
>>> return dirty;
>>> }
>>> -
>>> static unsigned int ffs_next_dirty_subpage(struct f2fs_folio_state *ffs,
>>> const struct folio *folio, unsigned int start,
>>> unsigned int end)
>>> @@ -3561,7 +3573,7 @@ bool f2fs_should_update_outplace(struct inode *inode, struct f2fs_io_info *fio)
>>> return true;
>>>
>>> if (fio) {
>>> - if (page_private_gcing(fio->page))
>>> + if (folio_test_f2fs_gcing(fio->folio))
>>> return true;
>>> if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
>>> f2fs_is_checkpointed_data(sbi, fio->old_blkaddr)))
>>> @@ -3587,8 +3599,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>>> struct dnode_of_data dn;
>>> struct node_info ni;
>>> struct f2fs_lock_context lc;
>>> + struct f2fs_folio_state *ffs;
>>> bool ipu_force = false;
>>> bool atomic_commit;
>>> + bool pending_added = false;
>>> + bool submitted = false;
>>> int err = 0;
>>>
>>> /* Use COW inode to make dnode_of_data for atomic write */
>>> @@ -3617,8 +3632,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>>> return -EINVAL;
>>>
>>> /* Deadlock due to between page->lock and f2fs_lock_op */
>>> - if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc))
>>> + if (fio->need_lock == LOCK_REQ && !f2fs_trylock_op(fio->sbi, &lc)) {
>>> + if (!f2fs_ffs_has_dirty_subpage(folio))
>>> + folio_clear_f2fs_gcing(folio);
>>> return -EAGAIN;
>>> + }
>>>
>>> err = f2fs_get_dnode_of_data(&dn, F2FS_FIO_LBLK(fio),
>>> LOOKUP_NODE);
>>> @@ -3630,7 +3648,6 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>>> /* This page is already truncated */
>>> if (fio->old_blkaddr == NULL_ADDR) {
>>> folio_clear_uptodate(folio);
>>> - folio_clear_f2fs_gcing(folio);
>>> goto out_writepage;
>>> }
>>> got_it:
>>> @@ -3680,6 +3697,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>>> fio->version = ni.version;
>>>
>>> __folio_start_writeback(folio, folio_test_dirty(folio));
>>> + if (f2fs_folio_has_ffs(folio)) {
>>> + ffs = (struct f2fs_folio_state *)folio->private;
>>> + atomic_inc(&ffs->write_pages_pending);
>>> + pending_added = true;
>>> + }
>>>
>>> if (fio->compr_blocks && fio->old_blkaddr == COMPRESS_ADDR)
>>> f2fs_i_compr_blocks_update(inode, fio->compr_blocks - 1, false);
>>> @@ -3694,6 +3716,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>>> err = -EIO;
>>> goto out_writepage;
>>> }
>>> + submitted = true;
>>> set_inode_flag(inode, FI_APPEND_WRITE);
>>> if (atomic_commit)
>>> folio_clear_f2fs_atomic(folio);
>>> @@ -3702,6 +3725,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
>>> out:
>>> if (fio->need_lock == LOCK_REQ)
>>> f2fs_unlock_op(fio->sbi, &lc);
>>> + if (!submitted) {
>>> + if (pending_added) {
>>> + f2fs_ffs_put_write_pending(folio, 1);
>>> + } else if (!f2fs_ffs_has_dirty_subpage(folio)) {
>>> + folio_clear_f2fs_gcing(folio);
>>
>> If f2fs_trylock_op() failed:
>>
>> if (fio->need_lock == LOCK_RETRY) {
>> if (!f2fs_trylock_op(fio->sbi, &lc)) {
>> err = -EAGAIN;
>> goto out_writepage;
>> }
>> fio->need_lock = LOCK_REQ;
>> }
>>
>> For order-0 folio, we may loss gcing flag becuase f2fs_ffs_has_dirty_subpage()
>> return false?
>>
>
> But GC path which calls move_data_page will clear f2fs gcing whatever error code
> f2fs_do_write_page returns right？ I think we may need to having an parameter,
I think you mean FGGC, if it f2fs_do_write_data_page() failed, we will drop both
dirty bit and gcing flag, and then we can expect to migrate this block in later GC.
But, for BGGC, if we failed to f2fs_do_write_data_page(), we will redirty the folio,
and then we should keep gcing flag, otherwise, it won't guaranteed by checkpoint (see
f2fs_is_cp_guaranteed), we may lose the data once checkpoint only persist its metadata
rather than its data.
Thanks,
> or some infomation carried in fio to judge whether we call f2fs_do_write_data_page
> in gc context?
^ permalink raw reply [flat|nested] 22+ messages in thread
end of thread, other threads:[~2026-10-27 10:55 UTC | newest]
Thread overview: 22+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-10-26 3:37 [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 01/15] f2fs: extend folio state for large folio write path Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 02/15] f2fs: carry subpage offset and count in write IO Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 03/15] f2fs: support regular file buffered writes on large folios Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 04/15] f2fs: support atomic file large folios buffered write Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 05/15] f2fs: support large folio writeback Nanzhe Zhao
2026-10-27 9:34 ` Chao Yu
2026-10-26 3:37 ` [PATCH v7 06/15] f2fs: account large folio dirty data at block granularity Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 07/15] f2fs: prepare mmap write faults for large folios Nanzhe Zhao
2026-10-27 9:35 ` Chao Yu
2026-10-26 3:37 ` [PATCH v7 08/15] f2fs: make GC migration large-folio aware Nanzhe Zhao
2026-10-27 9:37 ` Chao Yu
2026-10-27 10:11 ` Nanzhe Zhao
2026-10-27 10:55 ` Chao Yu
2026-10-26 3:37 ` [PATCH v7 09/15] f2fs: optimize small block size large folio read Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 10/15] f2fs: support partial uptodate " Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 11/15] f2fs: handle partial truncate of large folio dirty subpages Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 12/15] f2fs: fix zeroing paths for large folios Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 13/15] f2fs: handle block cloning within the same large folio Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 14/15] f2fs: allow large folio support to writeable files Nanzhe Zhao
2026-10-26 3:37 ` [PATCH v7 15/15] f2fs: make compressed files compatible with large folio Nanzhe Zhao
2026-10-27 9:47 ` [PATCH v7 00/15] f2fs: support & optimize large folios for writable files Chao Yu
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®