btrfs: refactor helper for bg flags to name conversion
authorDavid Sterba <dsterba@suse.com>
Fri, 17 May 2019 09:43:41 +0000 (11:43 +0200)
committerDavid Sterba <dsterba@suse.com>
Mon, 1 Jul 2019 11:34:58 +0000 (13:34 +0200)
The helper lacks the btrfs_ prefix and the parameter is the raw
blockgroup type, so none of the callers has to do the flags -> index
conversion.

Signed-off-by: David Sterba <dsterba@suse.com>
fs/btrfs/extent-tree.c
fs/btrfs/volumes.c
fs/btrfs/volumes.h

index 326fd8660efbc216e9881f7bd3fb2a0de42707eb..af73264e33a557a93055efa22453554eadcbf4e1 100644 (file)
@@ -10146,7 +10146,6 @@ void btrfs_add_raid_kobjects(struct btrfs_fs_info *fs_info)
        struct btrfs_space_info *space_info;
        struct raid_kobject *rkobj;
        LIST_HEAD(list);
        struct btrfs_space_info *space_info;
        struct raid_kobject *rkobj;
        LIST_HEAD(list);
-       int index;
        int ret = 0;
 
        spin_lock(&fs_info->pending_raid_kobjs_lock);
        int ret = 0;
 
        spin_lock(&fs_info->pending_raid_kobjs_lock);
@@ -10155,10 +10154,9 @@ void btrfs_add_raid_kobjects(struct btrfs_fs_info *fs_info)
 
        list_for_each_entry(rkobj, &list, list) {
                space_info = __find_space_info(fs_info, rkobj->flags);
 
        list_for_each_entry(rkobj, &list, list) {
                space_info = __find_space_info(fs_info, rkobj->flags);
-               index = btrfs_bg_flags_to_raid_index(rkobj->flags);
 
                ret = kobject_add(&rkobj->kobj, &space_info->kobj,
 
                ret = kobject_add(&rkobj->kobj, &space_info->kobj,
-                                 "%s", get_raid_name(index));
+                               "%s", btrfs_bg_type_to_raid_name(rkobj->flags));
                if (ret) {
                        kobject_put(&rkobj->kobj);
                        break;
                if (ret) {
                        kobject_put(&rkobj->kobj);
                        break;
index 2e0860d14ad2f19a00fc9eb870fd5b6dbe659d55..eb737bcd7aac6493e2040f2ab1345ce55dfa88bd 100644 (file)
@@ -123,12 +123,14 @@ const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES] = {
        },
 };
 
        },
 };
 
