f2fs: Convert move_data_page() to use a folio

Fetch a folio from the page cache and use it throughout, saving
eight hidden calls to compound_head().

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index faf9fa1c804d76b61f82cfa77f72b0173d38d7e0..d0fffa2bd9f057a9cc88bd27f4f2fedaf46f4ea4 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1449,14 +1449,14 @@ out:
 }
 
 static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
-                                                       unsigned int segno, int off)
+                                               unsigned int segno, int off)
 {
-       struct page *page;
+       struct folio *folio;
        int err = 0;
 
-       page = f2fs_get_lock_data_page(inode, bidx, true);
-       if (IS_ERR(page))
-               return PTR_ERR(page);
+       folio = f2fs_get_lock_data_folio(inode, bidx, true);
+       if (IS_ERR(folio))
+               return PTR_ERR(folio);
 
        if (!check_valid_map(F2FS_I_SB(inode), segno, off)) {
                err = -ENOENT;
@@ -1468,12 +1468,12 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
                goto out;
 
        if (gc_type == BG_GC) {
-               if (folio_test_writeback(page_folio(page))) {
+               if (folio_test_writeback(folio)) {
                        err = -EAGAIN;
                        goto out;
                }
-               set_page_dirty(page);
-               set_page_private_gcing(page);
+               folio_mark_dirty(folio);
+               set_page_private_gcing(&folio->page);
        } else {
                struct f2fs_io_info fio = {
                        .sbi = F2FS_I_SB(inode),
@@ -1483,37 +1483,37 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
                        .op = REQ_OP_WRITE,
                        .op_flags = REQ_SYNC,
                        .old_blkaddr = NULL_ADDR,
-                       .page = page,
+                       .page = &folio->page,
                        .encrypted_page = NULL,
                        .need_lock = LOCK_REQ,
                        .io_type = FS_GC_DATA_IO,
                };
-               bool is_dirty = PageDirty(page);
+               bool is_dirty = folio_test_dirty(folio);
 
 retry:
-               f2fs_wait_on_page_writeback(page, DATA, true, true);
+               f2fs_folio_wait_writeback(folio, DATA, true, true);
 
-               set_page_dirty(page);
-               if (clear_page_dirty_for_io(page)) {
+               folio_mark_dirty(folio);
+               if (folio_clear_dirty_for_io(folio)) {
                        inode_dec_dirty_pages(inode);
                        f2fs_remove_dirty_inode(inode);
                }
 
-               set_page_private_gcing(page);
+               set_page_private_gcing(&folio->page);
 
                err = f2fs_do_write_data_page(&fio);
                if (err) {
-                       clear_page_private_gcing(page);
+                       clear_page_private_gcing(&folio->page);
                        if (err == -ENOMEM) {
                                memalloc_retry_wait(GFP_NOFS);
                                goto retry;
                        }
                        if (is_dirty)
-                               set_page_dirty(page);
+                               folio_mark_dirty(folio);
                }
        }
 out:
-       f2fs_put_page(page, 1);
+       f2fs_folio_put(folio, true);
        return err;
 }