Skip to content

Commit 7309871

Browse files
chaseyuJaegeuk Kim
chaseyu
authored and
Jaegeuk Kim
committed
f2fs: clean up F2FS_I()
Use temporary variable instead of F2FS_I() for cleanup. Signed-off-by: Chao Yu <chao@kernel.org> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
1 parent f18d007 commit 7309871

File tree

5 files changed

+88
-93
lines changed

5 files changed

+88
-93
lines changed

‎fs/f2fs/f2fs.h

Lines changed: 14 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -4403,22 +4403,18 @@ static inline int set_compress_context(struct inode *inode)
44034403
{
44044404
#ifdef CONFIG_F2FS_FS_COMPRESSION
44054405
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
4406+
struct f2fs_inode_info *fi = F2FS_I(inode);
44064407

4407-
F2FS_I(inode)->i_compress_algorithm =
4408-
F2FS_OPTION(sbi).compress_algorithm;
4409-
F2FS_I(inode)->i_log_cluster_size =
4410-
F2FS_OPTION(sbi).compress_log_size;
4411-
F2FS_I(inode)->i_compress_flag =
4412-
F2FS_OPTION(sbi).compress_chksum ?
4413-
BIT(COMPRESS_CHKSUM) : 0;
4414-
F2FS_I(inode)->i_cluster_size =
4415-
BIT(F2FS_I(inode)->i_log_cluster_size);
4416-
if ((F2FS_I(inode)->i_compress_algorithm == COMPRESS_LZ4 ||
4417-
F2FS_I(inode)->i_compress_algorithm == COMPRESS_ZSTD) &&
4408+
fi->i_compress_algorithm = F2FS_OPTION(sbi).compress_algorithm;
4409+
fi->i_log_cluster_size = F2FS_OPTION(sbi).compress_log_size;
4410+
fi->i_compress_flag = F2FS_OPTION(sbi).compress_chksum ?
4411+
BIT(COMPRESS_CHKSUM) : 0;
4412+
fi->i_cluster_size = BIT(fi->i_log_cluster_size);
4413+
if ((fi->i_compress_algorithm == COMPRESS_LZ4 ||
4414+
fi->i_compress_algorithm == COMPRESS_ZSTD) &&
44184415
F2FS_OPTION(sbi).compress_level)
4419-
F2FS_I(inode)->i_compress_level =
4420-
F2FS_OPTION(sbi).compress_level;
4421-
F2FS_I(inode)->i_flags |= F2FS_COMPR_FL;
4416+
fi->i_compress_level = F2FS_OPTION(sbi).compress_level;
4417+
fi->i_flags |= F2FS_COMPR_FL;
44224418
set_inode_flag(inode, FI_COMPRESSED_FILE);
44234419
stat_inc_compr_inode(inode);
44244420
inc_compr_inode_stat(inode);
@@ -4433,15 +4429,15 @@ static inline bool f2fs_disable_compressed_file(struct inode *inode)
44334429
{
44344430
struct f2fs_inode_info *fi = F2FS_I(inode);
44354431

4436-
f2fs_down_write(&F2FS_I(inode)->i_sem);
4432+
f2fs_down_write(&fi->i_sem);
44374433

44384434
if (!f2fs_compressed_file(inode)) {
4439-
f2fs_up_write(&F2FS_I(inode)->i_sem);
4435+
f2fs_up_write(&fi->i_sem);
44404436
return true;
44414437
}
44424438
if (f2fs_is_mmap_file(inode) ||
44434439
(S_ISREG(inode->i_mode) && F2FS_HAS_BLOCKS(inode))) {
4444-
f2fs_up_write(&F2FS_I(inode)->i_sem);
4440+
f2fs_up_write(&fi->i_sem);
44454441
return false;
44464442
}
44474443

@@ -4450,7 +4446,7 @@ static inline bool f2fs_disable_compressed_file(struct inode *inode)
44504446
clear_inode_flag(inode, FI_COMPRESSED_FILE);
44514447
f2fs_mark_inode_dirty_sync(inode, true);
44524448

4453-
f2fs_up_write(&F2FS_I(inode)->i_sem);
4449+
f2fs_up_write(&fi->i_sem);
44544450
return true;
44554451
}
44564452

‎fs/f2fs/file.c

Lines changed: 34 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -981,6 +981,7 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
981981
struct iattr *attr)
982982
{
983983
struct inode *inode = d_inode(dentry);
984+
struct f2fs_inode_info *fi = F2FS_I(inode);
984985
int err;
985986

986987
if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
@@ -999,7 +1000,7 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
9991000
return -EOPNOTSUPP;
10001001
if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) &&
10011002
!IS_ALIGNED(attr->ia_size,
1002-
F2FS_BLK_TO_BYTES(F2FS_I(inode)->i_cluster_size)))
1003+
F2FS_BLK_TO_BYTES(fi->i_cluster_size)))
10031004
return -EINVAL;
10041005
}
10051006

