[f2fs-dev] [RFC PATCH v2 07/10] f2fs: make GC migration large-folio aware
From: Nanzhe Zhao
Date: Mon Jun 22 2026 - 12:16:54 EST
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@xxxxxxxxxx>
---
fs/f2fs/data.c | 93 ++++++++++++++++++++++++++++++++++++--------------
fs/f2fs/f2fs.h | 1 +
fs/f2fs/gc.c | 30 ++++++++++++++--
3 files changed, 97 insertions(+), 27 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index c37800befa1e..a53fe68640d9 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1239,19 +1239,31 @@ 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 (folio_has_ffs(folio)) {
+ struct f2fs_folio_state *ffs = folio->private;
+ unsigned long flags;
+
+ offset = offset_in_folio(folio, (loff_t)index << PAGE_SHIFT);
+ spin_lock_irqsave(&ffs->state_lock, flags);
+ ffs->read_pages_pending++;
+ spin_unlock_irqrestore(&ffs->state_lock, flags);
+ }
+
+ 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);
@@ -1363,20 +1375,13 @@ 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);
-
- f2fs_folio_put(folio, true);
- invalidate_inode_pages2_range(mapping, folio_index,
- folio_index + folio_nr_pages(folio) - 1);
- f2fs_schedule_timeout(DEFAULT_SCHEDULE_TIMEOUT);
- goto retry;
- }
+ if (folio_test_large(folio))
+ ffs_find_or_alloc(folio);
if (f2fs_lookup_read_extent_cache_block(inode, index,
&dn.data_blkaddr)) {
@@ -1411,7 +1416,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 (ffs_test_blk_uptodate(folio, index)) {
folio_unlock(folio);
return folio;
}
@@ -1424,15 +1429,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);
+ 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:
@@ -1449,7 +1456,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 (ffs_test_blk_uptodate(folio, index))
return folio;
f2fs_folio_put(folio, false);
@@ -1458,11 +1465,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 (ffs_test_blk_uptodate(folio, index))
return folio;
folio_wait_locked(folio);
- if (unlikely(!folio_test_uptodate(folio))) {
+ if (unlikely(!ffs_test_blk_uptodate(folio, index))) {
f2fs_folio_put(folio, false);
return ERR_PTR(-EIO);
}
@@ -1486,7 +1493,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 ||
+ !ffs_test_blk_uptodate(folio, index))) {
f2fs_folio_put(folio, true);
return ERR_PTR(-EIO);
}
@@ -2638,6 +2646,24 @@ static void ffs_mark_subrange_uptodate(struct folio *folio, size_t offset,
folio_mark_uptodate(folio);
}
+bool ffs_test_blk_dirty(const struct folio *folio, pgoff_t index)
+{
+ struct f2fs_folio_state *ffs;
+ size_t offset;
+ unsigned int idx, nr_subpages;
+
+ if (!folio_has_ffs(folio))
+ return folio_test_dirty(folio);
+
+ ffs = folio->private;
+ offset = offset_in_folio(folio, (loff_t)index << PAGE_SHIFT);
+ idx = offset >> PAGE_SHIFT;
+ nr_subpages = folio_nr_pages(folio);
+ if (idx >= nr_subpages)
+ return false;
+ return test_bit(nr_subpages + idx, ffs->state);
+}
+
void ffs_mark_subrange_dirty(struct folio *folio, size_t offset, size_t len)
{
struct f2fs_folio_state *ffs;
@@ -2673,6 +2699,23 @@ static bool __ffs_clear_subrange_dirty(struct folio *folio,
2 * nr_subpages;
}
+bool 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 (!folio_has_ffs(folio))
+ return false;
+
+ 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;
+}
+
void ffs_clear_subrange_dirty(struct folio *folio, size_t offset, size_t len)
{
struct f2fs_folio_state *ffs;
@@ -4862,7 +4905,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 1d2e40a42263..38680b729359 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -4257,6 +4257,7 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted,
int compr_blocks, bool allow_balance);
bool ffs_test_blk_uptodate(const struct folio *folio, pgoff_t index);
struct f2fs_folio_state *ffs_find_or_alloc(struct folio *folio);
+bool ffs_test_blk_dirty(const struct folio *folio, pgoff_t index);
void ffs_mark_subrange_dirty(struct folio *folio, size_t offset, size_t len);
bool 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 ffaa7ba76a1b..3c0e9009e02d 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1510,12 +1510,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 (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;
@@ -1530,6 +1537,8 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
err = -EAGAIN;
goto out;
}
+ if (large)
+ ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
folio_mark_dirty(folio);
folio_set_f2fs_gcing(folio);
} else {
@@ -1542,32 +1551,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,
+ .idx = bidx - folio->index,
+ .cnt = 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 = ffs_test_blk_dirty(folio, bidx);
retry:
f2fs_folio_wait_writeback(folio, DATA, true, true);
+ if (large) {
+ ffs = folio->private;
+ 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 &&
+ 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)
+ ffs_mark_subrange_dirty(folio, foff, PAGE_SIZE);
folio_mark_dirty(folio);
+ }
}
}
out:
--
2.34.1