* [f2fs-dev] [PATCH v2 01/14] f2fs: extend folio state for large folio write path
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:18 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-16 9:53 ` Chao Yu via Linux-f2fs-devel
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 02/14] f2fs: carry subpage offset and count in write IO Nanzhe Zhao via Linux-f2fs-devel
` (13 subsequent siblings)
14 siblings, 1 reply; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:18 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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, 98 insertions(+), 44 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index a3b02c067e89..b3303109a696 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;
-};
-
struct f2fs_bio {
struct work_struct work;
struct bio bio;
@@ -125,6 +119,9 @@ 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);
+
/*
* Update and unlock a bio's pages, and free the bio.
*
@@ -139,6 +136,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;
@@ -147,7 +161,7 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
bio_for_each_folio_all(fi, bio) {
struct folio *folio = fi.folio;
- unsigned nr_pages = fi.length >> PAGE_SHIFT;
+ unsigned int nr_pages = fi.length >> PAGE_SHIFT;
bool finished = true;
if (!folio_test_large(folio) &&
@@ -2487,17 +2501,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;
+
+ 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));
- if (ffs)
- return ffs;
+ if (f2fs_folio_has_ffs(folio))
+ return (struct f2fs_folio_state *)folio->private;
- ffs = f2fs_kmem_cache_alloc(ffs_entry_slab,
- GFP_NOIO | __GFP_ZERO, true, NULL);
+ 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;
}
@@ -2506,7 +2534,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;
}
@@ -2516,7 +2544,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,
@@ -2529,7 +2558,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 int nrpages;
struct f2fs_folio_state *ffs;
int ret = 0;
bool folio_in_bio = false;
@@ -2605,7 +2634,7 @@ 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);
/* set the bitmap to wait */
spin_lock_irq(&ffs->state_lock);
@@ -4522,21 +4551,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 ebc621f302e1..9a2366a6c113 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1618,6 +1618,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 */
@@ -1627,6 +1639,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,
@@ -2738,13 +2757,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) \
{ \
@@ -2756,14 +2797,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) \
{ \
@@ -2776,13 +2813,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) \
{ \
@@ -2808,7 +2842,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
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 01/14] f2fs: extend folio state for large folio write path
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 01/14] f2fs: extend folio state for large folio write path Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-16 9:53 ` Chao Yu via Linux-f2fs-devel
0 siblings, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-16 9:53 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:18, Nanzhe Zhao wrote:
> 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, 98 insertions(+), 44 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index a3b02c067e89..b3303109a696 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;
> -};
> -
> struct f2fs_bio {
> struct work_struct work;
> struct bio bio;
> @@ -125,6 +119,9 @@ 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);
> +
> /*
> * Update and unlock a bio's pages, and free the bio.
> *
> @@ -139,6 +136,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;
> @@ -147,7 +161,7 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
>
> bio_for_each_folio_all(fi, bio) {
> struct folio *folio = fi.folio;
> - unsigned nr_pages = fi.length >> PAGE_SHIFT;
> + unsigned int nr_pages = fi.length >> PAGE_SHIFT;
No needed? it's trivial though.
> bool finished = true;
>
> if (!folio_test_large(folio) &&
> @@ -2487,17 +2501,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;
> +
> + 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));
>
> - if (ffs)
> - return ffs;
> + if (f2fs_folio_has_ffs(folio))
> + return (struct f2fs_folio_state *)folio->private;
>
> - ffs = f2fs_kmem_cache_alloc(ffs_entry_slab,
> - GFP_NOIO | __GFP_ZERO, true, NULL);
> + 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;
> }
> @@ -2506,7 +2534,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;
> }
> @@ -2516,7 +2544,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,
> @@ -2529,7 +2558,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 int nrpages;
No needed? it's trivial though.
> struct f2fs_folio_state *ffs;
> int ret = 0;
> bool folio_in_bio = false;
> @@ -2605,7 +2634,7 @@ 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);
Do we need to handle no memory case?
Thanks,
>
> /* set the bitmap to wait */
> spin_lock_irq(&ffs->state_lock);
> @@ -4522,21 +4551,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 ebc621f302e1..9a2366a6c113 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -1618,6 +1618,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 */
> @@ -1627,6 +1639,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,
> @@ -2738,13 +2757,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) \
> { \
> @@ -2756,14 +2797,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) \
> { \
> @@ -2776,13 +2813,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) \
> { \
> @@ -2808,7 +2842,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;
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* [f2fs-dev] [PATCH v2 02/14] f2fs: carry subpage offset and count in write IO
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 01/14] f2fs: extend folio state for large folio write path Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:18 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios Nanzhe Zhao via Linux-f2fs-devel
` (12 subsequent siblings)
14 siblings, 0 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:18 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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 | 63 +++++++++++++++++++++++++++++++-------------
fs/f2fs/f2fs.h | 11 ++++++++
fs/f2fs/gc.c | 2 ++
fs/f2fs/inline.c | 1 +
fs/f2fs/node.c | 2 ++
fs/f2fs/segment.c | 4 ++-
8 files changed, 66 insertions(+), 20 deletions(-)
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index e95cd2118750..cd379183449e 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -264,6 +264,7 @@ static struct folio *__get_meta_folio(struct f2fs_sb_info *sbi, pgoff_t index,
.op_flags = REQ_META | REQ_PRIO,
.old_blkaddr = index,
.new_blkaddr = index,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.is_por = !is_meta ? 1 : 0,
};
@@ -456,6 +457,7 @@ int f2fs_ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
.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 ce88092d9ce2..b130e43b4566 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 b3303109a696..f14044e8a6f4 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -769,6 +769,9 @@ 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 = F2FS_FIO_BIO_OFFSET(fio);
+ size_t bio_len = F2FS_FIO_BIO_SIZE(fio);
if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr,
fio->is_por ? META_POR : (__is_meta_io(fio) ?
@@ -781,11 +784,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_page_count(fio->sbi, is_read_io(fio->op) ?
__read_io_type(data_folio) : WB_DATA_TYPE(fio->folio, false));
@@ -830,7 +833,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;
@@ -839,7 +843,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);
@@ -856,6 +860,9 @@ 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 = F2FS_FIO_BIO_OFFSET(fio);
+ size_t bio_len = F2FS_FIO_BIO_SIZE(fio);
struct f2fs_sb_info *sbi = fio->sbi;
enum temp_type temp;
bool found = false;
@@ -878,8 +885,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;
}
@@ -993,6 +1000,10 @@ 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 = F2FS_FIO_BIO_OFFSET(fio);
+ size_t bio_len = F2FS_FIO_BIO_SIZE(fio);
if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr,
__is_meta_io(fio) ? META_GENERIC : DATA_GENERIC))
@@ -1007,9 +1018,10 @@ 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;
@@ -1020,7 +1032,7 @@ int f2fs_merge_page_bio(struct f2fs_io_info *fio)
inc_page_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;
@@ -1056,6 +1068,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));
@@ -1094,33 +1110,39 @@ 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_page_count(sbi, type);
+ for (unsigned int i = 0; i < fio_cnt; i++)
+ inc_page_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 = F2FS_FIO_BIO_OFFSET(fio);
+ bio_len = F2FS_FIO_BIO_SIZE(fio);
+
+ if (!bio_add_folio(io->bio, bio_folio, bio_len, bio_offset)) {
__submit_merged_bio(io);
goto alloc_new;
}
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
@@ -2999,7 +3021,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))
@@ -3018,7 +3041,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;
@@ -3121,6 +3145,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 9a2366a6c113..326382ede1c3 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1348,6 +1348,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;
@@ -1368,6 +1370,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 c70deac9f1a3..16fce62740d7 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1227,6 +1227,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,
};
@@ -1337,6 +1338,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,
};
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 925bdaad013c..8db083b545bc 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/node.c b/fs/f2fs/node.c
index f16144b75d11..a19abc34c14a 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1475,6 +1475,7 @@ static int read_node_folio(struct folio *folio, blk_opf_t op_flags)
.op = REQ_OP_READ,
.op_flags = op_flags,
.folio = folio,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
};
int err;
@@ -1772,6 +1773,7 @@ static bool __write_node_folio(struct folio *folio, bool atomic, bool do_fsync,
.op = REQ_OP_WRITE,
.op_flags = wbc_to_write_flags(wbc),
.folio = folio,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.submitted = 0,
.io_type = io_type,
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index ffdd2c510b3c..644ddfb984c9 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -3873,7 +3873,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;
@@ -4195,6 +4196,7 @@ void f2fs_do_write_meta_page(struct f2fs_sb_info *sbi, struct folio *folio,
.old_blkaddr = folio->index,
.new_blkaddr = folio->index,
.folio = folio,
+ .folio_blkcnt = 1,
.encrypted_page = NULL,
.in_list = 0,
};
--
2.43.0
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 01/14] f2fs: extend folio state for large folio write path Nanzhe Zhao via Linux-f2fs-devel
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 02/14] f2fs: carry subpage offset and count in write IO Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:18 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-16 11:47 ` Chao Yu via Linux-f2fs-devel
` (2 more replies)
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 04/14] f2fs: support atomic file large folios buffered write Nanzhe Zhao via Linux-f2fs-devel
` (11 subsequent siblings)
14 siblings, 3 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:18 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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 | 300 +++++++++++++++++++++++++++++++++++++++++++++++--
fs/f2fs/f2fs.h | 1 +
fs/f2fs/file.c | 17 ++-
3 files changed, 304 insertions(+), 14 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index f14044e8a6f4..a490df4f50b3 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1233,6 +1233,35 @@ 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 = folio->private;
+
+ /* Add bias so end_io does not call folio_end_read(). */
+ f2fs_update_read_folio_pending(folio, 1);
+
+ f2fs_submit_page_read(inode, NULL, folio, index, blkaddr,
+ REQ_OP_READ, false);
+
+ /* 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_folio);
@@ -2570,6 +2599,114 @@ 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 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);
+}
+
+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 void f2fs_ffs_mark_subrange_dirty(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_set(ffs->state, nr_subpages + start, end - start);
+ 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 - 1, 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)
@@ -3927,6 +4064,110 @@ static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
return 0;
}
+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;
+
+ len = min_t(unsigned int, len, folio_size(folio) - ori_off);
+
+ /*
+ * When folio minimum order is non-zero, the fsverity
+ * page_cache_write() path enters f2fs_write_begin() via
+ * aops->write_begin without going through f2fs_write_iter(),
+ * so preallocation from f2fs_write_iter() is skipped. In that
+ * case, if FI_PREALLOCATED_ALL is not set, we must preallocate
+ * the write blocks here.
+ */
+ if (!is_inode_flag_set(inode, FI_PREALLOCATED_ALL)) {
+ struct f2fs_map_blocks map = {};
+
+ map.m_lblk = F2FS_BYTES_TO_BLK(sbi, pos);
+ map.m_len = F2FS_BLK_ALIGN(sbi, pos + len) - map.m_lblk;
+
+ if (!IS_DEVICE_ALIASING(inode))
+ map.m_may_create = true;
+ map.m_seg_type = NO_CHECK_TYPE;
+
+ err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_AIO);
+ if (err)
+ return err;
+ }
+
+ 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;
+ bool get_dn = false;
+
+ 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;
+ get_dn = true;
+ blkaddr = dn.data_blkaddr;
+
+ if (blkaddr == NEW_ADDR) {
+ size_t off = offset_in_folio(folio,
+ index << PAGE_SHIFT);
+
+ folio_zero_segment(folio, off, off + PAGE_SIZE);
+ f2fs_ffs_mark_subrange_uptodate(folio, off,
+ PAGE_SIZE);
+ goto out;
+ }
+
+ if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
+ DATA_GENERIC_ENHANCE_READ)) {
+ err = -EFSCORRUPTED;
+ goto out;
+ }
+ }
+
+ err = f2fs_submit_page_read_sync(inode, folio, index, blkaddr);
+out:
+ if (get_dn)
+ f2fs_put_dnode(&dn);
+ 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,
@@ -3938,6 +4179,7 @@ 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;
int err = 0;
trace_f2fs_write_begin(inode, pos, len);
@@ -3985,9 +4227,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;
@@ -4000,7 +4248,7 @@ static int f2fs_write_begin(const struct kiocb *iocb,
if (f2fs_is_atomic_file(inode))
err = prepare_atomic_write_begin(sbi, folio, pos, len,
&blkaddr, &need_balance);
- else
+ else if (!folio_test_large(folio))
err = prepare_write_begin(sbi, folio, pos, len,
&blkaddr, &need_balance);
if (err)
@@ -4021,6 +4269,14 @@ static int f2fs_write_begin(const struct kiocb *iocb,
f2fs_folio_wait_writeback(folio, DATA, false, true);
+ if (folio_test_large(folio)) {
+ err = prepare_large_folio_write_begin(inode,
+ folio, pos, len);
+ if (!err)
+ return 0;
+ goto put_folio;
+ }
+
if (len == folio_size(folio) || folio_test_uptodate(folio))
return 0;
@@ -4081,15 +4337,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
@@ -4108,6 +4369,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))
@@ -4170,8 +4434,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 326382ede1c3..8eccca6e5d27 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4392,6 +4392,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 b0bdc7a977b9..9071bd23e57b 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -5412,9 +5412,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
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-16 11:47 ` Chao Yu via Linux-f2fs-devel
2026-09-29 17:41 ` Daeho Jeong
2026-10-02 17:02 ` Daeho Jeong
2 siblings, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-16 11:47 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:18, Nanzhe Zhao wrote:
> 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 | 300 +++++++++++++++++++++++++++++++++++++++++++++++--
> fs/f2fs/f2fs.h | 1 +
> fs/f2fs/file.c | 17 ++-
> 3 files changed, 304 insertions(+), 14 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index f14044e8a6f4..a490df4f50b3 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -1233,6 +1233,35 @@ 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 = folio->private;
> +
> + /* Add bias so end_io does not call folio_end_read(). */
> + f2fs_update_read_folio_pending(folio, 1);
f2fs_update_read_folio_pending() was used here for the first time, do we need
to relocate definition in this patch?
> +
> + f2fs_submit_page_read(inode, NULL, folio, index, blkaddr,
> + REQ_OP_READ, false);
> +
> + /* 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_folio);
> @@ -2570,6 +2599,114 @@ 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 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);
> +}
> +
> +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 void f2fs_ffs_mark_subrange_dirty(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_set(ffs->state, nr_subpages + start, end - start);
> + 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 - 1, PAGE_SIZE);
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)
> @@ -3927,6 +4064,110 @@ static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
> return 0;
> }
>
> +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;
> +
> + len = min_t(unsigned int, len, folio_size(folio) - ori_off);
> +
> + /*
> + * When folio minimum order is non-zero, the fsverity
Seems there is a condition that folio minimum order is non-zero, do we
need to check this condition along w/ FI_PREALLOCATED_ALL?
> + * page_cache_write() path enters f2fs_write_begin() via
> + * aops->write_begin without going through f2fs_write_iter(),
> + * so preallocation from f2fs_write_iter() is skipped. In that
> + * case, if FI_PREALLOCATED_ALL is not set, we must preallocate
> + * the write blocks here.
> + */
> + if (!is_inode_flag_set(inode, FI_PREALLOCATED_ALL)) {
> + struct f2fs_map_blocks map = {};
> +
> + map.m_lblk = F2FS_BYTES_TO_BLK(sbi, pos);
> + map.m_len = F2FS_BLK_ALIGN(sbi, pos + len) - map.m_lblk;
> +
> + if (!IS_DEVICE_ALIASING(inode))
> + map.m_may_create = true;
> + map.m_seg_type = NO_CHECK_TYPE;
> +
> + err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_AIO);
> + if (err)
> + return err;
> + }
> +
> + 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;
> + bool get_dn = false;
> +
> + 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;
> + get_dn = true;
Can we call f2fs_put_dnode(&dn) here? since we don't need to cover dnode
lock during I/O?
Thanks,
> + blkaddr = dn.data_blkaddr;
> +
> + if (blkaddr == NEW_ADDR) {
> + size_t off = offset_in_folio(folio,
> + index << PAGE_SHIFT);
> +
> + folio_zero_segment(folio, off, off + PAGE_SIZE);
> + f2fs_ffs_mark_subrange_uptodate(folio, off,
> + PAGE_SIZE);
> + goto out;
> + }
> +
> + if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
> + DATA_GENERIC_ENHANCE_READ)) {
> + err = -EFSCORRUPTED;
> + goto out;
> + }
> + }
> +
> + err = f2fs_submit_page_read_sync(inode, folio, index, blkaddr);
> +out:
> + if (get_dn)
> + f2fs_put_dnode(&dn);
> + 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,
> @@ -3938,6 +4179,7 @@ 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;
> int err = 0;
>
> trace_f2fs_write_begin(inode, pos, len);
> @@ -3985,9 +4227,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;
> @@ -4000,7 +4248,7 @@ static int f2fs_write_begin(const struct kiocb *iocb,
> if (f2fs_is_atomic_file(inode))
> err = prepare_atomic_write_begin(sbi, folio, pos, len,
> &blkaddr, &need_balance);
> - else
> + else if (!folio_test_large(folio))
> err = prepare_write_begin(sbi, folio, pos, len,
> &blkaddr, &need_balance);
> if (err)
> @@ -4021,6 +4269,14 @@ static int f2fs_write_begin(const struct kiocb *iocb,
>
> f2fs_folio_wait_writeback(folio, DATA, false, true);
>
> + if (folio_test_large(folio)) {
> + err = prepare_large_folio_write_begin(inode,
> + folio, pos, len);
> + if (!err)
> + return 0;
> + goto put_folio;
> + }
> +
> if (len == folio_size(folio) || folio_test_uptodate(folio))
> return 0;
>
> @@ -4081,15 +4337,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
> @@ -4108,6 +4369,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))
> @@ -4170,8 +4434,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 326382ede1c3..8eccca6e5d27 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -4392,6 +4392,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 b0bdc7a977b9..9071bd23e57b 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -5412,9 +5412,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
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios Nanzhe Zhao via Linux-f2fs-devel
2026-09-16 11:47 ` Chao Yu via Linux-f2fs-devel
@ 2026-09-29 17:41 ` Daeho Jeong
2026-10-08 5:33 ` Nanzhe Zhao via Linux-f2fs-devel
2026-10-02 17:02 ` Daeho Jeong
2 siblings, 1 reply; 40+ messages in thread
From: Daeho Jeong @ 2026-09-29 17:41 UTC (permalink / raw)
To: Nanzhe Zhao
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Jaegeuk Kim, Pengfei Li, Ryan Roberts
On Mon, Sep 14, 2026 at 9:24 PM Nanzhe Zhao via Linux-f2fs-devel
<linux-f2fs-devel@lists.sourceforge.net> wrote:
>
> 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 | 300 +++++++++++++++++++++++++++++++++++++++++++++++--
> fs/f2fs/f2fs.h | 1 +
> fs/f2fs/file.c | 17 ++-
> 3 files changed, 304 insertions(+), 14 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index f14044e8a6f4..a490df4f50b3 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -1233,6 +1233,35 @@ 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 = folio->private;
> +
> + /* Add bias so end_io does not call folio_end_read(). */
> + f2fs_update_read_folio_pending(folio, 1);
> +
> + f2fs_submit_page_read(inode, NULL, folio, index, blkaddr,
> + REQ_OP_READ, false);
> +
> + /* 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_folio);
> @@ -2570,6 +2599,114 @@ 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 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);
> +}
> +
> +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 void f2fs_ffs_mark_subrange_dirty(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_set(ffs->state, nr_subpages + start, end - start);
> + 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 - 1, 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)
> @@ -3927,6 +4064,110 @@ static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
> return 0;
> }
>
> +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;
> +
> + len = min_t(unsigned int, len, folio_size(folio) - ori_off);
> +
> + /*
> + * When folio minimum order is non-zero, the fsverity
> + * page_cache_write() path enters f2fs_write_begin() via
> + * aops->write_begin without going through f2fs_write_iter(),
> + * so preallocation from f2fs_write_iter() is skipped. In that
> + * case, if FI_PREALLOCATED_ALL is not set, we must preallocate
> + * the write blocks here.
> + */
> + if (!is_inode_flag_set(inode, FI_PREALLOCATED_ALL)) {
> + struct f2fs_map_blocks map = {};
> +
> + map.m_lblk = F2FS_BYTES_TO_BLK(sbi, pos);
> + map.m_len = F2FS_BLK_ALIGN(sbi, pos + len) - map.m_lblk;
> +
> + if (!IS_DEVICE_ALIASING(inode))
> + map.m_may_create = true;
> + map.m_seg_type = NO_CHECK_TYPE;
> +
> + err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_AIO);
> + if (err)
> + return err;
> + }
Hi Nanzhe,
This runs with the folio locked, but f2fs_map_blocks() with m_may_create
calls f2fs_balance_fs(), right? If foreground GC then needs this
folio, it can deadlock.
The comment only mentions the fsverity path, but the condition is just
!FI_PREALLOCATED_ALL, so regular writes can get here too: Maybe, short writes
(fault_in fails), partial preallocation on -ENOSPC/-EDQUOT, and DIO
falling back to buffered I/O. On the fsverity path, FI_PREALLOCATED_ALL
is never set, so it always runs this with the folio locked.
How about only reserving blocks here, without balancing (e.g.
f2fs_reserve_block() and collecting node_changed)? f2fs_write_begin()
could then do the balance after unlocking and putting the folio, and
retry with "goto repeat".
Thanks,
> +
> + 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;
> + bool get_dn = false;
> +
> + 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;
> + get_dn = true;
> + blkaddr = dn.data_blkaddr;
> +
> + if (blkaddr == NEW_ADDR) {
> + size_t off = offset_in_folio(folio,
> + index << PAGE_SHIFT);
> +
> + folio_zero_segment(folio, off, off + PAGE_SIZE);
> + f2fs_ffs_mark_subrange_uptodate(folio, off,
> + PAGE_SIZE);
> + goto out;
> + }
> +
> + if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
> + DATA_GENERIC_ENHANCE_READ)) {
> + err = -EFSCORRUPTED;
> + goto out;
> + }
> + }
> +
> + err = f2fs_submit_page_read_sync(inode, folio, index, blkaddr);
> +out:
> + if (get_dn)
> + f2fs_put_dnode(&dn);
> + 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,
> @@ -3938,6 +4179,7 @@ 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;
> int err = 0;
>
> trace_f2fs_write_begin(inode, pos, len);
> @@ -3985,9 +4227,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;
> @@ -4000,7 +4248,7 @@ static int f2fs_write_begin(const struct kiocb *iocb,
> if (f2fs_is_atomic_file(inode))
> err = prepare_atomic_write_begin(sbi, folio, pos, len,
> &blkaddr, &need_balance);
> - else
> + else if (!folio_test_large(folio))
> err = prepare_write_begin(sbi, folio, pos, len,
> &blkaddr, &need_balance);
> if (err)
> @@ -4021,6 +4269,14 @@ static int f2fs_write_begin(const struct kiocb *iocb,
>
> f2fs_folio_wait_writeback(folio, DATA, false, true);
>
> + if (folio_test_large(folio)) {
> + err = prepare_large_folio_write_begin(inode,
> + folio, pos, len);
> + if (!err)
> + return 0;
> + goto put_folio;
> + }
> +
> if (len == folio_size(folio) || folio_test_uptodate(folio))
> return 0;
>
> @@ -4081,15 +4337,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
> @@ -4108,6 +4369,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))
> @@ -4170,8 +4434,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 326382ede1c3..8eccca6e5d27 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -4392,6 +4392,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 b0bdc7a977b9..9071bd23e57b 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -5412,9 +5412,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
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios
2026-09-29 17:41 ` Daeho Jeong
@ 2026-10-08 5:33 ` Nanzhe Zhao via Linux-f2fs-devel
0 siblings, 0 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-10-08 5:33 UTC (permalink / raw)
To: Daeho Jeong
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Pengfei Li, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Jaegeuk Kim, linux-f2fs-devel, Ryan Roberts
Hi Daeho,
Thanks for the change. I would like to integrate it into v3, folding it
into the "f2fs: support regular file buffered writes on large folios"
commit.
My patch adjusts the signature of 'prepare_atomic_write_begin()': for large
folio compatibility, the 'unsigned int len' parameter is replaced by 'pgoff_t index',
so that the helper can be called in a loop from 'prepare_large_folio_atomic_write_begin()'.
I found that len was a dead parameter in the original 'prepare_atomic_write_begin()',
so in v3 I will not pass blen to 'prepare_atomic_write_begin()'.
Thanks,
Nanzhe
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios Nanzhe Zhao via Linux-f2fs-devel
2026-09-16 11:47 ` Chao Yu via Linux-f2fs-devel
2026-09-29 17:41 ` Daeho Jeong
@ 2026-10-02 17:02 ` Daeho Jeong
2026-10-08 5:46 ` Nanzhe Zhao via Linux-f2fs-devel
2 siblings, 1 reply; 40+ messages in thread
From: Daeho Jeong @ 2026-10-02 17:02 UTC (permalink / raw)
To: Nanzhe Zhao
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Jaegeuk Kim, Pengfei Li, Ryan Roberts
On Mon, Sep 14, 2026 at 9:24 PM Nanzhe Zhao via Linux-f2fs-devel
<linux-f2fs-devel@lists.sourceforge.net> wrote:
>
> 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 | 300 +++++++++++++++++++++++++++++++++++++++++++++++--
> fs/f2fs/f2fs.h | 1 +
> fs/f2fs/file.c | 17 ++-
> 3 files changed, 304 insertions(+), 14 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index f14044e8a6f4..a490df4f50b3 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -1233,6 +1233,35 @@ 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 = folio->private;
> +
> + /* Add bias so end_io does not call folio_end_read(). */
> + f2fs_update_read_folio_pending(folio, 1);
> +
> + f2fs_submit_page_read(inode, NULL, folio, index, blkaddr,
> + REQ_OP_READ, false);
> +
> + /* 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_folio);
> @@ -2570,6 +2599,114 @@ 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 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);
> +}
> +
> +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 void f2fs_ffs_mark_subrange_dirty(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_set(ffs->state, nr_subpages + start, end - start);
> + 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 - 1, 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)
> @@ -3927,6 +4064,110 @@ static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
> return 0;
> }
>
> +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;
> +
> + len = min_t(unsigned int, len, folio_size(folio) - ori_off);
> +
> + /*
> + * When folio minimum order is non-zero, the fsverity
> + * page_cache_write() path enters f2fs_write_begin() via
> + * aops->write_begin without going through f2fs_write_iter(),
> + * so preallocation from f2fs_write_iter() is skipped. In that
> + * case, if FI_PREALLOCATED_ALL is not set, we must preallocate
> + * the write blocks here.
> + */
> + if (!is_inode_flag_set(inode, FI_PREALLOCATED_ALL)) {
> + struct f2fs_map_blocks map = {};
> +
> + map.m_lblk = F2FS_BYTES_TO_BLK(sbi, pos);
> + map.m_len = F2FS_BLK_ALIGN(sbi, pos + len) - map.m_lblk;
> +
> + if (!IS_DEVICE_ALIASING(inode))
> + map.m_may_create = true;
> + map.m_seg_type = NO_CHECK_TYPE;
> +
> + err = f2fs_map_blocks(inode, &map, F2FS_GET_BLOCK_PRE_AIO);
> + if (err)
> + return err;
> + }
> +
> + 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;
> + bool get_dn = false;
> +
> + 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;
> + get_dn = true;
> + blkaddr = dn.data_blkaddr;
> +
> + if (blkaddr == NEW_ADDR) {
> + size_t off = offset_in_folio(folio,
> + index << PAGE_SHIFT);
> +
> + folio_zero_segment(folio, off, off + PAGE_SIZE);
> + f2fs_ffs_mark_subrange_uptodate(folio, off,
> + PAGE_SIZE);
> + goto out;
> + }
> +
> + if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
> + DATA_GENERIC_ENHANCE_READ)) {
> + err = -EFSCORRUPTED;
> + goto out;
> + }
> + }
> +
> + err = f2fs_submit_page_read_sync(inode, folio, index, blkaddr);
> +out:
> + if (get_dn)
> + f2fs_put_dnode(&dn);
> + 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,
> @@ -3938,6 +4179,7 @@ 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;
> int err = 0;
>
> trace_f2fs_write_begin(inode, pos, len);
> @@ -3985,9 +4227,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;
> @@ -4000,7 +4248,7 @@ static int f2fs_write_begin(const struct kiocb *iocb,
> if (f2fs_is_atomic_file(inode))
> err = prepare_atomic_write_begin(sbi, folio, pos, len,
> &blkaddr, &need_balance);
> - else
> + else if (!folio_test_large(folio))
> err = prepare_write_begin(sbi, folio, pos, len,
> &blkaddr, &need_balance);
> if (err)
> @@ -4021,6 +4269,14 @@ static int f2fs_write_begin(const struct kiocb *iocb,
>
> f2fs_folio_wait_writeback(folio, DATA, false, true);
>
> + if (folio_test_large(folio)) {
> + err = prepare_large_folio_write_begin(inode,
> + folio, pos, len);
> + if (!err)
> + return 0;
> + goto put_folio;
> + }
> +
> if (len == folio_size(folio) || folio_test_uptodate(folio))
> return 0;
Hi Nanzhe,
generic_perform_write() only keeps [pos, pos + len) from crossing a
mapping_max_folio_size() boundary; it does not limit len to the folio
that ->write_begin() returns. Without large folios this kept the range
within one page, so the order-0 path could use len as is. With large
folios enabled for regular files, len can extend beyond an order-0
folio, but the order-0 path still uses the raw len:
- "len == folio_size(folio)" is taken to mean that the whole folio
will be overwritten, so the folio is not read.
- prepare_write_begin() skips the block lookup when
"len == PAGE_SIZE" and FI_PREALLOCATED_ALL is set.
prepare_large_folio_write_begin() already clamps len to the folio. The
order-0 path needs the same. I use a separate variable so that the
large folio path still gets the original len when the folio is looked
up again after "goto repeat":
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
pgoff_t index = pos >> PAGE_SHIFT;
bool need_balance = false;
block_t blkaddr = NULL_ADDR;
+ unsigned int blen;
int err = 0;
@@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
*foliop = folio;
+ /*
+ * generic_perform_write() does not limit len to this folio, so it
+ * may extend beyond an order-0 folio.
+ */
+ blen = min_t(unsigned int, len,
+ folio_size(folio) - offset_in_folio(folio, pos));
+
if (f2fs_is_atomic_file(inode) && !folio_test_large(folio))
- err = prepare_atomic_write_begin(sbi, folio, pos, len,
+ err = prepare_atomic_write_begin(sbi, folio, pos, blen,
&blkaddr, &need_balance);
else if (!folio_test_large(folio))
- err = prepare_write_begin(sbi, folio, pos, len,
+ err = prepare_write_begin(sbi, folio, pos, blen,
&blkaddr, &need_balance);
if (err)
goto put_folio;
@@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
goto put_folio;
}
- if (len == folio_size(folio) || folio_test_uptodate(folio))
+ if (blen == folio_size(folio) || folio_test_uptodate(folio))
return 0;
Thanks,
Daeho
>
> @@ -4081,15 +4337,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
> @@ -4108,6 +4369,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))
> @@ -4170,8 +4434,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 326382ede1c3..8eccca6e5d27 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -4392,6 +4392,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 b0bdc7a977b9..9071bd23e57b 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -5412,9 +5412,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
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios
2026-10-02 17:02 ` Daeho Jeong
@ 2026-10-08 5:46 ` Nanzhe Zhao via Linux-f2fs-devel
0 siblings, 0 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-10-08 5:46 UTC (permalink / raw)
To: Daeho Jeong
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Pengfei Li, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Jaegeuk Kim, linux-f2fs-devel, Ryan Roberts
Hi Daeho,
This reply should have been posted here.
> Hi Daeho,
>
> Thanks for the change. I would like to integrate it into v3, folding it
> into the "f2fs: support regular file buffered writes on large folios"
> commit.
>
> My patch adjusts the signature of 'prepare_atomic_write_begin()': for large
> folio compatibility, the 'unsigned int len' parameter is replaced by 'pgoff_t index',
> so that the helper can be called in a loop from 'prepare_large_folio_atomic_write_begin()'.
> I found that len was a dead parameter in the original 'prepare_atomic_write_begin()',
> so in v3 I will not pass blen to 'prepare_atomic_write_begin()'.
>
> Thanks,
> Nanzhe
Sorry for the wrong threading.
Thanks,
Nanzhe
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* [f2fs-dev] [PATCH v2 04/14] f2fs: support atomic file large folios buffered write
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (2 preceding siblings ...)
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 03/14] f2fs: support regular file buffered writes on large folios Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:18 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-16 12:07 ` Chao Yu via Linux-f2fs-devel
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 05/14] f2fs: support large folio writeback Nanzhe Zhao via Linux-f2fs-devel
` (10 subsequent siblings)
14 siblings, 1 reply; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:18 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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 | 88 ++++++++++++++++++++++++++++++++++++++++++++++----
1 file changed, 81 insertions(+), 7 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index a490df4f50b3..eb5fb8e52851 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -4016,18 +4016,16 @@ 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,
+ struct inode *inode, pgoff_t index,
block_t *blk_addr, bool *node_changed)
{
- 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;
/* If pos is beyond the end of file, reserve a new block in COW inode */
- if ((pos & PAGE_MASK) >= i_size_read(inode))
+ if ((index << PAGE_SHIFT) >= i_size_read(inode))
goto reserve_block;
/* Look for the block in COW inode first */
@@ -4168,6 +4166,74 @@ 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)
+{
+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ size_t ori_off = offset_in_folio(folio, pos);
+ pgoff_t start, end, index;
+ unsigned int orig_order;
+ 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);
+ 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:
+ /*
+ * Expand the 4K-page balance decision per subpage: check
+ * right after each preallocated block.
+ */
+ if (node_changed && !IS_NOQUOTA(inode) &&
+ has_not_enough_free_secs(sbi, 0, 0)) {
+ orig_order = folio_order(folio);
+ folio_unlock(folio);
+ f2fs_balance_fs(sbi, true);
+ folio_lock(folio);
+ if (unlikely(folio->mapping != mapping ||
+ folio_order(folio) != orig_order))
+ 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,
@@ -4245,8 +4311,8 @@ static int f2fs_write_begin(const struct kiocb *iocb,
*foliop = folio;
- if (f2fs_is_atomic_file(inode))
- err = prepare_atomic_write_begin(sbi, folio, pos, len,
+ if (f2fs_is_atomic_file(inode) && !folio_test_large(folio))
+ err = prepare_atomic_write_begin(sbi, inode, folio->index,
&blkaddr, &need_balance);
else if (!folio_test_large(folio))
err = prepare_write_begin(sbi, folio, pos, len,
@@ -4270,10 +4336,18 @@ static int f2fs_write_begin(const struct kiocb *iocb,
f2fs_folio_wait_writeback(folio, DATA, false, true);
if (folio_test_large(folio)) {
- err = prepare_large_folio_write_begin(inode,
+ if (f2fs_is_atomic_file(inode))
+ err = prepare_large_folio_atomic_write_begin(inode,
+ mapping, folio, pos, len);
+ else
+ err = prepare_large_folio_write_begin(inode,
folio, pos, len);
if (!err)
return 0;
+ if (err == -EAGAIN) {
+ f2fs_folio_put(folio, true);
+ goto repeat;
+ }
goto put_folio;
}
--
2.43.0
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 04/14] f2fs: support atomic file large folios buffered write
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 04/14] f2fs: support atomic file large folios buffered write Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-16 12:07 ` Chao Yu via Linux-f2fs-devel
2026-09-23 3:21 ` Nanzhe Zhao via Linux-f2fs-devel
0 siblings, 1 reply; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-16 12:07 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:18, Nanzhe Zhao wrote:
> 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 | 88 ++++++++++++++++++++++++++++++++++++++++++++++----
> 1 file changed, 81 insertions(+), 7 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index a490df4f50b3..eb5fb8e52851 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -4016,18 +4016,16 @@ 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,
> + struct inode *inode, pgoff_t index,
> block_t *blk_addr, bool *node_changed)
> {
> - 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;
>
> /* If pos is beyond the end of file, reserve a new block in COW inode */
^^^
Need to update comments here? there is no @pos in the function.
> - if ((pos & PAGE_MASK) >= i_size_read(inode))
> + if ((index << PAGE_SHIFT) >= i_size_read(inode))
> goto reserve_block;
>
> /* Look for the block in COW inode first */
> @@ -4168,6 +4166,74 @@ 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)
> +{
> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> + size_t ori_off = offset_in_folio(folio, pos);
> + pgoff_t start, end, index;
> + unsigned int orig_order;
> + 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);
> + 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:
> + /*
> + * Expand the 4K-page balance decision per subpage: check
> + * right after each preallocated block.
> + */
> + if (node_changed && !IS_NOQUOTA(inode) &&
!IS_NOQUOTA(inode) is not needed.
> + has_not_enough_free_secs(sbi, 0, 0)) {
> + orig_order = folio_order(folio);
> + folio_unlock(folio);
> + f2fs_balance_fs(sbi, true);
> + folio_lock(folio);
> + if (unlikely(folio->mapping != mapping ||
> + folio_order(folio) != orig_order))
> + return -EAGAIN;
> + }
Why can't we merge this logic w/ others? it seems duplicated.
Thanks,
> + }
> +
> + return 0;
> +}
> +
> static int f2fs_write_begin(const struct kiocb *iocb,
> struct address_space *mapping,
> loff_t pos, unsigned len, struct folio **foliop,
> @@ -4245,8 +4311,8 @@ static int f2fs_write_begin(const struct kiocb *iocb,
>
> *foliop = folio;
>
> - if (f2fs_is_atomic_file(inode))
> - err = prepare_atomic_write_begin(sbi, folio, pos, len,
> + if (f2fs_is_atomic_file(inode) && !folio_test_large(folio))
> + err = prepare_atomic_write_begin(sbi, inode, folio->index,
> &blkaddr, &need_balance);
> else if (!folio_test_large(folio))
> err = prepare_write_begin(sbi, folio, pos, len,
> @@ -4270,10 +4336,18 @@ static int f2fs_write_begin(const struct kiocb *iocb,
> f2fs_folio_wait_writeback(folio, DATA, false, true);
>
> if (folio_test_large(folio)) {
> - err = prepare_large_folio_write_begin(inode,
> + if (f2fs_is_atomic_file(inode))
> + err = prepare_large_folio_atomic_write_begin(inode,
> + mapping, folio, pos, len);
> + else
> + err = prepare_large_folio_write_begin(inode,
> folio, pos, len);
> if (!err)
> return 0;
> + if (err == -EAGAIN) {
> + f2fs_folio_put(folio, true);
> + goto repeat;
> + }
> goto put_folio;
> }
>
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 04/14] f2fs: support atomic file large folios buffered write
2026-09-16 12:07 ` Chao Yu via Linux-f2fs-devel
@ 2026-09-23 3:21 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-23 7:22 ` Chao Yu via Linux-f2fs-devel
0 siblings, 1 reply; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-23 3:21 UTC (permalink / raw)
To: Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Jaegeuk Kim, Pengfei Li, Ryan Roberts
Hi Chao,
Thanks for the review.
I think I can extract the duplicate logic in a helper and the full change
may be like this?
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -4721,6 +4721,31 @@
return 0;
}
+static bool f2fs_try_balance_folio(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;
+
+ if (!node_changed || IS_NOQUOTA(inode) ||
+ !has_not_enough_free_secs(sbi, 0, 0))
+ return false;
+
+ orig_order = folio_order(folio);
+ folio_unlock(folio);
+ f2fs_balance_fs(sbi, true);
+ folio_lock(folio);
+
+ if (folio->mapping != mapping)
+ return true;
+
+ if (folio_order(folio) != orig_order)
+ return true;
+
+ return false;
+}
+
static int prepare_large_folio_atomic_write_begin(struct inode *inode,
struct address_space *mapping, struct folio *folio, loff_t pos,
unsigned int len)
@@ -4728,7 +4753,6 @@
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
size_t ori_off = offset_in_folio(folio, pos);
pgoff_t start, end, index;
- unsigned int orig_order;
int err = 0;
len = min_t(unsigned int, len, folio_size(folio) - ori_off);
@@ -4774,16 +4798,8 @@
* Expand the 4K-page balance decision per subpage: check
* right after each preallocated block.
*/
- if (node_changed && !IS_NOQUOTA(inode) &&
- has_not_enough_free_secs(sbi, 0, 0)) {
- orig_order = folio_order(folio);
- folio_unlock(folio);
- f2fs_balance_fs(sbi, true);
- folio_lock(folio);
- if (unlikely(folio->mapping != mapping ||
- folio_order(folio) != orig_order))
- return -EAGAIN;
- }
+ if (f2fs_try_balance_folio(folio, mapping, node_changed))
+ return -EAGAIN;
}
return 0;
@@ -4876,17 +4892,10 @@
if (err)
goto put_folio;
- if (need_balance && !IS_NOQUOTA(inode) &&
- has_not_enough_free_secs(sbi, 0, 0)) {
+ if (f2fs_try_balance_folio(folio, mapping, need_balance)) {
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);
- goto repeat;
- }
+ folio_put(folio);
+ goto repeat;
}
f2fs_folio_wait_writeback(folio, DATA, false, true);
--
Nanzhe Zhao
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 04/14] f2fs: support atomic file large folios buffered write
2026-09-23 3:21 ` Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-23 7:22 ` Chao Yu via Linux-f2fs-devel
0 siblings, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-23 7:22 UTC (permalink / raw)
To: Nanzhe Zhao
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Jaegeuk Kim, Pengfei Li, Ryan Roberts
On 9/23/26 11:21, Nanzhe Zhao wrote:
> I think I can extract the duplicate logic in a helper and the full change
> may be like this?
Alright, is there a way to relocate below code block before f2fs_balance_fs()?
if (folio_test_large(folio)) {
if (f2fs_is_atomic_file(inode))
err = prepare_large_folio_atomic_write_begin(inode,
mapping, folio, pos, len);
else
err = prepare_large_folio_write_begin(inode,
folio, pos, len);
if (!err)
return 0;
if (err == -EAGAIN) {
f2fs_folio_put(folio, true);
goto repeat;
}
goto put_folio;
}
Thanks,
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* [f2fs-dev] [PATCH v2 05/14] f2fs: support large folio writeback
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (3 preceding siblings ...)
2026-09-15 4:18 ` [f2fs-dev] [PATCH v2 04/14] f2fs: support atomic file large folios buffered write Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:19 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-17 3:48 ` Chao Yu via Linux-f2fs-devel
` (2 more replies)
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 06/14] f2fs: prepare mmap write faults for large folios Nanzhe Zhao via Linux-f2fs-devel
` (9 subsequent siblings)
14 siblings, 3 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:19 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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 | 412 ++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 407 insertions(+), 5 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index eb5fb8e52851..1f9c99689f38 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -355,7 +355,9 @@ 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;
enum count_type type;
+ bool finished = true;
#ifdef CONFIG_F2FS_FS_COMPRESSION
if (f2fs_is_compressed_page(folio)) {
@@ -379,10 +381,19 @@ static void f2fs_write_end_bio(struct bio *bio)
folio->index, NODE_TYPE_REGULAR, true);
f2fs_bug_on(sbi, folio->index != nid_of_node(sbi, folio));
}
+ if (f2fs_folio_has_ffs(folio)) {
+ struct f2fs_folio_state *ffs =
+ (struct f2fs_folio_state *)folio->private;
+
+ finished = atomic_sub_and_test(nr_pages,
+ &ffs->write_pages_pending);
+ }
+
if (f2fs_in_warm_node_list(sbi, folio))
f2fs_del_fsync_node_entry(sbi, folio);
- dec_page_count(sbi, type);
+ while (nr_pages--)
+ dec_page_count(sbi, type);
/*
* we should access sbi before folio_end_writeback() to
@@ -392,8 +403,10 @@ 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);
+ if (finished) {
+ folio_clear_f2fs_gcing(folio);
+ folio_end_writeback(folio);
+ }
}
bio_put(bio);
@@ -2654,7 +2667,7 @@ static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
folio_mark_uptodate(folio);
}
-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;
@@ -2677,6 +2690,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)
@@ -3256,6 +3362,133 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
return err;
}
+static int f2fs_write_single_data_folio(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);
+ 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);
+ if (submitted)
+ (*submitted)++;
+ submitted_blk = true;
+ set_inode_flag(inode, FI_APPEND_WRITE);
+ trace_f2fs_do_write_data_page(folio, OPU);
+ goto block_done;
+block_done:
+ if (dn_held)
+ f2fs_put_dnode(&dn);
+ if (!submitted_blk && ffs)
+ atomic_dec(&ffs->write_pages_pending);
+ if (!err) {
+ *pos = (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,
@@ -3705,6 +3938,172 @@ 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 next = 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;
+ next = true;
+ retry = false;
+
+ if (atomic_read(&sbi->wb_sync_req[DATA]) &&
+ wbc->sync_mode == WB_SYNC_NONE) {
+ folio_redirty_for_writepage(wbc, folio);
+ next = false;
+ goto retry_out;
+ }
+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, DATA, 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);
+
+ 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_single_data_folio(folio, &submitted,
+ wbc, io_type, &pos, r_len);
+ folio_submitted += submitted;
+ if (err)
+ goto out;
+
+ nwritten += submitted;
+ }
+
+ if (!err && 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), 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)))
+ folio_redirty_for_writepage(wbc, folio);
+ else
+ inode_dec_dirty_pages(inode);
+
+ if (bias_added) {
+ if (atomic_dec_and_test(&ffs->write_pages_pending))
+ folio_end_writeback(folio);
+ } else if (!folio_submitted && folio_test_writeback(folio)) {
+ folio_end_writeback(folio);
+ }
+
+retry_out:
+ if (folio_test_locked(folio))
+ folio_unlock(folio);
+
+ if (op_locked) {
+ f2fs_unlock_op(sbi, &lc);
+ op_locked = false;
+ }
+
+ if (err || !next)
+ break;
+ }
+
+ if (nwritten)
+ f2fs_submit_merged_write_cond(F2FS_M_SB(mapping), mapping->host,
+ NULL, 0, DATA);
+
+ return err;
+}
+
static inline bool __should_serialize_io(struct inode *inode,
struct writeback_control *wbc)
{
@@ -3799,7 +4198,10 @@ 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))
+ 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);
--
2.43.0
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 05/14] f2fs: support large folio writeback
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 05/14] f2fs: support large folio writeback Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-17 3:48 ` Chao Yu via Linux-f2fs-devel
2026-09-21 2:52 ` Chao Yu via Linux-f2fs-devel
2026-10-02 20:51 ` Daeho Jeong
2 siblings, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-17 3:48 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:19, Nanzhe Zhao wrote:
> 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 | 412 ++++++++++++++++++++++++++++++++++++++++++++++++-
> 1 file changed, 407 insertions(+), 5 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index eb5fb8e52851..1f9c99689f38 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -355,7 +355,9 @@ 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;
> enum count_type type;
> + bool finished = true;
>
> #ifdef CONFIG_F2FS_FS_COMPRESSION
> if (f2fs_is_compressed_page(folio)) {
> @@ -379,10 +381,19 @@ static void f2fs_write_end_bio(struct bio *bio)
> folio->index, NODE_TYPE_REGULAR, true);
> f2fs_bug_on(sbi, folio->index != nid_of_node(sbi, folio));
> }
> + if (f2fs_folio_has_ffs(folio)) {
> + struct f2fs_folio_state *ffs =
> + (struct f2fs_folio_state *)folio->private;
> +
> + finished = atomic_sub_and_test(nr_pages,
> + &ffs->write_pages_pending);
> + }
> +
> if (f2fs_in_warm_node_list(sbi, folio))
> f2fs_del_fsync_node_entry(sbi, folio);
>
> - dec_page_count(sbi, type);
> + while (nr_pages--)
> + dec_page_count(sbi, type);
>
> /*
> * we should access sbi before folio_end_writeback() to
> @@ -392,8 +403,10 @@ 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);
> + if (finished) {
> + folio_clear_f2fs_gcing(folio);
> + folio_end_writeback(folio);
> + }
> }
>
> bio_put(bio);
> @@ -2654,7 +2667,7 @@ static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
> folio_mark_uptodate(folio);
> }
>
> -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;
> @@ -2677,6 +2690,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)
> @@ -3256,6 +3362,133 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> return err;
> }
>
> +static int f2fs_write_single_data_folio(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);
> + if (submitted)
> + (*submitted)++;
> + submitted_blk = true;
> + set_inode_flag(inode, FI_APPEND_WRITE);
> + trace_f2fs_do_write_data_page(folio, OPU);
> + goto block_done;
Redundant "goto block_done;"?
> +block_done:
> + if (dn_held)
> + f2fs_put_dnode(&dn);
> + if (!submitted_blk && ffs)
> + atomic_dec(&ffs->write_pages_pending);
> + if (!err) {
> + *pos = (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,
> @@ -3705,6 +3938,172 @@ 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 next = 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;
> + next = true;
> + retry = false;
> +
> + if (atomic_read(&sbi->wb_sync_req[DATA]) &&
> + wbc->sync_mode == WB_SYNC_NONE) {
> + folio_redirty_for_writepage(wbc, folio);
> + next = false;
> + goto retry_out;
> + }
> +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, DATA, 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);
> +
> + 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_single_data_folio(folio, &submitted,
> + wbc, io_type, &pos, r_len);
> + folio_submitted += submitted;
> + if (err)
> + goto out;
> +
> + nwritten += submitted;
> + }
> +
> + if (!err && 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), 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)))
> + folio_redirty_for_writepage(wbc, folio);
> + else
> + inode_dec_dirty_pages(inode);
> +
> + if (bias_added) {
> + if (atomic_dec_and_test(&ffs->write_pages_pending))
> + folio_end_writeback(folio);
> + } else if (!folio_submitted && folio_test_writeback(folio)) {
> + folio_end_writeback(folio);
> + }
> +
> +retry_out:
> + if (folio_test_locked(folio))
Any case the folio is unlocked?
> + folio_unlock(folio);
> +
> + if (op_locked) {
> + f2fs_unlock_op(sbi, &lc);
> + op_locked = false;
> + }
> +
> + if (err || !next)
> + break;
We can not break writeback_iter() loop directly? it may cause reference leak on folio?
IIUC, the right way is pass err to writeback_iter() to break the loop?
Thanks,
> + }
> +
> + if (nwritten)
> + f2fs_submit_merged_write_cond(F2FS_M_SB(mapping), mapping->host,
> + NULL, 0, DATA);
> +
> + return err;
> +}
> +
> static inline bool __should_serialize_io(struct inode *inode,
> struct writeback_control *wbc)
> {
> @@ -3799,7 +4198,10 @@ 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))
> + 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);
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 05/14] f2fs: support large folio writeback
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 05/14] f2fs: support large folio writeback Nanzhe Zhao via Linux-f2fs-devel
2026-09-17 3:48 ` Chao Yu via Linux-f2fs-devel
@ 2026-09-21 2:52 ` Chao Yu via Linux-f2fs-devel
2026-10-02 20:51 ` Daeho Jeong
2 siblings, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-21 2:52 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:19, Nanzhe Zhao wrote:
> @@ -3799,7 +4198,10 @@ 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))
if (mapping_large_folio_support(inode->i_mapping) && !f2fs_has_inline_data(inode))
As we need to writeback inline data into inode via f2fs_write_cache_pages().
Thanks,
> + 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);
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [f2fs-dev] [PATCH v2 05/14] f2fs: support large folio writeback
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 05/14] f2fs: support large folio writeback Nanzhe Zhao via Linux-f2fs-devel
2026-09-17 3:48 ` Chao Yu via Linux-f2fs-devel
2026-09-21 2:52 ` Chao Yu via Linux-f2fs-devel
@ 2026-10-02 20:51 ` Daeho Jeong
2 siblings, 0 replies; 40+ messages in thread
From: Daeho Jeong @ 2026-10-02 20:51 UTC (permalink / raw)
To: Nanzhe Zhao
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Jaegeuk Kim, Pengfei Li, Ryan Roberts
On Mon, Sep 14, 2026 at 9:21 PM Nanzhe Zhao via Linux-f2fs-devel
<linux-f2fs-devel@lists.sourceforge.net> wrote:
>
> 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 | 412 ++++++++++++++++++++++++++++++++++++++++++++++++-
> 1 file changed, 407 insertions(+), 5 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index eb5fb8e52851..1f9c99689f38 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -355,7 +355,9 @@ 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;
> enum count_type type;
> + bool finished = true;
>
> #ifdef CONFIG_F2FS_FS_COMPRESSION
> if (f2fs_is_compressed_page(folio)) {
> @@ -379,10 +381,19 @@ static void f2fs_write_end_bio(struct bio *bio)
> folio->index, NODE_TYPE_REGULAR, true);
> f2fs_bug_on(sbi, folio->index != nid_of_node(sbi, folio));
> }
> + if (f2fs_folio_has_ffs(folio)) {
> + struct f2fs_folio_state *ffs =
> + (struct f2fs_folio_state *)folio->private;
> +
> + finished = atomic_sub_and_test(nr_pages,
> + &ffs->write_pages_pending);
> + }
> +
> if (f2fs_in_warm_node_list(sbi, folio))
> f2fs_del_fsync_node_entry(sbi, folio);
>
> - dec_page_count(sbi, type);
> + while (nr_pages--)
> + dec_page_count(sbi, type);
>
> /*
> * we should access sbi before folio_end_writeback() to
> @@ -392,8 +403,10 @@ 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);
> + if (finished) {
> + folio_clear_f2fs_gcing(folio);
> + folio_end_writeback(folio);
> + }
> }
>
> bio_put(bio);
> @@ -2654,7 +2667,7 @@ static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
> folio_mark_uptodate(folio);
> }
>
> -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;
> @@ -2677,6 +2690,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)
> @@ -3256,6 +3362,133 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
> return err;
> }
>
> +static int f2fs_write_single_data_folio(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);
Hi Nanzhe,
The atomic flag is per folio, but COW blocks are reserved per block in
write_begin. A block dirtied without write_begin, e.g. by
truncate_partial_data_page(), has no COW block, but it is still looked
up in the COW inode here:
- NULL_ADDR: the truncated-block check added in 10/14 drops the block,
so its data never reaches the disk.
- -ENOENT (no COW dnode): the folio is redirtied and every writeback
fails, so F2FS_IOC_COMMIT_ATOMIC_WRITE never succeeds.
For example, on a 4KB page kernel, with blocks 0-3 allocated and cached
in one 16KB folio:
ioctl(fd, F2FS_IOC_START_ATOMIC_WRITE);
pwrite(fd, buf, 4096, 0); /* COW block for block 0 only */
ftruncate(fd, 4196); /* dirties block 1 only */
ioctl(fd, F2FS_IOC_COMMIT_ATOMIC_WRITE);
The zeroed tail of block 1 is lost, so extending the file later shows
the old data in [4196, 8192).
A block without a COW block was not written atomically, so it can go to
the original inode, like an order-0 folio that did not go through
write_begin:
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ static int f2fs_write_single_data_folio(struct folio *folio, int *submitted,
}
err = f2fs_get_dnode_of_data(&dn, data_idx, LOOKUP_NODE);
+
+ /* A block without a COW block was not written atomically */
+ 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)
goto block_done;
dn_held = true;
Also, -ENOENT from the original inode still fails the whole folio here,
while f2fs_write_single_data_page() ignores it. Should this path do the
same?
Thanks,
Daeho
> + 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);
> + 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);
> + if (submitted)
> + (*submitted)++;
> + submitted_blk = true;
> + set_inode_flag(inode, FI_APPEND_WRITE);
> + trace_f2fs_do_write_data_page(folio, OPU);
> + goto block_done;
> +block_done:
> + if (dn_held)
> + f2fs_put_dnode(&dn);
> + if (!submitted_blk && ffs)
> + atomic_dec(&ffs->write_pages_pending);
> + if (!err) {
> + *pos = (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,
> @@ -3705,6 +3938,172 @@ 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 next = 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;
> + next = true;
> + retry = false;
> +
> + if (atomic_read(&sbi->wb_sync_req[DATA]) &&
> + wbc->sync_mode == WB_SYNC_NONE) {
> + folio_redirty_for_writepage(wbc, folio);
> + next = false;
> + goto retry_out;
> + }
> +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, DATA, 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);
> +
> + 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_single_data_folio(folio, &submitted,
> + wbc, io_type, &pos, r_len);
> + folio_submitted += submitted;
> + if (err)
> + goto out;
> +
> + nwritten += submitted;
> + }
> +
> + if (!err && 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), 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)))
> + folio_redirty_for_writepage(wbc, folio);
> + else
> + inode_dec_dirty_pages(inode);
> +
> + if (bias_added) {
> + if (atomic_dec_and_test(&ffs->write_pages_pending))
> + folio_end_writeback(folio);
> + } else if (!folio_submitted && folio_test_writeback(folio)) {
> + folio_end_writeback(folio);
> + }
> +
> +retry_out:
> + if (folio_test_locked(folio))
> + folio_unlock(folio);
> +
> + if (op_locked) {
> + f2fs_unlock_op(sbi, &lc);
> + op_locked = false;
> + }
> +
> + if (err || !next)
> + break;
> + }
> +
> + if (nwritten)
> + f2fs_submit_merged_write_cond(F2FS_M_SB(mapping), mapping->host,
> + NULL, 0, DATA);
> +
> + return err;
> +}
> +
> static inline bool __should_serialize_io(struct inode *inode,
> struct writeback_control *wbc)
> {
> @@ -3799,7 +4198,10 @@ 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))
> + 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);
> --
> 2.43.0
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* [f2fs-dev] [PATCH v2 06/14] f2fs: prepare mmap write faults for large folios
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (4 preceding siblings ...)
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 05/14] f2fs: support large folio writeback Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:19 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-17 6:32 ` Chao Yu via Linux-f2fs-devel
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 07/14] f2fs: make GC migration large-folio aware Nanzhe Zhao via Linux-f2fs-devel
` (8 subsequent siblings)
14 siblings, 1 reply; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:19 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
Now write protect `mmap` also need to support large folio,
Change `f2fs_vm_page_mkwrite` to acheive that.
Note it currently marks the whole large folio dirty
to avoid data loss which causes write amplification.
Further optimization is welcome.
PG_mappedtodisk is useless in f2fs, so drop the
folio_test_mappedtodisk() check and its goto out_sem
shortcut in f2fs_vm_page_mkwrite(). We extend the
folio_zero_segment() in mkwrite 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 added to cover that
shortcut is no longer needed.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/f2fs.h | 4 ++
fs/f2fs/file.c | 107 ++++++++++++++++++++++++++++++-------------------
2 files changed, 70 insertions(+), 41 deletions(-)
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 8eccca6e5d27..f48e2627d90a 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4393,6 +4393,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 9071bd23e57b..738a751c3903 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -118,13 +118,47 @@ 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, DATA, 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;
int err = 0;
vm_fault_t ret;
@@ -161,7 +195,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;
@@ -179,72 +213,63 @@ 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);
folio_lock(folio);
+ 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 ? valid_end - folio_start : 0;
+
if (unlikely(folio->mapping != inode->i_mapping ||
- folio_pos(folio) > i_size_read(inode) ||
- !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;
- }
+ pgoff_t i, nr = DIV_ROUND_UP(dirty_len, PAGE_SIZE);
- if (err) {
- folio_unlock(folio);
- goto out_sem;
+ 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;
+ }
}
- f2fs_folio_wait_writeback(folio, DATA, false, true);
-
- /* wait for GCed page writeback via META_MAPPING */
- f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
-
- /*
- * check to see if the page is mapped already (no holes)
- */
- if (folio_test_mappedtodisk(folio))
- goto out_sem;
-
/* page is wholly or partially inside EOF */
- if (((loff_t)(folio->index + 1) << PAGE_SHIFT) >
- i_size_read(inode)) {
- loff_t offset;
+ if (folio_start + folio_size(folio) > isize) {
+ size_t offset = offset_in_folio(folio, isize);
- offset = i_size_read(inode) & ~PAGE_MASK;
folio_zero_segment(folio, offset, folio_size(folio));
}
+
+ if (folio_test_large(folio)) {
+ if (!f2fs_ffs_find_or_alloc(folio)) {
+ folio_unlock(folio);
+ err = -ENOMEM;
+ goto out_sem;
+ }
+ 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
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 06/14] f2fs: prepare mmap write faults for large folios
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 06/14] f2fs: prepare mmap write faults for large folios Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-17 6:32 ` Chao Yu via Linux-f2fs-devel
0 siblings, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-17 6:32 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:19, Nanzhe Zhao wrote:
> Now write protect `mmap` also need to support large folio,
> Change `f2fs_vm_page_mkwrite` to acheive that.
>
> Note it currently marks the whole large folio dirty
> to avoid data loss which causes write amplification.
> Further optimization is welcome.
>
> PG_mappedtodisk is useless in f2fs, so drop the
> folio_test_mappedtodisk() check and its goto out_sem
> shortcut in f2fs_vm_page_mkwrite(). We extend the
> folio_zero_segment() in mkwrite 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 added to cover that
> shortcut is no longer needed.
>
> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
> ---
> fs/f2fs/f2fs.h | 4 ++
> fs/f2fs/file.c | 107 ++++++++++++++++++++++++++++++-------------------
> 2 files changed, 70 insertions(+), 41 deletions(-)
>
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index 8eccca6e5d27..f48e2627d90a 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -4393,6 +4393,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 9071bd23e57b..738a751c3903 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -118,13 +118,47 @@ 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, DATA, 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;
>
> @@ -161,7 +195,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;
> @@ -179,72 +213,63 @@ 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);
>
> folio_lock(folio);
> + 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 ? valid_end - folio_start : 0;
valid_end <= folio_start, is this a possible case? if the folio is post EOF,
can it be dirtied via mmap?
> +
> if (unlikely(folio->mapping != inode->i_mapping ||
> - folio_pos(folio) > i_size_read(inode) ||
> - !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;
> - }
> + pgoff_t i, nr = DIV_ROUND_UP(dirty_len, PAGE_SIZE);
>
> - if (err) {
> - folio_unlock(folio);
> - goto out_sem;
> + 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;
> + }
> }
>
> - f2fs_folio_wait_writeback(folio, DATA, false, true);
> -
> - /* wait for GCed page writeback via META_MAPPING */
> - f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
> -
> - /*
> - * check to see if the page is mapped already (no holes)
> - */
> - if (folio_test_mappedtodisk(folio))
> - goto out_sem;
I think we'd better to drop this logic in a separated patch, it doesn't
belong to current patch?
Thanks,
> -
> /* page is wholly or partially inside EOF */
> - if (((loff_t)(folio->index + 1) << PAGE_SHIFT) >
> - i_size_read(inode)) {
> - loff_t offset;
> + if (folio_start + folio_size(folio) > isize) {
> + size_t offset = offset_in_folio(folio, isize);
>
> - offset = i_size_read(inode) & ~PAGE_MASK;
> folio_zero_segment(folio, offset, folio_size(folio));
> }
> +
> + if (folio_test_large(folio)) {
> + if (!f2fs_ffs_find_or_alloc(folio)) {
> + folio_unlock(folio);
> + err = -ENOMEM;
> + goto out_sem;
> + }
> + 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;
> }
>
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* [f2fs-dev] [PATCH v2 07/14] f2fs: make GC migration large-folio aware
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (5 preceding siblings ...)
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 06/14] f2fs: prepare mmap write faults for large folios Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:19 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 08/14] f2fs: optimize small block size large folio read Nanzhe Zhao via Linux-f2fs-devel
` (7 subsequent siblings)
14 siblings, 0 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:19 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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(), f2fs_find_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.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 75 ++++++++++++++++++++++++++++++-----------------
fs/f2fs/f2fs.h | 1 +
fs/f2fs/gc.c | 30 +++++++++++++++++--
fs/f2fs/segment.c | 2 +-
4 files changed, 78 insertions(+), 30 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 1f9c99689f38..287d83debf95 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1226,19 +1226,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;
- bio = f2fs_grab_read_bio(inode, vi, blkaddr, 1, op_flags, folio->index,
+ 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, index,
for_write);
/* wait for GCed page writeback via META_MAPPING */
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_page_count(sbi, F2FS_RD_DATA);
@@ -1379,20 +1386,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,
@@ -1428,7 +1431,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;
}
@@ -1441,15 +1444,17 @@ 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;
}
- 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:
@@ -1466,7 +1471,7 @@ struct folio *f2fs_find_data_folio(struct inode *inode, pgoff_t index,
folio = f2fs_filemap_get_folio(mapping, index, FGP_ACCESSED, 0);
if (IS_ERR(folio))
goto read;
- if (folio_test_uptodate(folio))
+ if (f2fs_ffs_test_blk_uptodate(folio, index))
return folio;
f2fs_folio_put(folio, false);
@@ -1475,11 +1480,11 @@ struct folio *f2fs_find_data_folio(struct inode *inode, pgoff_t index,
if (IS_ERR(folio))
return folio;
- if (folio_test_uptodate(folio))
+ if (f2fs_ffs_test_blk_uptodate(folio, index))
return folio;
folio_wait_locked(folio);
- if (unlikely(!folio_test_uptodate(folio))) {
+ if (unlikely(!f2fs_ffs_test_blk_uptodate(folio, index))) {
f2fs_folio_put(folio, false);
return ERR_PTR(-EIO);
}
@@ -1503,7 +1508,8 @@ 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_ffs_test_blk_uptodate(folio, index))) {
f2fs_folio_put(folio, true);
return ERR_PTR(-EIO);
}
@@ -2667,6 +2673,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 = folio->private;
+ nr_subpages = folio_nr_pages(folio);
+ idx = index - folio->index;
+ return test_bit(nr_subpages + idx, ffs->state);
+}
+
void f2fs_ffs_mark_subrange_dirty(struct folio *folio,
size_t offset, size_t len)
{
@@ -2724,14 +2746,13 @@ bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
if (!f2fs_folio_has_ffs(folio))
return false;
- ffs = (struct f2fs_folio_state *)folio->private;
+ ffs = 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)
@@ -3225,7 +3246,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)))
@@ -4781,7 +4802,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)) {
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index f48e2627d90a..6be08e45341c 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4394,6 +4394,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 16fce62740d7..147836f1155f 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1509,12 +1509,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;
@@ -1529,6 +1536,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 {
@@ -1541,32 +1550,49 @@ 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,
};
- bool is_dirty = folio_test_dirty(folio);
+ struct f2fs_folio_state *ffs = NULL;
+ bool is_dirty = f2fs_ffs_test_blk_dirty(folio, bidx);
retry:
f2fs_folio_wait_writeback(folio, DATA, true, true);
+ if (large) {
+ ffs = folio->private;
+ f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
+ }
folio_mark_dirty(folio);
if (folio_clear_dirty_for_io(folio)) {
inode_dec_dirty_pages(inode);
f2fs_remove_dirty_inode(inode);
+ if (large &&
+ f2fs_ffs_clear_subrange_dirty_and_test(folio, foff, PAGE_SIZE))
+ folio_mark_dirty(folio);
}
+ if (large)
+ atomic_inc(&ffs->write_pages_pending);
folio_set_f2fs_gcing(folio);
err = f2fs_do_write_data_page(&fio);
if (err) {
folio_clear_f2fs_gcing(folio);
+ if (large)
+ atomic_dec(&ffs->write_pages_pending);
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 644ddfb984c9..a81cc8c5c34a 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -3860,7 +3860,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
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* [f2fs-dev] [PATCH v2 08/14] f2fs: optimize small block size large folio read
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (6 preceding siblings ...)
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 07/14] f2fs: make GC migration large-folio aware Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:19 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-16 4:33 ` Daeho Jeong
2026-09-17 8:09 ` Chao Yu via Linux-f2fs-devel
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 09/14] f2fs: support partial uptodate " Nanzhe Zhao via Linux-f2fs-devel
` (6 subsequent siblings)
14 siblings, 2 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:19 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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. If the contiguous mapping covers the whole
folio, skip f2fs_folio_state allocation for that folio.
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 65 ++++++++++++++++++++++++++++++++++----------------
1 file changed, 45 insertions(+), 20 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 287d83debf95..09ad5cf0d9aa 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -173,8 +173,9 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
continue;
}
- if (folio_test_large(folio)) {
- struct f2fs_folio_state *ffs = folio->private;
+ if (f2fs_folio_has_ffs(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;
@@ -2844,8 +2845,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 int nrpages;
- struct f2fs_folio_state *ffs;
+ unsigned int nrpages, len_blks;
int ret = 0;
bool folio_in_bio = false;
@@ -2868,11 +2868,17 @@ 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;
+ bool whole_folio_in_bio;
+ unsigned int i;
+
+ len_blks = 1;
+
/*
* Map blocks using the previous result first.
*/
@@ -2901,13 +2907,31 @@ 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;
+ }
}
+
+ /*
+ * If an entire folio is added to one bio,
+ * folio_end_read() can complete the folio read status
+ * without relying on f2fs_folio_state.
+ */
+ whole_folio_in_bio = offset == 0 &&
+ len_blks == folio_nr_pages(folio);
+
} 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;
@@ -2917,15 +2941,13 @@ static int f2fs_read_data_large_folio(struct inode *inode,
}
/* We must increment read_pages_pending before possible BIOs submitting
- * to prevent from premature folio_end_read() call on folio
+ * to prevent from premature folio_end_read() call on folio.
*/
- if (folio_test_large(folio)) {
- ffs = f2fs_ffs_find_or_alloc(folio);
+ if (folio_test_large(folio) && !whole_folio_in_bio) {
+ f2fs_ffs_find_or_alloc(folio);
/* 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);
}
/*
@@ -2949,17 +2971,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_page_count(F2FS_I_SB(inode), F2FS_RD_DATA);
+ for (i = 0; i < len_blks; i++)
+ inc_page_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
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 08/14] f2fs: optimize small block size large folio read
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 08/14] f2fs: optimize small block size large folio read Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-16 4:33 ` Daeho Jeong
2026-09-23 2:36 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-24 1:34 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-17 8:09 ` Chao Yu via Linux-f2fs-devel
1 sibling, 2 replies; 40+ messages in thread
From: Daeho Jeong @ 2026-09-16 4:33 UTC (permalink / raw)
To: Nanzhe Zhao
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Jaegeuk Kim, Pengfei Li, Ryan Roberts
On Mon, Sep 14, 2026 at 9:21 PM Nanzhe Zhao via Linux-f2fs-devel
<linux-f2fs-devel@lists.sourceforge.net> wrote:
>
> 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. If the contiguous mapping covers the whole
> folio, skip f2fs_folio_state allocation for that folio.
>
> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
> ---
> fs/f2fs/data.c | 65 ++++++++++++++++++++++++++++++++++----------------
> 1 file changed, 45 insertions(+), 20 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 287d83debf95..09ad5cf0d9aa 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -173,8 +173,9 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
> continue;
> }
>
> - if (folio_test_large(folio)) {
> - struct f2fs_folio_state *ffs = folio->private;
> + if (f2fs_folio_has_ffs(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;
> @@ -2844,8 +2845,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 int nrpages;
> - struct f2fs_folio_state *ffs;
> + unsigned int nrpages, len_blks;
> int ret = 0;
> bool folio_in_bio = false;
>
> @@ -2868,11 +2868,17 @@ 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;
> + bool whole_folio_in_bio;
> + unsigned int i;
> +
> + len_blks = 1;
> +
> /*
> * Map blocks using the previous result first.
> */
> @@ -2901,13 +2907,31 @@ 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;
> + }
> }
> +
> + /*
> + * If an entire folio is added to one bio,
> + * folio_end_read() can complete the folio read status
> + * without relying on f2fs_folio_state.
> + */
> + whole_folio_in_bio = offset == 0 &&
> + len_blks == folio_nr_pages(folio);
> +
> } 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;
> @@ -2917,15 +2941,13 @@ static int f2fs_read_data_large_folio(struct inode *inode,
> }
>
> /* We must increment read_pages_pending before possible BIOs submitting
> - * to prevent from premature folio_end_read() call on folio
> + * to prevent from premature folio_end_read() call on folio.
> */
> - if (folio_test_large(folio)) {
> - ffs = f2fs_ffs_find_or_alloc(folio);
> + if (folio_test_large(folio) && !whole_folio_in_bio) {
Hi Nanzhe,
I found a hang issue caused by the whole_folio_in_bio optimization
during my local 16KB page-4KB block testing:
Plz, check the whole_folio_in_bio optimization is safe for the below conditions.
1. read_blocks_pending underflow: If a folio already has ffs attached
(from previous writes/holes/reads), whole_folio_in_bio skips
incrementing read_blocks_pending.
When the BIO completes, f2fs_finish_read_bio() still decrements it,
underflowing the counter.
2. BIO split risk: If a large folio BIO gets split by the block/crypto
layer, f2fs_finish_read_bio() would call folio_end_read() prematurely
on the first completing piece.
Thanks,
> + f2fs_ffs_find_or_alloc(folio);
>
> /* 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);
> }
>
> /*
> @@ -2949,17 +2971,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_page_count(F2FS_I_SB(inode), F2FS_RD_DATA);
> + for (i = 0; i < len_blks; i++)
> + inc_page_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
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 08/14] f2fs: optimize small block size large folio read
2026-09-16 4:33 ` Daeho Jeong
@ 2026-09-23 2:36 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-24 1:34 ` Nanzhe Zhao via Linux-f2fs-devel
1 sibling, 0 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-23 2:36 UTC (permalink / raw)
To: Daeho Jeong
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Jaegeuk Kim, Pengfei Li, Ryan Roberts
On Tue, 15 Sep 2026 21:33:15 -0700, Daeho Jeong wrote:
> 1. read_blocks_pending underflow: If a folio already has ffs attached
> (from previous writes/holes/reads), whole_folio_in_bio skips
> incrementing read_blocks_pending. When the BIO completes,
> f2fs_finish_read_bio() still decrements it, underflowing the counter.
> 2. BIO split risk: If a large folio BIO gets split by the block/crypto
> layer, f2fs_finish_read_bio() would call folio_end_read() prematurely
> on the first completing piece.
Hi Daeho,
Thanks for pointing this out.
It seems I need to drop the whole_folio_in_bio change in the next version.
(BIO splitting at the block layer can only be solved by read_pages_pending.)
I understand that in that case I'd better re-measure the I/O performance of
the whole patch series for the next version?
Thanks!
--
Nanzhe Zhao
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [f2fs-dev] [PATCH v2 08/14] f2fs: optimize small block size large folio read
2026-09-16 4:33 ` Daeho Jeong
2026-09-23 2:36 ` Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-24 1:34 ` Nanzhe Zhao via Linux-f2fs-devel
1 sibling, 0 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-24 1:34 UTC (permalink / raw)
To: daeho43
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Jaegeuk Kim, Pengfei Li, Ryan Roberts
Hi Daeho,
>2. BIO split risk: If a large folio BIO gets split by the block/crypto
> layer, f2fs_finish_read_bio() would call folio_end_read() prematurely
> on the first completing piece.
I investigated the block layer code a bit, especially the block layer bio
split, and I don't see this will cause a problem.
The call chain of a submitted bio that can be split may look like the
following:
f2fs_read_data_large_folio() fs/f2fs/data.c
submit_bio() block/blk-core.c
submit_bio_noacct() block/blk-core.c
submit_bio_noacct_nocheck() block/blk-core.c
__submit_bio_noacct_mq() block/blk-core.c
__submit_bio() block/blk-core.c
blk_mq_submit_bio() block/blk-mq.c
__bio_split_to_limits() block/blk.h
bio_split_rw() block/blk-merge.c
bio_submit_split() block/blk-merge.c
bio_submit_split_bioset() block/blk-merge.c
split = bio_split(bio, ...) block/bio.c
bio_alloc_clone() block/bio.c
bio_chain(split, bio) block/bio.c
There are two things I've found:
(1) The split bio does not inherit the original bio's ->bi_end_io.
bio_split() -> bio_alloc_clone() allocates the new bio with
bio_alloc_bioset(bdev, 0, bio_src->bi_opf, ...), so bio_init() sets
->bi_end_io = NULL, and __bio_clone() (block/bio.c) only copies
BIO_CLONED, bi_ioprio/bi_write_hint, bi_iter, bi_io_vec and the
blkg/crypt/integrity state. ->bi_end_io is not copied.
It is bio_submit_split_bioset() that then calls bio_chain(split, bio)
(block/bio.c), which sets:
split->bi_private = parent;
split->bi_end_io = bio_chain_endio;
bio_inc_remaining(parent); /* include/linux/bio.h */
(2) The original (parent) bio's ->bi_end_io is called only once
__bi_remaining reaches 0.
bio_endio() (block/bio.c) first calls bio_remaining_done()
(block/bio.c). While the bio is chained, that helper atomically
decrements __bi_remaining and returns false unless the result is 0:
if (!bio_remaining_done(bio))
return;
Only when it reaches 0 does bio_endio() go on to call bio->bi_end_io().
So the first completing piece (the split bio) only runs
__bio_chain_endio() (block/bio.c), which forwards bi_status,
bio_put()s the child and returns the parent. The parent's real end_io,
f2fs_read_end_io() -> f2fs_finish_read_bio() -> folio_end_read(), is
reached once, on the parent, after every piece has completed.
(Note: the decrement is done by bio_remaining_done(), not by
__bio_chain_endio().)
This is same for crypto.
inline-encryption bio that has to be split goes through the
exact same block layer path above, and bio_split_io_at()
(block/blk-merge.c) only widens the alignment mask to the crypto data
unit size.
So unless there is a path where a split bio carries the parent's end_io,
which I missed, I think f2fs_finish_read_bio() is not called early ?
I also verified the completion behavior on a qemu with kernel version 7.3.0-rc1,
x86_64, f2fs on virtio-blk, order-4 folios, max_sectors_kb=4096, reading a
file sequentially so that the f2fs bio grows to 128 order-4 folios (8MB)
and is split at 4MB. One split cycle is like this:
(parent bio=ffff888105522f20, split bio created by bio_alloc_clone =ffff888104728cc0):
dd-679 [007] ..... 152.814006: f2fs_read_data_large_folio: BIOTRACE: f2fs_read_data_large_folio: bio=ffff888105522f20 folio=ffffea0004194400 index=4080 len_blks=16 whole_folio_in_bio=1
dd-679 [007] ..... 152.814012: bio_chain: BIOTRACE: bio_chain: child=ffff888104728cc0 parent=ffff888105522f20 parent_remaining=2
dd-679 [007] ..... 152.814013: bio_submit_split_bioset: BIOTRACE: bio_submit_split_bioset: parent=ffff888105522f20 split=ffff888104728cc0 split_sectors=8192 parent_remaining=2
dd-679 [007] d.h1. 152.816600: bio_endio: BIOTRACE: __bio_chain_endio: child=ffff888104728cc0 parent=ffff888105522f20 status=0
dd-679 [007] d.h1. 152.816603: bio_endio: BIOTRACE: bio_remaining_done: bio=ffff888105522f20 remaining=1
dd-679 [007] d.h1. 152.816605: bio_endio: BIOTRACE: bio_remaining_done: bio=ffff888105522f20 remaining=0
dd-679 [007] d.h1. 152.816605: bio_endio: BIOTRACE: bio_endio: bio=ffff888105522f20 end_io=f2fs_read_end_io
dd-679 [007] d.h1. 152.816607: f2fs_finish_read_bio: BIOTRACE: f2fs_finish_read_bio: bio=ffff888105522f20 folio=ffffea0004198800 index=2048 nr_pages=4294967295 finished=1
The trace_printk() diff that prints the above logs are here:
diff --git a/block/bio.c b/block/bio.c
index 898b2f5ef8c8..5fa0fa6a2d56 100644
--- a/block/bio.c
+++ b/block/bio.c
@@ -324,6 +324,9 @@ static struct bio *__bio_chain_endio(struct bio *bio)
{
struct bio *parent = bio->bi_private;
+ trace_printk("BIOTRACE: %s: child=%px parent=%px status=%d\n",
+ __func__, bio, parent, bio->bi_status);
+
if (bio->bi_status && !parent->bi_status)
parent->bi_status = bio->bi_status;
bio_put(bio);
@@ -357,6 +360,8 @@ void bio_chain(struct bio *bio, struct bio *parent)
bio->bi_private = parent;
bio->bi_end_io = bio_chain_endio;
bio_inc_remaining(parent);
+ trace_printk("BIOTRACE: %s: child=%px parent=%px parent_remaining=%d\n",
+ __func__, bio, parent, atomic_read(&parent->__bi_remaining));
}
EXPORT_SYMBOL(bio_chain);
@@ -1850,6 +1855,8 @@ EXPORT_SYMBOL_GPL(__bio_complete_in_task);
static inline bool bio_remaining_done(struct bio *bio)
{
+ int remaining;
+
/*
* If we're not chaining, then ->__bi_remaining is always 1 and
* we always end io on the first invocation.
@@ -1859,7 +1866,10 @@ static inline bool bio_remaining_done(struct bio *bio)
BUG_ON(atomic_read(&bio->__bi_remaining) <= 0);
- if (atomic_dec_and_test(&bio->__bi_remaining)) {
+ remaining = atomic_dec_return(&bio->__bi_remaining);
+ trace_printk("BIOTRACE: %s: bio=%px remaining=%d\n",
+ __func__, bio, remaining);
+ if (remaining == 0) {
bio_clear_flag(bio, BIO_CHAIN);
return true;
}
@@ -1924,8 +1934,11 @@ void bio_endio(struct bio *bio)
if (bio_flagged(bio, BIO_COMPLETE_IN_TASK) && bio_in_atomic())
__bio_complete_in_task(bio);
- else if (bio->bi_end_io)
+ else if (bio->bi_end_io) {
+ trace_printk("BIOTRACE: %s: bio=%px end_io=%ps\n",
+ __func__, bio, (void *)bio->bi_end_io);
bio->bi_end_io(bio);
+ }
}
EXPORT_SYMBOL(bio_endio);
diff --git a/block/blk-merge.c b/block/blk-merge.c
index 258a726071d1..834910c61fc6 100644
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -127,6 +127,9 @@ struct bio *bio_submit_split_bioset(struct bio *bio, unsigned int split_sectors,
}
bio_chain(split, bio);
+ trace_printk("BIOTRACE: %s: parent=%px split=%px split_sectors=%u parent_remaining=%d\n",
+ __func__, bio, split, split_sectors,
+ atomic_read(&bio->__bi_remaining));
trace_block_split(split, bio->bi_iter.bi_sector);
WARN_ON_ONCE(bio_zone_write_plugging(bio));
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index f5421334ecf3..0376e02c011b 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -197,6 +197,9 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
folio, folio->index, NODE_TYPE_REGULAR, true))
bio->bi_status = BLK_STS_IOERR;
+ trace_printk("BIOTRACE: %s: bio=%px folio=%px index=%lu nr_pages=%u finished=%d\n",
+ __func__, bio, folio, folio->index, nr_pages,
+ finished);
if (finished)
folio_end_read(folio,
bio->bi_status == BLK_STS_OK && uptodate);
@@ -3079,6 +3082,9 @@ static int f2fs_read_data_large_folio(struct inode *inode,
goto submit_and_realloc;
folio_in_bio = true;
+ trace_printk("BIOTRACE: %s: bio=%px folio=%px index=%lu len_blks=%u whole_folio_in_bio=%d\n",
+ __func__, bio, folio, folio->index, len_blks,
+ whole_folio_in_bio);
for (i = 0; i < len_blks; i++)
inc_page_count(F2FS_I_SB(inode), F2FS_RD_DATA);
f2fs_update_iostat(F2FS_I_SB(inode), NULL, FS_DATA_READ_IO,
>1. read_blocks_pending underflow: If a folio already has ffs attached
> (from previous writes/holes/reads), whole_folio_in_bio skips
> incrementing read_blocks_pending.
> When the BIO completes, f2fs_finish_read_bio() still decrements it,
> underflowing the counter.
Yes. Thanks for pointing out. I think only when read_pages_pending is not
zero should it decrease in f2fs_finish_read_bio like this ?
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -182,7 +182,8 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
if (bio->bi_status == BLK_STS_OK)
uptodate = __ffs_mark_subrange_uptodate(folio, ffs,
fi.offset, fi.length);
- ffs->read_pages_pending -= nr_pages;
+ if (ffs->read_pages_pending)
+ ffs->read_pages_pending -= nr_pages;
finished = !ffs->read_pages_pending;
spin_unlock_irqrestore(&ffs->state_lock, flags);
}
Thanks!
--
Nanzhe Zhao
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread
* Re: [f2fs-dev] [PATCH v2 08/14] f2fs: optimize small block size large folio read
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 08/14] f2fs: optimize small block size large folio read Nanzhe Zhao via Linux-f2fs-devel
2026-09-16 4:33 ` Daeho Jeong
@ 2026-09-17 8:09 ` Chao Yu via Linux-f2fs-devel
1 sibling, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-17 8:09 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:19, Nanzhe Zhao wrote:
> 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. If the contiguous mapping covers the whole
> folio, skip f2fs_folio_state allocation for that folio.
>
> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
> ---
> fs/f2fs/data.c | 65 ++++++++++++++++++++++++++++++++++----------------
> 1 file changed, 45 insertions(+), 20 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 287d83debf95..09ad5cf0d9aa 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -173,8 +173,9 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
> continue;
> }
>
> - if (folio_test_large(folio)) {
> - struct f2fs_folio_state *ffs = folio->private;
> + if (f2fs_folio_has_ffs(folio)) {
> + struct f2fs_folio_state *ffs =
> + (struct f2fs_folio_state *)folio->private;
I just notice that in somewhere, we missed to cast the private field to
f2fs_folio_state pointer as below, please take a look.
ffs = folio->private;
>
> spin_lock_irqsave(&ffs->state_lock, flags);
> ffs->read_pages_pending -= nr_pages;
> @@ -2844,8 +2845,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 int nrpages;
> - struct f2fs_folio_state *ffs;
> + unsigned int nrpages, len_blks;
> int ret = 0;
> bool folio_in_bio = false;
>
> @@ -2868,11 +2868,17 @@ 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;
> + bool whole_folio_in_bio;
> + unsigned int i;
> +
> + len_blks = 1;
> +
> /*
> * Map blocks using the previous result first.
> */
> @@ -2901,13 +2907,31 @@ 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;
> + }
> }
> +
> + /*
> + * If an entire folio is added to one bio,
> + * folio_end_read() can complete the folio read status
> + * without relying on f2fs_folio_state.
> + */
> + whole_folio_in_bio = offset == 0 &&
> + len_blks == folio_nr_pages(folio);
> +
> } 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;
> @@ -2917,15 +2941,13 @@ static int f2fs_read_data_large_folio(struct inode *inode,
> }
>
> /* We must increment read_pages_pending before possible BIOs submitting
> - * to prevent from premature folio_end_read() call on folio
> + * to prevent from premature folio_end_read() call on folio.
> */
> - if (folio_test_large(folio)) {
> - ffs = f2fs_ffs_find_or_alloc(folio);
> + if (folio_test_large(folio) && !whole_folio_in_bio) {
> + f2fs_ffs_find_or_alloc(folio);
Need to check return value?
Thanks,
>
> /* 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);
> }
>
> /*
> @@ -2949,17 +2971,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_page_count(F2FS_I_SB(inode), F2FS_RD_DATA);
> + for (i = 0; i < len_blks; i++)
> + inc_page_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:
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* [f2fs-dev] [PATCH v2 09/14] f2fs: support partial uptodate large folio read
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (7 preceding siblings ...)
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 08/14] f2fs: optimize small block size large folio read Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:19 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 10/14] f2fs: handle partial truncate of large folio dirty subpages Nanzhe Zhao via Linux-f2fs-devel
` (5 subsequent siblings)
14 siblings, 0 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:19 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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 | 71 +++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 70 insertions(+), 1 deletion(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 09ad5cf0d9aa..d9e3a5c370d7 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -163,6 +163,7 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
struct folio *folio = fi.folio;
unsigned int 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)) {
@@ -178,6 +179,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 (bio->bi_status == BLK_STS_OK)
+ 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);
@@ -194,7 +198,8 @@ static void f2fs_finish_read_bio(struct bio *bio, bool in_task)
bio->bi_status = BLK_STS_IOERR;
if (finished)
- folio_end_read(folio, bio->bi_status == BLK_STS_OK);
+ folio_end_read(folio,
+ bio->bi_status == BLK_STS_OK && uptodate);
}
if (ctx)
@@ -2835,6 +2840,56 @@ 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 = 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 folio *folio, pgoff_t offset,
+ unsigned int *len_blks)
+{
+ struct f2fs_folio_state *ffs;
+ unsigned int next, end;
+
+ if (!f2fs_folio_has_ffs(folio) || *len_blks <= 1)
+ return;
+
+ ffs = 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)
@@ -2846,6 +2901,7 @@ static int f2fs_read_data_large_folio(struct inode *inode,
unsigned max_nr_pages = rac ? readahead_count(rac) :
folio_nr_pages(folio);
unsigned int nrpages, len_blks;
+ struct f2fs_folio_state *ffs;
int ret = 0;
bool folio_in_bio = false;
@@ -2879,6 +2935,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.
*/
@@ -2911,6 +2972,7 @@ 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(folio, offset, &len_blks);
for (i = 0; i < len_blks; i++) {
if (!f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
@@ -2937,6 +2999,13 @@ static int f2fs_read_data_large_folio(struct inode *inode,
ret = -EIO;
goto err_out;
}
+ if (folio_test_large(folio)) {
+ ffs = f2fs_ffs_find_or_alloc(folio);
+ spin_lock_irq(&ffs->state_lock);
+ __ffs_mark_subrange_uptodate(folio, ffs,
+ page_offset, PAGE_SIZE);
+ spin_unlock_irq(&ffs->state_lock);
+ }
continue;
}
--
2.43.0
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* [f2fs-dev] [PATCH v2 10/14] f2fs: handle partial truncate of large folio dirty subpages
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (8 preceding siblings ...)
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 09/14] f2fs: support partial uptodate " Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:19 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-17 8:30 ` Chao Yu via Linux-f2fs-devel
2026-09-17 8:32 ` Chao Yu via Linux-f2fs-devel
2026-09-15 4:25 ` [f2fs-dev] [PATCH v2 11/14] f2fs: fix zeroing paths for large folios Nanzhe Zhao via Linux-f2fs-devel
` (4 subsequent siblings)
14 siblings, 2 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:19 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
A large folio can be partial truncated and stays in folio mapping, we
need to clear the subrange dirty bits and uptodate bits that the partial
truncate covers. If this partial truncate happens to clear the last
subrange dirty bits, then cancel the whole folio dirty state.
Also add a guard in f2fs_write_single_data_folio() so a large folio
subpage whose disk block was already truncated (NULL_ADDR) is skipped
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 65 insertions(+), 1 deletion(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index d9e3a5c370d7..bf9b9c9b722f 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2679,6 +2679,34 @@ 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)) {
+ if (folio_test_uptodate(folio))
+ folio_clear_uptodate(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);
+ if (folio_test_uptodate(folio))
+ folio_clear_uptodate(folio);
+}
+
bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
{
struct f2fs_folio_state *ffs;
@@ -3545,6 +3573,14 @@ static int f2fs_write_single_data_folio(struct folio *folio, int *submitted,
fio.old_blkaddr = dn.data_blkaddr;
+ /* This page is already truncated */
+ if (fio.old_blkaddr == NULL_ADDR) {
+ ffs_clear_subrange_uptodate(folio,
+ i << PAGE_SHIFT, PAGE_SIZE);
+ folio_clear_f2fs_gcing(folio);
+ goto block_done;
+ }
+
got_it:
if (__is_valid_data_blkaddr(fio.old_blkaddr) &&
!f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr,
@@ -4987,8 +5023,36 @@ void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length)
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
if (inode->i_ino >= F2FS_ROOT_INO(sbi) &&
- (offset || length != folio_size(folio)))
+ (offset || length != folio_size(folio))) {
+ size_t clear_start = round_up(offset, PAGE_SIZE);
+ size_t clear_end = round_down(offset + length, PAGE_SIZE);
+ size_t clear_length;
+ bool dirty;
+
+ /*
+ * If the truncated range falls within a single subpage, no
+ * subpage state needs to be cleared.
+ */
+ if (clear_start >= clear_end || !f2fs_folio_has_ffs(folio))
+ return;
+
+ clear_length = clear_end - clear_start;
+ dirty = f2fs_ffs_clear_subrange_dirty_and_test(folio,
+ clear_start, clear_length);
+ ffs_clear_subrange_uptodate(folio, clear_start, clear_length);
+
+ /*
+ * If the truncated subrange happens to clear the remaining
+ * dirty bitmap of the whole folio, cancel the folio-level
+ * dirty state.
+ */
+ if (!dirty && folio_test_dirty(folio)) {
+ inode_dec_dirty_pages(inode);
+ f2fs_remove_dirty_inode(inode);
+ folio_cancel_dirty(folio);
+ }
return;
+ }
if (folio_test_dirty(folio)) {
if (inode->i_ino == F2FS_META_INO(sbi)) {
--
2.43.0
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 10/14] f2fs: handle partial truncate of large folio dirty subpages
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 10/14] f2fs: handle partial truncate of large folio dirty subpages Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-17 8:30 ` Chao Yu via Linux-f2fs-devel
2026-09-23 2:50 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-17 8:32 ` Chao Yu via Linux-f2fs-devel
1 sibling, 1 reply; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-17 8:30 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:19, Nanzhe Zhao wrote:
> A large folio can be partial truncated and stays in folio mapping, we
> need to clear the subrange dirty bits and uptodate bits that the partial
> truncate covers. If this partial truncate happens to clear the last
> subrange dirty bits, then cancel the whole folio dirty state.
>
> Also add a guard in f2fs_write_single_data_folio() so a large folio
> subpage whose disk block was already truncated (NULL_ADDR) is skipped
>
> Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
> ---
> fs/f2fs/data.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++-
> 1 file changed, 65 insertions(+), 1 deletion(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index d9e3a5c370d7..bf9b9c9b722f 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -2679,6 +2679,34 @@ 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)) {
> + if (folio_test_uptodate(folio))
> + folio_clear_uptodate(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);
> + if (folio_test_uptodate(folio))
> + folio_clear_uptodate(folio);
> +}
> +
> bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
> {
> struct f2fs_folio_state *ffs;
> @@ -3545,6 +3573,14 @@ static int f2fs_write_single_data_folio(struct folio *folio, int *submitted,
>
> fio.old_blkaddr = dn.data_blkaddr;
>
> + /* This page is already truncated */
> + if (fio.old_blkaddr == NULL_ADDR) {
> + ffs_clear_subrange_uptodate(folio,
> + i << PAGE_SHIFT, PAGE_SIZE);
> + folio_clear_f2fs_gcing(folio);
Since gcing flag is per-folio, so if block #0 is on gcing, but block #1 is
truncated, it will drop on gcing flag of folio, result in triggering IPU on
such dirtied block of large folio? also it will affect f2fs_is_cp_guaranteed()?
Thanks,
> + goto block_done;
> + }
> +
> got_it:
> if (__is_valid_data_blkaddr(fio.old_blkaddr) &&
> !f2fs_is_valid_blkaddr(sbi, fio.old_blkaddr,
> @@ -4987,8 +5023,36 @@ void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length)
> struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
>
> if (inode->i_ino >= F2FS_ROOT_INO(sbi) &&
> - (offset || length != folio_size(folio)))
> + (offset || length != folio_size(folio))) {
> + size_t clear_start = round_up(offset, PAGE_SIZE);
> + size_t clear_end = round_down(offset + length, PAGE_SIZE);
> + size_t clear_length;
> + bool dirty;
> +
> + /*
> + * If the truncated range falls within a single subpage, no
> + * subpage state needs to be cleared.
> + */
> + if (clear_start >= clear_end || !f2fs_folio_has_ffs(folio))
> + return;
> +
> + clear_length = clear_end - clear_start;
> + dirty = f2fs_ffs_clear_subrange_dirty_and_test(folio,
> + clear_start, clear_length);
> + ffs_clear_subrange_uptodate(folio, clear_start, clear_length);
> +
> + /*
> + * If the truncated subrange happens to clear the remaining
> + * dirty bitmap of the whole folio, cancel the folio-level
> + * dirty state.
> + */
> + if (!dirty && folio_test_dirty(folio)) {
> + inode_dec_dirty_pages(inode);
> + f2fs_remove_dirty_inode(inode);
> + folio_cancel_dirty(folio);
> + }
> return;
> + }
>
> if (folio_test_dirty(folio)) {
> if (inode->i_ino == F2FS_META_INO(sbi)) {
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 10/14] f2fs: handle partial truncate of large folio dirty subpages
2026-09-17 8:30 ` Chao Yu via Linux-f2fs-devel
@ 2026-09-23 2:50 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-23 7:18 ` Chao Yu via Linux-f2fs-devel
0 siblings, 1 reply; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-23 2:50 UTC (permalink / raw)
To: Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Jaegeuk Kim, Pengfei Li, Ryan Roberts
On Thu, 17 Sep 2026 16:30:59 +0800, Chao Yu wrote:
> Since gcing flag is per-folio, so if block #0 is on gcing, but block #1 is
> truncated, it will drop on gcing flag of folio, result in triggering IPU on
> such dirtied block of large folio? also it will affect f2fs_is_cp_guaranteed()?
Hi Chao,
Thanks for the review. I think I may should change like this?
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index f5421334ecf3..a94153be0533 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -351,6 +351,27 @@ static void f2fs_read_end_io(struct bio *bio)
f2fs_verify_and_finish_bio(bio, intask);
}
+static bool f2fs_ffs_has_dirty_subpage(struct folio *folio)
+{
+ struct f2fs_folio_state *ffs;
+ unsigned long flags;
+ unsigned int nr_subpages;
+ bool dirty;
+
+ if (!f2fs_folio_has_ffs(folio))
+ return false;
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ nr_subpages = folio_nr_pages(folio);
+
+ spin_lock_irqsave(&ffs->state_lock, flags);
+ dirty = find_next_bit(ffs->state, 2 * nr_subpages,
+ nr_subpages) < 2 * nr_subpages;
+ spin_unlock_irqrestore(&ffs->state_lock, flags);
+
+ return dirty;
+}
+
static void f2fs_write_end_bio(struct bio *bio)
{
struct f2fs_sb_info *sbi = bio->bi_private;
@@ -410,7 +431,8 @@ static void f2fs_write_end_bio(struct bio *bio)
wake_up(&sbi->cp_wait);
if (finished) {
- folio_clear_f2fs_gcing(folio);
+ if (!f2fs_ffs_has_dirty_subpage(folio))
+ folio_clear_f2fs_gcing(folio);
folio_end_writeback(folio);
}
}
@@ -3575,11 +3597,10 @@ static int f2fs_write_single_data_folio(struct folio *folio, int *submitted,
fio.old_blkaddr = dn.data_blkaddr;
/* This page is already truncated */
if (fio.old_blkaddr == NULL_ADDR) {
ffs_clear_subrange_uptodate(folio,
i << PAGE_SHIFT, PAGE_SIZE);
- folio_clear_f2fs_gcing(folio);
goto block_done;
}
@@ -4122,6 +4143,7 @@ static int f2fs_write_cache_folios(struct address_space *mapping,
bool verity_in_progress;
int folio_submitted = 0;
bool bias_added = false;
+ bool dirty;
submitted = 0;
next = true;
@@ -4224,15 +4246,19 @@ static int f2fs_write_cache_folios(struct address_space *mapping,
* partially written back), the folio must stay dirty so that
* the remaining subranges are written back later.
*/
- if (f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
- (err ? pos : end_pos) - folio_pos(folio)))
+ dirty = f2fs_ffs_clear_subrange_dirty_and_test(folio, 0,
+ (err ? pos : end_pos) - folio_pos(folio));
+ if (dirty)
folio_redirty_for_writepage(wbc, folio);
else
inode_dec_dirty_pages(inode);
if (bias_added) {
- if (atomic_dec_and_test(&ffs->write_pages_pending))
+ if (atomic_dec_and_test(&ffs->write_pages_pending)) {
+ if (!dirty)
+ folio_clear_f2fs_gcing(folio);
folio_end_writeback(folio);
+ }
} else if (!folio_submitted && folio_test_writeback(folio)) {
folio_end_writeback(folio);
}
@@ -5054,6 +5080,8 @@ void f2fs_invalidate_folio(struct folio *folio, size_t offset, size_t length)
f2fs_remove_dirty_inode(inode);
folio_cancel_dirty(folio);
}
+ if (!dirty && !folio_test_writeback(folio))
+ folio_clear_f2fs_gcing(folio);
return;
}
--
Nanzhe Zhao
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 10/14] f2fs: handle partial truncate of large folio dirty subpages
2026-09-23 2:50 ` Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-23 7:18 ` Chao Yu via Linux-f2fs-devel
0 siblings, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-23 7:18 UTC (permalink / raw)
To: Nanzhe Zhao
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Jaegeuk Kim, Pengfei Li, Ryan Roberts
On 9/23/26 10:50, Nanzhe Zhao wrote:
> Thanks for the review. I think I may should change like this?
Seems fine, thanks for the update.
Thanks,
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [f2fs-dev] [PATCH v2 10/14] f2fs: handle partial truncate of large folio dirty subpages
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 10/14] f2fs: handle partial truncate of large folio dirty subpages Nanzhe Zhao via Linux-f2fs-devel
2026-09-17 8:30 ` Chao Yu via Linux-f2fs-devel
@ 2026-09-17 8:32 ` Chao Yu via Linux-f2fs-devel
1 sibling, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-17 8:32 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:19, Nanzhe Zhao wrote:
> @@ -3545,6 +3573,14 @@ static int f2fs_write_single_data_folio(struct folio *folio, int *submitted,
>
> fio.old_blkaddr = dn.data_blkaddr;
>
> + /* This page is already truncated */
> + if (fio.old_blkaddr == NULL_ADDR) {
> + ffs_clear_subrange_uptodate(folio,
> + i << PAGE_SHIFT, PAGE_SIZE);
(unsigned long long)i << PAGE_SHIFT
Thanks,
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* [f2fs-dev] [PATCH v2 11/14] f2fs: fix zeroing paths for large folios
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (9 preceding siblings ...)
2026-09-15 4:19 ` [f2fs-dev] [PATCH v2 10/14] f2fs: handle partial truncate of large folio dirty subpages Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:25 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-15 4:25 ` [f2fs-dev] [PATCH v2 12/14] f2fs: handle block cloning within the same large folio Nanzhe Zhao via Linux-f2fs-devel
` (3 subsequent siblings)
14 siblings, 0 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:25 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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 | 16 ++++++++++++----
fs/f2fs/f2fs.h | 1 +
fs/f2fs/file.c | 21 ++++++++++++++++-----
3 files changed, 29 insertions(+), 9 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index bf9b9c9b722f..295424f2ade5 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1549,6 +1549,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_folio_put(ifolio, true);
+ return ERR_PTR(-ENOMEM);
+ }
+
set_new_dnode(&dn, inode, ifolio, NULL, 0);
err = f2fs_reserve_block(&dn, index);
if (err) {
@@ -1562,9 +1568,11 @@ struct folio *f2fs_get_new_data_folio(struct inode *inode,
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);
@@ -2656,7 +2664,7 @@ static bool __ffs_mark_subrange_uptodate(struct folio *folio,
return bitmap_full(ffs->state, nr_subpages);
}
-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 6be08e45341c..d99a812810d3 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4381,6 +4381,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 folio *ifolio, 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 738a751c3903..54aa045b549e 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -825,12 +825,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) {
@@ -848,12 +849,18 @@ 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, DATA, 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) {
+ f2fs_ffs_mark_subrange_dirty(folio, folio_off,
+ blk_end - folio_off);
folio_mark_dirty(folio);
+ }
f2fs_folio_put(folio, true);
return 0;
}
@@ -1321,6 +1328,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;
@@ -1335,7 +1343,10 @@ static int fill_zero(struct inode *inode, pgoff_t index,
return PTR_ERR(folio);
f2fs_folio_wait_writeback(folio, DATA, 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);
+ f2fs_ffs_mark_subrange_dirty(folio, folio_off, len);
folio_mark_dirty(folio);
f2fs_folio_put(folio, true);
return 0;
--
2.43.0
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* [f2fs-dev] [PATCH v2 12/14] f2fs: handle block cloning within the same large folio
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (10 preceding siblings ...)
2026-09-15 4:25 ` [f2fs-dev] [PATCH v2 11/14] f2fs: fix zeroing paths for large folios Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:25 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-15 4:25 ` [f2fs-dev] [PATCH v2 13/14] f2fs: allow large folio support to writeable files Nanzhe Zhao via Linux-f2fs-devel
` (2 subsequent siblings)
14 siblings, 0 replies; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:25 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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 54aa045b549e..a36d243ca305 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1586,25 +1586,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, DATA, 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
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* [f2fs-dev] [PATCH v2 13/14] f2fs: allow large folio support to writeable files
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (11 preceding siblings ...)
2026-09-15 4:25 ` [f2fs-dev] [PATCH v2 12/14] f2fs: handle block cloning within the same large folio Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:25 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-17 14:07 ` Chao Yu via Linux-f2fs-devel
2026-09-15 4:25 ` [f2fs-dev] [PATCH v2 14/14] f2fs: make compressed files compatible with large folio Nanzhe Zhao via Linux-f2fs-devel
2026-09-30 17:08 ` [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Jaegeuk Kim via Linux-f2fs-devel
14 siblings, 1 reply; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:25 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
Now we make all write path support large folios,
so we open permission to let writeable file set
large folio mapping.
Keep fs-layer encrypted files excluded unless inline encryption is
enabled, since f2fs_encrypt_one_page() still encrypts one PAGE_SIZE
page and cannot handle large folios.
Inline files are allowed as well; their index #0 folio stays order-0
(see the large folio write path), so the existing inline read/convert
paths are not affected and large folios are used from the second folio
on.
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, 26 insertions(+), 20 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 295424f2ade5..c9dba8d0ad3d 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2941,7 +2941,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 d99a812810d3..d608376b1456 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -5251,6 +5251,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 a36d243ca305..db71cadefabd 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -162,17 +162,6 @@ 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));
- return VM_FAULT_SIGBUS;
- }
if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
err = -EIO;
@@ -712,9 +701,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)
@@ -1186,8 +1172,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 8db083b545bc..51cc2e6c0284 100644
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -238,6 +238,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);
ifolio = f2fs_get_inode_folio(sbi, inode->i_ino);
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 24205a35be04..c8a4c62c9927 100644
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -643,9 +643,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 ff86ee07290d..9d0cec72aacc 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
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 13/14] f2fs: allow large folio support to writeable files
2026-09-15 4:25 ` [f2fs-dev] [PATCH v2 13/14] f2fs: allow large folio support to writeable files Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-17 14:07 ` Chao Yu via Linux-f2fs-devel
0 siblings, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-17 14:07 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:25, Nanzhe Zhao wrote:
> Now we make all write path support large folios,
> so we open permission to let writeable file set
> large folio mapping.
>
> Keep fs-layer encrypted files excluded unless inline encryption is
> enabled, since f2fs_encrypt_one_page() still encrypts one PAGE_SIZE
> page and cannot handle large folios.
>
> Inline files are allowed as well; their index #0 folio stays order-0
> (see the large folio write path), so the existing inline read/convert
> paths are not affected and large folios are used from the second folio
> on.
>
> 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, 26 insertions(+), 20 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 295424f2ade5..c9dba8d0ad3d 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -2941,7 +2941,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 d99a812810d3..d608376b1456 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -5251,6 +5251,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 a36d243ca305..db71cadefabd 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -162,17 +162,6 @@ 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));
> - return VM_FAULT_SIGBUS;
> - }
>
> if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED)) {
> err = -EIO;
> @@ -712,9 +701,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)
> @@ -1186,8 +1172,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 8db083b545bc..51cc2e6c0284 100644
> --- a/fs/f2fs/inline.c
> +++ b/fs/f2fs/inline.c
> @@ -238,6 +238,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);
>
> ifolio = f2fs_get_inode_folio(sbi, inode->i_ino);
> diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
> index 24205a35be04..c8a4c62c9927 100644
> --- a/fs/f2fs/inode.c
> +++ b/fs/f2fs/inode.c
> @@ -643,9 +643,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 ff86ee07290d..9d0cec72aacc 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);
After this patch, we can set set large folio bit on new inode, and then
setting compressed flag via ioctl.
It allows to write data on large folio of compressed file, but still it
does not support read via f2fs_read_data_large_folio()? IIUC.
Thanks,
> return inode;
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* [f2fs-dev] [PATCH v2 14/14] f2fs: make compressed files compatible with large folio
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (12 preceding siblings ...)
2026-09-15 4:25 ` [f2fs-dev] [PATCH v2 13/14] f2fs: allow large folio support to writeable files Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-15 4:25 ` Nanzhe Zhao via Linux-f2fs-devel
2026-09-22 3:09 ` Chao Yu via Linux-f2fs-devel
2026-09-30 17:08 ` [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Jaegeuk Kim via Linux-f2fs-devel
14 siblings, 1 reply; 40+ messages in thread
From: Nanzhe Zhao via Linux-f2fs-devel @ 2026-09-15 4:25 UTC (permalink / raw)
To: linux-f2fs-devel, Jaegeuk Kim, Chao Yu
Cc: Barry Song, Nanzhe Zhao, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
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 771216f45207..b4f436ffd9ac 100644
--- a/Documentation/filesystems/f2fs.rst
+++ b/Documentation/filesystems/f2fs.rst
@@ -941,6 +941,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 b130e43b4566..fa0f8449a12c 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 c9dba8d0ad3d..f5421334ecf3 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2941,12 +2941,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)
@@ -4828,7 +4822,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 db71cadefabd..c5cb0b0384b6 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -5002,6 +5002,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
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [f2fs-dev] [PATCH v2 14/14] f2fs: make compressed files compatible with large folio
2026-09-15 4:25 ` [f2fs-dev] [PATCH v2 14/14] f2fs: make compressed files compatible with large folio Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-22 3:09 ` Chao Yu via Linux-f2fs-devel
0 siblings, 0 replies; 40+ messages in thread
From: Chao Yu via Linux-f2fs-devel @ 2026-09-22 3:09 UTC (permalink / raw)
To: Nanzhe Zhao, linux-f2fs-devel, Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, Bo Zhang, Kalesh Singh, Nanzhe Zhao,
Pengfei Li, Ryan Roberts
On 9/15/26 12:25, Nanzhe Zhao wrote:
> 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 771216f45207..b4f436ffd9ac 100644
> --- a/Documentation/filesystems/f2fs.rst
> +++ b/Documentation/filesystems/f2fs.rst
> @@ -941,6 +941,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 b130e43b4566..fa0f8449a12c 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 c9dba8d0ad3d..f5421334ecf3 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -2941,12 +2941,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)
> @@ -4828,7 +4822,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 db71cadefabd..c5cb0b0384b6 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -5002,6 +5002,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))
It needs to print log here to give notice.
e.g "not support if large folio bit is set, drop inode cache to unset the flag and retry" ?
Thanks,
> + return -EOPNOTSUPP;
> +
> f2fs_balance_fs(sbi, true);
>
> ret = mnt_want_write_file(filp);
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files
2026-09-15 4:18 [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Nanzhe Zhao via Linux-f2fs-devel
` (13 preceding siblings ...)
2026-09-15 4:25 ` [f2fs-dev] [PATCH v2 14/14] f2fs: make compressed files compatible with large folio Nanzhe Zhao via Linux-f2fs-devel
@ 2026-09-30 17:08 ` Jaegeuk Kim via Linux-f2fs-devel
2026-10-03 13:40 ` [f2fs-dev] 答复: [External Mail]Re: " 赵南哲 via Linux-f2fs-devel
14 siblings, 1 reply; 40+ messages in thread
From: Jaegeuk Kim via Linux-f2fs-devel @ 2026-09-30 17:08 UTC (permalink / raw)
To: Nanzhe Zhao
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel,
David Hildenbrand, linux-f2fs-devel, Bo Zhang, Kalesh Singh,
Nanzhe Zhao, Pengfei Li, Ryan Roberts
Hi Nanzhe, are you going to submit v3 soon?
Thanks,
On 09/15, Nanzhe Zhao via Linux-f2fs-devel wrote:
> 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.
>
> Benchmark details can be found in the RFC v2 cover letter [1].
>
> [1] https://lore.kernel.org/r/20260622160830.324455-1-zhaonanzhe@xiaomi.com
>
> Changes in v2:
> - Addressed most of Chao's and Daeho's review comments.
> - Updated docs for compress policy with large folios.
> - Link to v1: https://lore.kernel.org/r/20260826082641.2007658-1-zhaonanzhe@xiaomi.com
>
> Many thanks to Chao and Daeho for your extensive reviews and valuable
> suggestions!
>
> Nanzhe Zhao (14):
> 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: 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 | 2 +
> fs/f2fs/compress.c | 3 +
> fs/f2fs/data.c | 1221 +++++++++++++++++++++++++---
> fs/f2fs/f2fs.h | 105 ++-
> fs/f2fs/file.c | 229 ++++--
> fs/f2fs/gc.c | 32 +-
> fs/f2fs/inline.c | 7 +
> fs/f2fs/inode.c | 4 +-
> fs/f2fs/namei.c | 1 +
> fs/f2fs/node.c | 2 +
> fs/f2fs/segment.c | 6 +-
> 12 files changed, 1404 insertions(+), 218 deletions(-)
>
> --
> 2.43.0
>
>
>
> _______________________________________________
> Linux-f2fs-devel mailing list
> Linux-f2fs-devel@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread* [f2fs-dev] 答复: [External Mail]Re: [PATCH v2 00/14] f2fs: support & optimize large folios for writable files
2026-09-30 17:08 ` [f2fs-dev] [PATCH v2 00/14] f2fs: support & optimize large folios for writable files Jaegeuk Kim via Linux-f2fs-devel
@ 2026-10-03 13:40 ` 赵南哲 via Linux-f2fs-devel
0 siblings, 0 replies; 40+ messages in thread
From: 赵南哲 via Linux-f2fs-devel @ 2026-10-03 13:40 UTC (permalink / raw)
To: Jaegeuk Kim
Cc: Barry Song, Juan Yescas, Dev Jain, linux-kernel@vger.kernel.org,
David Hildenbrand, linux-f2fs-devel@lists.sourceforge.net,
张博, Kalesh Singh, Nanzhe Zhao,
李鹏飞, Ryan Roberts
Hi Jaeguk:
Oh......, I'm on holiday from Oct 1 to Oct 7,so the next version may not be
that soon and I apologize fot that. I'will catch on that once I've got time.
Thanks,
Nanzhe
#/******本邮件及其附件含有小米公司的保密信息，仅限于发送给上面地址中列出的个人或群组。禁止任何其他人以任何形式使用（包括但不限于全部或部分地泄露、复制、或散发）本邮件中的信息。如果您错收了本邮件，请您立即电话或邮件通知发件人并删除本邮件！ This e-mail and its attachments contain confidential information from XIAOMI, which is intended only for the person or entity whose address is listed above. Any use of the information contained herein in any way (including, but not limited to, total or partial disclosure, reproduction, or dissemination) by persons other than the intended recipient(s) is prohibited. If you receive this e-mail in error, please notify the sender by phone or email immediately and delete it!******/#
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 40+ messages in thread