UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

dm raid: remove all the bitops wrappers 

Removes obfuscation that is of little value.

Signed-off-by: Mike Snitzer <snitzer@redhat.com>
This commit is contained in:
Mike Snitzer 2016-06-02 12:27:46 -04:00
parent bb91a63fcc
commit 4286325b4b
1 changed files with 89 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

214
drivers/md/dm-raid.c
View File

@ -46,27 +46,46 @@ struct raid_dev {
}; };
/* /*
* Flags for rs->ctr_flags field. * Bits for establishing rs->ctr_flags
* *
* 1 = no flag value * 1 = no flag value
* 2 = flag with value * 2 = flag with value
*/ */
#define CTR_FLAG_SYNC 0x1 /* 1 */ /* Not with raid0! */ #define __CTR_FLAG_SYNC 0 /* 1 */ /* Not with raid0! */
#define CTR_FLAG_NOSYNC 0x2 /* 1 */ /* Not with raid0! */ #define __CTR_FLAG_NOSYNC 1 /* 1 */ /* Not with raid0! */
#define CTR_FLAG_REBUILD 0x4 /* 2 */ /* Not with raid0! */ #define __CTR_FLAG_REBUILD 2 /* 2 */ /* Not with raid0! */
#define CTR_FLAG_DAEMON_SLEEP 0x8 /* 2 */ /* Not with raid0! */ #define __CTR_FLAG_DAEMON_SLEEP 3 /* 2 */ /* Not with raid0! */
#define CTR_FLAG_MIN_RECOVERY_RATE 0x10 /* 2 */ /* Not with raid0! */ #define __CTR_FLAG_MIN_RECOVERY_RATE 4 /* 2 */ /* Not with raid0! */
#define CTR_FLAG_MAX_RECOVERY_RATE 0x20 /* 2 */ /* Not with raid0! */ #define __CTR_FLAG_MAX_RECOVERY_RATE 5 /* 2 */ /* Not with raid0! */
#define CTR_FLAG_MAX_WRITE_BEHIND 0x40 /* 2 */ /* Only with raid1! */ #define __CTR_FLAG_MAX_WRITE_BEHIND 6 /* 2 */ /* Only with raid1! */
#define CTR_FLAG_WRITE_MOSTLY 0x80 /* 2 */ /* Only with raid1! */ #define __CTR_FLAG_WRITE_MOSTLY 7 /* 2 */ /* Only with raid1! */
#define CTR_FLAG_STRIPE_CACHE 0x100 /* 2 */ /* Only with raid4/5/6! */ #define __CTR_FLAG_STRIPE_CACHE 8 /* 2 */ /* Only with raid4/5/6! */
#define CTR_FLAG_REGION_SIZE 0x200 /* 2 */ /* Not with raid0! */ #define __CTR_FLAG_REGION_SIZE 9 /* 2 */ /* Not with raid0! */
#define CTR_FLAG_RAID10_COPIES 0x400 /* 2 */ /* Only with raid10 */ #define __CTR_FLAG_RAID10_COPIES 10 /* 2 */ /* Only with raid10 */
#define CTR_FLAG_RAID10_FORMAT 0x800 /* 2 */ /* Only with raid10 */ #define __CTR_FLAG_RAID10_FORMAT 11 /* 2 */ /* Only with raid10 */
/* New for v1.9.0 */ /* New for v1.9.0 */
#define CTR_FLAG_DELTA_DISKS 0x1000 /* 2 */ /* Only with reshapable raid4/5/6/10! */ #define __CTR_FLAG_DELTA_DISKS 12 /* 2 */ /* Only with reshapable raid4/5/6/10! */
#define CTR_FLAG_DATA_OFFSET 0x2000 /* 2 */ /* Only with reshapable raid4/5/6/10! */ #define __CTR_FLAG_DATA_OFFSET 13 /* 2 */ /* Only with reshapable raid4/5/6/10! */
#define CTR_FLAG_RAID10_USE_NEAR_SETS 0x4000 /* 2 */ /* Only with raid10! */ #define __CTR_FLAG_RAID10_USE_NEAR_SETS 14 /* 2 */ /* Only with raid10! */
/*
* Flags for rs->ctr_flags field.
*/
#define CTR_FLAG_SYNC (1 << __CTR_FLAG_SYNC)
#define CTR_FLAG_NOSYNC (1 << __CTR_FLAG_NOSYNC)
#define CTR_FLAG_REBUILD (1 << __CTR_FLAG_REBUILD)
#define CTR_FLAG_DAEMON_SLEEP (1 << __CTR_FLAG_DAEMON_SLEEP)
#define CTR_FLAG_MIN_RECOVERY_RATE (1 << __CTR_FLAG_MIN_RECOVERY_RATE)
#define CTR_FLAG_MAX_RECOVERY_RATE (1 << __CTR_FLAG_MAX_RECOVERY_RATE)
#define CTR_FLAG_MAX_WRITE_BEHIND (1 << __CTR_FLAG_MAX_WRITE_BEHIND)
#define CTR_FLAG_WRITE_MOSTLY (1 << __CTR_FLAG_WRITE_MOSTLY)
#define CTR_FLAG_STRIPE_CACHE (1 << __CTR_FLAG_STRIPE_CACHE)
#define CTR_FLAG_REGION_SIZE (1 << __CTR_FLAG_REGION_SIZE)
#define CTR_FLAG_RAID10_COPIES (1 << __CTR_FLAG_RAID10_COPIES)
#define CTR_FLAG_RAID10_FORMAT (1 << __CTR_FLAG_RAID10_FORMAT)
#define CTR_FLAG_DELTA_DISKS (1 << __CTR_FLAG_DELTA_DISKS)
#define CTR_FLAG_DATA_OFFSET (1 << __CTR_FLAG_DATA_OFFSET)
#define CTR_FLAG_RAID10_USE_NEAR_SETS (1 << __CTR_FLAG_RAID10_USE_NEAR_SETS)
/* /*
* Definitions of various constructor flags to * Definitions of various constructor flags to
@ -158,8 +177,8 @@ struct raid_set {
struct dm_target *ti; struct dm_target *ti;
uint32_t bitmap_loaded; uint32_t bitmap_loaded;
uint32_t ctr_flags; unsigned long ctr_flags;
uint32_t runtime_flags; unsigned long runtime_flags;
uint64_t rebuild_disks[DISKS_ARRAY_ELEMS]; uint64_t rebuild_disks[DISKS_ARRAY_ELEMS];
@ -249,65 +268,9 @@ static bool __within_range(long v, long min, long max)
return v >= min && v <= max; return v >= min && v <= max;
} }
/* ctr flag bit manipulation... */
/* Set single @flag in @flags */
static void _set_flag(uint32_t flag, uint32_t *flags)
{
WARN_ON_ONCE(hweight32(flag) != 1);
*flags |= flag;
}
/* Clear single @flag in @flags */
static void _clear_flag(uint32_t flag, uint32_t *flags)
{
WARN_ON_ONCE(hweight32(flag) != 1);
*flags &= ~flag;
}
/* Test single @flag in @flags */
static bool _test_flag(uint32_t flag, uint32_t flags)
{
WARN_ON_ONCE(hweight32(flag) != 1);
return (flag & flags) ? true : false;
}
/* Test multiple @flags in @all_flags */
static bool _test_flags(uint32_t flags, uint32_t all_flags)
{
return (flags & all_flags) ? true : false;
}
/* Clear (multiple) @flags in @all_flags */
static void _clear_flags(uint32_t flags, uint32_t *all_flags)
{
*all_flags &= ~flags;
}
/* Return true if single @flag is set in @*flags, else set it and return false */
static bool _test_and_set_flag(uint32_t flag, uint32_t *flags)
{
if (_test_flag(flag, *flags))
return true;
_set_flag(flag, flags);
return false;
}
/* Return true if single @flag is set in @*flags and clear it, else return false */
static bool _test_and_clear_flag(uint32_t flag, uint32_t *flags)
{
if (_test_flag(flag, *flags)) {
_clear_flag(flag, flags);
return true;
}
return false;
}
/* ...ctr and runtime flag bit manipulation */
/* All table line arguments are defined here */ /* All table line arguments are defined here */
static struct arg_name_flag { static struct arg_name_flag {
const uint32_t flag; const unsigned long flag;
const char *name; const char *name;
} _arg_name_flags[] = { } _arg_name_flags[] = {
{ CTR_FLAG_SYNC, "sync"}, { CTR_FLAG_SYNC, "sync"},
@ -334,7 +297,7 @@ static const char *dm_raid_arg_name_by_flag(const uint32_t flag)
struct arg_name_flag *anf = _arg_name_flags + ARRAY_SIZE(_arg_name_flags); struct arg_name_flag *anf = _arg_name_flags + ARRAY_SIZE(_arg_name_flags);
while (anf-- > _arg_name_flags) while (anf-- > _arg_name_flags)
if (_test_flag(flag, anf->flag)) if (flag & anf->flag)
return anf->name; return anf->name;
} else } else
@ -425,8 +388,8 @@ static uint32_t _invalid_flags(struct raid_set *rs)
*/ */
static int rs_check_for_invalid_flags(struct raid_set *rs) static int rs_check_for_invalid_flags(struct raid_set *rs)
{ {
if (_test_flags(rs->ctr_flags, _invalid_flags(rs))) { if (rs->ctr_flags & _invalid_flags(rs)) {
rs->ti->error = "Invalid flag combined"; rs->ti->error = "Invalid flags combination";
return -EINVAL; return -EINVAL;
} }
@ -533,13 +496,13 @@ static int raid10_format_to_md_layout(struct raid_set *rs,
else if (algorithm == ALGORITHM_RAID10_OFFSET) { else if (algorithm == ALGORITHM_RAID10_OFFSET) {
f = copies; f = copies;
r = RAID10_OFFSET; r = RAID10_OFFSET;
if (!_test_flag(CTR_FLAG_RAID10_USE_NEAR_SETS, rs->ctr_flags)) if (!test_bit(__CTR_FLAG_RAID10_USE_NEAR_SETS, &rs->ctr_flags))
r |= RAID10_USE_FAR_SETS; r |= RAID10_USE_FAR_SETS;
} else if (algorithm == ALGORITHM_RAID10_FAR) { } else if (algorithm == ALGORITHM_RAID10_FAR) {
f = copies; f = copies;
r = !RAID10_OFFSET; r = !RAID10_OFFSET;
if (!_test_flag(CTR_FLAG_RAID10_USE_NEAR_SETS, rs->ctr_flags)) if (!test_bit(__CTR_FLAG_RAID10_USE_NEAR_SETS, &rs->ctr_flags))
r |= RAID10_USE_FAR_SETS; r |= RAID10_USE_FAR_SETS;
} else } else
@ -1061,7 +1024,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
} }
if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_NOSYNC))) { if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_NOSYNC))) {
if (_test_and_set_flag(CTR_FLAG_NOSYNC, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags)) {
rs->ti->error = "Only one 'nosync' argument allowed"; rs->ti->error = "Only one 'nosync' argument allowed";
return -EINVAL; return -EINVAL;
} }
@ -1069,7 +1032,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
continue; continue;
} }
if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_SYNC))) { if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_SYNC))) {
if (_test_and_set_flag(CTR_FLAG_SYNC, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_SYNC, &rs->ctr_flags)) {
rs->ti->error = "Only one 'sync' argument allowed"; rs->ti->error = "Only one 'sync' argument allowed";
return -EINVAL; return -EINVAL;
} }
@ -1077,7 +1040,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
continue; continue;
} }
if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_USE_NEAR_SETS))) { if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_USE_NEAR_SETS))) {
if (_test_and_set_flag(CTR_FLAG_RAID10_USE_NEAR_SETS, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_RAID10_USE_NEAR_SETS, &rs->ctr_flags)) {
rs->ti->error = "Only one 'raid10_use_new_sets' argument allowed"; rs->ti->error = "Only one 'raid10_use_new_sets' argument allowed";
return -EINVAL; return -EINVAL;
} }
@ -1096,7 +1059,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
*/ */
if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_FORMAT))) { if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_FORMAT))) {
if (_test_and_set_flag(CTR_FLAG_RAID10_FORMAT, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_RAID10_FORMAT, &rs->ctr_flags)) {
rs->ti->error = "Only one 'raid10_format' argument pair allowed"; rs->ti->error = "Only one 'raid10_format' argument pair allowed";
return -EINVAL; return -EINVAL;
} }
@ -1137,7 +1100,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
clear_bit(In_sync, &rd->rdev.flags); clear_bit(In_sync, &rd->rdev.flags);
clear_bit(Faulty, &rd->rdev.flags); clear_bit(Faulty, &rd->rdev.flags);
rd->rdev.recovery_offset = 0; rd->rdev.recovery_offset = 0;
_set_flag(CTR_FLAG_REBUILD, &rs->ctr_flags); set_bit(__CTR_FLAG_REBUILD, &rs->ctr_flags);
} else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_WRITE_MOSTLY))) { } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_WRITE_MOSTLY))) {
if (!rt_is_raid1(rt)) { if (!rt_is_raid1(rt)) {
rs->ti->error = "write_mostly option is only valid for RAID1"; rs->ti->error = "write_mostly option is only valid for RAID1";
@ -1150,14 +1113,14 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
} }
set_bit(WriteMostly, &rs->dev[value].rdev.flags); set_bit(WriteMostly, &rs->dev[value].rdev.flags);
_set_flag(CTR_FLAG_WRITE_MOSTLY, &rs->ctr_flags); set_bit(__CTR_FLAG_WRITE_MOSTLY, &rs->ctr_flags);
} else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_MAX_WRITE_BEHIND))) { } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_MAX_WRITE_BEHIND))) {
if (!rt_is_raid1(rt)) { if (!rt_is_raid1(rt)) {
rs->ti->error = "max_write_behind option is only valid for RAID1"; rs->ti->error = "max_write_behind option is only valid for RAID1";
return -EINVAL; return -EINVAL;
} }
if (_test_and_set_flag(CTR_FLAG_MAX_WRITE_BEHIND, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_MAX_WRITE_BEHIND, &rs->ctr_flags)) {
rs->ti->error = "Only one max_write_behind argument pair allowed"; rs->ti->error = "Only one max_write_behind argument pair allowed";
return -EINVAL; return -EINVAL;
} }
@ -1174,7 +1137,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
rs->md.bitmap_info.max_write_behind = value; rs->md.bitmap_info.max_write_behind = value;
} else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_DAEMON_SLEEP))) { } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_DAEMON_SLEEP))) {
if (_test_and_set_flag(CTR_FLAG_DAEMON_SLEEP, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_DAEMON_SLEEP, &rs->ctr_flags)) {
rs->ti->error = "Only one daemon_sleep argument pair allowed"; rs->ti->error = "Only one daemon_sleep argument pair allowed";
return -EINVAL; return -EINVAL;
} }
@ -1185,7 +1148,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
rs->md.bitmap_info.daemon_sleep = value; rs->md.bitmap_info.daemon_sleep = value;
} else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_DATA_OFFSET))) { } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_DATA_OFFSET))) {
/* Userspace passes new data_offset after having extended the the data image LV */ /* Userspace passes new data_offset after having extended the the data image LV */
if (_test_and_set_flag(CTR_FLAG_DATA_OFFSET, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_DATA_OFFSET, &rs->ctr_flags)) {
rs->ti->error = "Only one data_offset argument pair allowed"; rs->ti->error = "Only one data_offset argument pair allowed";
return -EINVAL; return -EINVAL;
} }
@ -1197,7 +1160,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
rs->data_offset = value; rs->data_offset = value;
} else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_DELTA_DISKS))) { } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_DELTA_DISKS))) {
/* Define the +/-# of disks to add to/remove from the given raid set */ /* Define the +/-# of disks to add to/remove from the given raid set */
if (_test_and_set_flag(CTR_FLAG_DELTA_DISKS, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_DELTA_DISKS, &rs->ctr_flags)) {
rs->ti->error = "Only one delta_disks argument pair allowed"; rs->ti->error = "Only one delta_disks argument pair allowed";
return -EINVAL; return -EINVAL;
} }
@ -1209,7 +1172,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
rs->delta_disks = value; rs->delta_disks = value;
} else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_STRIPE_CACHE))) { } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_STRIPE_CACHE))) {
if (_test_and_set_flag(CTR_FLAG_STRIPE_CACHE, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_STRIPE_CACHE, &rs->ctr_flags)) {
rs->ti->error = "Only one stripe_cache argument pair allowed"; rs->ti->error = "Only one stripe_cache argument pair allowed";
return -EINVAL; return -EINVAL;
} }
@ -1230,7 +1193,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
} }
} else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_MIN_RECOVERY_RATE))) { } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_MIN_RECOVERY_RATE))) {
if (_test_and_set_flag(CTR_FLAG_MIN_RECOVERY_RATE, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_MIN_RECOVERY_RATE, &rs->ctr_flags)) {
rs->ti->error = "Only one min_recovery_rate argument pair allowed"; rs->ti->error = "Only one min_recovery_rate argument pair allowed";
return -EINVAL; return -EINVAL;
} }
@ -1240,7 +1203,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
} }
rs->md.sync_speed_min = (int)value; rs->md.sync_speed_min = (int)value;
} else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_MAX_RECOVERY_RATE))) { } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_MAX_RECOVERY_RATE))) {
if (_test_and_set_flag(CTR_FLAG_MIN_RECOVERY_RATE, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_MIN_RECOVERY_RATE, &rs->ctr_flags)) {
rs->ti->error = "Only one max_recovery_rate argument pair allowed"; rs->ti->error = "Only one max_recovery_rate argument pair allowed";
return -EINVAL; return -EINVAL;
} }
@ -1250,14 +1213,14 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
} }
rs->md.sync_speed_max = (int)value; rs->md.sync_speed_max = (int)value;
} else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_REGION_SIZE))) { } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_REGION_SIZE))) {
if (_test_and_set_flag(CTR_FLAG_REGION_SIZE, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_REGION_SIZE, &rs->ctr_flags)) {
rs->ti->error = "Only one region_size argument pair allowed"; rs->ti->error = "Only one region_size argument pair allowed";
return -EINVAL; return -EINVAL;
} }
region_size = value; region_size = value;
} else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_COPIES))) { } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_COPIES))) {
if (_test_and_set_flag(CTR_FLAG_RAID10_COPIES, &rs->ctr_flags)) { if (test_and_set_bit(__CTR_FLAG_RAID10_COPIES, &rs->ctr_flags)) {
rs->ti->error = "Only one raid10_copies argument pair allowed"; rs->ti->error = "Only one raid10_copies argument pair allowed";
return -EINVAL; return -EINVAL;
} }
@ -1306,7 +1269,7 @@ static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as,
if ((rt->algorithm == ALGORITHM_RAID10_DEFAULT || if ((rt->algorithm == ALGORITHM_RAID10_DEFAULT ||
rt->algorithm == ALGORITHM_RAID10_NEAR) && rt->algorithm == ALGORITHM_RAID10_NEAR) &&
_test_flag(CTR_FLAG_RAID10_USE_NEAR_SETS, rs->ctr_flags)) { test_bit(__CTR_FLAG_RAID10_USE_NEAR_SETS, &rs->ctr_flags)) {
rs->ti->error = "RAID10 format 'near' and 'raid10_use_near_sets' are incompatible"; rs->ti->error = "RAID10 format 'near' and 'raid10_use_near_sets' are incompatible";
return -EINVAL; return -EINVAL;
} }
@ -1624,7 +1587,7 @@ static void sb_retrieve_failed_devices(struct dm_raid_superblock *sb, uint64_t *
failed_devices[0] = le64_to_cpu(sb->failed_devices); failed_devices[0] = le64_to_cpu(sb->failed_devices);
memset(failed_devices + 1, 0, sizeof(sb->extended_failed_devices)); memset(failed_devices + 1, 0, sizeof(sb->extended_failed_devices));
if (_test_flag(FEATURE_FLAG_SUPPORTS_V190, le32_to_cpu(sb->compat_features))) { if (le32_to_cpu(sb->compat_features) & FEATURE_FLAG_SUPPORTS_V190) {
int i = ARRAY_SIZE(sb->extended_failed_devices); int i = ARRAY_SIZE(sb->extended_failed_devices);
while (i--) while (i--)
@ -1702,9 +1665,10 @@ static void super_sync(struct mddev *mddev, struct md_rdev *rdev)
if (mddev->delta_disks < 0 || mddev->reshape_backwards) if (mddev->delta_disks < 0 || mddev->reshape_backwards)
sb->flags |= cpu_to_le32(SB_FLAG_RESHAPE_BACKWARDS); sb->flags |= cpu_to_le32(SB_FLAG_RESHAPE_BACKWARDS);
} else } else {
/* Flag no reshape */ /* Clear reshape flags */
_clear_flags(cpu_to_le32(SB_FLAG_RESHAPE_ACTIVE|SB_FLAG_RESHAPE_BACKWARDS), &sb->flags); sb->flags &= ~(cpu_to_le32(SB_FLAG_RESHAPE_ACTIVE|SB_FLAG_RESHAPE_BACKWARDS));
}
sb->array_sectors = cpu_to_le64(mddev->array_sectors); sb->array_sectors = cpu_to_le64(mddev->array_sectors);
sb->data_offset = cpu_to_le64(rdev->data_offset); sb->data_offset = cpu_to_le64(rdev->data_offset);
@ -1799,7 +1763,7 @@ static int super_init_validation(struct raid_set *rs, struct md_rdev *rdev)
* Reshaping is supported, e.g. reshape_position is valid * Reshaping is supported, e.g. reshape_position is valid
* in superblock and superblock content is authoritative. * in superblock and superblock content is authoritative.
*/ */
if (_test_flag(FEATURE_FLAG_SUPPORTS_V190, le32_to_cpu(sb->compat_features))) { if (le32_to_cpu(sb->compat_features) & FEATURE_FLAG_SUPPORTS_V190) {
/* Superblock is authoritative wrt given raid set layout! */ /* Superblock is authoritative wrt given raid set layout! */
mddev->raid_disks = le32_to_cpu(sb->num_devices); mddev->raid_disks = le32_to_cpu(sb->num_devices);
mddev->level = le32_to_cpu(sb->level); mddev->level = le32_to_cpu(sb->level);
@ -1812,14 +1776,14 @@ static int super_init_validation(struct raid_set *rs, struct md_rdev *rdev)
mddev->array_sectors = le64_to_cpu(sb->array_sectors); mddev->array_sectors = le64_to_cpu(sb->array_sectors);
/* raid was reshaping and got interrupted */ /* raid was reshaping and got interrupted */
if (_test_flag(SB_FLAG_RESHAPE_ACTIVE, le32_to_cpu(sb->flags))) { if (le32_to_cpu(sb->flags) & SB_FLAG_RESHAPE_ACTIVE) {
if (_test_flag(CTR_FLAG_DELTA_DISKS, rs->ctr_flags)) { if (test_bit(__CTR_FLAG_DELTA_DISKS, &rs->ctr_flags)) {
DMERR("Reshape requested but raid set is still reshaping"); DMERR("Reshape requested but raid set is still reshaping");
return -EINVAL; return -EINVAL;
} }
if (mddev->delta_disks < 0 || if (mddev->delta_disks < 0 ||
(!mddev->delta_disks && _test_flag(SB_FLAG_RESHAPE_BACKWARDS, le32_to_cpu(sb->flags)))) (!mddev->delta_disks && (le32_to_cpu(sb->flags) & SB_FLAG_RESHAPE_BACKWARDS)))
mddev->reshape_backwards = 1; mddev->reshape_backwards = 1;
else else
mddev->reshape_backwards = 0; mddev->reshape_backwards = 0;
@ -1864,7 +1828,7 @@ static int super_init_validation(struct raid_set *rs, struct md_rdev *rdev)
rs_set_new(rs); rs_set_new(rs);
} }
if (!_test_flag(CTR_FLAG_NOSYNC, rs->ctr_flags)) if (!test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags))
mddev->recovery_cp = le64_to_cpu(sb->array_resync_offset); mddev->recovery_cp = le64_to_cpu(sb->array_resync_offset);
/* /*
@ -1902,7 +1866,7 @@ static int super_init_validation(struct raid_set *rs, struct md_rdev *rdev)
if (new_devs == rs->raid_disks) { if (new_devs == rs->raid_disks) {
DMINFO("Superblocks created for new raid set"); DMINFO("Superblocks created for new raid set");
set_bit(MD_ARRAY_FIRST_USE, &mddev->flags); set_bit(MD_ARRAY_FIRST_USE, &mddev->flags);
_set_flag(RT_FLAG_UPDATE_SBS, &rs->runtime_flags); set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags);
mddev->recovery_cp = 0; mddev->recovery_cp = 0;
} else if (new_devs && new_devs != rs->raid_disks && !rebuilds) { } else if (new_devs && new_devs != rs->raid_disks && !rebuilds) {
DMERR("New device injected into existing raid set without " DMERR("New device injected into existing raid set without "
@ -2065,7 +2029,7 @@ static int analyse_superblocks(struct dm_target *ti, struct raid_set *rs)
* that the "sync" directive is disallowed during the * that the "sync" directive is disallowed during the
* reshape. * reshape.
*/ */
if (_test_flag(CTR_FLAG_SYNC, rs->ctr_flags)) if (test_bit(__CTR_FLAG_SYNC, &rs->ctr_flags))
continue; continue;
if (!rdev->meta_bdev) if (!rdev->meta_bdev)
@ -2342,7 +2306,7 @@ static int raid_ctr(struct dm_target *ti, unsigned argc, char **argv)
return r; return r;
/* Tell preresume to update superblocks with new layout */ /* Tell preresume to update superblocks with new layout */
_set_flag(RT_FLAG_UPDATE_SBS, &rs->runtime_flags); set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags);
rs_set_new(rs); rs_set_new(rs);
} else } else
rs_set_cur(rs); rs_set_cur(rs);
@ -2553,7 +2517,7 @@ static void raid_status(struct dm_target *ti, status_type_t type,
/* Access most recent mddev properties for status output */ /* Access most recent mddev properties for status output */
smp_rmb(); smp_rmb();
/* Get sensible max sectors even if raid set not yet started */ /* Get sensible max sectors even if raid set not yet started */
resync_max_sectors = _test_flag(RT_FLAG_RS_PRERESUMED, rs->runtime_flags) ? resync_max_sectors = test_bit(RT_FLAG_RS_PRERESUMED, &rs->runtime_flags) ?
mddev->resync_max_sectors : mddev->dev_sectors; mddev->resync_max_sectors : mddev->dev_sectors;
progress = rs_get_progress(rs, resync_max_sectors, &array_in_sync); progress = rs_get_progress(rs, resync_max_sectors, &array_in_sync);
resync_mismatches = (mddev->last_sync_action && !strcasecmp(mddev->last_sync_action, "check")) ? resync_mismatches = (mddev->last_sync_action && !strcasecmp(mddev->last_sync_action, "check")) ?
@ -2624,29 +2588,29 @@ static void raid_status(struct dm_target *ti, status_type_t type,
hweight32(rs->ctr_flags & CTR_FLAG_OPTIONS_ONE_ARG) * 2; hweight32(rs->ctr_flags & CTR_FLAG_OPTIONS_ONE_ARG) * 2;
/* Emit table line */ /* Emit table line */
DMEMIT("%s %u %u", rs->raid_type->name, raid_param_cnt, mddev->new_chunk_sectors); DMEMIT("%s %u %u", rs->raid_type->name, raid_param_cnt, mddev->new_chunk_sectors);
if (_test_flag(CTR_FLAG_RAID10_FORMAT, rs->ctr_flags)) if (test_bit(__CTR_FLAG_RAID10_FORMAT, &rs->ctr_flags))
DMEMIT(" %s %s", dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_FORMAT), DMEMIT(" %s %s", dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_FORMAT),
raid10_md_layout_to_format(mddev->layout)); raid10_md_layout_to_format(mddev->layout));
if (_test_flag(CTR_FLAG_RAID10_COPIES, rs->ctr_flags)) if (test_bit(__CTR_FLAG_RAID10_COPIES, &rs->ctr_flags))
DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_COPIES), DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_COPIES),
raid10_md_layout_to_copies(mddev->layout)); raid10_md_layout_to_copies(mddev->layout));
if (_test_flag(CTR_FLAG_NOSYNC, rs->ctr_flags)) if (test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags))
DMEMIT(" %s", dm_raid_arg_name_by_flag(CTR_FLAG_NOSYNC)); DMEMIT(" %s", dm_raid_arg_name_by_flag(CTR_FLAG_NOSYNC));
if (_test_flag(CTR_FLAG_SYNC, rs->ctr_flags)) if (test_bit(__CTR_FLAG_SYNC, &rs->ctr_flags))
DMEMIT(" %s", dm_raid_arg_name_by_flag(CTR_FLAG_SYNC)); DMEMIT(" %s", dm_raid_arg_name_by_flag(CTR_FLAG_SYNC));
if (_test_flag(CTR_FLAG_REGION_SIZE, rs->ctr_flags)) if (test_bit(__CTR_FLAG_REGION_SIZE, &rs->ctr_flags))
DMEMIT(" %s %llu", dm_raid_arg_name_by_flag(CTR_FLAG_REGION_SIZE), DMEMIT(" %s %llu", dm_raid_arg_name_by_flag(CTR_FLAG_REGION_SIZE),
(unsigned long long) to_sector(mddev->bitmap_info.chunksize)); (unsigned long long) to_sector(mddev->bitmap_info.chunksize));
if (_test_flag(CTR_FLAG_DATA_OFFSET, rs->ctr_flags)) if (test_bit(__CTR_FLAG_DATA_OFFSET, &rs->ctr_flags))
DMEMIT(" %s %llu", dm_raid_arg_name_by_flag(CTR_FLAG_DATA_OFFSET), DMEMIT(" %s %llu", dm_raid_arg_name_by_flag(CTR_FLAG_DATA_OFFSET),
(unsigned long long) rs->data_offset); (unsigned long long) rs->data_offset);
if (_test_flag(CTR_FLAG_DAEMON_SLEEP, rs->ctr_flags)) if (test_bit(__CTR_FLAG_DAEMON_SLEEP, &rs->ctr_flags))
DMEMIT(" %s %lu", dm_raid_arg_name_by_flag(CTR_FLAG_DAEMON_SLEEP), DMEMIT(" %s %lu", dm_raid_arg_name_by_flag(CTR_FLAG_DAEMON_SLEEP),
mddev->bitmap_info.daemon_sleep); mddev->bitmap_info.daemon_sleep);
if (_test_flag(CTR_FLAG_DELTA_DISKS, rs->ctr_flags)) if (test_bit(__CTR_FLAG_DELTA_DISKS, &rs->ctr_flags))
DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_DELTA_DISKS), DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_DELTA_DISKS),
mddev->delta_disks); mddev->delta_disks);
if (_test_flag(CTR_FLAG_STRIPE_CACHE, rs->ctr_flags)) if (test_bit(__CTR_FLAG_STRIPE_CACHE, &rs->ctr_flags))
DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_STRIPE_CACHE), DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_STRIPE_CACHE),
max_nr_stripes); max_nr_stripes);
rdev_for_each(rdev, mddev) rdev_for_each(rdev, mddev)
@ -2657,13 +2621,13 @@ static void raid_status(struct dm_target *ti, status_type_t type,
if (test_bit(WriteMostly, &rdev->flags)) if (test_bit(WriteMostly, &rdev->flags))
DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_WRITE_MOSTLY), DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_WRITE_MOSTLY),
rdev->raid_disk); rdev->raid_disk);
if (_test_flag(CTR_FLAG_MAX_WRITE_BEHIND, rs->ctr_flags)) if (test_bit(__CTR_FLAG_MAX_WRITE_BEHIND, &rs->ctr_flags))
DMEMIT(" %s %lu", dm_raid_arg_name_by_flag(CTR_FLAG_MAX_WRITE_BEHIND), DMEMIT(" %s %lu", dm_raid_arg_name_by_flag(CTR_FLAG_MAX_WRITE_BEHIND),
mddev->bitmap_info.max_write_behind); mddev->bitmap_info.max_write_behind);
if (_test_flag(CTR_FLAG_MAX_RECOVERY_RATE, rs->ctr_flags)) if (test_bit(__CTR_FLAG_MAX_RECOVERY_RATE, &rs->ctr_flags))
DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_MAX_RECOVERY_RATE), DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_MAX_RECOVERY_RATE),
mddev->sync_speed_max); mddev->sync_speed_max);
if (_test_flag(CTR_FLAG_MIN_RECOVERY_RATE, rs->ctr_flags)) if (test_bit(__CTR_FLAG_MIN_RECOVERY_RATE, &rs->ctr_flags))
DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_MIN_RECOVERY_RATE), DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_MIN_RECOVERY_RATE),
mddev->sync_speed_min); mddev->sync_speed_min);
DMEMIT(" %d", rs->raid_disks); DMEMIT(" %d", rs->raid_disks);
@ -2835,7 +2799,7 @@ static int _bitmap_load(struct raid_set *rs)
/* Try loading the bitmap unless "raid0", which does not have one */ /* Try loading the bitmap unless "raid0", which does not have one */
if (!rs_is_raid0(rs) && if (!rs_is_raid0(rs) &&
!_test_and_set_flag(RT_FLAG_RS_BITMAP_LOADED, &rs->runtime_flags)) { !test_and_set_bit(RT_FLAG_RS_BITMAP_LOADED, &rs->runtime_flags)) {
r = bitmap_load(&rs->md); r = bitmap_load(&rs->md);
if (r) if (r)
DMERR("Failed to load bitmap"); DMERR("Failed to load bitmap");
@ -2850,7 +2814,7 @@ static int raid_preresume(struct dm_target *ti)
struct mddev *mddev = &rs->md; struct mddev *mddev = &rs->md;
/* This is a resume after a suspend of the set -> it's already started */ /* This is a resume after a suspend of the set -> it's already started */
if (_test_and_set_flag(RT_FLAG_RS_PRERESUMED, &rs->runtime_flags)) if (test_and_set_bit(RT_FLAG_RS_PRERESUMED, &rs->runtime_flags))
return 0; return 0;
/* /*
@ -2865,7 +2829,7 @@ static int raid_preresume(struct dm_target *ti)
* Have to switch to readwrite and back in order to * Have to switch to readwrite and back in order to
* allow for the superblock updates. * allow for the superblock updates.
*/ */
if (_test_and_clear_flag(RT_FLAG_UPDATE_SBS, &rs->runtime_flags)) { if (test_and_clear_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags)) {
set_bit(MD_CHANGE_DEVS, &mddev->flags); set_bit(MD_CHANGE_DEVS, &mddev->flags);
mddev->ro = 0; mddev->ro = 0;
md_update_sb(mddev, 1); md_update_sb(mddev, 1);
@ -2887,7 +2851,7 @@ static void raid_resume(struct dm_target *ti)
struct raid_set *rs = ti->private; struct raid_set *rs = ti->private;
struct mddev *mddev = &rs->md; struct mddev *mddev = &rs->md;
if (_test_and_set_flag(RT_FLAG_RS_RESUMED, &rs->runtime_flags)) { if (test_and_set_bit(RT_FLAG_RS_RESUMED, &rs->runtime_flags)) {
/* /*
* A secondary resume while the device is active. * A secondary resume while the device is active.
* Take this opportunity to check whether any failed * Take this opportunity to check whether any failed