f2fs: Add folio counterparts to page_private_flags functions

Name these new functions folio_test_f2fs_*(), folio_set_f2fs_*() and
folio_clear_f2fs_*().  Convert all callers which currently have a folio
and cast back to a page.

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/checkpoint.c b/fs/f2fs/checkpoint.c
index 07ca10c666491d8455bed31094cc4e97ee8a5a08..db3831f7f2f5aae6b607c3d39f515f4d69930a5e 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -485,7 +485,7 @@ static bool f2fs_dirty_meta_folio(struct address_space *mapping,
                folio_mark_uptodate(folio);
        if (filemap_dirty_folio(mapping, folio)) {
                inc_page_count(F2FS_M_SB(mapping), F2FS_DIRTY_META);
-               set_page_private_reference(&folio->page);
+               folio_set_f2fs_reference(folio);
                return true;
        }
        return false;
@@ -1045,7 +1045,7 @@ void f2fs_update_dirty_folio(struct inode *inode, struct folio *folio)
        inode_inc_dirty_pages(inode);
        spin_unlock(&sbi->inode_lock[type]);
 
-       set_page_private_reference(&folio->page);
+       folio_set_f2fs_reference(folio);
 }
 
 void f2fs_remove_dirty_inode(struct inode *inode)

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 8a2414ce39ffa4b74e62116859787df1f9bab69c..f3e11f5672ecff3e173726068d79df57a631deb3 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -360,7 +360,7 @@ static void f2fs_write_end_io(struct bio *bio)
                dec_page_count(sbi, type);
                if (f2fs_in_warm_node_list(sbi, folio))
                        f2fs_del_fsync_node_entry(sbi, folio);
-               clear_page_private_gcing(&folio->page);
+               folio_clear_f2fs_gcing(folio);
                folio_end_writeback(folio);
        }
        if (!get_pages(sbi, F2FS_WB_CP_DATA) &&
@@ -2659,7 +2659,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
 
        /* Use COW inode to make dnode_of_data for atomic write */
        atomic_commit = f2fs_is_atomic_file(inode) &&
-                               page_private_atomic(folio_page(folio, 0));
+                               folio_test_f2fs_atomic(folio);
        if (atomic_commit)
                set_new_dnode(&dn, F2FS_I(inode)->cow_inode, NULL, NULL, 0);
        else
@@ -2690,7 +2690,7 @@ 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);
-               clear_page_private_gcing(folio_page(folio, 0));
+               folio_clear_f2fs_gcing(folio);
                goto out_writepage;
        }
 got_it:
@@ -2760,7 +2760,7 @@ got_it:
        trace_f2fs_do_write_data_page(folio, OPU);
        set_inode_flag(inode, FI_APPEND_WRITE);
        if (atomic_commit)
-               clear_page_private_atomic(folio_page(folio, 0));
+               folio_clear_f2fs_atomic(folio);
 out_writepage:
        f2fs_put_dnode(&dn);
 out:
@@ -3383,7 +3383,7 @@ restart:
                        f2fs_do_read_inline_data(folio, ifolio);
                        set_inode_flag(inode, FI_DATA_EXIST);
                        if (inode->i_nlink)
-                               set_page_private_inline(&ifolio->page);
+                               folio_set_f2fs_inline(ifolio);
                        goto out;
                }
                err = f2fs_convert_inline_folio(&dn, folio);