-const char *get_raid_name(enum btrfs_raid_types type)
+const char *btrfs_bg_type_to_raid_name(u64 flags)
 {
 {
-       if (type >= BTRFS_NR_RAID_TYPES)
+       const int index = btrfs_bg_flags_to_raid_index(flags);
+
+       if (index >= BTRFS_NR_RAID_TYPES)
                return NULL;
 
                return NULL;
 
-       return btrfs_raid_array[type].raid_name;
+       return btrfs_raid_array[index].raid_name;
 }
 
 /*
 }
 
 /*
@@ -3926,11 +3928,9 @@ static void describe_balance_args(struct btrfs_balance_args *bargs, char *buf,
                bp += ret;                                              \
        } while (0)
 
                bp += ret;                                              \
        } while (0)
 
-       if (flags & BTRFS_BALANCE_ARGS_CONVERT) {
-               int index = btrfs_bg_flags_to_raid_index(bargs->target);
-
-               CHECK_APPEND_1ARG("convert=%s,", get_raid_name(index));
-       }
+       if (flags & BTRFS_BALANCE_ARGS_CONVERT)
+               CHECK_APPEND_1ARG("convert=%s,",
+                                 btrfs_bg_type_to_raid_name(bargs->target));
 
        if (flags & BTRFS_BALANCE_ARGS_SOFT)
                CHECK_APPEND_NOARG("soft,");
 
        if (flags & BTRFS_BALANCE_ARGS_SOFT)
                CHECK_APPEND_NOARG("soft,");
@@ -4088,29 +4088,23 @@ int btrfs_balance(struct btrfs_fs_info *fs_info,
                        allowed |= btrfs_raid_array[i].bg_flag;
 
        if (validate_convert_profile(&bctl->data, allowed)) {
                        allowed |= btrfs_raid_array[i].bg_flag;
 
        if (validate_convert_profile(&bctl->data, allowed)) {
-               int index = btrfs_bg_flags_to_raid_index(bctl->data.target);
-
                btrfs_err(fs_info,
                          "balance: invalid convert data profile %s",
                btrfs_err(fs_info,
                          "balance: invalid convert data profile %s",
-                         get_raid_name(index));
+                         btrfs_bg_type_to_raid_name(bctl->data.target));
                ret = -EINVAL;
                goto out;
        }
        if (validate_convert_profile(&bctl->meta, allowed)) {
                ret = -EINVAL;
                goto out;
        }
        if (validate_convert_profile(&bctl->meta, allowed)) {
-               int index = btrfs_bg_flags_to_raid_index(bctl->meta.target);
-
                btrfs_err(fs_info,
                          "balance: invalid convert metadata profile %s",
                btrfs_err(fs_info,
                          "balance: invalid convert metadata profile %s",
-                         get_raid_name(index));
+                         btrfs_bg_type_to_raid_name(bctl->meta.target));
                ret = -EINVAL;
                goto out;
        }
        if (validate_convert_profile(&bctl->sys, allowed)) {
                ret = -EINVAL;
                goto out;
        }
        if (validate_convert_profile(&bctl->sys, allowed)) {
-               int index = btrfs_bg_flags_to_raid_index(bctl->sys.target);
-
                btrfs_err(fs_info,
                          "balance: invalid convert system profile %s",
                btrfs_err(fs_info,
                          "balance: invalid convert system profile %s",
-                         get_raid_name(index));
+                         btrfs_bg_type_to_raid_name(bctl->sys.target));
                ret = -EINVAL;
                goto out;
        }
                ret = -EINVAL;
                goto out;
        }
@@ -4159,12 +4153,10 @@ int btrfs_balance(struct btrfs_fs_info *fs_info,
 
        if (btrfs_get_num_tolerated_disk_barrier_failures(meta_target) <
                btrfs_get_num_tolerated_disk_barrier_failures(data_target)) {
 
        if (btrfs_get_num_tolerated_disk_barrier_failures(meta_target) <
                btrfs_get_num_tolerated_disk_barrier_failures(data_target)) {
-               int meta_index = btrfs_bg_flags_to_raid_index(meta_target);
-               int data_index = btrfs_bg_flags_to_raid_index(data_target);
-
                btrfs_warn(fs_info,
        "balance: metadata profile %s has lower redundancy than data profile %s",
                btrfs_warn(fs_info,
        "balance: metadata profile %s has lower redundancy than data profile %s",
-                          get_raid_name(meta_index), get_raid_name(data_index));
+                               btrfs_bg_type_to_raid_name(meta_target),
+                               btrfs_bg_type_to_raid_name(data_target));
        }
 
        ret = insert_balance_item(fs_info, bctl);
        }
 
        ret = insert_balance_item(fs_info, bctl);
index 73520a6ed90ad8d66e22b18d9b73f950e693e652..4a7a4d90ded8e41a3e6f9789b6311ed3415966dd 100644 (file)
@@ -556,8 +556,6 @@ static inline enum btrfs_raid_types btrfs_bg_flags_to_raid_index(u64 flags)
        return BTRFS_RAID_SINGLE; /* BTRFS_BLOCK_GROUP_SINGLE */
 }
 
        return BTRFS_RAID_SINGLE; /* BTRFS_BLOCK_GROUP_SINGLE */
 }
 
-const char *get_raid_name(enum btrfs_raid_types type);
-
 void btrfs_commit_device_sizes(struct btrfs_transaction *trans);
 
 struct list_head *btrfs_get_fs_uuids(void);
 void btrfs_commit_device_sizes(struct btrfs_transaction *trans);
 
 struct list_head *btrfs_get_fs_uuids(void);
@@ -567,6 +565,7 @@ bool btrfs_check_rw_degradable(struct btrfs_fs_info *fs_info,
                                        struct btrfs_device *failing_dev);
 
 int btrfs_bg_type_to_factor(u64 flags);
                                        struct btrfs_device *failing_dev);
 
 int btrfs_bg_type_to_factor(u64 flags);
+const char *btrfs_bg_type_to_raid_name(u64 flags);
 int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info);
 
 #endif
 int btrfs_verify_dev_extents(struct btrfs_fs_info *fs_info);
 
 #endif