superrob1500
/
mirror-linux
mirror of https://github.com/torvalds/linux
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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>
pull/1314/head
Matthew Wilcox (Oracle) 2025-07-08 18:03:34 +01:00 committed by Jaegeuk Kim
parent ad38574a8e
commit a5f3be6e65
8 changed files with 18 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
fs/f2fs/f2fs.h
View File

@ -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) #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); 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, static inline unsigned int get_dnode_base(struct inode *inode,
struct folio *node_folio) struct folio *node_folio)
{ {
if (!IS_INODE(&node_folio->page)) if (!IS_INODE(node_folio))
return 0; return 0;
return inode ? get_extra_isize(inode) : return inode ? get_extra_isize(inode) :

2
fs/f2fs/file.c
View File

@ -819,7 +819,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
count -= dn.ofs_in_node; count -= dn.ofs_in_node;
f2fs_bug_on(sbi, count < 0); 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); f2fs_truncate_data_blocks_range(&dn, count);
free_from += count; free_from += count;
} }

2
fs/f2fs/gc.c
View File

@ -1162,7 +1162,7 @@ static bool is_alive(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
return false; return false;
} }
if (IS_INODE(&node_folio->page)) { if (IS_INODE(node_folio)) {
base = offset_in_addr(F2FS_INODE(node_folio)); base = offset_in_addr(F2FS_INODE(node_folio));
max_addrs = DEF_ADDRS_PER_INODE; max_addrs = DEF_ADDRS_PER_INODE;
} else { } else {

2
fs/f2fs/inline.c
View File

@ -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 o -> remove data blocks, and then recover inline_data
* x x -> recover data blocks * x x -> recover data blocks
*/ */
if (IS_INODE(&nfolio->page)) if (IS_INODE(nfolio))
ri = F2FS_INODE(nfolio); ri = F2FS_INODE(nfolio);
if (f2fs_has_inline_data(inode) && if (f2fs_has_inline_data(inode) &&

2
fs/f2fs/inode.c
View File

@ -124,7 +124,7 @@ bool f2fs_enable_inode_chksum(struct f2fs_sb_info *sbi, struct folio *folio)
if (!f2fs_sb_has_inode_chksum(sbi)) if (!f2fs_sb_has_inode_chksum(sbi))
return false; 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; return false;
if (!F2FS_FITS_IN_INODE(ri, le16_to_cpu(ri->i_extra_isize), if (!F2FS_FITS_IN_INODE(ri, le16_to_cpu(ri->i_extra_isize),

14
fs/f2fs/node.c
View File

@ -973,7 +973,7 @@ static int truncate_dnode(struct dnode_of_data *dn)
else if (IS_ERR(folio)) else if (IS_ERR(folio))
return PTR_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", f2fs_err(sbi, "incorrect node reference, ino: %lu, nid: %u, ino_of_node: %u",
dn->inode->i_ino, dn->nid, ino_of_node(folio)); dn->inode->i_ino, dn->nid, ino_of_node(folio));
set_sbi_flag(sbi, SBI_NEED_FSCK); 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, struct folio *folio, pgoff_t nid,
enum node_type ntype) enum node_type ntype)
{ {
struct page *page = &folio->page;
if (unlikely(nid != nid_of_node(folio) || 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 && (ntype == NODE_TYPE_XATTR &&
!f2fs_has_xattr_block(ofs_of_node(folio))) || !f2fs_has_xattr_block(ofs_of_node(folio))) ||
time_to_inject(sbi, FAULT_INCONSISTENT_FOOTER))) { time_to_inject(sbi, FAULT_INCONSISTENT_FOOTER))) {
@ -1867,7 +1865,7 @@ continue_unlock:
if (!atomic || folio == last_folio) { if (!atomic || folio == last_folio) {
set_fsync_mark(folio, 1); set_fsync_mark(folio, 1);
percpu_counter_inc(&sbi->rf_node_block_count); percpu_counter_inc(&sbi->rf_node_block_count);
if (IS_INODE(&folio->page)) { if (IS_INODE(folio)) {
if (is_inode_flag_set(inode, if (is_inode_flag_set(inode,
FI_DIRTY_INODE)) FI_DIRTY_INODE))
f2fs_update_inode(inode, folio); 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++) { for (i = 0; i < nr_folios; i++) {
struct folio *folio = fbatch.folios[i]; struct folio *folio = fbatch.folios[i];
if (!IS_INODE(&folio->page)) if (!IS_INODE(folio))
continue; continue;
folio_lock(folio); folio_lock(folio);
@ -2077,7 +2075,7 @@ continue_unlock:
} }
/* flush dirty inode */ /* flush dirty inode */
if (IS_INODE(&folio->page) && flush_dirty_inode(folio)) if (IS_INODE(folio) && flush_dirty_inode(folio))
goto lock_node; goto lock_node;
write_node: write_node:
f2fs_folio_wait_writeback(folio, NODE, true, true); 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)) if (!folio_test_uptodate(folio))
folio_mark_uptodate(folio); folio_mark_uptodate(folio);
#ifdef CONFIG_F2FS_CHECK_FS #ifdef CONFIG_F2FS_CHECK_FS
if (IS_INODE(&folio->page)) if (IS_INODE(folio))
f2fs_inode_chksum_set(F2FS_M_SB(mapping), folio); f2fs_inode_chksum_set(F2FS_M_SB(mapping), folio);
#endif #endif
if (filemap_dirty_folio(mapping, folio)) { if (filemap_dirty_folio(mapping, folio)) {

8
fs/f2fs/recovery.c
View File

@ -437,7 +437,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head,
bool quota_inode = false; bool quota_inode = false;
if (!check_only && if (!check_only &&
IS_INODE(&folio->page) && IS_INODE(folio) &&
is_dent_dnode(folio)) { is_dent_dnode(folio)) {
err = f2fs_recover_inode_page(sbi, folio); err = f2fs_recover_inode_page(sbi, folio);
if (err) { if (err) {
@ -463,7 +463,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head,
} }
entry->blkaddr = blkaddr; entry->blkaddr = blkaddr;
if (IS_INODE(&folio->page) && is_dent_dnode(folio)) if (IS_INODE(folio) && is_dent_dnode(folio))
entry->last_dentry = blkaddr; entry->last_dentry = blkaddr;
next: next:
/* check next segment */ /* 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; int err = 0, recovered = 0;
/* step 1: recover xattr */ /* step 1: recover xattr */
if (IS_INODE(&folio->page)) { if (IS_INODE(folio)) {
err = f2fs_recover_inline_xattr(inode, folio); err = f2fs_recover_inline_xattr(inode, folio);
if (err) if (err)
goto out; 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). * In this case, we can lose the latest inode(x).
* So, call recover_inode for the inode update. * So, call recover_inode for the inode update.
*/ */
if (IS_INODE(&folio->page)) { if (IS_INODE(folio)) {
err = recover_inode(entry->inode, folio); err = recover_inode(entry->inode, folio);
if (err) { if (err) {
f2fs_folio_put(folio, true); f2fs_folio_put(folio, true);

2
include/linux/f2fs_fs.h
View File

@ -268,7 +268,7 @@ struct node_footer {
/* Node IDs in an Indirect Block */ /* Node IDs in an Indirect Block */
#define NIDS_PER_BLOCK ((F2FS_BLKSIZE - sizeof(struct node_footer)) / sizeof(__le32)) #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_DIR1_BLOCK (DEF_ADDRS_PER_INODE + 1)
#define NODE_DIR2_BLOCK (DEF_ADDRS_PER_INODE + 2) #define NODE_DIR2_BLOCK (DEF_ADDRS_PER_INODE + 2)