@@ -1053,7 +1054,7 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
10531054
return err;
10541055
}
10551056

1056-
f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1057+
f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
10571058
filemap_invalidate_lock(inode->i_mapping);
10581059

10591060
truncate_setsize(inode, attr->ia_size);
@@ -1065,14 +1066,14 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
10651066
* larger than i_size.
10661067
*/
10671068
filemap_invalidate_unlock(inode->i_mapping);
1068-
f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1069+
f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
10691070
if (err)
10701071
return err;
10711072

1072-
spin_lock(&F2FS_I(inode)->i_size_lock);
1073+
spin_lock(&fi->i_size_lock);
10731074
inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
1074-
F2FS_I(inode)->last_disk_size = i_size_read(inode);
1075-
spin_unlock(&F2FS_I(inode)->i_size_lock);
1075+
fi->last_disk_size = i_size_read(inode);
1076+
spin_unlock(&fi->i_size_lock);
10761077
}
10771078

10781079
__setattr_copy(idmap, inode, attr);
@@ -1082,7 +1083,7 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
10821083

10831084
if (is_inode_flag_set(inode, FI_ACL_MODE)) {
10841085
if (!err)
1085-
inode->i_mode = F2FS_I(inode)->i_acl_mode;
1086+
inode->i_mode = fi->i_acl_mode;
10861087
clear_inode_flag(inode, FI_ACL_MODE);
10871088
}
10881089
}
@@ -1990,15 +1991,15 @@ static int f2fs_setflags_common(struct inode *inode, u32 iflags, u32 mask)
19901991
if (err)
19911992
return err;
19921993

1993-
f2fs_down_write(&F2FS_I(inode)->i_sem);
1994+
f2fs_down_write(&fi->i_sem);
19941995
if (!f2fs_may_compress(inode) ||
19951996
(S_ISREG(inode->i_mode) &&
19961997
F2FS_HAS_BLOCKS(inode))) {
1997-
f2fs_up_write(&F2FS_I(inode)->i_sem);
1998+
f2fs_up_write(&fi->i_sem);
19981999
return -EINVAL;
19992000
}
20002001
err = set_compress_context(inode);
2001-
f2fs_up_write(&F2FS_I(inode)->i_sem);
2002+
f2fs_up_write(&fi->i_sem);
20022003

