f2fs: Pass a folio to IS_INODE()

All callers now have a folio so pass it in.  Also make it const to help
the compiler.

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/f2fs.h b/fs/f2fs/f2fs.h
index 3933327d8cc3f00530dd7329c4bd86918689c7d8..09ddc0626dfee5c6b23a8f92e0ee4df8564d201c 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -3019,9 +3019,9 @@ static inline void f2fs_radix_tree_insert(struct radix_tree_root *root,
 
 #define RAW_IS_INODE(p)        ((p)->footer.nid == (p)->footer.ino)
 
-static inline bool IS_INODE(struct page *page)
+static inline bool IS_INODE(const struct folio *folio)
 {
-       struct f2fs_node *p = F2FS_NODE(page);
+       struct f2fs_node *p = F2FS_NODE(&folio->page);
 
        return RAW_IS_INODE(p);
 }
@@ -3041,7 +3041,7 @@ static inline int f2fs_has_extra_attr(struct inode *inode);
 static inline unsigned int get_dnode_base(struct inode *inode,
                                        struct folio *node_folio)
 {
-       if (!IS_INODE(&node_folio->page))
+       if (!IS_INODE(node_folio))
                return 0;
 
        return inode ? get_extra_isize(inode) :

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 60618c52ba50c2a107ec495ee44c750f260fc6c1..36b32757d5b9cc5dcb50c0a056158b2d4f9b4afc 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -819,7 +819,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
        count -= dn.ofs_in_node;
        f2fs_bug_on(sbi, count < 0);
 
-       if (dn.ofs_in_node || IS_INODE(&dn.node_folio->page)) {
+       if (dn.ofs_in_node || IS_INODE(dn.node_folio)) {
                f2fs_truncate_data_blocks_range(&dn, count);
                free_from += count;
        }

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 781b955cbb774e36acfa7cbc7922713a7eb5a77c..c1d4ecbd2505d7b33db60f1f5405b544a83fc1d3 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -1162,7 +1162,7 @@ static bool is_alive(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
                return false;
        }
 
-       if (IS_INODE(&node_folio->page)) {
+       if (IS_INODE(node_folio)) {
                base = offset_in_addr(F2FS_INODE(node_folio));
                max_addrs = DEF_ADDRS_PER_INODE;
        } else {

diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 9851310cdb87eb547976409101b965efb66658d1..51adc43d5a5c9ee8c3a709750ccb0284b317c7d6 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -305,7 +305,7 @@ int f2fs_recover_inline_data(struct inode *inode, struct folio *nfolio)
         *    x       o  -> remove data blocks, and then recover inline_data
         *    x       x  -> recover data blocks
         */
-       if (IS_INODE(&nfolio->page))
+       if (IS_INODE(nfolio))
                ri = F2FS_INODE(nfolio);
 
        if (f2fs_has_inline_data(inode) &&

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index a8f64d206d19660fcb1411fc5e60886fd52ededc..dd3b43c24831b5524bf6fef75aef91839af185f5 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -124,7 +124,7 @@ bool f2fs_enable_inode_chksum(struct f2fs_sb_info *sbi, struct folio *folio)
        if (!f2fs_sb_has_inode_chksum(sbi))
                return false;
 
-       if (!IS_INODE(&folio->page) || !(ri->i_inline & F2FS_EXTRA_ATTR))
+       if (!IS_INODE(folio) || !(ri->i_inline & F2FS_EXTRA_ATTR))
                return false;
 
        if (!F2FS_FITS_IN_INODE(ri, le16_to_cpu(ri->i_extra_isize),

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index b56e627e0b5642d01320dccd8082ad7cf003d14a..908a1eb9c4155e00c20b8f6b54b031fdb3644a0a 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -973,7 +973,7 @@ static int truncate_dnode(struct dnode_of_data *dn)
        else if (IS_ERR(folio))
                return PTR_ERR(folio);
 
-       if (IS_INODE(&folio->page) || ino_of_node(folio) != dn->inode->i_ino) {
+       if (IS_INODE(folio) || ino_of_node(folio) != dn->inode->i_ino) {
                f2fs_err(sbi, "incorrect node reference, ino: %lu, nid: %u, ino_of_node: %u",
                                dn->inode->i_ino, dn->nid, ino_of_node(folio));
                set_sbi_flag(sbi, SBI_NEED_FSCK);
@@ -1474,10 +1474,8 @@ static int sanity_check_node_footer(struct f2fs_sb_info *sbi,
                                        struct folio *folio, pgoff_t nid,
                                        enum node_type ntype)
 {
-       struct page *page = &folio->page;
-
        if (unlikely(nid != nid_of_node(folio) ||
-               (ntype == NODE_TYPE_INODE && !IS_INODE(page)) ||
+               (ntype == NODE_TYPE_INODE && !IS_INODE(folio)) ||
                (ntype == NODE_TYPE_XATTR &&
                !f2fs_has_xattr_block(ofs_of_node(folio))) ||
                time_to_inject(sbi, FAULT_INCONSISTENT_FOOTER))) {
@@ -1867,7 +1865,7 @@ continue_unlock:
                        if (!atomic || folio == last_folio) {
                                set_fsync_mark(folio, 1);
                                percpu_counter_inc(&sbi->rf_node_block_count);
-                               if (IS_INODE(&folio->page)) {
+                               if (IS_INODE(folio)) {
                                        if (is_inode_flag_set(inode,
                                                                FI_DIRTY_INODE))
                                                f2fs_update_inode(inode, folio);
@@ -1976,7 +1974,7 @@ void f2fs_flush_inline_data(struct f2fs_sb_info *sbi)
                for (i = 0; i < nr_folios; i++) {
                        struct folio *folio = fbatch.folios[i];
 
-                       if (!IS_INODE(&folio->page))
+                       if (!IS_INODE(folio))
                                continue;
 
                        folio_lock(folio);
@@ -2077,7 +2075,7 @@ continue_unlock:
                        }
 
                        /* flush dirty inode */
-                       if (IS_INODE(&folio->page) && flush_dirty_inode(folio))
+                       if (IS_INODE(folio) && flush_dirty_inode(folio))
                                goto lock_node;
 write_node:
                        f2fs_folio_wait_writeback(folio, NODE, true, true);
@@ -2213,7 +2211,7 @@ static bool f2fs_dirty_node_folio(struct address_space *mapping,
        if (!folio_test_uptodate(folio))
                folio_mark_uptodate(folio);
 #ifdef CONFIG_F2FS_CHECK_FS
-       if (IS_INODE(&folio->page))
+       if (IS_INODE(folio))
                f2fs_inode_chksum_set(F2FS_M_SB(mapping), folio);
 #endif
        if (filemap_dirty_folio(mapping, folio)) {

diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 894b27b0329d0c0635d99d30a6eebb4330ab5e81..4cb3a91801b4d5e7d7ddf6fc93f90bff52418457 100644 (file)
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -437,7 +437,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head,
                        bool quota_inode = false;
 
                        if (!check_only &&
-                                       IS_INODE(&folio->page) &&
+                                       IS_INODE(folio) &&
                                        is_dent_dnode(folio)) {
                                err = f2fs_recover_inode_page(sbi, folio);
                                if (err) {
@@ -463,7 +463,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head,
                }
                entry->blkaddr = blkaddr;
 
-               if (IS_INODE(&folio->page) && is_dent_dnode(folio))
+               if (IS_INODE(folio) && is_dent_dnode(folio))
                        entry->last_dentry = blkaddr;
 next:
                /* check next segment */
@@ -628,7 +628,7 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
        int err = 0, recovered = 0;
 
        /* step 1: recover xattr */
-       if (IS_INODE(&folio->page)) {
+       if (IS_INODE(folio)) {
                err = f2fs_recover_inline_xattr(inode, folio);
                if (err)
                        goto out;
@@ -821,7 +821,7 @@ static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list,
                 * In this case, we can lose the latest inode(x).
                 * So, call recover_inode for the inode update.
                 */
-               if (IS_INODE(&folio->page)) {
+               if (IS_INODE(folio)) {
                        err = recover_inode(entry->inode, folio);
                        if (err) {
                                f2fs_folio_put(folio, true);

diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index 25857877eaec08d91ecf5ebd289b037f69337bc5..2f8b8bfc0e73154710d3f55c96bcfbfa43587ddb 100644 (file)
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -268,7 +268,7 @@ struct node_footer {
 /* Node IDs in an Indirect Block */
 #define NIDS_PER_BLOCK         ((F2FS_BLKSIZE - sizeof(struct node_footer)) / sizeof(__le32))
 
-#define ADDRS_PER_PAGE(folio, inode)   (addrs_per_page(inode, IS_INODE(&folio->page)))
+#define ADDRS_PER_PAGE(folio, inode)   (addrs_per_page(inode, IS_INODE(folio)))
 
 #define        NODE_DIR1_BLOCK         (DEF_ADDRS_PER_INODE + 1)
 #define        NODE_DIR2_BLOCK         (DEF_ADDRS_PER_INODE + 2)