f2fs: introduce IS_F2FS_IPU_* macro

BugLink: https://bugs.launchpad.net/bugs/2011430
[ Upstream commit fdb7ccc3f9cb316c399b072c7a75a106678eb421 ]

IS_F2FS_IPU_* macro can be used to identify whether
f2fs ipu related policies are enabled.

BTW, convert to use BIT() instead of open code.

Signed-off-by: Yangtao Li <frank.li@vivo.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
Stable-dep-of: c5bf83483382 ("f2fs: fix to set ipu policy")
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 5263d97bef1dd7fc8900d26b04f6238dde80b9e1..a28d05895f5c74ee6b046bc7d51247dfb1af6326 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2535,34 +2535,29 @@ static inline bool check_inplace_update_policy(struct inode *inode,
                                struct f2fs_io_info *fio)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
-       unsigned int policy = SM_I(sbi)->ipu_policy;
 
-       if (policy & (0x1 << F2FS_IPU_HONOR_OPU_WRITE) &&
-                       is_inode_flag_set(inode, FI_OPU_WRITE))
+       if (IS_F2FS_IPU_HONOR_OPU_WRITE(sbi) &&
+           is_inode_flag_set(inode, FI_OPU_WRITE))
                return false;
-       if (policy & (0x1 << F2FS_IPU_FORCE))
+       if (IS_F2FS_IPU_FORCE(sbi))
                return true;
-       if (policy & (0x1 << F2FS_IPU_SSR) && f2fs_need_SSR(sbi))
+       if (IS_F2FS_IPU_SSR(sbi) && f2fs_need_SSR(sbi))
                return true;
-       if (policy & (0x1 << F2FS_IPU_UTIL) &&
-                       utilization(sbi) > SM_I(sbi)->min_ipu_util)
+       if (IS_F2FS_IPU_UTIL(sbi) && utilization(sbi) > SM_I(sbi)->min_ipu_util)
                return true;
-       if (policy & (0x1 << F2FS_IPU_SSR_UTIL) && f2fs_need_SSR(sbi) &&
-                       utilization(sbi) > SM_I(sbi)->min_ipu_util)
+       if (IS_F2FS_IPU_SSR_UTIL(sbi) && f2fs_need_SSR(sbi) &&
+           utilization(sbi) > SM_I(sbi)->min_ipu_util)
                return true;
 
        /*
         * IPU for rewrite async pages
         */
-       if (policy & (0x1 << F2FS_IPU_ASYNC) &&
-                       fio && fio->op == REQ_OP_WRITE &&
-                       !(fio->op_flags & REQ_SYNC) &&
-                       !IS_ENCRYPTED(inode))
+       if (IS_F2FS_IPU_ASYNC(sbi) && fio && fio->op == REQ_OP_WRITE &&
+           !(fio->op_flags & REQ_SYNC) && !IS_ENCRYPTED(inode))
                return true;
 
        /* this is only set during fdatasync */
-       if (policy & (0x1 << F2FS_IPU_FSYNC) &&
-                       is_inode_flag_set(inode, FI_NEED_IPU))
+       if (IS_F2FS_IPU_FSYNC(sbi) && is_inode_flag_set(inode, FI_NEED_IPU))
                return true;
 
        if (unlikely(fio && is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index cf430f34d196827b2656adedaa1c1ae9e2cf50aa..06cae55265841b2de7f774680ac5907b2d22f35c 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -3498,7 +3498,7 @@ int f2fs_inplace_write_data(struct f2fs_io_info *fio)
 
        stat_inc_inplace_blocks(fio->sbi);
 
-       if (fio->bio && !(SM_I(sbi)->ipu_policy & (1 << F2FS_IPU_NOCACHE)))
+       if (fio->bio && !IS_F2FS_IPU_NOCACHE(sbi))
                err = f2fs_merge_page_bio(fio);
        else
                err = f2fs_submit_page_bio(fio);
@@ -5137,7 +5137,7 @@ int f2fs_build_segment_manager(struct f2fs_sb_info *sbi)
                sm_info->rec_prefree_segments = DEF_MAX_RECLAIM_PREFREE_SEGMENTS;
 
        if (!f2fs_lfs_mode(sbi))
-               sm_info->ipu_policy = 1 << F2FS_IPU_FSYNC;
+               sm_info->ipu_policy = BIT(F2FS_IPU_FSYNC);
        sm_info->min_ipu_util = DEF_MIN_IPU_UTIL;
        sm_info->min_fsync_blocks = DEF_MIN_FSYNC_BLOCKS;
        sm_info->min_seq_blocks = sbi->blocks_per_seg;

diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 3ad1b7b6fa9467430fbfeaa1a66c51259974e489..e77518c49f388260d157c3781c9dae28c64cf58a 100644 (file)
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -681,6 +681,21 @@ enum {
        F2FS_IPU_HONOR_OPU_WRITE,
 };
 
+#define F2FS_IPU_POLICY(name)                                  \
+static inline int IS_##name(struct f2fs_sb_info *sbi)          \
+{                                                              \
+       return SM_I(sbi)->ipu_policy & BIT(name);               \
+}
+
+F2FS_IPU_POLICY(F2FS_IPU_FORCE);
+F2FS_IPU_POLICY(F2FS_IPU_SSR);
+F2FS_IPU_POLICY(F2FS_IPU_UTIL);
+F2FS_IPU_POLICY(F2FS_IPU_SSR_UTIL);
+F2FS_IPU_POLICY(F2FS_IPU_FSYNC);
+F2FS_IPU_POLICY(F2FS_IPU_ASYNC);
+F2FS_IPU_POLICY(F2FS_IPU_NOCACHE);
+F2FS_IPU_POLICY(F2FS_IPU_HONOR_OPU_WRITE);
+
 static inline unsigned int curseg_segno(struct f2fs_sb_info *sbi,
                int type)
 {

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 1f812b9ce985b358f363c7523ab518a2d4d9f6d4..87d56a9883e656e528fe28a135ba369f0961fffb 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -4089,8 +4089,8 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
                if (f2fs_block_unit_discard(sbi))
                        SM_I(sbi)->dcc_info->discard_granularity =
                                                MIN_DISCARD_GRANULARITY;
-               SM_I(sbi)->ipu_policy = 1 << F2FS_IPU_FORCE |
-                                       1 << F2FS_IPU_HONOR_OPU_WRITE;
+               SM_I(sbi)->ipu_policy = BIT(F2FS_IPU_FORCE) |
+                                       BIT(F2FS_IPU_HONOR_OPU_WRITE);
        }
 
        sbi->readdir_ra = true;