f2fs: convert f2fs_write_begin() to use folio

Convert to use folio, so that we can get rid of 'page->index' to
prepare for removal of 'index' field in structure page [1].

[1] https://lore.kernel.org/all/Zp8fgUSIBGQ1TN0D@casper.infradead.org/

Cc: Matthew Wilcox <willy@infradead.org>
Signed-off-by: Chao Yu <chao@kernel.org>
Reviewed-by: Li Zetao <lizetao1@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 0655fddfc4baf4fd6a5e79c5806644210d7f98e3..85ac05c3655a5890b0fa2c6784f23deaca450dbd 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -3378,11 +3378,11 @@ void f2fs_write_failed(struct inode *inode, loff_t to)
 }
 
 static int prepare_write_begin(struct f2fs_sb_info *sbi,
-                       struct page *page, loff_t pos, unsigned len,
+                       struct folio *folio, loff_t pos, unsigned int len,
                        block_t *blk_addr, bool *node_changed)
 {
-       struct inode *inode = page->mapping->host;
-       pgoff_t index = page->index;
+       struct inode *inode = folio->mapping->host;
+       pgoff_t index = folio->index;
        struct dnode_of_data dn;
        struct page *ipage;
        bool locked = false;
@@ -3419,13 +3419,13 @@ restart:
 
        if (f2fs_has_inline_data(inode)) {
                if (pos + len <= MAX_INLINE_DATA(inode)) {
-                       f2fs_do_read_inline_data(page_folio(page), ipage);
+                       f2fs_do_read_inline_data(folio, ipage);
                        set_inode_flag(inode, FI_DATA_EXIST);
                        if (inode->i_nlink)
                                set_page_private_inline(ipage);
                        goto out;
                }
-               err = f2fs_convert_inline_page(&dn, page);
+               err = f2fs_convert_inline_page(&dn, folio_page(folio, 0));
                if (err || dn.data_blkaddr != NULL_ADDR)
                        goto out;
        }
@@ -3518,12 +3518,12 @@ unlock_out:
 }
 
 static int prepare_atomic_write_begin(struct f2fs_sb_info *sbi,
-                       struct page *page, loff_t pos, unsigned int len,
+                       struct folio *folio, loff_t pos, unsigned int len,
                        block_t *blk_addr, bool *node_changed, bool *use_cow)
 {
-       struct inode *inode = page->mapping->host;
+       struct inode *inode = folio->mapping->host;
        struct inode *cow_inode = F2FS_I(inode)->cow_inode;
-       pgoff_t index = page->index;
+       pgoff_t index = folio->index;
        int err = 0;
        block_t ori_blk_addr = NULL_ADDR;
 
@@ -3566,6 +3566,7 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
        struct inode *inode = mapping->host;
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct page *page = NULL;
+       struct folio *folio;
        pgoff_t index = ((unsigned long long) pos) >> PAGE_SHIFT;
        bool need_balance = false;
        bool use_cow = false;
@@ -3625,22 +3626,23 @@ repeat:
        /* TODO: cluster can be compressed due to race with .writepage */
 
        *pagep = page;
+       folio = page_folio(page);
 
        if (f2fs_is_atomic_file(inode))
-               err = prepare_atomic_write_begin(sbi, page, pos, len,
+               err = prepare_atomic_write_begin(sbi, folio, pos, len,
                                        &blkaddr, &need_balance, &use_cow);
        else
-               err = prepare_write_begin(sbi, page, pos, len,
+               err = prepare_write_begin(sbi, folio, pos, len,
                                        &blkaddr, &need_balance);
        if (err)
                goto fail;
 
        if (need_balance && !IS_NOQUOTA(inode) &&
                        has_not_enough_free_secs(sbi, 0, 0)) {
-               unlock_page(page);
+               folio_unlock(folio);
                f2fs_balance_fs(sbi, true);
-               lock_page(page);
-               if (page->mapping != mapping) {
+               folio_lock(folio);
+               if (folio->mapping != mapping) {
                        /* The page got truncated from under us */
                        f2fs_put_page(page, 1);
                        goto repeat;
@@ -3649,18 +3651,18 @@ repeat:
 
        f2fs_wait_on_page_writeback(page, DATA, false, true);
 
-       if (len == PAGE_SIZE || PageUptodate(page))
+       if (len == PAGE_SIZE || folio_test_uptodate(folio))
                return 0;
 
        if (!(pos & (PAGE_SIZE - 1)) && (pos + len) >= i_size_read(inode) &&
            !f2fs_verity_in_progress(inode)) {
-               zero_user_segment(page, len, PAGE_SIZE);
+               folio_zero_segment(folio, len, folio_size(folio));
                return 0;
        }
 
        if (blkaddr == NEW_ADDR) {
-               zero_user_segment(page, 0, PAGE_SIZE);
-               SetPageUptodate(page);
+               folio_zero_segment(folio, 0, folio_size(folio));
+               folio_mark_uptodate(folio);
        } else {
                if (!f2fs_is_valid_blkaddr(sbi, blkaddr,
                                DATA_GENERIC_ENHANCE_READ)) {
@@ -3669,16 +3671,16 @@ repeat:
                }
                err = f2fs_submit_page_read(use_cow ?
                                F2FS_I(inode)->cow_inode : inode,
-                               page_folio(page), blkaddr, 0, true);
+                               folio, blkaddr, 0, true);
                if (err)
                        goto fail;
 
-               lock_page(page);
-               if (unlikely(page->mapping != mapping)) {
+               folio_lock(folio);
+               if (unlikely(folio->mapping != mapping)) {
                        f2fs_put_page(page, 1);
                        goto repeat;
                }
-               if (unlikely(!PageUptodate(page))) {
+               if (unlikely(!folio_test_uptodate(folio))) {
                        err = -EIO;
                        goto fail;
                }