f2fs: convert to use bitmap API

[ Upstream commit 447286ebadaafa551550704ff0b42eb08b1d1cb2 ]

Let's use BIT() and GENMASK() instead of open it.

Signed-off-by: Yangtao Li <frank.li@vivo.com>
Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
Stable-dep-of: f5f3bd903a5d ("f2fs: set the default compress_level on ioctl")
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 5df04ed010caea3c18be082eec97fde04556b1f9..eb4d69f53337f453d69d5d60392c52bea20737d9 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -984,7 +984,7 @@ int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi)
 
        cp_blk_no = le32_to_cpu(fsb->cp_blkaddr);
        if (cur_page == cp2)
-               cp_blk_no += 1 << le32_to_cpu(fsb->log_blocks_per_seg);
+               cp_blk_no += BIT(le32_to_cpu(fsb->log_blocks_per_seg));
 
        for (i = 1; i < cp_blks; i++) {
                void *sit_bitmap_ptr;

diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c
index d509b47381d517d1b21a3e86547e6eb02fd23055..c3ba202a7c29f7d3c426dc27b6cc09faea1f9150 100644 (file)
--- a/fs/f2fs/compress.c
+++ b/fs/f2fs/compress.c
@@ -673,7 +673,7 @@ static int f2fs_compress_pages(struct compress_ctx *cc)
 
        cc->cbuf->clen = cpu_to_le32(cc->clen);
 
-       if (fi->i_compress_flag & 1 << COMPRESS_CHKSUM)
+       if (fi->i_compress_flag & BIT(COMPRESS_CHKSUM))
                chksum = f2fs_crc32(F2FS_I_SB(cc->inode),
                                        cc->cbuf->cdata, cc->clen);
        cc->cbuf->chksum = cpu_to_le32(chksum);
@@ -771,7 +771,7 @@ void f2fs_decompress_cluster(struct decompress_io_ctx *dic, bool in_task)
 
        ret = cops->decompress_pages(dic);
 
-       if (!ret && (fi->i_compress_flag & 1 << COMPRESS_CHKSUM)) {
+       if (!ret && (fi->i_compress_flag & BIT(COMPRESS_CHKSUM))) {
                u32 provided = le32_to_cpu(dic->cbuf->chksum);
                u32 calculated = f2fs_crc32(sbi, dic->cbuf->cdata, dic->clen);
 

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index ea05710ca9bdf0b47544ce0c3d189c52730d82f8..3666c1fd77a6462eaf7edfc191c0349823929b02 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -95,17 +95,17 @@ static enum count_type __read_io_type(struct page *page)
 /* postprocessing steps for read bios */
 enum bio_post_read_step {
 #ifdef CONFIG_FS_ENCRYPTION
-       STEP_DECRYPT    = 1 << 0,
+       STEP_DECRYPT    = BIT(0),
 #else
        STEP_DECRYPT    = 0,    /* compile out the decryption-related code */
 #endif
 #ifdef CONFIG_F2FS_FS_COMPRESSION
-       STEP_DECOMPRESS = 1 << 1,
+       STEP_DECOMPRESS = BIT(1),
 #else
        STEP_DECOMPRESS = 0,    /* compile out the decompression-related code */
 #endif
 #ifdef CONFIG_FS_VERITY
-       STEP_VERITY     = 1 << 2,
+       STEP_VERITY     = BIT(2),
 #else
        STEP_VERITY     = 0,    /* compile out the verity-related code */
 #endif
@@ -409,7 +409,7 @@ int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr)
 
 static blk_opf_t f2fs_io_flags(struct f2fs_io_info *fio)
 {
-       unsigned int temp_mask = (1 << NR_TEMP_TYPE) - 1;
+       unsigned int temp_mask = GENMASK(NR_TEMP_TYPE - 1, 0);
        unsigned int fua_flag, meta_flag, io_flag;
        blk_opf_t op_flags = 0;
 
@@ -431,9 +431,9 @@ static blk_opf_t f2fs_io_flags(struct f2fs_io_info *fio)
         *    5 |    4 |   3 |    2 |    1 |   0 |
         * Cold | Warm | Hot | Cold | Warm | Hot |
         */
-       if ((1 << fio->temp) & meta_flag)
+       if (BIT(fio->temp) & meta_flag)
                op_flags |= REQ_META;
-       if ((1 << fio->temp) & fua_flag)
+       if (BIT(fio->temp) & fua_flag)
                op_flags |= REQ_FUA;
        return op_flags;
 }

diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index 8373eba3a1337e0f37e46da85ebb59eb9c66ca2b..510736d2ae110a1bca54d0ff9038c082f0d43ab8 100644 (file)
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -29,7 +29,7 @@ static unsigned long dir_blocks(struct inode *inode)
 static unsigned int dir_buckets(unsigned int level, int dir_level)
 {
        if (level + dir_level < MAX_DIR_HASH_DEPTH / 2)
-               return 1 << (level + dir_level);
+               return BIT(level + dir_level);
        else
                return MAX_DIR_BUCKETS;
 }

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index faf1a4953e8457b6c0b087e7b7442cbf15fadc03..6fa3ac2097b270c3b9867a5c01552722a4567e13 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -64,7 +64,7 @@ enum {
 };
 
 #ifdef CONFIG_F2FS_FAULT_INJECTION
-#define F2FS_ALL_FAULT_TYPE            ((1 << FAULT_MAX) - 1)
+#define F2FS_ALL_FAULT_TYPE            (GENMASK(FAULT_MAX - 1, 0))
 
 struct f2fs_fault_info {
        atomic_t inject_ops;
@@ -73,7 +73,7 @@ struct f2fs_fault_info {
 };
 
 extern const char *f2fs_fault_name[FAULT_MAX];
-#define IS_FAULT_SET(fi, type) ((fi)->inject_type & (1 << (type)))
+#define IS_FAULT_SET(fi, type) ((fi)->inject_type & BIT(type))
 #endif
 
 /*
@@ -1412,7 +1412,7 @@ static inline void set_page_private_##name(struct page *page) \
 static inline void clear_page_private_##name(struct page *page) \
 { \
        clear_bit(PAGE_PRIVATE_##flagname, &page_private(page)); \
-       if (page_private(page) == 1 << PAGE_PRIVATE_NOT_POINTER) { \
+       if (page_private(page) == BIT(PAGE_PRIVATE_NOT_POINTER)) { \
                set_page_private(page, 0); \
                if (PagePrivate(page)) { \
                        ClearPagePrivate(page); \
@@ -1462,8 +1462,8 @@ static inline void set_page_private_data(struct page *page, unsigned long data)
 
 static inline void clear_page_private_data(struct page *page)
 {
-       page_private(page) &= (1 << PAGE_PRIVATE_MAX) - 1;
-       if (page_private(page) == 1 << PAGE_PRIVATE_NOT_POINTER) {
+       page_private(page) &= GENMASK(PAGE_PRIVATE_MAX - 1, 0);
+       if (page_private(page) == BIT(PAGE_PRIVATE_NOT_POINTER)) {
                set_page_private(page, 0);
                if (PagePrivate(page)) {
                        ClearPagePrivate(page);
@@ -2882,7 +2882,7 @@ static inline int f2fs_test_bit(unsigned int nr, char *addr)
        int mask;
 
        addr += (nr >> 3);
-       mask = 1 << (7 - (nr & 0x07));
+       mask = BIT(7 - (nr & 0x07));
        return mask & *addr;
 }
 
@@ -2891,7 +2891,7 @@ static inline void f2fs_set_bit(unsigned int nr, char *addr)
        int mask;
 
        addr += (nr >> 3);
-       mask = 1 << (7 - (nr & 0x07));
+       mask = BIT(7 - (nr & 0x07));
        *addr |= mask;
 }
 
@@ -2900,7 +2900,7 @@ static inline void f2fs_clear_bit(unsigned int nr, char *addr)
        int mask;
 
        addr += (nr >> 3);
-       mask = 1 << (7 - (nr & 0x07));
+       mask = BIT(7 - (nr & 0x07));
        *addr &= ~mask;
 }
 
@@ -2910,7 +2910,7 @@ static inline int f2fs_test_and_set_bit(unsigned int nr, char *addr)
        int ret;
 
        addr += (nr >> 3);
-       mask = 1 << (7 - (nr & 0x07));
+       mask = BIT(7 - (nr & 0x07));
        ret = mask & *addr;
        *addr |= mask;
        return ret;
@@ -2922,7 +2922,7 @@ static inline int f2fs_test_and_clear_bit(unsigned int nr, char *addr)
        int ret;
 
        addr += (nr >> 3);
-       mask = 1 << (7 - (nr & 0x07));
+       mask = BIT(7 - (nr & 0x07));
        ret = mask & *addr;
        *addr &= ~mask;
        return ret;
@@ -2933,7 +2933,7 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
        int mask;
 
        addr += (nr >> 3);
-       mask = 1 << (7 - (nr & 0x07));
+       mask = BIT(7 - (nr & 0x07));
        *addr ^= mask;
 }
 
@@ -4333,9 +4333,9 @@ static inline int set_compress_context(struct inode *inode)
                        F2FS_OPTION(sbi).compress_log_size;
        F2FS_I(inode)->i_compress_flag =
                        F2FS_OPTION(sbi).compress_chksum ?
-                               1 << COMPRESS_CHKSUM : 0;
+                               BIT(COMPRESS_CHKSUM) : 0;
        F2FS_I(inode)->i_cluster_size =
-                       1 << F2FS_I(inode)->i_log_cluster_size;
+                       BIT(F2FS_I(inode)->i_log_cluster_size);
        if ((F2FS_I(inode)->i_compress_algorithm == COMPRESS_LZ4 ||
                F2FS_I(inode)->i_compress_algorithm == COMPRESS_ZSTD) &&
                        F2FS_OPTION(sbi).compress_level)

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index d0c17366ebf485ab6ccc4d6f95d7ff34b5afdae2..126c074deebdc14dba0c69d6d3d8cda4783e8559 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -3983,7 +3983,7 @@ static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg)
 
        F2FS_I(inode)->i_compress_algorithm = option.algorithm;
        F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size;
-       F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size;
+       F2FS_I(inode)->i_cluster_size = BIT(option.log_cluster_size);
        f2fs_mark_inode_dirty_sync(inode, true);
 
        if (!f2fs_is_compress_backend_ready(inode))

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 933554985d32811ca56f9b0ec252174cdcab923d..0010579f1736832286417626fb0926ffb36c248d 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -460,8 +460,8 @@ static int do_read_inode(struct inode *inode)
                        fi->i_compress_level = compress_flag >>
                                                COMPRESS_LEVEL_OFFSET;
                        fi->i_compress_flag = compress_flag &
-                                       (BIT(COMPRESS_LEVEL_OFFSET) - 1);
-                       fi->i_cluster_size = 1 << fi->i_log_cluster_size;
+                                       GENMASK(COMPRESS_LEVEL_OFFSET - 1, 0);
+                       fi->i_cluster_size = BIT(fi->i_log_cluster_size);
                        set_inode_flag(inode, FI_COMPRESSED_FILE);
                }
        }

diff --git a/fs/f2fs/node.h b/fs/f2fs/node.h
index 0aa48704c77a0271bafab2fa549684cd575d8bcc..7068f3ac036a54b7a38f9de3d3d8d43267196741 100644 (file)
--- a/fs/f2fs/node.h
+++ b/fs/f2fs/node.h
@@ -93,17 +93,15 @@ static inline void copy_node_info(struct node_info *dst,
 static inline void set_nat_flag(struct nat_entry *ne,
                                unsigned int type, bool set)
 {
-       unsigned char mask = 0x01 << type;
        if (set)
-               ne->ni.flag |= mask;
+               ne->ni.flag |= BIT(type);
        else
-               ne->ni.flag &= ~mask;
+               ne->ni.flag &= ~BIT(type);
 }
 
 static inline bool get_nat_flag(struct nat_entry *ne, unsigned int type)
 {
-       unsigned char mask = 0x01 << type;
-       return ne->ni.flag & mask;
+       return ne->ni.flag & BIT(type);
 }
 
 static inline void nat_reset_flag(struct nat_entry *ne)
@@ -224,7 +222,7 @@ static inline pgoff_t next_nat_addr(struct f2fs_sb_info *sbi,
        struct f2fs_nm_info *nm_i = NM_I(sbi);
 
        block_addr -= nm_i->nat_blkaddr;
-       block_addr ^= 1 << sbi->log_blocks_per_seg;
+       block_addr ^= BIT(sbi->log_blocks_per_seg);
        return block_addr + nm_i->nat_blkaddr;
 }
 
@@ -394,7 +392,7 @@ static inline nid_t get_nid(struct page *p, int off, bool i)
 static inline int is_node(struct page *page, int type)
 {
        struct f2fs_node *rn = F2FS_NODE(page);
-       return le32_to_cpu(rn->footer.flag) & (1 << type);
+       return le32_to_cpu(rn->footer.flag) & BIT(type);
 }
 
 #define is_cold_node(page)     is_node(page, COLD_BIT_SHIFT)
@@ -407,9 +405,9 @@ static inline void set_cold_node(struct page *page, bool is_dir)
        unsigned int flag = le32_to_cpu(rn->footer.flag);
 
        if (is_dir)
-               flag &= ~(0x1 << COLD_BIT_SHIFT);
+               flag &= ~BIT(COLD_BIT_SHIFT);
        else
-               flag |= (0x1 << COLD_BIT_SHIFT);
+               flag |= BIT(COLD_BIT_SHIFT);
        rn->footer.flag = cpu_to_le32(flag);
 }
 
@@ -418,9 +416,9 @@ static inline void set_mark(struct page *page, int mark, int type)
        struct f2fs_node *rn = F2FS_NODE(page);
        unsigned int flag = le32_to_cpu(rn->footer.flag);
        if (mark)
-               flag |= (0x1 << type);
+               flag |= BIT(type);
        else
-               flag &= ~(0x1 << type);
+               flag &= ~BIT(type);
        rn->footer.flag = cpu_to_le32(flag);
 
 #ifdef CONFIG_F2FS_CHECK_FS

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 1ba85ef97cbd3a4cab4067a9e5d24369b263e709..4f87e0e374c25b27d92cae242a1010d043ab1ad6 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -898,8 +898,8 @@ static int parse_options(struct super_block *sb, char *options, bool is_remount)
                        if (args->from && match_int(args, &arg))
                                return -EINVAL;
                        if (arg <= 0 || arg > __ilog2_u32(BIO_MAX_VECS)) {
-                               f2fs_warn(sbi, "Not support %d, larger than %d",
-                                         1 << arg, BIO_MAX_VECS);
+                               f2fs_warn(sbi, "Not support %ld, larger than %d",
+                                       BIT(arg), BIO_MAX_VECS);
                                return -EINVAL;
                        }
                        F2FS_OPTION(sbi).write_io_size_bits = arg;
@@ -1340,7 +1340,7 @@ default_check:
 #endif
 
        if (F2FS_IO_SIZE_BITS(sbi) && !f2fs_lfs_mode(sbi)) {
-               f2fs_err(sbi, "Should set mode=lfs with %uKB-sized IO",
+               f2fs_err(sbi, "Should set mode=lfs with %luKB-sized IO",
                         F2FS_IO_SIZE_KB(sbi));
                return -EINVAL;
        }
@@ -3356,7 +3356,7 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi,
        total_sections = le32_to_cpu(raw_super->section_count);
 
        /* blocks_per_seg should be 512, given the above check */
-       blocks_per_seg = 1 << le32_to_cpu(raw_super->log_blocks_per_seg);
+       blocks_per_seg = BIT(le32_to_cpu(raw_super->log_blocks_per_seg));
 
        if (segment_count > F2FS_MAX_SEGMENT ||
                                segment_count < F2FS_MIN_SEGMENTS) {
@@ -3625,9 +3625,9 @@ static void init_sb_info(struct f2fs_sb_info *sbi)
        sbi->log_sectors_per_block =
                le32_to_cpu(raw_super->log_sectors_per_block);
        sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);
-       sbi->blocksize = 1 << sbi->log_blocksize;
+       sbi->blocksize = BIT(sbi->log_blocksize);
        sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
-       sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
+       sbi->blocks_per_seg = BIT(sbi->log_blocks_per_seg);
        sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
        sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
        sbi->total_sections = le32_to_cpu(raw_super->section_count);
@@ -3883,7 +3883,7 @@ void f2fs_handle_stop(struct f2fs_sb_info *sbi, unsigned char reason)
 
        f2fs_down_write(&sbi->sb_lock);
 
-       if (raw_super->s_stop_reason[reason] < ((1 << BITS_PER_BYTE) - 1))
+       if (raw_super->s_stop_reason[reason] < GENMASK(BITS_PER_BYTE - 1, 0))
                raw_super->s_stop_reason[reason]++;
 
        err = f2fs_commit_super(sbi, false);
@@ -4033,7 +4033,7 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
                          FDEV(i).start_blk, FDEV(i).end_blk);
        }
        f2fs_info(sbi,
-                 "IO Block Size: %8d KB", F2FS_IO_SIZE_KB(sbi));
+                 "IO Block Size: %8ld KB", F2FS_IO_SIZE_KB(sbi));
        return 0;
 }
 

diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index 3d68bfa75cf2aac005e58bb62a270e9e44d43547..751a108e612ff76c9b18156748aeec5048826ab5 100644 (file)
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -451,7 +451,7 @@ out:
        if (ret < 0)
                return ret;
 #ifdef CONFIG_F2FS_FAULT_INJECTION
-       if (a->struct_type == FAULT_INFO_TYPE && t >= (1 << FAULT_MAX))
+       if (a->struct_type == FAULT_INFO_TYPE && t >= BIT(FAULT_MAX))
                return -EINVAL;
        if (a->struct_type == FAULT_INFO_RATE && t >= UINT_MAX)
                return -EINVAL;

diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index ee0d75d9a302d47649c79c7dcb4c24abd0bbd547..1e0df607e40c42285de960c7d2b2887b98019e76 100644 (file)
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -40,9 +40,8 @@
 
 #define F2FS_ENC_UTF8_12_1     1
 
-#define F2FS_IO_SIZE(sbi)      (1 << F2FS_OPTION(sbi).write_io_size_bits) /* Blocks */
-#define F2FS_IO_SIZE_KB(sbi)   (1 << (F2FS_OPTION(sbi).write_io_size_bits + 2)) /* KB */
-#define F2FS_IO_SIZE_BYTES(sbi)        (1 << (F2FS_OPTION(sbi).write_io_size_bits + 12)) /* B */
+#define F2FS_IO_SIZE(sbi)      BIT(F2FS_OPTION(sbi).write_io_size_bits) /* Blocks */
+#define F2FS_IO_SIZE_KB(sbi)   BIT(F2FS_OPTION(sbi).write_io_size_bits + 2) /* KB */
 #define F2FS_IO_SIZE_BITS(sbi) (F2FS_OPTION(sbi).write_io_size_bits) /* power of 2 */
 #define F2FS_IO_SIZE_MASK(sbi) (F2FS_IO_SIZE(sbi) - 1)
 #define F2FS_IO_ALIGNED(sbi)   (F2FS_IO_SIZE(sbi) > 1)
@@ -340,7 +339,7 @@ enum {
        OFFSET_BIT_SHIFT
 };
 
-#define OFFSET_BIT_MASK                (0x07)  /* (0x01 << OFFSET_BIT_SHIFT) - 1 */
+#define OFFSET_BIT_MASK                GENMASK(OFFSET_BIT_SHIFT - 1, 0)
 
 struct node_footer {
        __le32 nid;             /* node id */
@@ -545,7 +544,7 @@ typedef __le32      f2fs_hash_t;
 #define MAX_DIR_HASH_DEPTH     63
 
 /* MAX buckets in one level of dir */
-#define MAX_DIR_BUCKETS                (1 << ((MAX_DIR_HASH_DEPTH / 2) - 1))
+#define MAX_DIR_BUCKETS                BIT((MAX_DIR_HASH_DEPTH / 2) - 1)
 
 /*
  * space utilization of regular dentry and inline dentry (w/o extra reservation)