20032004
if (err)
20042005
return err;
@@ -3588,6 +3589,7 @@ static int release_compress_blocks(struct dnode_of_data *dn, pgoff_t count)
35883589
static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
35893590
{
35903591
struct inode *inode = file_inode(filp);
3592+
struct f2fs_inode_info *fi = F2FS_I(inode);
35913593
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
35923594
pgoff_t page_idx = 0, last_idx;
35933595
unsigned int released_blocks = 0;
@@ -3625,7 +3627,7 @@ static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
36253627
if (ret)
36263628
goto out;
36273629

3628-
if (!atomic_read(&F2FS_I(inode)->i_compr_blocks)) {
3630+
if (!atomic_read(&fi->i_compr_blocks)) {
36293631
ret = -EPERM;
36303632
goto out;
36313633
}
@@ -3634,7 +3636,7 @@ static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
36343636
inode_set_ctime_current(inode);
36353637
f2fs_mark_inode_dirty_sync(inode, true);
36363638

3637-
f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3639+
f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
36383640
filemap_invalidate_lock(inode->i_mapping);
36393641

36403642
last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
@@ -3660,7 +3662,7 @@ static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
36603662

36613663
end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
36623664
count = min(end_offset - dn.ofs_in_node, last_idx - page_idx);
3663-
count = round_up(count, F2FS_I(inode)->i_cluster_size);
3665+
count = round_up(count, fi->i_cluster_size);
36643666

36653667
ret = release_compress_blocks(&dn, count);
36663668

@@ -3676,7 +3678,7 @@ static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
36763678
}
36773679

36783680
filemap_invalidate_unlock(inode->i_mapping);
3679-
f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3681+
f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
36803682
out:
36813683
if (released_blocks)
36823684
f2fs_update_time(sbi, REQ_TIME);
@@ -3687,14 +3689,14 @@ static int f2fs_release_compress_blocks(struct file *filp, unsigned long arg)
36873689
if (ret >= 0) {
36883690
ret = put_user(released_blocks, (u64 __user *)arg);
36893691
} else if (released_blocks &&
3690-
atomic_read(&F2FS_I(inode)->i_compr_blocks)) {
3692+
atomic_read(&fi->i_compr_blocks)) {
36913693
set_sbi_flag(sbi, SBI_NEED_FSCK);
36923694
f2fs_warn(sbi, "%s: partial blocks were released i_ino=%lx "
36933695
"iblocks=%llu, released=%u, compr_blocks=%u, "
36943696
"run fsck to fix.",
36953697
__func__, inode->i_ino, inode->i_blocks,
36963698
released_blocks,
3697-
atomic_read(&F2FS_I(inode)->i_compr_blocks));
3699+
atomic_read(&fi->i_compr_blocks));
36983700
}
36993701

37003702
return ret;
@@ -3783,6 +3785,7 @@ static int reserve_compress_blocks(struct dnode_of_data *dn, pgoff_t count,
37833785
static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
37843786
{
37853787
struct inode *inode = file_inode(filp);
3788+
struct f2fs_inode_info *fi = F2FS_I(inode);
37863789
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
37873790
pgoff_t page_idx = 0, last_idx;
37883791
unsigned int reserved_blocks = 0;
@@ -3808,10 +3811,10 @@ static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
38083811
goto unlock_inode;
38093812
}
38103813

3811-
if (atomic_read(&F2FS_I(inode)->i_compr_blocks))
3814+
if (atomic_read(&fi->i_compr_blocks))
38123815
goto unlock_inode;
38133816

3814-
f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3817+
f2fs_down_write(&fi->i_gc_rwsem[WRITE]);
38153818
filemap_invalidate_lock(inode->i_mapping);
38163819

38173820
last_idx = DIV_ROUND_UP(i_size_read(inode), PAGE_SIZE);
@@ -3837,7 +3840,7 @@ static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
38373840

38383841
end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
38393842
count = min(end_offset - dn.ofs_in_node, last_idx - page_idx);
3840-
count = round_up(count, F2FS_I(inode)->i_cluster_size);
3843+
count = round_up(count, fi->i_cluster_size);
38413844

38423845
ret = reserve_compress_blocks(&dn, count, &reserved_blocks);
38433846

@@ -3852,7 +3855,7 @@ static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
38523855
}
38533856

38543857
filemap_invalidate_unlock(inode->i_mapping);
3855-
f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
3858+
f2fs_up_write(&fi->i_gc_rwsem[WRITE]);
38563859

38573860
if (!ret) {
38583861
clear_inode_flag(inode, FI_COMPRESS_RELEASED);
@@ -3868,14 +3871,14 @@ static int f2fs_reserve_compress_blocks(struct file *filp, unsigned long arg)
38683871
if (!ret) {
38693872
ret = put_user(reserved_blocks, (u64 __user *)arg);
38703873
} else if (reserved_blocks &&
3871-
atomic_read(&F2FS_I(inode)->i_compr_blocks)) {
3874+
atomic_read(&fi->i_compr_blocks)) {
38723875
set_sbi_flag(sbi, SBI_NEED_FSCK);
38733876
f2fs_warn(sbi, "%s: partial blocks were reserved i_ino=%lx "
38743877
"iblocks=%llu, reserved=%u, compr_blocks=%u, "
38753878
"run fsck to fix.",
38763879
__func__, inode->i_ino, inode->i_blocks,
38773880
reserved_blocks,
3878-
atomic_read(&F2FS_I(inode)->i_compr_blocks));
3881+
atomic_read(&fi->i_compr_blocks));
38793882
}
38803883

