From: Nanzhe Zhao <nzzhao.sigma@gmail.com>
To: linux-f2fs-devel@lists.sourceforge.net,
Jaegeuk Kim <jaegeuk@kernel.org>, Chao Yu <chao@kernel.org>
Cc: Barry Song <baohua@kernel.org>, Juan Yescas <jyescas@google.com>,
Daeho Jeong <daehojeong@google.com>,
Pengfei Li <lipengfei28@xiaomi.com>, Dev Jain <Dev.Jain@arm.com>,
David Hildenbrand <David.Hildenbrand@arm.com>,
linux-kernel@vger.kernel.org, Bo Zhang <zhangbo56@xiaomi.com>,
Kalesh Singh <kaleshsingh@google.com>,
Nanzhe Zhao <nzzhao@126.com>, Nanzhe Zhao <zhaonanzhe@xiaomi.com>,
Ryan Roberts <Ryan.Roberts@arm.com>
Subject: [PATCH v6 08/15] f2fs: make GC migration large-folio aware
Date: Thu, 22 Oct 2026 15:53:35 +0800 [thread overview]
Message-ID: <20261022075343.3043003-9-nzzhao.sigma@gmail.com> (raw)
In-Reply-To: <20261022075343.3043003-1-nzzhao.sigma@gmail.com>
From: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
GC can operate on a 4K block that is cached inside a large folio.
The data lookup helpers therefore need to test and update uptodate
state for the addressed subpage instead of rejecting large folios or
treating the whole folio as the target block.
Let f2fs_get_read_data_folio() and f2fs_get_lock_data_folio() to use
subpage uptodate state. Submit single-block reads at the requested
folio offset and zero only the addressed 4K range for NEW_ADDR.
Also update `move_data_page` to mark, clear, and restore dirty
state for the target subpage, and submit write I/O with the subpage
offset recorded in f2fs_io_info.
The write_pages_pending reference is taken by f2fs_do_write_data_page()
and dropped from its common error path, so a block that is truncated
concurrently no longer leaks the counter.
Reported-by: kernel test robot <yi1.lai@intel.com>
Closes: https://lore.kernel.org/oe-lkp/202610081027.b13dcf10-lkp@intel.com
Signed-off-by: Nanzhe Zhao <zhaonanzhe@xiaomi.com>
---
fs/f2fs/data.c | 63 ++++++++++++++++++++++++++++++++++-------------
fs/f2fs/f2fs.h | 1 +
fs/f2fs/gc.c | 29 ++++++++++++++++++----
fs/f2fs/segment.c | 2 +-
4 files changed, 72 insertions(+), 23 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index f415c3eb4e78..5671395130b2 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1679,20 +1679,16 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
struct dnode_of_data dn;
struct folio *folio;
int err;
-retry:
+
folio = f2fs_grab_cache_folio(mapping, index, for_write);
if (IS_ERR(folio))
return folio;
if (folio_test_large(folio)) {
- pgoff_t folio_index = mapping_align_index(mapping, index);
- unsigned long nr_pages = folio_nr_pages(folio);
-
- f2fs_folio_put(folio, true);
- invalidate_inode_pages2_range(mapping, folio_index,
- folio_index + nr_pages - 1);
- f2fs_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
- goto retry;
+ if (!f2fs_ffs_find_or_alloc(folio)) {
+ err = -ENOMEM;
+ goto put_err;
+ }
}
if (f2fs_lookup_read_extent_cache_block(inode, index,
@@ -1728,7 +1724,7 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
goto put_err;
}
got_it:
- if (folio_test_uptodate(folio)) {
+ if (f2fs_ffs_test_blk_uptodate(folio, index)) {
folio_unlock(folio);
return folio;
}
@@ -1741,9 +1737,11 @@ struct folio *f2fs_get_read_data_folio(struct inode *inode, pgoff_t index,
* f2fs_init_inode_metadata.
*/
if (dn.data_blkaddr == NEW_ADDR) {
- folio_zero_segment(folio, 0, folio_size(folio));
- if (!folio_test_uptodate(folio))
- folio_mark_uptodate(folio);
+ size_t offset = offset_in_folio(folio,
+ (loff_t)index << PAGE_SHIFT);
+
+ folio_zero_segment(folio, offset, offset + PAGE_SIZE);
+ f2fs_ffs_mark_subrange_uptodate(folio, offset, PAGE_SIZE);
folio_unlock(folio);
return folio;
}
@@ -1803,7 +1801,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);
}
@@ -2952,6 +2951,22 @@ static void f2fs_ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
folio_mark_uptodate(folio);
}
+bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
+{
+ struct f2fs_folio_state *ffs;
+ unsigned int idx, nr_subpages;
+
+ f2fs_bug_on(F2FS_F_SB(folio), !folio_contains(folio, index));
+
+ if (!f2fs_folio_has_ffs(folio))
+ return folio_test_dirty(folio);
+
+ ffs = (struct f2fs_folio_state *)folio->private;
+ nr_subpages = folio_nr_pages(folio);
+ idx = index - folio->index;
+ return test_bit(nr_subpages + idx, ffs->state);
+}
+
static unsigned int __ffs_mark_subrange_dirty(struct folio *folio,
struct f2fs_folio_state *ffs, size_t offset, size_t len)
{
@@ -3045,7 +3060,6 @@ bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
return dirty;
}
-
static unsigned int ffs_next_dirty_subpage(struct f2fs_folio_state *ffs,
const struct folio *folio, unsigned int start,
unsigned int end)
@@ -3543,7 +3557,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)))
@@ -3569,8 +3583,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
struct dnode_of_data dn;
struct node_info ni;
struct f2fs_lock_context lc;
+ struct f2fs_folio_state *ffs;
bool ipu_force = false;
bool atomic_commit;
+ bool pending_added = false;
+ bool submitted = false;
int err = 0;
/* Use COW inode to make dnode_of_data for atomic write */
@@ -3612,7 +3629,6 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
/* This page is already truncated */
if (fio->old_blkaddr == NULL_ADDR) {
folio_clear_uptodate(folio);
- folio_clear_f2fs_gcing(folio);
goto out_writepage;
}
got_it:
@@ -3662,6 +3678,11 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
fio->version = ni.version;
__folio_start_writeback(folio, folio_test_dirty(folio));
+ if (f2fs_folio_has_ffs(folio)) {
+ ffs = (struct f2fs_folio_state *)folio->private;
+ atomic_inc(&ffs->write_pages_pending);
+ pending_added = true;
+ }
if (fio->compr_blocks && fio->old_blkaddr == COMPRESS_ADDR)
f2fs_i_compr_blocks_update(inode, fio->compr_blocks - 1, false);
@@ -3676,6 +3697,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
err = -EIO;
goto out_writepage;
}
+ submitted = true;
set_inode_flag(inode, FI_APPEND_WRITE);
if (atomic_commit)
folio_clear_f2fs_atomic(folio);
@@ -3684,6 +3706,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
out:
if (fio->need_lock == LOCK_REQ)
f2fs_unlock_op(fio->sbi, &lc);
+ if (!submitted) {
+ if (pending_added) {
+ f2fs_ffs_put_write_pending(folio, 1);
+ } else if (!f2fs_ffs_has_dirty_subpage(folio)) {
+ folio_clear_f2fs_gcing(folio);
+ }
+ }
return err;
}
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 915ca72cf276..1b63dd961f15 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4493,6 +4493,7 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted,
int compr_blocks, bool allow_balance);
bool f2fs_ffs_test_blk_uptodate(const struct folio *folio, pgoff_t index);
struct f2fs_folio_state *f2fs_ffs_find_or_alloc(struct folio *folio);
+bool f2fs_ffs_test_blk_dirty(const struct folio *folio, pgoff_t index);
void f2fs_ffs_mark_subrange_dirty(struct folio *folio, size_t offset, size_t len);
bool f2fs_ffs_clear_subrange_dirty_and_test(struct folio *folio, size_t offset,
size_t len);
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 67a4224a5d75..c3e01f6811b4 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1520,12 +1520,19 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
unsigned int segno, int off)
{
struct folio *folio;
+ size_t foff = 0;
+ bool large = false;
int err = 0;
folio = f2fs_get_lock_data_folio(inode, bidx, true);
if (IS_ERR(folio))
return PTR_ERR(folio);
+ if (f2fs_folio_has_ffs(folio)) {
+ large = true;
+ foff = offset_in_folio(folio, (loff_t)bidx << PAGE_SHIFT);
+ }
+
if (!check_valid_map(F2FS_I_SB(inode), segno, off)) {
err = -ENOENT;
goto out;
@@ -1540,6 +1547,8 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
err = -EAGAIN;
goto out;
}
+ if (large)
+ f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
folio_mark_dirty(folio);
folio_set_f2fs_gcing(folio);
} else {
@@ -1552,33 +1561,43 @@ 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);
+ bool is_dirty = f2fs_ffs_test_blk_dirty(folio, bidx);
retry:
f2fs_folio_wait_writeback(folio, true, true);
+ if (large)
+ f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
folio_mark_dirty(folio);
if (folio_clear_dirty_for_io(folio)) {
- inode_dec_dirty_block(inode);
- f2fs_remove_dirty_inode(inode);
+ if (!large) {
+ inode_dec_dirty_block(inode);
+ f2fs_remove_dirty_inode(inode);
+ } else if (f2fs_ffs_clear_subrange_dirty_and_test(folio,
+ foff, PAGE_SIZE)) {
+ folio_mark_dirty(folio);
+ }
}
folio_set_f2fs_gcing(folio);
err = f2fs_do_write_data_page(&fio);
if (err) {
- folio_clear_f2fs_gcing(folio);
if (err == -ENOMEM) {
memalloc_retry_wait(GFP_NOFS);
goto retry;
}
- if (is_dirty)
+ if (is_dirty) {
+ if (large)
+ f2fs_ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
folio_mark_dirty(folio);
+ }
}
}
out:
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index cbb65e0343c8..e017a5f2a67f 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -3863,7 +3863,7 @@ static int __get_segment_type_6(struct f2fs_io_info *fio)
if (is_inode_flag_set(inode, FI_ALIGNED_WRITE))
return CURSEG_COLD_DATA_PINNED;
- if (page_private_gcing(fio->page)) {
+ if (folio_test_f2fs_gcing(fio->folio)) {
if (fio->sbi->am.atgc_enabled &&
(fio->io_type == FS_DATA_IO) &&
(fio->sbi->gc_mode != GC_URGENT_HIGH) &&
--
2.43.0
next prev parent reply other threads:[~2026-10-22 7:54 UTC|newest]
Thread overview: 16+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-10-22 7:53 [PATCH v6 00/15] f2fs: support & optimize large folios for writable files Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 01/15] f2fs: extend folio state for large folio write path Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 02/15] f2fs: carry subpage offset and count in write IO Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 03/15] f2fs: support regular file buffered writes on large folios Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 04/15] f2fs: support atomic file large folios buffered write Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 05/15] f2fs: support large folio writeback Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 06/15] f2fs: account large folio dirty data at block granularity Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 07/15] f2fs: prepare mmap write faults for large folios Nanzhe Zhao
2026-10-22 7:53 ` Nanzhe Zhao [this message]
2026-10-22 7:53 ` [PATCH v6 09/15] f2fs: optimize small block size large folio read Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 10/15] f2fs: support partial uptodate " Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 11/15] f2fs: handle partial truncate of large folio dirty subpages Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 12/15] f2fs: fix zeroing paths for large folios Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 13/15] f2fs: handle block cloning within the same large folio Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 14/15] f2fs: allow large folio support to writeable files Nanzhe Zhao
2026-10-22 7:53 ` [PATCH v6 15/15] f2fs: make compressed files compatible with large folio Nanzhe Zhao
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261022075343.3043003-9-nzzhao.sigma@gmail.com \
--to=nzzhao.sigma@gmail.com \
--cc=David.Hildenbrand@arm.com \
--cc=Dev.Jain@arm.com \
--cc=Ryan.Roberts@arm.com \
--cc=baohua@kernel.org \
--cc=chao@kernel.org \
--cc=daehojeong@google.com \
--cc=jaegeuk@kernel.org \
--cc=jyescas@google.com \
--cc=kaleshsingh@google.com \
--cc=linux-f2fs-devel@lists.sourceforge.net \
--cc=linux-kernel@vger.kernel.org \
--cc=lipengfei28@xiaomi.com \
--cc=nzzhao@126.com \
--cc=zhangbo56@xiaomi.com \
--cc=zhaonanzhe@xiaomi.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®