f2fs: Pass a folio to F2FS_INODE()

All callers now have a folio, so pass it in.  Also make it const as
F2FS_INODE() does not modify the struct folio passed in (the data it
describes is mutable, but it does not change the contents of the struct).
This may improve code generation.

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/dir.c b/fs/f2fs/dir.c
index c36b3b22bfffd9403a29d55001620514f0bc11a2..888dca7e82ac98f367fdf453fe2a20a6ac7d96e6 100644 (file)
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -454,7 +454,7 @@ static void init_dent_inode(struct inode *dir, struct inode *inode,
        f2fs_folio_wait_writeback(ifolio, NODE, true, true);
 
        /* copy name info. to this inode folio */
-       ri = F2FS_INODE(&ifolio->page);
+       ri = F2FS_INODE(ifolio);
        ri->i_namelen = cpu_to_le32(fname->disk_name.len);
        memcpy(ri->i_name, fname->disk_name.name, fname->disk_name.len);
        if (IS_ENCRYPTED(dir)) {

diff --git a/fs/f2fs/extent_cache.c b/fs/f2fs/extent_cache.c
index 5be503a875dce20c8ac971a738b1cf3984b13c9f..a6eb3d73231e5370e53eae6c7123e4b73fab6d73 100644 (file)
--- a/fs/f2fs/extent_cache.c
+++ b/fs/f2fs/extent_cache.c
@@ -22,7 +22,7 @@
 bool sanity_check_extent_cache(struct inode *inode, struct folio *ifolio)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-       struct f2fs_extent *i_ext = &F2FS_INODE(&ifolio->page)->i_ext;
+       struct f2fs_extent *i_ext = &F2FS_INODE(ifolio)->i_ext;
        struct extent_info ei;
        int devi;
 
@@ -411,7 +411,7 @@ void f2fs_init_read_extent_tree(struct inode *inode, struct folio *ifolio)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct extent_tree_info *eti = &sbi->extent_tree[EX_READ];
-       struct f2fs_extent *i_ext = &F2FS_INODE(&ifolio->page)->i_ext;
+       struct f2fs_extent *i_ext = &F2FS_INODE(ifolio)->i_ext;
        struct extent_tree *et;
        struct extent_node *en;
        struct extent_info ei = {0};

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 3efe6a2485585ba6ca5507cc820a8e51fc40fee5..c33ed614c01108c941548348c1fc1d49b623f794 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2053,9 +2053,9 @@ static inline struct f2fs_node *F2FS_NODE(const struct page *page)
        return (struct f2fs_node *)page_address(page);
 }
 
-static inline struct f2fs_inode *F2FS_INODE(struct page *page)
+static inline struct f2fs_inode *F2FS_INODE(const struct folio *folio)
 {
-       return &((struct f2fs_node *)page_address(page))->i;
+       return &((struct f2fs_node *)folio_address(folio))->i;
 }
 
 static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
@@ -3371,9 +3371,10 @@ static inline unsigned int addrs_per_page(struct inode *inode,
        return addrs;
 }
 
-static inline void *inline_xattr_addr(struct inode *inode, struct folio *folio)
+static inline
+void *inline_xattr_addr(struct inode *inode, const struct folio *folio)
 {
-       struct f2fs_inode *ri = F2FS_INODE(&folio->page);
+       struct f2fs_inode *ri = F2FS_INODE(folio);
 
        return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
                                        get_inline_xattr_addrs(inode)]);

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

diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index fa072e4a561666f248e480bad418c97a35482586..4c636a8043f8b4f07ecd0f3d421fe331396e78ae 100644 (file)
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -35,7 +35,7 @@ bool f2fs_may_inline_data(struct inode *inode)
 
 static bool inode_has_blocks(struct inode *inode, struct folio *ifolio)
 {
-       struct f2fs_inode *ri = F2FS_INODE(&ifolio->page);
+       struct f2fs_inode *ri = F2FS_INODE(ifolio);
        int i;
 
        if (F2FS_HAS_BLOCKS(inode))
@@ -306,7 +306,7 @@ int f2fs_recover_inline_data(struct inode *inode, struct folio *nfolio)
         *    x       x  -> recover data blocks
         */
        if (IS_INODE(&nfolio->page))
-               ri = F2FS_INODE(&nfolio->page);
+               ri = F2FS_INODE(nfolio);
 
        if (f2fs_has_inline_data(inode) &&
                        ri && (ri->i_inline & F2FS_INLINE_DATA)) {
@@ -825,7 +825,7 @@ int f2fs_inline_data_fiemap(struct inode *inode,
 
        byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;
        byteaddr += (char *)inline_data_addr(inode, ifolio) -
-                                       (char *)F2FS_INODE(&ifolio->page);
+                                       (char *)F2FS_INODE(ifolio);
        err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
        trace_f2fs_fiemap(inode, start, byteaddr, ilen, flags, err);
 out:

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 3d1ee92a613c1e509dae6f9c16448d6472d4f009..6caf4817e99b7f07d097eb0d42ac3b7eac0f78ec 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -108,7 +108,7 @@ static void __recover_inline_status(struct inode *inode, struct folio *ifolio)
                        f2fs_folio_wait_writeback(ifolio, NODE, true, true);
 
                        set_inode_flag(inode, FI_DATA_EXIST);
-                       set_raw_inline(inode, F2FS_INODE(&ifolio->page));
+                       set_raw_inline(inode, F2FS_INODE(ifolio));
                        folio_mark_dirty(ifolio);
                        return;
                }
@@ -270,10 +270,10 @@ static bool sanity_check_inode(struct inode *inode, struct folio *node_folio)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct f2fs_inode_info *fi = F2FS_I(inode);
-       struct f2fs_inode *ri = F2FS_INODE(&node_folio->page);
+       struct f2fs_inode *ri = F2FS_INODE(node_folio);
        unsigned long long iblocks;
 
-       iblocks = le64_to_cpu(F2FS_INODE(&node_folio->page)->i_blocks);
+       iblocks = le64_to_cpu(F2FS_INODE(node_folio)->i_blocks);
        if (!iblocks) {
                f2fs_warn(sbi, "%s: corrupted inode i_blocks i_ino=%lx iblocks=%llu, run fsck to fix.",
                          __func__, inode->i_ino, iblocks);
@@ -419,7 +419,7 @@ static int do_read_inode(struct inode *inode)
        if (IS_ERR(node_folio))
                return PTR_ERR(node_folio);
 
-       ri = F2FS_INODE(&node_folio->page);
+       ri = F2FS_INODE(node_folio);
 
        inode->i_mode = le16_to_cpu(ri->i_mode);
        i_uid_write(inode, le32_to_cpu(ri->i_uid));
@@ -669,7 +669,7 @@ void f2fs_update_inode(struct inode *inode, struct folio *node_folio)
 
        f2fs_inode_synced(inode);
 
-       ri = F2FS_INODE(&node_folio->page);
+       ri = F2FS_INODE(node_folio);
 
        ri->i_mode = cpu_to_le16(inode->i_mode);
        ri->i_advise = fi->i_advise;

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index a9aade30c4cb3119f4ce700b0f95bd2e7cf92317..ce9cc32fec3f6c21a2dd2dc1d55d99d0d626d9b4 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1172,7 +1172,7 @@ int f2fs_truncate_inode_blocks(struct inode *inode, pgoff_t from)
        set_new_dnode(&dn, inode, folio, NULL, 0);
        folio_unlock(folio);
 
-       ri = F2FS_INODE(&folio->page);
+       ri = F2FS_INODE(folio);
        switch (level) {
        case 0:
        case 1:
@@ -2727,7 +2727,7 @@ int f2fs_recover_inline_xattr(struct inode *inode, struct folio *folio)
        if (IS_ERR(ifolio))
                return PTR_ERR(ifolio);
 
-       ri = F2FS_INODE(&folio->page);
+       ri = F2FS_INODE(folio);
        if (ri->i_inline & F2FS_INLINE_XATTR) {
                if (!f2fs_has_inline_xattr(inode)) {
                        set_inode_flag(inode, FI_INLINE_XATTR);
@@ -2830,8 +2830,8 @@ retry:
        fill_node_footer(&ifolio->page, ino, ino, 0, true);
        set_cold_node(&ifolio->page, false);
 
-       src = F2FS_INODE(&folio->page);
-       dst = F2FS_INODE(&ifolio->page);
+       src = F2FS_INODE(folio);
+       dst = F2FS_INODE(ifolio);
 
        memcpy(dst, src, offsetof(struct f2fs_inode, i_ext));
        dst->i_size = 0;

diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 5120713ffd53347bdcf988ee1be02729c1be82b5..448a2bbc0b2f93c93f478918d6a7d58078d2c67a 100644 (file)
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -160,7 +160,7 @@ static int init_recovered_filename(const struct inode *dir,
 static int recover_dentry(struct inode *inode, struct folio *ifolio,
                                                struct list_head *dir_list)
 {
-       struct f2fs_inode *raw_inode = F2FS_INODE(&ifolio->page);
+       struct f2fs_inode *raw_inode = F2FS_INODE(ifolio);
        nid_t pino = le32_to_cpu(raw_inode->i_pino);
        struct f2fs_dir_entry *de;
        struct f2fs_filename fname;
@@ -240,7 +240,7 @@ out:
 
 static int recover_quota_data(struct inode *inode, struct folio *folio)
 {
-       struct f2fs_inode *raw = F2FS_INODE(&folio->page);
+       struct f2fs_inode *raw = F2FS_INODE(folio);
        struct iattr attr;
        uid_t i_uid = le32_to_cpu(raw->i_uid);
        gid_t i_gid = le32_to_cpu(raw->i_gid);
@@ -279,7 +279,7 @@ static void recover_inline_flags(struct inode *inode, struct f2fs_inode *ri)
 
 static int recover_inode(struct inode *inode, struct folio *folio)
 {
-       struct f2fs_inode *raw = F2FS_INODE(&folio->page);
+       struct f2fs_inode *raw = F2FS_INODE(folio);
        struct f2fs_inode_info *fi = F2FS_I(inode);
        char *name;
        int err;
@@ -333,7 +333,7 @@ static int recover_inode(struct inode *inode, struct folio *folio)
        if (file_enc_name(inode))
                name = "<encrypted>";
        else
-               name = F2FS_INODE(&folio->page)->i_name;
+               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);