f2fs: Pass a folio to ino_of_node()

All callers have a folio so pass it in.  Also make the argument const
as the function does not modify it.

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/data.c b/fs/f2fs/data.c
index 40292e4ad3419496ce3b7ea47225e5be631518ef..95db528bcd35e44898da4481d81cb8801f60b2c1 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -574,7 +574,7 @@ static bool __has_merged_page(struct bio *bio, struct inode *inode,
                        return true;
                if (page && page == &target->page)
                        return true;
-               if (ino && ino == ino_of_node(&target->page))
+               if (ino && ino == ino_of_node(target))
                        return true;
        }
 

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 6caf4817e99b7f07d097eb0d42ac3b7eac0f78ec..249cc37ad35bd3b02ff629a1426b6484ea049ce7 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -178,7 +178,7 @@ bool f2fs_inode_chksum_verify(struct f2fs_sb_info *sbi, struct folio *folio)
 
        if (provided != calculated)
                f2fs_warn(sbi, "checksum invalid, nid = %lu, ino_of_node = %x, %x vs. %x",
-                         folio->index, ino_of_node(&folio->page),
+                         folio->index, ino_of_node(folio),
                          provided, calculated);
 
        return provided == calculated;
@@ -280,14 +280,14 @@ static bool sanity_check_inode(struct inode *inode, struct folio *node_folio)
                return false;
        }
 
-       if (ino_of_node(&node_folio->page) != nid_of_node(&node_folio->page)) {
+       if (ino_of_node(node_folio) != nid_of_node(&node_folio->page)) {
                f2fs_warn(sbi, "%s: corrupted inode footer i_ino=%lx, ino,nid: [%u, %u] run fsck to fix.",
                          __func__, inode->i_ino,
-                         ino_of_node(&node_folio->page), nid_of_node(&node_folio->page));
+                         ino_of_node(node_folio), nid_of_node(&node_folio->page));
                return false;
        }
 
-       if (ino_of_node(&node_folio->page) == fi->i_xattr_nid) {
+       if (ino_of_node(node_folio) == fi->i_xattr_nid) {
                f2fs_warn(sbi, "%s: corrupted inode i_ino=%lx, xnid=%x, run fsck to fix.",
                          __func__, inode->i_ino, fi->i_xattr_nid);
                return false;

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index ce9cc32fec3f6c21a2dd2dc1d55d99d0d626d9b4..b3956daacbf8698062993f5f54bead0361e45473 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -974,9 +974,9 @@ 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->page) != dn->inode->i_ino) {
+       if (IS_INODE(&folio->page) || 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->page));
+                               dn->inode->i_ino, dn->nid, ino_of_node(folio));
                set_sbi_flag(sbi, SBI_NEED_FSCK);
                f2fs_handle_error(sbi, ERROR_INVALID_NODE_REFERENCE);
                f2fs_folio_put(folio, true);
@@ -1484,7 +1484,7 @@ static int sanity_check_node_footer(struct f2fs_sb_info *sbi,
                time_to_inject(sbi, FAULT_INCONSISTENT_FOOTER))) {
                f2fs_warn(sbi, "inconsistent node block, node_type:%d, nid:%lu, "
                          "node_footer[nid:%u,ino:%u,ofs:%u,cpver:%llu,blkaddr:%u]",
-                         ntype, nid, nid_of_node(page), ino_of_node(page),
+                         ntype, nid, nid_of_node(page), ino_of_node(folio),
                          ofs_of_node(page), cpver_of_node(page),
                          next_blkaddr_of_node(folio));
                set_sbi_flag(sbi, SBI_NEED_FSCK);
@@ -1633,7 +1633,7 @@ static struct folio *last_fsync_dnode(struct f2fs_sb_info *sbi, nid_t ino)
 
                        if (!IS_DNODE(&folio->page) || !is_cold_node(&folio->page))
                                continue;
-                       if (ino_of_node(&folio->page) != ino)
+                       if (ino_of_node(folio) != ino)
                                continue;
 
                        folio_lock(folio);
@@ -1643,7 +1643,7 @@ continue_unlock:
                                folio_unlock(folio);
                                continue;
                        }
