f2fs: clean up f2fs_sb_has_xxx functions

This patch introduces F2FS_FEATURE_FUNCS to clean up the definitions of
different f2fs_sb_has_xxx functions.

Signed-off-by: Sheng Yong <shengyong1@huawei.com>
Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 1c5b050ef9008072bfcc4cc579badeead0a19949..6c3c9784de0620f2d9dc7974c8f33b5ce34fb932 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -206,7 +206,7 @@ static inline void __submit_bio(struct f2fs_sb_info *sbi,
                if (type != DATA && type != NODE)
                        goto submit_io;
 
-               if (f2fs_sb_mounted_blkzoned(sbi->sb) && current->plug)
+               if (f2fs_sb_has_blkzoned(sbi->sb) && current->plug)
                        blk_finish_plug(current->plug);
 
                start = bio->bi_iter.bi_size >> F2FS_BLKSIZE_BITS;

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index d57b7dd8f1af6d557052be6699f4bffa40f9dab2..9f3841be992f6fc5bd6b3ee686e5460a5b775f03 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -3182,45 +3182,20 @@ static inline bool f2fs_bio_encrypted(struct bio *bio)
        return bio->bi_private != NULL;
 }
 
-static inline int f2fs_sb_has_crypto(struct super_block *sb)
-{
-       return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_ENCRYPT);
-}
-
-static inline int f2fs_sb_mounted_blkzoned(struct super_block *sb)
-{
-       return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_BLKZONED);
+#define F2FS_FEATURE_FUNCS(name, flagname) \
+static inline int f2fs_sb_has_##name(struct super_block *sb) \
+{ \
+       return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_##flagname); \
 }
 