38813884
return ret;
@@ -4101,6 +4104,7 @@ static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg)
41014104
static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg)
41024105
{
41034106
struct inode *inode = file_inode(filp);
4107+
struct f2fs_inode_info *fi = F2FS_I(inode);
41044108
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
41054109
struct f2fs_comp_option option;
41064110
int ret = 0;
@@ -4141,25 +4145,25 @@ static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg)
41414145
goto out;
41424146
}
41434147

4144-
F2FS_I(inode)->i_compress_algorithm = option.algorithm;
4145-
F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size;
4146-
F2FS_I(inode)->i_cluster_size = BIT(option.log_cluster_size);
4148+
fi->i_compress_algorithm = option.algorithm;
4149+
fi->i_log_cluster_size = option.log_cluster_size;
4150+
fi->i_cluster_size = BIT(option.log_cluster_size);
41474151
/* Set default level */
4148-
if (F2FS_I(inode)->i_compress_algorithm == COMPRESS_ZSTD)
4149-
F2FS_I(inode)->i_compress_level = F2FS_ZSTD_DEFAULT_CLEVEL;
4152+
if (fi->i_compress_algorithm == COMPRESS_ZSTD)
4153+
fi->i_compress_level = F2FS_ZSTD_DEFAULT_CLEVEL;
41504154
else
4151-
F2FS_I(inode)->i_compress_level = 0;
4155+
fi->i_compress_level = 0;
41524156
/* Adjust mount option level */
41534157
if (option.algorithm == F2FS_OPTION(sbi).compress_algorithm &&
41544158
F2FS_OPTION(sbi).compress_level)
4155-
F2FS_I(inode)->i_compress_level = F2FS_OPTION(sbi).compress_level;
4159+
fi->i_compress_level = F2FS_OPTION(sbi).compress_level;
41564160
f2fs_mark_inode_dirty_sync(inode, true);
41574161

41584162
if (!f2fs_is_compress_backend_ready(inode))
41594163
f2fs_warn(sbi, "compression algorithm is successfully set, "
41604164
"but current kernel doesn't support this algorithm.");
41614165
out:
4162-
f2fs_up_write(&F2FS_I(inode)->i_sem);
4166+
f2fs_up_write(&fi->i_sem);
41634167
inode_unlock(inode);
41644168
mnt_drop_write_file(filp);
41654169

‎fs/f2fs/inode.c

Lines changed: 23 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -636,8 +636,9 @@ struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino)
636636

637637
void f2fs_update_inode(struct inode *inode, struct page *node_page)
638638
{
639+
struct f2fs_inode_info *fi = F2FS_I(inode);
639640
struct f2fs_inode *ri;
640-
struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ];
641+
struct extent_tree *et = fi->extent_tree[EX_READ];
641642

642643
f2fs_wait_on_page_writeback(node_page, NODE, true, true);
643644
set_page_dirty(node_page);
@@ -647,7 +648,7 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page)
647648
ri = F2FS_INODE(node_page);
648649

