Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ccd31cb2 authored Feb 06, 2018 by Sheng Yong Committed by Jaegeuk Kim Mar 13, 2018

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>

parent 3bb09a0e

fs/f2fs/data.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -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;

fs/f2fs/f2fs.h

+13 −38

Original line number	Diff line number	Diff line
		@@ -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)

fs/f2fs/file.c

+3 −3

Original line number	Diff line number	Diff line
		@@ -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))

fs/f2fs/segment.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -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 @@ void clear_prefree_segments(struct f2fs_sb_info sbi, struct cp_control cpc)
		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;

fs/f2fs/super.c

+7 −7

Original line number	Diff line number	Diff line
		@@ -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 @@ static int f2fs_fill_super(struct super_block sb, void data, int silent)
		* 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;