-                       if (ino_of_node(&folio->page) != ino)
+                       if (ino_of_node(folio) != ino)
                                goto continue_unlock;
 
                        if (!folio_test_dirty(folio)) {
@@ -1673,7 +1673,7 @@ static bool __write_node_folio(struct folio *folio, bool atomic, bool *submitted
        struct node_info ni;
        struct f2fs_io_info fio = {
                .sbi = sbi,
-               .ino = ino_of_node(&folio->page),
+               .ino = ino_of_node(folio),
                .type = NODE,
                .op = REQ_OP_WRITE,
                .op_flags = wbc_to_write_flags(wbc),
@@ -1842,7 +1842,7 @@ retry:
 
                        if (!IS_DNODE(&folio->page) || !is_cold_node(&folio->page))
                                continue;
-                       if (ino_of_node(&folio->page) != ino)
+                       if (ino_of_node(folio) != ino)
                                continue;
 
                        folio_lock(folio);
@@ -1852,7 +1852,7 @@ continue_unlock:
                                folio_unlock(folio);
                                continue;
                        }
-                       if (ino_of_node(&folio->page) != ino)
+                       if (ino_of_node(folio) != ino)
                                goto continue_unlock;
 
                        if (!folio_test_dirty(folio) && folio != last_folio) {
@@ -1948,7 +1948,7 @@ static bool flush_dirty_inode(struct folio *folio)
 {
        struct f2fs_sb_info *sbi = F2FS_F_SB(folio);
        struct inode *inode;
-       nid_t ino = ino_of_node(&folio->page);
+       nid_t ino = ino_of_node(folio);
 
        inode = find_inode_nowait(sbi->sb, ino, f2fs_match_ino, NULL);
        if (!inode)
@@ -1991,7 +1991,7 @@ void f2fs_flush_inline_data(struct f2fs_sb_info *sbi)
                        if (page_private_inline(&folio->page)) {
                                clear_page_private_inline(&folio->page);
                                folio_unlock(folio);
-                               flush_inline_data(sbi, ino_of_node(&folio->page));
+                               flush_inline_data(sbi, ino_of_node(folio));
                                continue;
                        }
 unlock:
@@ -2073,7 +2073,7 @@ continue_unlock:
                        if (page_private_inline(&folio->page)) {
                                clear_page_private_inline(&folio->page);
                                folio_unlock(folio);
-                               flush_inline_data(sbi, ino_of_node(&folio->page));
+                               flush_inline_data(sbi, ino_of_node(folio));
                                goto lock_node;
                        }
 
@@ -2804,7 +2804,7 @@ recover_xnid:
 int f2fs_recover_inode_page(struct f2fs_sb_info *sbi, struct folio *folio)
 {
        struct f2fs_inode *src, *dst;
-       nid_t ino = ino_of_node(&folio->page);
+       nid_t ino = ino_of_node(folio);
        struct node_info old_ni, new_ni;
        struct folio *ifolio;
        int err;

diff --git a/fs/f2fs/node.h b/fs/f2fs/node.h
index b5218d642545ad3fa0fe000e107ea224c2ac6f72..3bf9d637168c88bca8231a62f788938650ad868d 100644 (file)
--- a/fs/f2fs/node.h
+++ b/fs/f2fs/node.h
@@ -243,9 +243,9 @@ static inline void set_to_next_nat(struct f2fs_nm_info *nm_i, nid_t start_nid)
 #endif
 }
 
-static inline nid_t ino_of_node(struct page *node_page)
+static inline nid_t ino_of_node(const struct folio *node_folio)
 {
-       struct f2fs_node *rn = F2FS_NODE(node_page);
+       struct f2fs_node *rn = F2FS_NODE(&node_folio->page);
        return le32_to_cpu(rn->footer.ino);
 }
 

diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 448a2bbc0b2f93c93f478918d6a7d58078d2c67a..b81ae66fff4da370373c473508578643a58510c9 100644 (file)
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -233,7 +233,7 @@ out:
        else
                name = raw_inode->i_name;
        f2fs_notice(F2FS_I_SB(inode), "%s: ino = %x, name = %s, dir = %lx, err = %d",
-                   __func__, ino_of_node(&ifolio->page), name,
+                   __func__, ino_of_node(ifolio), name,
                    IS_ERR(dir) ? 0 : dir->i_ino, err);
        return err;
 }
@@ -336,7 +336,7 @@ static int recover_inode(struct inode *inode, struct folio *folio)
                name = F2FS_INODE(folio)->i_name;
 
        f2fs_notice(F2FS_I_SB(inode), "recover_inode: ino = %x, name = %s, inline = %x",
-                   ino_of_node(&folio->page), name, raw->i_inline);
+                   ino_of_node(folio), name, raw->i_inline);
        return 0;
 }
 
@@ -432,7 +432,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head,
                if (!is_fsync_dnode(&folio->page))
                        goto next;
 
-               entry = get_fsync_inode(head, ino_of_node(&folio->page));
+               entry = get_fsync_inode(head, ino_of_node(folio));
                if (!entry) {
                        bool quota_inode = false;
 
@@ -451,7 +451,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head,
                         * CP | dnode(F) | inode(DF)
                         * For this case, we should not give up now.
                         */
-                       entry = add_fsync_inode(sbi, head, ino_of_node(&folio->page),
+                       entry = add_fsync_inode(sbi, head, ino_of_node(folio),
                                                                quota_inode);
                        if (IS_ERR(entry)) {
                                err = PTR_ERR(entry);
@@ -553,7 +553,7 @@ got_it:
                return PTR_ERR(node_folio);
 
        offset = ofs_of_node(&node_folio->page);
-       ino = ino_of_node(&node_folio->page);
+       ino = ino_of_node(node_folio);
        f2fs_folio_put(node_folio, true);
 
        if (ino != dn->inode->i_ino) {
@@ -668,7 +668,7 @@ retry_dn:
        if (err)
                goto err;
 
-       f2fs_bug_on(sbi, ni.ino != ino_of_node(&folio->page));
+       f2fs_bug_on(sbi, ni.ino != ino_of_node(folio));
 
        if (ofs_of_node(&dn.node_folio->page) != ofs_of_node(&folio->page)) {
                f2fs_warn(sbi, "Inconsistent ofs_of_node, ino:%lu, ofs:%u, %u",
@@ -812,7 +812,7 @@ static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list,
                }
                recoverable_dnode++;
 
-               entry = get_fsync_inode(inode_list, ino_of_node(&folio->page));
+               entry = get_fsync_inode(inode_list, ino_of_node(folio));
                if (!entry)
                        goto next;
                fsynced_dnode++;