for (raid_type = 0; raid_type < BTRFS_NR_RAID_TYPES; raid_type++) {
                if (raid_type == BTRFS_RAID_SINGLE)
                        continue;
-               if (!(flags & btrfs_raid_group[raid_type]))
+               if (!(flags & btrfs_raid_array[raid_type].bg_flag))
                        continue;
                min_tolerated = min(min_tolerated,
                                    btrfs_raid_array[raid_type].
 
        /* First, mask out the RAID levels which aren't possible */
        for (raid_type = 0; raid_type < BTRFS_NR_RAID_TYPES; raid_type++) {
                if (num_devices >= btrfs_raid_array[raid_type].devs_min)
-                       allowed |= btrfs_raid_group[raid_type];
+                       allowed |= btrfs_raid_array[raid_type].bg_flag;
        }
        allowed &= flags;
 
 
                .devs_increment = 2,
                .ncopies        = 2,
                .raid_name      = "raid10",
+               .bg_flag        = BTRFS_BLOCK_GROUP_RAID10,
        },
        [BTRFS_RAID_RAID1] = {
                .sub_stripes    = 1,
                .devs_increment = 2,
                .ncopies        = 2,
                .raid_name      = "raid1",
+               .bg_flag        = BTRFS_BLOCK_GROUP_RAID1,
        },
        [BTRFS_RAID_DUP] = {
                .sub_stripes    = 1,
                .devs_increment = 1,
                .ncopies        = 2,
                .raid_name      = "dup",
+               .bg_flag        = BTRFS_BLOCK_GROUP_DUP,
        },
        [BTRFS_RAID_RAID0] = {
                .sub_stripes    = 1,
                .devs_increment = 1,
                .ncopies        = 1,
                .raid_name      = "raid0",
+               .bg_flag        = BTRFS_BLOCK_GROUP_RAID0,
        },
        [BTRFS_RAID_SINGLE] = {
                .sub_stripes    = 1,
                .devs_increment = 1,
                .ncopies        = 1,
                .raid_name      = "single",
+               .bg_flag        = 0,
        },
        [BTRFS_RAID_RAID5] = {
                .sub_stripes    = 1,
                .devs_increment = 1,
                .ncopies        = 2,
                .raid_name      = "raid5",
+               .bg_flag        = BTRFS_BLOCK_GROUP_RAID5,
        },
        [BTRFS_RAID_RAID6] = {
                .sub_stripes    = 1,
                .devs_increment = 1,
                .ncopies        = 3,
                .raid_name      = "raid6",
+               .bg_flag        = BTRFS_BLOCK_GROUP_RAID6,
        },
 };
 
        return btrfs_raid_array[type].raid_name;
 }
 
-const u64 btrfs_raid_group[BTRFS_NR_RAID_TYPES] = {
-       [BTRFS_RAID_RAID10] = BTRFS_BLOCK_GROUP_RAID10,
-       [BTRFS_RAID_RAID1]  = BTRFS_BLOCK_GROUP_RAID1,
-       [BTRFS_RAID_DUP]    = BTRFS_BLOCK_GROUP_DUP,
-       [BTRFS_RAID_RAID0]  = BTRFS_BLOCK_GROUP_RAID0,
-       [BTRFS_RAID_SINGLE] = 0,
-       [BTRFS_RAID_RAID5]  = BTRFS_BLOCK_GROUP_RAID5,
-       [BTRFS_RAID_RAID6]  = BTRFS_BLOCK_GROUP_RAID6,
-};
-
 /*
  * Table to convert BTRFS_RAID_* to the error code if minimum number of devices
  * condition is not met. Zero means there's no corresponding
        } while (read_seqretry(&fs_info->profiles_lock, seq));
 
        for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
-               if (!(all_avail & btrfs_raid_group[i]))
+               if (!(all_avail & btrfs_raid_array[i].bg_flag))
                        continue;
 
                if (num_devices < btrfs_raid_array[i].devs_min) {
 
        int devs_increment;     /* ndevs has to be a multiple of this */
        int ncopies;            /* how many copies to data has */
        const char raid_name[8]; /* name of the raid */
+       u64 bg_flag;            /* block group flag of the raid */
 };
 
 extern const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES];
 extern const int btrfs_raid_mindev_error[BTRFS_NR_RAID_TYPES];
-extern const u64 btrfs_raid_group[BTRFS_NR_RAID_TYPES];
 
 struct map_lookup {
        u64 type;