-static inline int f2fs_sb_has_extra_attr(struct super_block *sb)
-{
-       return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_EXTRA_ATTR);
-}
-
-static inline int f2fs_sb_has_project_quota(struct super_block *sb)
-{
-       return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_PRJQUOTA);
-}
-
-static inline int f2fs_sb_has_inode_chksum(struct super_block *sb)
-{
-       return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_INODE_CHKSUM);
-}
-
-static inline int f2fs_sb_has_flexible_inline_xattr(struct super_block *sb)
-{
-       return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_FLEXIBLE_INLINE_XATTR);
-}
-
-static inline int f2fs_sb_has_quota_ino(struct super_block *sb)
-{
-       return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_QUOTA_INO);
-}
-
-static inline int f2fs_sb_has_inode_crtime(struct super_block *sb)
-{
-       return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_INODE_CRTIME);
-}
+F2FS_FEATURE_FUNCS(encrypt, ENCRYPT);
+F2FS_FEATURE_FUNCS(blkzoned, BLKZONED);
+F2FS_FEATURE_FUNCS(extra_attr, EXTRA_ATTR);
+F2FS_FEATURE_FUNCS(project_quota, PRJQUOTA);
+F2FS_FEATURE_FUNCS(inode_chksum, INODE_CHKSUM);
+F2FS_FEATURE_FUNCS(flexible_inline_xattr, FLEXIBLE_INLINE_XATTR);
+F2FS_FEATURE_FUNCS(quota_ino, QUOTA_INO);
+F2FS_FEATURE_FUNCS(inode_crtime, INODE_CRTIME);
 
 #ifdef CONFIG_BLK_DEV_ZONED
 static inline int get_blkz_type(struct f2fs_sb_info *sbi,
@@ -3240,7 +3215,7 @@ static inline bool f2fs_discard_en(struct f2fs_sb_info *sbi)
 {
        struct request_queue *q = bdev_get_queue(sbi->sb->s_bdev);
 
-       return blk_queue_discard(q) || f2fs_sb_mounted_blkzoned(sbi->sb);
+       return blk_queue_discard(q) || f2fs_sb_has_blkzoned(sbi->sb);
 }
 
 static inline void set_opt_mode(struct f2fs_sb_info *sbi, unsigned int mt)

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 672a542e546478cc09d8a10d564f87e9705084dc..29956e16c58c4dd5eef0047367e34bab617555ea 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1938,7 +1938,7 @@ static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
 {
        struct inode *inode = file_inode(filp);
 
-       if (!f2fs_sb_has_crypto(inode->i_sb))
+       if (!f2fs_sb_has_encrypt(inode->i_sb))
                return -EOPNOTSUPP;
 
        f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
@@ -1948,7 +1948,7 @@ static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
 
 static int f2fs_ioc_get_encryption_policy(struct file *filp, unsigned long arg)
 {
-       if (!f2fs_sb_has_crypto(file_inode(filp)->i_sb))
+       if (!f2fs_sb_has_encrypt(file_inode(filp)->i_sb))
                return -EOPNOTSUPP;
        return fscrypt_ioctl_get_policy(filp, (void __user *)arg);
 }
@@ -1959,7 +1959,7 @@ static int f2fs_ioc_get_encryption_pwsalt(struct file *filp, unsigned long arg)
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        int err;
 
-       if (!f2fs_sb_has_crypto(inode->i_sb))
+       if (!f2fs_sb_has_encrypt(inode->i_sb))
                return -EOPNOTSUPP;
 
        if (uuid_is_nonzero(sbi->raw_super->encrypt_pw_salt))

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 427b75ed1e29f86fae3ca10a1f984e3b95bda9f1..0646d5de8cd018c469c8e693aa8d7f49c8b267ec 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -1485,7 +1485,7 @@ static int __issue_discard_async(struct f2fs_sb_info *sbi,
                struct block_device *bdev, block_t blkstart, block_t blklen)
 {
 #ifdef CONFIG_BLK_DEV_ZONED
-       if (f2fs_sb_mounted_blkzoned(sbi->sb) &&
+       if (f2fs_sb_has_blkzoned(sbi->sb) &&
                                bdev_zoned_model(bdev) != BLK_ZONED_NONE)
                return __f2fs_issue_discard_zone(sbi, bdev, blkstart, blklen);
 #endif
@@ -1683,7 +1683,7 @@ find_next:
                                        sbi->blocks_per_seg, cur_pos);
                        len = next_pos - cur_pos;
 
-                       if (f2fs_sb_mounted_blkzoned(sbi->sb) ||
+                       if (f2fs_sb_has_blkzoned(sbi->sb) ||
                            (force && len < cpc->trim_minlen))
                                goto skip;
 

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 2e427a15b37e4dcf72b794f508a8fe7d3fd0ab0a..ff6da6e05ec9b934f378982a89efc26efca62089 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -405,14 +405,14 @@ static int parse_options(struct super_block *sb, char *options)
                        q = bdev_get_queue(sb->s_bdev);
                        if (blk_queue_discard(q)) {
                                set_opt(sbi, DISCARD);
-                       } else if (!f2fs_sb_mounted_blkzoned(sb)) {
+                       } else if (!f2fs_sb_has_blkzoned(sb)) {
                                f2fs_msg(sb, KERN_WARNING,
                                        "mounting with \"discard\" option, but "
                                        "the device does not support discard");
                        }
                        break;
                case Opt_nodiscard:
-                       if (f2fs_sb_mounted_blkzoned(sb)) {
+                       if (f2fs_sb_has_blkzoned(sb)) {
                                f2fs_msg(sb, KERN_WARNING,
                                        "discard is required for zoned block devices");
                                return -EINVAL;
@@ -561,7 +561,7 @@ static int parse_options(struct super_block *sb, char *options)
                                return -ENOMEM;
                        if (strlen(name) == 8 &&
                                        !strncmp(name, "adaptive", 8)) {
-                               if (f2fs_sb_mounted_blkzoned(sb)) {
+                               if (f2fs_sb_has_blkzoned(sb)) {
                                        f2fs_msg(sb, KERN_WARNING,
                                                 "adaptive mode is not allowed with "
                                                 "zoned block device feature");
@@ -1282,7 +1282,7 @@ static void default_options(struct f2fs_sb_info *sbi)
        set_opt(sbi, NOHEAP);
        sbi->sb->s_flags |= SB_LAZYTIME;
        set_opt(sbi, FLUSH_MERGE);
-       if (f2fs_sb_mounted_blkzoned(sbi->sb)) {
+       if (f2fs_sb_has_blkzoned(sbi->sb)) {
                set_opt_mode(sbi, F2FS_MOUNT_LFS);
                set_opt(sbi, DISCARD);
        } else {
@@ -2246,7 +2246,7 @@ static int init_blkz_info(struct f2fs_sb_info *sbi, int devi)
        unsigned int n = 0;
        int err = -EIO;
 
-       if (!f2fs_sb_mounted_blkzoned(sbi->sb))
+       if (!f2fs_sb_has_blkzoned(sbi->sb))
                return 0;
 
        if (sbi->blocks_per_blkz && sbi->blocks_per_blkz !=
@@ -2453,7 +2453,7 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi)
 
 #ifdef CONFIG_BLK_DEV_ZONED
                if (bdev_zoned_model(FDEV(i).bdev) == BLK_ZONED_HM &&
-                               !f2fs_sb_mounted_blkzoned(sbi->sb)) {
+                               !f2fs_sb_has_blkzoned(sbi->sb)) {
                        f2fs_msg(sbi->sb, KERN_ERR,
                                "Zoned block device feature not enabled\n");
                        return -EINVAL;
@@ -2548,7 +2548,7 @@ try_onemore:
         * devices, but mandatory for host-managed zoned block devices.
         */
 #ifndef CONFIG_BLK_DEV_ZONED
-       if (f2fs_sb_mounted_blkzoned(sb)) {
+       if (f2fs_sb_has_blkzoned(sb)) {
                f2fs_msg(sb, KERN_ERR,
                         "Zoned block device support is not enabled\n");
                err = -EOPNOTSUPP;

diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index d978c7b6ea04a6c6062ec4c55c1b74adb53274a1..374ee5c82f940942bf52fc4b80fdf4e29c0c785b 100644 (file)
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -92,10 +92,10 @@ static ssize_t features_show(struct f2fs_attr *a,
        if (!sb->s_bdev->bd_part)
                return snprintf(buf, PAGE_SIZE, "0\n");
 
-       if (f2fs_sb_has_crypto(sb))
+       if (f2fs_sb_has_encrypt(sb))
                len += snprintf(buf, PAGE_SIZE - len, "%s",
                                                "encryption");
-       if (f2fs_sb_mounted_blkzoned(sb))
+       if (f2fs_sb_has_blkzoned(sb))
                len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
                                len ? ", " : "", "blkzoned");
        if (f2fs_sb_has_extra_attr(sb))