From: Nanzhe <[email protected]> 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 <[email protected]> --- fs/f2fs/data.c | 93 ++++++++++++++++++++++++++++++++++++-------------- fs/f2fs/f2fs.h | 3 ++ fs/f2fs/gc.c | 30 ++++++++++++++-- 3 files changed, 99 insertions(+), 27 deletions(-) diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index 346057826835..033b28be2ae7 100644 --- a/fs/f2fs/data.c +++ b/fs/f2fs/data.c @@ -1211,19 +1211,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); @@ -1335,20 +1347,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)) { @@ -1383,7 +1388,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; } @@ -1396,15 +1401,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: @@ -1421,7 +1428,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); @@ -1430,11 +1437,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); } @@ -1458,7 +1465,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); } @@ -2596,6 +2604,24 @@ void ffs_mark_subrange_uptodate(struct folio *folio, size_t offset, size_t len) 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; @@ -2631,6 +2657,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; +} + static void ffs_clear_subrange_dirty(struct folio *folio, size_t offset, size_t len) { @@ -4767,7 +4810,7 @@ static int f2fs_write_begin(const struct kiocb *iocb, f2fs_submit_page_read(use_cow ? F2FS_I(inode)->cow_inode : 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 c9d0e9b41a91..e122e324c300 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -4256,7 +4256,10 @@ int f2fs_write_single_data_page(struct folio *folio, int *submitted, bool ffs_test_blk_uptodate(const struct folio *folio, pgoff_t index); void ffs_mark_subrange_uptodate(struct folio *folio, size_t offset, size_t len); 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); 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/gc.c b/fs/f2fs/gc.c index 69e0a867219d..68dc10a987d9 100644 --- a/fs/f2fs/gc.c +++ b/fs/f2fs/gc.c @@ -1514,12 +1514,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; @@ -1534,6 +1541,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 { @@ -1546,32 +1555,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 _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