@@ -3703,7 +3703,7 @@ static int f2fs_write_end(struct file *file,
        folio_mark_dirty(folio);
 
        if (f2fs_is_atomic_file(inode))
-               set_page_private_atomic(folio_page(folio, 0));
+               folio_set_f2fs_atomic(folio);
 
        if (pos + copied > i_size_read(inode) &&
            !f2fs_verity_in_progress(inode)) {

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 09ddc0626dfee5c6b23a8f92e0ee4df8564d201c..0e607305e308fe939d265508efac1414080f505b 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2461,6 +2461,13 @@ release_quota:
 }
 
 #define PAGE_PRIVATE_GET_FUNC(name, flagname) \
+static inline bool folio_test_f2fs_##name(const struct folio *folio)   \
+{                                                                      \
+       unsigned long priv = (unsigned long)folio->private;             \
+       unsigned long v = (1UL << PAGE_PRIVATE_NOT_POINTER) |           \
+                            (1UL << PAGE_PRIVATE_##flagname);          \
+       return (priv & v) == v;                                         \
+}                                                                      \
 static inline bool page_private_##name(struct page *page) \
 { \
        return PagePrivate(page) && \
@@ -2469,6 +2476,17 @@ static inline bool page_private_##name(struct page *page) \
 }
 
 #define PAGE_PRIVATE_SET_FUNC(name, flagname) \
+static inline void folio_set_f2fs_##name(struct folio *folio)          \
+{                                                                      \
+       unsigned long v = (1UL << PAGE_PRIVATE_NOT_POINTER) |           \
+                            (1UL << PAGE_PRIVATE_##flagname);          \
+       if (!folio->private)                                            \
+               folio_attach_private(folio, (void *)v);                 \
+       else {                                                          \
+               v |= (unsigned long)folio->private;                     \
+               folio->private = (void *)v;                             \
+       }                                                               \
+}                                                                      \
 static inline void set_page_private_##name(struct page *page) \
 { \
        if (!PagePrivate(page)) \
@@ -2478,6 +2496,16 @@ static inline void set_page_private_##name(struct page *page) \
 }
 
 #define PAGE_PRIVATE_CLEAR_FUNC(name, flagname) \
+static inline void folio_clear_f2fs_##name(struct folio *folio)                \
+{                                                                      \
+       unsigned long v = (unsigned long)folio->private;                \
+                                                                       \
+       v &= ~(1UL << PAGE_PRIVATE_##flagname);                         \
+       if (v == (1UL << PAGE_PRIVATE_NOT_POINTER))                     \
+               folio_detach_private(folio);                            \
+       else                                                            \
+               folio->private = (void *)v;                             \
+}                                                                      \
 static inline void clear_page_private_##name(struct page *page) \
 { \
        clear_bit(PAGE_PRIVATE_##flagname, &page_private(page)); \

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 36b32757d5b9cc5dcb50c0a056158b2d4f9b4afc..4039ccb5022cfbdfbfb88181491fce2fefccb391 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1463,7 +1463,7 @@ static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode,
 
                        memcpy_folio(fdst, 0, fsrc, 0, PAGE_SIZE);
                        folio_mark_dirty(fdst);
-                       set_page_private_gcing(&fdst->page);
+                       folio_set_f2fs_gcing(fdst);
                        f2fs_folio_put(fdst, true);
                        f2fs_folio_put(fsrc, true);
 
@@ -2987,7 +2987,7 @@ do_map:
                        f2fs_folio_wait_writeback(folio, DATA, true, true);
 
                        folio_mark_dirty(folio);
-                       set_page_private_gcing(&folio->page);
+                       folio_set_f2fs_gcing(folio);
                        f2fs_folio_put(folio, true);
 
                        idx++;
@@ -4424,7 +4424,7 @@ static int redirty_blocks(struct inode *inode, pgoff_t page_idx, int len)
                f2fs_folio_wait_writeback(folio, DATA, true, true);
 
                folio_mark_dirty(folio);
-               set_page_private_gcing(&folio->page);
+               folio_set_f2fs_gcing(folio);
                redirty_idx = folio_next_index(folio);
                folio_unlock(folio);
                folio_put_refs(folio, 2);

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index c1d4ecbd2505d7b33db60f1f5405b544a83fc1d3..271c7f90741b65444362afa331aa3af612480005 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1473,7 +1473,7 @@ static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
                        goto out;
                }
                folio_mark_dirty(folio);
-               set_page_private_gcing(&folio->page);
+               folio_set_f2fs_gcing(folio);
        } else {
                struct f2fs_io_info fio = {
                        .sbi = F2FS_I_SB(inode),
@@ -1499,11 +1499,11 @@ retry:
                        f2fs_remove_dirty_inode(inode);
                }
 
-               set_page_private_gcing(&folio->page);
+               folio_set_f2fs_gcing(folio);
 
                err = f2fs_do_write_data_page(&fio);
                if (err) {
-                       clear_page_private_gcing(&folio->page);
+                       folio_clear_f2fs_gcing(folio);
                        if (err == -ENOMEM) {
                                memalloc_retry_wait(GFP_NOFS);
                                goto retry;

diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 51adc43d5a5c9ee8c3a709750ccb0284b317c7d6..58ac831ef704eaadc9723f5c655f210acc78e992 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -206,7 +206,7 @@ int f2fs_convert_inline_folio(struct dnode_of_data *dn, struct folio *folio)
 
        /* clear inline data and flag after data writeback */
        f2fs_truncate_inline_inode(dn->inode, dn->inode_folio, 0);
-       clear_page_private_inline(&dn->inode_folio->page);
+       folio_clear_f2fs_inline(dn->inode_folio);
 clear_out:
        stat_dec_inline_inode(dn->inode);
        clear_inode_flag(dn->inode, FI_INLINE_DATA);
@@ -286,7 +286,7 @@ int f2fs_write_inline_data(struct inode *inode, struct folio *folio)
        set_inode_flag(inode, FI_APPEND_WRITE);
        set_inode_flag(inode, FI_DATA_EXIST);
 
-       clear_page_private_inline(&ifolio->page);
+       folio_clear_f2fs_inline(ifolio);
        f2fs_folio_put(ifolio, 1);
        return 0;
 }

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index dd3b43c24831b5524bf6fef75aef91839af185f5..cc9bea5b97f3abef6388caa38c7bcd96e1d78d95 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -749,7 +749,7 @@ void f2fs_update_inode(struct inode *inode, struct folio *node_folio)
 
        /* deleted inode */
        if (inode->i_nlink == 0)
-               clear_page_private_inline(&node_folio->page);
+               folio_clear_f2fs_inline(node_folio);
 
        init_idisk_time(inode);
 #ifdef CONFIG_F2FS_CHECK_FS

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index 908a1eb9c4155e00c20b8f6b54b031fdb3644a0a..f1c6c0c8ee741f14c00e99a37940c20f9e427541 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1985,8 +1985,8 @@ void f2fs_flush_inline_data(struct f2fs_sb_info *sbi)
                                goto unlock;
 
                        /* flush inline_data, if it's async context. */
-                       if (page_private_inline(&folio->page)) {
-                               clear_page_private_inline(&folio->page);
+                       if (folio_test_f2fs_inline(folio)) {
+                               folio_clear_f2fs_inline(folio);
                                folio_unlock(folio);
                                flush_inline_data(sbi, ino_of_node(folio));
                                continue;
@@ -2067,8 +2067,8 @@ continue_unlock:
                                goto write_node;
 
                        /* flush inline_data */
-                       if (page_private_inline(&folio->page)) {
-                               clear_page_private_inline(&folio->page);
+                       if (folio_test_f2fs_inline(folio)) {
+                               folio_clear_f2fs_inline(folio);
                                folio_unlock(folio);
                                flush_inline_data(sbi, ino_of_node(folio));
                                goto lock_node;
@@ -2216,7 +2216,7 @@ static bool f2fs_dirty_node_folio(struct address_space *mapping,
 #endif
        if (filemap_dirty_folio(mapping, folio)) {
                inc_page_count(F2FS_M_SB(mapping), F2FS_DIRTY_NODES);
-               set_page_private_reference(&folio->page);
+               folio_set_f2fs_reference(folio);
                return true;
        }
        return false;