649650
ri->i_mode = cpu_to_le16(inode->i_mode);
650-
ri->i_advise = F2FS_I(inode)->i_advise;
651+
ri->i_advise = fi->i_advise;
651652
ri->i_uid = cpu_to_le32(i_uid_read(inode));
652653
ri->i_gid = cpu_to_le32(i_gid_read(inode));
653654
ri->i_links = cpu_to_le32(inode->i_nlink);
@@ -673,58 +674,49 @@ void f2fs_update_inode(struct inode *inode, struct page *node_page)
673674
ri->i_ctime_nsec = cpu_to_le32(inode_get_ctime_nsec(inode));
674675
ri->i_mtime_nsec = cpu_to_le32(inode_get_mtime_nsec(inode));
675676
if (S_ISDIR(inode->i_mode))
676-
ri->i_current_depth =
677-
cpu_to_le32(F2FS_I(inode)->i_current_depth);
677+
ri->i_current_depth = cpu_to_le32(fi->i_current_depth);
678678
else if (S_ISREG(inode->i_mode))
679-
ri->i_gc_failures = cpu_to_le16(F2FS_I(inode)->i_gc_failures);
680-
ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);
681-
ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);
682-
ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);
679+
ri->i_gc_failures = cpu_to_le16(fi->i_gc_failures);
680+
ri->i_xattr_nid = cpu_to_le32(fi->i_xattr_nid);
681+
ri->i_flags = cpu_to_le32(fi->i_flags);
682+
ri->i_pino = cpu_to_le32(fi->i_pino);
683683
ri->i_generation = cpu_to_le32(inode->i_generation);
684-
ri->i_dir_level = F2FS_I(inode)->i_dir_level;
684+
ri->i_dir_level = fi->i_dir_level;
685685

686686
if (f2fs_has_extra_attr(inode)) {
687-
ri->i_extra_isize = cpu_to_le16(F2FS_I(inode)->i_extra_isize);
687+
ri->i_extra_isize = cpu_to_le16(fi->i_extra_isize);
688688

689689
if (f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(inode)))
690690
ri->i_inline_xattr_size =
691-
cpu_to_le16(F2FS_I(inode)->i_inline_xattr_size);
691+
cpu_to_le16(fi->i_inline_xattr_size);
692692

693693
if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)) &&
694-
F2FS_FITS_IN_INODE(ri, F2FS_I(inode)->i_extra_isize,
695-
i_projid)) {
694+
F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid)) {
696695
projid_t i_projid;
697696

698-
i_projid = from_kprojid(&init_user_ns,
699-
F2FS_I(inode)->i_projid);
697+
i_projid = from_kprojid(&init_user_ns, fi->i_projid);
700698
ri->i_projid = cpu_to_le32(i_projid);
701699
}
702700

703701
if (f2fs_sb_has_inode_crtime(F2FS_I_SB(inode)) &&
704-
F2FS_FITS_IN_INODE(ri, F2FS_I(inode)->i_extra_isize,
705-
i_crtime)) {
706-
ri->i_crtime =
707-
cpu_to_le64(F2FS_I(inode)->i_crtime.tv_sec);
708-
ri->i_crtime_nsec =
709-
cpu_to_le32(F2FS_I(inode)->i_crtime.tv_nsec);
702+
F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) {
703+
ri->i_crtime = cpu_to_le64(fi->i_crtime.tv_sec);
704+
ri->i_crtime_nsec = cpu_to_le32(fi->i_crtime.tv_nsec);
710705
}
711706

712707
if (f2fs_sb_has_compression(F2FS_I_SB(inode)) &&
713-
F2FS_FITS_IN_INODE(ri, F2FS_I(inode)->i_extra_isize,
708+
F2FS_FITS_IN_INODE(ri, fi->i_extra_isize,
714709
i_compress_flag)) {
715710
unsigned short compress_flag;
716711

717-
ri->i_compr_blocks =
718-
cpu_to_le64(atomic_read(
719-
&F2FS_I(inode)->i_compr_blocks));
720-
ri->i_compress_algorithm =
721-
F2FS_I(inode)->i_compress_algorithm;
722-
compress_flag = F2FS_I(inode)->i_compress_flag |
723-
F2FS_I(inode)->i_compress_level <<
712+
ri->i_compr_blocks = cpu_to_le64(
713+
atomic_read(&fi->i_compr_blocks));
714+
ri->i_compress_algorithm = fi->i_compress_algorithm;
715+
compress_flag = fi->i_compress_flag |
716+
fi->i_compress_level <<
724717
COMPRESS_LEVEL_OFFSET;
725718
ri->i_compress_flag = cpu_to_le16(compress_flag);
726-
ri->i_log_cluster_size =
727-
F2FS_I(inode)->i_log_cluster_size;
719+
ri->i_log_cluster_size = fi->i_log_cluster_size;
728720
}
729721
}
730722

0 commit comments

Comments
 (0)