1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2010-2011 Neil Brown 4 * Copyright (C) 2010-2018 Red Hat, Inc. All rights reserved. 5 * 6 * This file is released under the GPL. 7 */ 8 9 #include <linux/slab.h> 10 #include <linux/module.h> 11 12 #include "md.h" 13 #include "raid1.h" 14 #include "raid5.h" 15 #include "raid10.h" 16 #include "md-bitmap.h" 17 #include "dm-core.h" 18 19 #include <linux/device-mapper.h> 20 21 #define DM_MSG_PREFIX "raid" 22 #define MAX_RAID_DEVICES 253 /* md-raid kernel limit */ 23 24 /* 25 * Minimum sectors of free reshape space per raid device 26 */ 27 #define MIN_FREE_RESHAPE_SPACE to_sector(4*4096) 28 29 /* 30 * Minimum journal space 4 MiB in sectors. 31 */ 32 #define MIN_RAID456_JOURNAL_SPACE (4*2048) 33 34 static bool devices_handle_discard_safely; 35 36 /* 37 * The following flags are used by dm-raid to set up the array state. 38 * They must be cleared before md_run is called. 39 */ 40 #define FirstUse 10 /* rdev flag */ 41 42 struct raid_dev { 43 /* 44 * Two DM devices, one to hold metadata and one to hold the 45 * actual data/parity. The reason for this is to not confuse 46 * ti->len and give more flexibility in altering size and 47 * characteristics. 48 * 49 * While it is possible for this device to be associated 50 * with a different physical device than the data_dev, it 51 * is intended for it to be the same. 52 * |--------- Physical Device ---------| 53 * |- meta_dev -|------ data_dev ------| 54 */ 55 struct dm_dev *meta_dev; 56 struct dm_dev *data_dev; 57 struct md_rdev rdev; 58 }; 59 60 /* 61 * Bits for establishing rs->ctr_flags 62 * 63 * 1 = no flag value 64 * 2 = flag with value 65 */ 66 #define __CTR_FLAG_SYNC 0 /* 1 */ /* Not with raid0! */ 67 #define __CTR_FLAG_NOSYNC 1 /* 1 */ /* Not with raid0! */ 68 #define __CTR_FLAG_REBUILD 2 /* 2 */ /* Not with raid0! */ 69 #define __CTR_FLAG_DAEMON_SLEEP 3 /* 2 */ /* Not with raid0! */ 70 #define __CTR_FLAG_MIN_RECOVERY_RATE 4 /* 2 */ /* Not with raid0! */ 71 #define __CTR_FLAG_MAX_RECOVERY_RATE 5 /* 2 */ /* Not with raid0! */ 72 #define __CTR_FLAG_MAX_WRITE_BEHIND 6 /* 2 */ /* Only with raid1! */ 73 #define __CTR_FLAG_WRITE_MOSTLY 7 /* 2 */ /* Only with raid1! */ 74 #define __CTR_FLAG_STRIPE_CACHE 8 /* 2 */ /* Only with raid4/5/6! */ 75 #define __CTR_FLAG_REGION_SIZE 9 /* 2 */ /* Not with raid0! */ 76 #define __CTR_FLAG_RAID10_COPIES 10 /* 2 */ /* Only with raid10 */ 77 #define __CTR_FLAG_RAID10_FORMAT 11 /* 2 */ /* Only with raid10 */ 78 /* New for v1.9.0 */ 79 #define __CTR_FLAG_DELTA_DISKS 12 /* 2 */ /* Only with reshapable raid1/4/5/6/10! */ 80 #define __CTR_FLAG_DATA_OFFSET 13 /* 2 */ /* Only with reshapable raid4/5/6/10! */ 81 #define __CTR_FLAG_RAID10_USE_NEAR_SETS 14 /* 2 */ /* Only with raid10! */ 82 83 /* New for v1.10.0 */ 84 #define __CTR_FLAG_JOURNAL_DEV 15 /* 2 */ /* Only with raid4/5/6 (journal device)! */ 85 86 /* New for v1.11.1 */ 87 #define __CTR_FLAG_JOURNAL_MODE 16 /* 2 */ /* Only with raid4/5/6 (journal mode)! */ 88 89 /* 90 * Flags for rs->ctr_flags field. 91 */ 92 #define CTR_FLAG_SYNC (1 << __CTR_FLAG_SYNC) 93 #define CTR_FLAG_NOSYNC (1 << __CTR_FLAG_NOSYNC) 94 #define CTR_FLAG_REBUILD (1 << __CTR_FLAG_REBUILD) 95 #define CTR_FLAG_DAEMON_SLEEP (1 << __CTR_FLAG_DAEMON_SLEEP) 96 #define CTR_FLAG_MIN_RECOVERY_RATE (1 << __CTR_FLAG_MIN_RECOVERY_RATE) 97 #define CTR_FLAG_MAX_RECOVERY_RATE (1 << __CTR_FLAG_MAX_RECOVERY_RATE) 98 #define CTR_FLAG_MAX_WRITE_BEHIND (1 << __CTR_FLAG_MAX_WRITE_BEHIND) 99 #define CTR_FLAG_WRITE_MOSTLY (1 << __CTR_FLAG_WRITE_MOSTLY) 100 #define CTR_FLAG_STRIPE_CACHE (1 << __CTR_FLAG_STRIPE_CACHE) 101 #define CTR_FLAG_REGION_SIZE (1 << __CTR_FLAG_REGION_SIZE) 102 #define CTR_FLAG_RAID10_COPIES (1 << __CTR_FLAG_RAID10_COPIES) 103 #define CTR_FLAG_RAID10_FORMAT (1 << __CTR_FLAG_RAID10_FORMAT) 104 #define CTR_FLAG_DELTA_DISKS (1 << __CTR_FLAG_DELTA_DISKS) 105 #define CTR_FLAG_DATA_OFFSET (1 << __CTR_FLAG_DATA_OFFSET) 106 #define CTR_FLAG_RAID10_USE_NEAR_SETS (1 << __CTR_FLAG_RAID10_USE_NEAR_SETS) 107 #define CTR_FLAG_JOURNAL_DEV (1 << __CTR_FLAG_JOURNAL_DEV) 108 #define CTR_FLAG_JOURNAL_MODE (1 << __CTR_FLAG_JOURNAL_MODE) 109 110 /* 111 * Definitions of various constructor flags to 112 * be used in checks of valid / invalid flags 113 * per raid level. 114 */ 115 /* Define all any sync flags */ 116 #define CTR_FLAGS_ANY_SYNC (CTR_FLAG_SYNC | CTR_FLAG_NOSYNC) 117 118 /* Define flags for options without argument (e.g. 'nosync') */ 119 #define CTR_FLAG_OPTIONS_NO_ARGS (CTR_FLAGS_ANY_SYNC | \ 120 CTR_FLAG_RAID10_USE_NEAR_SETS) 121 122 /* Define flags for options with one argument (e.g. 'delta_disks +2') */ 123 #define CTR_FLAG_OPTIONS_ONE_ARG (CTR_FLAG_REBUILD | \ 124 CTR_FLAG_WRITE_MOSTLY | \ 125 CTR_FLAG_DAEMON_SLEEP | \ 126 CTR_FLAG_MIN_RECOVERY_RATE | \ 127 CTR_FLAG_MAX_RECOVERY_RATE | \ 128 CTR_FLAG_MAX_WRITE_BEHIND | \ 129 CTR_FLAG_STRIPE_CACHE | \ 130 CTR_FLAG_REGION_SIZE | \ 131 CTR_FLAG_RAID10_COPIES | \ 132 CTR_FLAG_RAID10_FORMAT | \ 133 CTR_FLAG_DELTA_DISKS | \ 134 CTR_FLAG_DATA_OFFSET | \ 135 CTR_FLAG_JOURNAL_DEV | \ 136 CTR_FLAG_JOURNAL_MODE) 137 138 /* Valid options definitions per raid level... */ 139 140 /* "raid0" does only accept data offset */ 141 #define RAID0_VALID_FLAGS (CTR_FLAG_DATA_OFFSET) 142 143 /* "raid1" does not accept stripe cache, data offset, delta_disks or any raid10 options */ 144 #define RAID1_VALID_FLAGS (CTR_FLAGS_ANY_SYNC | \ 145 CTR_FLAG_REBUILD | \ 146 CTR_FLAG_WRITE_MOSTLY | \ 147 CTR_FLAG_DAEMON_SLEEP | \ 148 CTR_FLAG_MIN_RECOVERY_RATE | \ 149 CTR_FLAG_MAX_RECOVERY_RATE | \ 150 CTR_FLAG_MAX_WRITE_BEHIND | \ 151 CTR_FLAG_REGION_SIZE | \ 152 CTR_FLAG_DELTA_DISKS | \ 153 CTR_FLAG_DATA_OFFSET) 154 155 /* "raid10" does not accept any raid1 or stripe cache options */ 156 #define RAID10_VALID_FLAGS (CTR_FLAGS_ANY_SYNC | \ 157 CTR_FLAG_REBUILD | \ 158 CTR_FLAG_DAEMON_SLEEP | \ 159 CTR_FLAG_MIN_RECOVERY_RATE | \ 160 CTR_FLAG_MAX_RECOVERY_RATE | \ 161 CTR_FLAG_REGION_SIZE | \ 162 CTR_FLAG_RAID10_COPIES | \ 163 CTR_FLAG_RAID10_FORMAT | \ 164 CTR_FLAG_DELTA_DISKS | \ 165 CTR_FLAG_DATA_OFFSET | \ 166 CTR_FLAG_RAID10_USE_NEAR_SETS) 167 168 /* 169 * "raid4/5/6" do not accept any raid1 or raid10 specific options 170 * 171 * "raid6" does not accept "nosync", because it is not guaranteed 172 * that both parity and q-syndrome are being written properly with 173 * any writes 174 */ 175 #define RAID45_VALID_FLAGS (CTR_FLAGS_ANY_SYNC | \ 176 CTR_FLAG_REBUILD | \ 177 CTR_FLAG_DAEMON_SLEEP | \ 178 CTR_FLAG_MIN_RECOVERY_RATE | \ 179 CTR_FLAG_MAX_RECOVERY_RATE | \ 180 CTR_FLAG_STRIPE_CACHE | \ 181 CTR_FLAG_REGION_SIZE | \ 182 CTR_FLAG_DELTA_DISKS | \ 183 CTR_FLAG_DATA_OFFSET | \ 184 CTR_FLAG_JOURNAL_DEV | \ 185 CTR_FLAG_JOURNAL_MODE) 186 187 #define RAID6_VALID_FLAGS (CTR_FLAG_SYNC | \ 188 CTR_FLAG_REBUILD | \ 189 CTR_FLAG_DAEMON_SLEEP | \ 190 CTR_FLAG_MIN_RECOVERY_RATE | \ 191 CTR_FLAG_MAX_RECOVERY_RATE | \ 192 CTR_FLAG_STRIPE_CACHE | \ 193 CTR_FLAG_REGION_SIZE | \ 194 CTR_FLAG_DELTA_DISKS | \ 195 CTR_FLAG_DATA_OFFSET | \ 196 CTR_FLAG_JOURNAL_DEV | \ 197 CTR_FLAG_JOURNAL_MODE) 198 /* ...valid options definitions per raid level */ 199 200 /* 201 * Flags for rs->runtime_flags field 202 * (RT_FLAG prefix meaning "runtime flag") 203 * 204 * These are all internal and used to define runtime state, 205 * e.g. to prevent another resume from preresume processing 206 * the raid set all over again. 207 */ 208 #define RT_FLAG_RS_PRERESUMED 0 209 #define RT_FLAG_RS_RESUMED 1 210 #define RT_FLAG_RS_BITMAP_LOADED 2 211 #define RT_FLAG_UPDATE_SBS 3 212 #define RT_FLAG_RESHAPE_RS 4 213 #define RT_FLAG_RS_SUSPENDED 5 214 #define RT_FLAG_RS_IN_SYNC 6 215 #define RT_FLAG_RS_RESYNCING 7 216 #define RT_FLAG_RS_GROW 8 217 #define RT_FLAG_RS_FROZEN 9 218 219 /* Array elements of 64 bit needed for rebuild/failed disk bits */ 220 #define DISKS_ARRAY_ELEMS ((MAX_RAID_DEVICES + (sizeof(uint64_t) * 8 - 1)) / sizeof(uint64_t) / 8) 221 222 /* 223 * raid set level, layout and chunk sectors backup/restore 224 */ 225 struct rs_layout { 226 int new_level; 227 int new_layout; 228 int new_chunk_sectors; 229 }; 230 231 struct raid_set { 232 struct dm_target *ti; 233 234 uint32_t stripe_cache_entries; 235 unsigned long ctr_flags; 236 unsigned long runtime_flags; 237 238 uint64_t rebuild_disks[DISKS_ARRAY_ELEMS]; 239 240 int raid_disks; 241 int delta_disks; 242 int data_offset; 243 int raid10_copies; 244 int requested_bitmap_chunk_sectors; 245 246 struct mddev md; 247 struct raid_type *raid_type; 248 249 sector_t array_sectors; 250 sector_t dev_sectors; 251 252 /* Optional raid4/5/6 journal device */ 253 struct journal_dev { 254 struct dm_dev *dev; 255 struct md_rdev rdev; 256 int mode; 257 } journal_dev; 258 259 struct raid_dev dev[] __counted_by(raid_disks); 260 }; 261 262 static void rs_config_backup(struct raid_set *rs, struct rs_layout *l) 263 { 264 struct mddev *mddev = &rs->md; 265 266 l->new_level = mddev->new_level; 267 l->new_layout = mddev->new_layout; 268 l->new_chunk_sectors = mddev->new_chunk_sectors; 269 } 270 271 static void rs_config_restore(struct raid_set *rs, struct rs_layout *l) 272 { 273 struct mddev *mddev = &rs->md; 274 275 mddev->new_level = l->new_level; 276 mddev->new_layout = l->new_layout; 277 mddev->new_chunk_sectors = l->new_chunk_sectors; 278 } 279 280 /* raid10 algorithms (i.e. formats) */ 281 #define ALGORITHM_RAID10_DEFAULT 0 282 #define ALGORITHM_RAID10_NEAR 1 283 #define ALGORITHM_RAID10_OFFSET 2 284 #define ALGORITHM_RAID10_FAR 3 285 286 /* Supported raid types and properties. */ 287 static struct raid_type { 288 const char *name; /* RAID algorithm. */ 289 const char *descr; /* Descriptor text for logging. */ 290 const unsigned int parity_devs; /* # of parity devices. */ 291 const unsigned int minimal_devs;/* minimal # of devices in set. */ 292 const unsigned int level; /* RAID level. */ 293 const unsigned int algorithm; /* RAID algorithm. */ 294 } raid_types[] = { 295 {"raid0", "raid0 (striping)", 0, 2, 0, 0 /* NONE */}, 296 {"raid1", "raid1 (mirroring)", 0, 2, 1, 0 /* NONE */}, 297 {"raid10_far", "raid10 far (striped mirrors)", 0, 2, 10, ALGORITHM_RAID10_FAR}, 298 {"raid10_offset", "raid10 offset (striped mirrors)", 0, 2, 10, ALGORITHM_RAID10_OFFSET}, 299 {"raid10_near", "raid10 near (striped mirrors)", 0, 2, 10, ALGORITHM_RAID10_NEAR}, 300 {"raid10", "raid10 (striped mirrors)", 0, 2, 10, ALGORITHM_RAID10_DEFAULT}, 301 {"raid4", "raid4 (dedicated first parity disk)", 1, 2, 5, ALGORITHM_PARITY_0}, /* raid4 layout = raid5_0 */ 302 {"raid5_n", "raid5 (dedicated last parity disk)", 1, 2, 5, ALGORITHM_PARITY_N}, 303 {"raid5_ls", "raid5 (left symmetric)", 1, 2, 5, ALGORITHM_LEFT_SYMMETRIC}, 304 {"raid5_rs", "raid5 (right symmetric)", 1, 2, 5, ALGORITHM_RIGHT_SYMMETRIC}, 305 {"raid5_la", "raid5 (left asymmetric)", 1, 2, 5, ALGORITHM_LEFT_ASYMMETRIC}, 306 {"raid5_ra", "raid5 (right asymmetric)", 1, 2, 5, ALGORITHM_RIGHT_ASYMMETRIC}, 307 {"raid6_zr", "raid6 (zero restart)", 2, 4, 6, ALGORITHM_ROTATING_ZERO_RESTART}, 308 {"raid6_nr", "raid6 (N restart)", 2, 4, 6, ALGORITHM_ROTATING_N_RESTART}, 309 {"raid6_nc", "raid6 (N continue)", 2, 4, 6, ALGORITHM_ROTATING_N_CONTINUE}, 310 {"raid6_n_6", "raid6 (dedicated parity/Q n/6)", 2, 4, 6, ALGORITHM_PARITY_N_6}, 311 {"raid6_ls_6", "raid6 (left symmetric dedicated Q 6)", 2, 4, 6, ALGORITHM_LEFT_SYMMETRIC_6}, 312 {"raid6_rs_6", "raid6 (right symmetric dedicated Q 6)", 2, 4, 6, ALGORITHM_RIGHT_SYMMETRIC_6}, 313 {"raid6_la_6", "raid6 (left asymmetric dedicated Q 6)", 2, 4, 6, ALGORITHM_LEFT_ASYMMETRIC_6}, 314 {"raid6_ra_6", "raid6 (right asymmetric dedicated Q 6)", 2, 4, 6, ALGORITHM_RIGHT_ASYMMETRIC_6} 315 }; 316 317 /* True, if @v is in inclusive range [@min, @max] */ 318 static bool __within_range(long v, long min, long max) 319 { 320 return v >= min && v <= max; 321 } 322 323 /* All table line arguments are defined here */ 324 static struct arg_name_flag { 325 const unsigned long flag; 326 const char *name; 327 } __arg_name_flags[] = { 328 { CTR_FLAG_SYNC, "sync"}, 329 { CTR_FLAG_NOSYNC, "nosync"}, 330 { CTR_FLAG_REBUILD, "rebuild"}, 331 { CTR_FLAG_DAEMON_SLEEP, "daemon_sleep"}, 332 { CTR_FLAG_MIN_RECOVERY_RATE, "min_recovery_rate"}, 333 { CTR_FLAG_MAX_RECOVERY_RATE, "max_recovery_rate"}, 334 { CTR_FLAG_MAX_WRITE_BEHIND, "max_write_behind"}, 335 { CTR_FLAG_WRITE_MOSTLY, "write_mostly"}, 336 { CTR_FLAG_STRIPE_CACHE, "stripe_cache"}, 337 { CTR_FLAG_REGION_SIZE, "region_size"}, 338 { CTR_FLAG_RAID10_COPIES, "raid10_copies"}, 339 { CTR_FLAG_RAID10_FORMAT, "raid10_format"}, 340 { CTR_FLAG_DATA_OFFSET, "data_offset"}, 341 { CTR_FLAG_DELTA_DISKS, "delta_disks"}, 342 { CTR_FLAG_RAID10_USE_NEAR_SETS, "raid10_use_near_sets"}, 343 { CTR_FLAG_JOURNAL_DEV, "journal_dev" }, 344 { CTR_FLAG_JOURNAL_MODE, "journal_mode" }, 345 }; 346 347 /* Return argument name string for given @flag */ 348 static const char *dm_raid_arg_name_by_flag(const uint32_t flag) 349 { 350 if (hweight32(flag) == 1) { 351 struct arg_name_flag *anf = __arg_name_flags + ARRAY_SIZE(__arg_name_flags); 352 353 while (anf-- > __arg_name_flags) 354 if (flag & anf->flag) 355 return anf->name; 356 357 } else 358 DMERR("%s called with more than one flag!", __func__); 359 360 return NULL; 361 } 362 363 /* Define correlation of raid456 journal cache modes and dm-raid target line parameters */ 364 static struct { 365 const int mode; 366 const char *param; 367 } _raid456_journal_mode[] = { 368 { R5C_JOURNAL_MODE_WRITE_THROUGH, "writethrough" }, 369 { R5C_JOURNAL_MODE_WRITE_BACK, "writeback" } 370 }; 371 372 /* Return MD raid4/5/6 journal mode for dm @journal_mode one */ 373 static int dm_raid_journal_mode_to_md(const char *mode) 374 { 375 int m = ARRAY_SIZE(_raid456_journal_mode); 376 377 while (m--) 378 if (!strcasecmp(mode, _raid456_journal_mode[m].param)) 379 return _raid456_journal_mode[m].mode; 380 381 return -EINVAL; 382 } 383 384 /* Return dm-raid raid4/5/6 journal mode string for @mode */ 385 static const char *md_journal_mode_to_dm_raid(const int mode) 386 { 387 int m = ARRAY_SIZE(_raid456_journal_mode); 388 389 while (m--) 390 if (mode == _raid456_journal_mode[m].mode) 391 return _raid456_journal_mode[m].param; 392 393 return "unknown"; 394 } 395 396 /* 397 * Bool helpers to test for various raid levels of a raid set. 398 * It's level as reported by the superblock rather than 399 * the requested raid_type passed to the constructor. 400 */ 401 /* Return true, if raid set in @rs is raid0 */ 402 static bool rs_is_raid0(struct raid_set *rs) 403 { 404 return !rs->md.level; 405 } 406 407 /* Return true, if raid set in @rs is raid1 */ 408 static bool rs_is_raid1(struct raid_set *rs) 409 { 410 return rs->md.level == 1; 411 } 412 413 /* Return true, if raid set in @rs is raid10 */ 414 static bool rs_is_raid10(struct raid_set *rs) 415 { 416 return rs->md.level == 10; 417 } 418 419 /* Return true, if raid set in @rs is level 6 */ 420 static bool rs_is_raid6(struct raid_set *rs) 421 { 422 return rs->md.level == 6; 423 } 424 425 /* Return true, if raid set in @rs is level 4, 5 or 6 */ 426 static bool rs_is_raid456(struct raid_set *rs) 427 { 428 return __within_range(rs->md.level, 4, 6); 429 } 430 431 /* Return true, if raid set in @rs is reshapable */ 432 static bool __is_raid10_far(int layout); 433 static bool rs_is_reshapable(struct raid_set *rs) 434 { 435 return rs_is_raid456(rs) || 436 (rs_is_raid10(rs) && !__is_raid10_far(rs->md.new_layout)); 437 } 438 439 /* Return true, if raid set in @rs is recovering */ 440 static bool rs_is_recovering(struct raid_set *rs) 441 { 442 return rs->md.recovery_cp < rs->md.dev_sectors; 443 } 444 445 /* Return true, if raid set in @rs is reshaping */ 446 static bool rs_is_reshaping(struct raid_set *rs) 447 { 448 return rs->md.reshape_position != MaxSector; 449 } 450 451 /* 452 * bool helpers to test for various raid levels of a raid type @rt 453 */ 454 455 /* Return true, if raid type in @rt is raid0 */ 456 static bool rt_is_raid0(struct raid_type *rt) 457 { 458 return !rt->level; 459 } 460 461 /* Return true, if raid type in @rt is raid1 */ 462 static bool rt_is_raid1(struct raid_type *rt) 463 { 464 return rt->level == 1; 465 } 466 467 /* Return true, if raid type in @rt is raid10 */ 468 static bool rt_is_raid10(struct raid_type *rt) 469 { 470 return rt->level == 10; 471 } 472 473 /* Return true, if raid type in @rt is raid4/5 */ 474 static bool rt_is_raid45(struct raid_type *rt) 475 { 476 return __within_range(rt->level, 4, 5); 477 } 478 479 /* Return true, if raid type in @rt is raid6 */ 480 static bool rt_is_raid6(struct raid_type *rt) 481 { 482 return rt->level == 6; 483 } 484 485 /* Return true, if raid type in @rt is raid4/5/6 */ 486 static bool rt_is_raid456(struct raid_type *rt) 487 { 488 return __within_range(rt->level, 4, 6); 489 } 490 /* END: raid level bools */ 491 492 /* Return valid ctr flags for the raid level of @rs */ 493 static unsigned long __valid_flags(struct raid_set *rs) 494 { 495 if (rt_is_raid0(rs->raid_type)) 496 return RAID0_VALID_FLAGS; 497 else if (rt_is_raid1(rs->raid_type)) 498 return RAID1_VALID_FLAGS; 499 else if (rt_is_raid10(rs->raid_type)) 500 return RAID10_VALID_FLAGS; 501 else if (rt_is_raid45(rs->raid_type)) 502 return RAID45_VALID_FLAGS; 503 else if (rt_is_raid6(rs->raid_type)) 504 return RAID6_VALID_FLAGS; 505 506 return 0; 507 } 508 509 /* 510 * Check for valid flags set on @rs 511 * 512 * Has to be called after parsing of the ctr flags! 513 */ 514 static int rs_check_for_valid_flags(struct raid_set *rs) 515 { 516 if (rs->ctr_flags & ~__valid_flags(rs)) { 517 rs->ti->error = "Invalid flags combination"; 518 return -EINVAL; 519 } 520 521 return 0; 522 } 523 524 /* MD raid10 bit definitions and helpers */ 525 #define RAID10_OFFSET (1 << 16) /* stripes with data copies area adjacent on devices */ 526 #define RAID10_BROCKEN_USE_FAR_SETS (1 << 17) /* Broken in raid10.c: use sets instead of whole stripe rotation */ 527 #define RAID10_USE_FAR_SETS (1 << 18) /* Use sets instead of whole stripe rotation */ 528 #define RAID10_FAR_COPIES_SHIFT 8 /* raid10 # far copies shift (2nd byte of layout) */ 529 530 /* Return md raid10 near copies for @layout */ 531 static unsigned int __raid10_near_copies(int layout) 532 { 533 return layout & 0xFF; 534 } 535 536 /* Return md raid10 far copies for @layout */ 537 static unsigned int __raid10_far_copies(int layout) 538 { 539 return __raid10_near_copies(layout >> RAID10_FAR_COPIES_SHIFT); 540 } 541 542 /* Return true if md raid10 offset for @layout */ 543 static bool __is_raid10_offset(int layout) 544 { 545 return !!(layout & RAID10_OFFSET); 546 } 547 548 /* Return true if md raid10 near for @layout */ 549 static bool __is_raid10_near(int layout) 550 { 551 return !__is_raid10_offset(layout) && __raid10_near_copies(layout) > 1; 552 } 553 554 /* Return true if md raid10 far for @layout */ 555 static bool __is_raid10_far(int layout) 556 { 557 return !__is_raid10_offset(layout) && __raid10_far_copies(layout) > 1; 558 } 559 560 /* Return md raid10 layout string for @layout */ 561 static const char *raid10_md_layout_to_format(int layout) 562 { 563 /* 564 * Bit 16 stands for "offset" 565 * (i.e. adjacent stripes hold copies) 566 * 567 * Refer to MD's raid10.c for details 568 */ 569 if (__is_raid10_offset(layout)) 570 return "offset"; 571 572 if (__raid10_near_copies(layout) > 1) 573 return "near"; 574 575 if (__raid10_far_copies(layout) > 1) 576 return "far"; 577 578 return "unknown"; 579 } 580 581 /* Return md raid10 algorithm for @name */ 582 static int raid10_name_to_format(const char *name) 583 { 584 if (!strcasecmp(name, "near")) 585 return ALGORITHM_RAID10_NEAR; 586 else if (!strcasecmp(name, "offset")) 587 return ALGORITHM_RAID10_OFFSET; 588 else if (!strcasecmp(name, "far")) 589 return ALGORITHM_RAID10_FAR; 590 591 return -EINVAL; 592 } 593 594 /* Return md raid10 copies for @layout */ 595 static unsigned int raid10_md_layout_to_copies(int layout) 596 { 597 return max(__raid10_near_copies(layout), __raid10_far_copies(layout)); 598 } 599 600 /* Return md raid10 format id for @format string */ 601 static int raid10_format_to_md_layout(struct raid_set *rs, 602 unsigned int algorithm, 603 unsigned int copies) 604 { 605 unsigned int n = 1, f = 1, r = 0; 606 607 /* 608 * MD resilienece flaw: 609 * 610 * enabling use_far_sets for far/offset formats causes copies 611 * to be colocated on the same devs together with their origins! 612 * 613 * -> disable it for now in the definition above 614 */ 615 if (algorithm == ALGORITHM_RAID10_DEFAULT || 616 algorithm == ALGORITHM_RAID10_NEAR) 617 n = copies; 618 619 else if (algorithm == ALGORITHM_RAID10_OFFSET) { 620 f = copies; 621 r = RAID10_OFFSET; 622 if (!test_bit(__CTR_FLAG_RAID10_USE_NEAR_SETS, &rs->ctr_flags)) 623 r |= RAID10_USE_FAR_SETS; 624 625 } else if (algorithm == ALGORITHM_RAID10_FAR) { 626 f = copies; 627 if (!test_bit(__CTR_FLAG_RAID10_USE_NEAR_SETS, &rs->ctr_flags)) 628 r |= RAID10_USE_FAR_SETS; 629 630 } else 631 return -EINVAL; 632 633 return r | (f << RAID10_FAR_COPIES_SHIFT) | n; 634 } 635 /* END: MD raid10 bit definitions and helpers */ 636 637 /* Check for any of the raid10 algorithms */ 638 static bool __got_raid10(struct raid_type *rtp, const int layout) 639 { 640 if (rtp->level == 10) { 641 switch (rtp->algorithm) { 642 case ALGORITHM_RAID10_DEFAULT: 643 case ALGORITHM_RAID10_NEAR: 644 return __is_raid10_near(layout); 645 case ALGORITHM_RAID10_OFFSET: 646 return __is_raid10_offset(layout); 647 case ALGORITHM_RAID10_FAR: 648 return __is_raid10_far(layout); 649 default: 650 break; 651 } 652 } 653 654 return false; 655 } 656 657 /* Return raid_type for @name */ 658 static struct raid_type *get_raid_type(const char *name) 659 { 660 struct raid_type *rtp = raid_types + ARRAY_SIZE(raid_types); 661 662 while (rtp-- > raid_types) 663 if (!strcasecmp(rtp->name, name)) 664 return rtp; 665 666 return NULL; 667 } 668 669 /* Return raid_type for @name based derived from @level and @layout */ 670 static struct raid_type *get_raid_type_by_ll(const int level, const int layout) 671 { 672 struct raid_type *rtp = raid_types + ARRAY_SIZE(raid_types); 673 674 while (rtp-- > raid_types) { 675 /* RAID10 special checks based on @layout flags/properties */ 676 if (rtp->level == level && 677 (__got_raid10(rtp, layout) || rtp->algorithm == layout)) 678 return rtp; 679 } 680 681 return NULL; 682 } 683 684 /* Adjust rdev sectors */ 685 static void rs_set_rdev_sectors(struct raid_set *rs) 686 { 687 struct mddev *mddev = &rs->md; 688 struct md_rdev *rdev; 689 690 /* 691 * raid10 sets rdev->sector to the device size, which 692 * is unintended in case of out-of-place reshaping 693 */ 694 rdev_for_each(rdev, mddev) 695 if (!test_bit(Journal, &rdev->flags)) 696 rdev->sectors = mddev->dev_sectors; 697 } 698 699 /* 700 * Change bdev capacity of @rs in case of a disk add/remove reshape 701 */ 702 static void rs_set_capacity(struct raid_set *rs) 703 { 704 struct gendisk *gendisk = dm_disk(dm_table_get_md(rs->ti->table)); 705 706 set_capacity_and_notify(gendisk, rs->md.array_sectors); 707 } 708 709 /* 710 * Set the mddev properties in @rs to the current 711 * ones retrieved from the freshest superblock 712 */ 713 static void rs_set_cur(struct raid_set *rs) 714 { 715 struct mddev *mddev = &rs->md; 716 717 mddev->new_level = mddev->level; 718 mddev->new_layout = mddev->layout; 719 mddev->new_chunk_sectors = mddev->chunk_sectors; 720 } 721 722 /* 723 * Set the mddev properties in @rs to the new 724 * ones requested by the ctr 725 */ 726 static void rs_set_new(struct raid_set *rs) 727 { 728 struct mddev *mddev = &rs->md; 729 730 mddev->level = mddev->new_level; 731 mddev->layout = mddev->new_layout; 732 mddev->chunk_sectors = mddev->new_chunk_sectors; 733 mddev->raid_disks = rs->raid_disks; 734 mddev->delta_disks = 0; 735 } 736 737 static struct raid_set *raid_set_alloc(struct dm_target *ti, struct raid_type *raid_type, 738 unsigned int raid_devs) 739 { 740 unsigned int i; 741 struct raid_set *rs; 742 743 if (raid_devs <= raid_type->parity_devs) { 744 ti->error = "Insufficient number of devices"; 745 return ERR_PTR(-EINVAL); 746 } 747 748 rs = kzalloc(struct_size(rs, dev, raid_devs), GFP_KERNEL); 749 if (!rs) { 750 ti->error = "Cannot allocate raid context"; 751 return ERR_PTR(-ENOMEM); 752 } 753 754 if (mddev_init(&rs->md)) { 755 kfree(rs); 756 ti->error = "Cannot initialize raid context"; 757 return ERR_PTR(-ENOMEM); 758 } 759 760 rs->raid_disks = raid_devs; 761 rs->delta_disks = 0; 762 763 rs->ti = ti; 764 rs->raid_type = raid_type; 765 rs->stripe_cache_entries = 256; 766 rs->md.raid_disks = raid_devs; 767 rs->md.level = raid_type->level; 768 rs->md.new_level = rs->md.level; 769 rs->md.layout = raid_type->algorithm; 770 rs->md.new_layout = rs->md.layout; 771 rs->md.delta_disks = 0; 772 rs->md.recovery_cp = MaxSector; 773 774 for (i = 0; i < raid_devs; i++) 775 md_rdev_init(&rs->dev[i].rdev); 776 777 /* 778 * Remaining items to be initialized by further RAID params: 779 * rs->md.persistent 780 * rs->md.external 781 * rs->md.chunk_sectors 782 * rs->md.new_chunk_sectors 783 * rs->md.dev_sectors 784 */ 785 786 return rs; 787 } 788 789 /* Free all @rs allocations */ 790 static void raid_set_free(struct raid_set *rs) 791 { 792 int i; 793 794 if (rs->journal_dev.dev) { 795 md_rdev_clear(&rs->journal_dev.rdev); 796 dm_put_device(rs->ti, rs->journal_dev.dev); 797 } 798 799 for (i = 0; i < rs->raid_disks; i++) { 800 if (rs->dev[i].meta_dev) 801 dm_put_device(rs->ti, rs->dev[i].meta_dev); 802 md_rdev_clear(&rs->dev[i].rdev); 803 if (rs->dev[i].data_dev) 804 dm_put_device(rs->ti, rs->dev[i].data_dev); 805 } 806 807 mddev_destroy(&rs->md); 808 kfree(rs); 809 } 810 811 /* 812 * For every device we have two words 813 * <meta_dev>: meta device name or '-' if missing 814 * <data_dev>: data device name or '-' if missing 815 * 816 * The following are permitted: 817 * - - 818 * - <data_dev> 819 * <meta_dev> <data_dev> 820 * 821 * The following is not allowed: 822 * <meta_dev> - 823 * 824 * This code parses those words. If there is a failure, 825 * the caller must use raid_set_free() to unwind the operations. 826 */ 827 static int parse_dev_params(struct raid_set *rs, struct dm_arg_set *as) 828 { 829 int i; 830 int rebuild = 0; 831 int metadata_available = 0; 832 int r = 0; 833 const char *arg; 834 835 /* Put off the number of raid devices argument to get to dev pairs */ 836 arg = dm_shift_arg(as); 837 if (!arg) 838 return -EINVAL; 839 840 for (i = 0; i < rs->raid_disks; i++) { 841 rs->dev[i].rdev.raid_disk = i; 842 843 rs->dev[i].meta_dev = NULL; 844 rs->dev[i].data_dev = NULL; 845 846 /* 847 * There are no offsets initially. 848 * Out of place reshape will set them accordingly. 849 */ 850 rs->dev[i].rdev.data_offset = 0; 851 rs->dev[i].rdev.new_data_offset = 0; 852 rs->dev[i].rdev.mddev = &rs->md; 853 854 arg = dm_shift_arg(as); 855 if (!arg) 856 return -EINVAL; 857 858 if (strcmp(arg, "-")) { 859 r = dm_get_device(rs->ti, arg, dm_table_get_mode(rs->ti->table), 860 &rs->dev[i].meta_dev); 861 if (r) { 862 rs->ti->error = "RAID metadata device lookup failure"; 863 return r; 864 } 865 866 rs->dev[i].rdev.sb_page = alloc_page(GFP_KERNEL); 867 if (!rs->dev[i].rdev.sb_page) { 868 rs->ti->error = "Failed to allocate superblock page"; 869 return -ENOMEM; 870 } 871 } 872 873 arg = dm_shift_arg(as); 874 if (!arg) 875 return -EINVAL; 876 877 if (!strcmp(arg, "-")) { 878 if (!test_bit(In_sync, &rs->dev[i].rdev.flags) && 879 (!rs->dev[i].rdev.recovery_offset)) { 880 rs->ti->error = "Drive designated for rebuild not specified"; 881 return -EINVAL; 882 } 883 884 if (rs->dev[i].meta_dev) { 885 rs->ti->error = "No data device supplied with metadata device"; 886 return -EINVAL; 887 } 888 889 continue; 890 } 891 892 r = dm_get_device(rs->ti, arg, dm_table_get_mode(rs->ti->table), 893 &rs->dev[i].data_dev); 894 if (r) { 895 rs->ti->error = "RAID device lookup failure"; 896 return r; 897 } 898 899 if (rs->dev[i].meta_dev) { 900 metadata_available = 1; 901 rs->dev[i].rdev.meta_bdev = rs->dev[i].meta_dev->bdev; 902 } 903 rs->dev[i].rdev.bdev = rs->dev[i].data_dev->bdev; 904 list_add_tail(&rs->dev[i].rdev.same_set, &rs->md.disks); 905 if (!test_bit(In_sync, &rs->dev[i].rdev.flags)) 906 rebuild++; 907 } 908 909 if (rs->journal_dev.dev) 910 list_add_tail(&rs->journal_dev.rdev.same_set, &rs->md.disks); 911 912 if (metadata_available) { 913 rs->md.external = 0; 914 rs->md.persistent = 1; 915 rs->md.major_version = 2; 916 } else if (rebuild && !rs->md.recovery_cp) { 917 /* 918 * Without metadata, we will not be able to tell if the array 919 * is in-sync or not - we must assume it is not. Therefore, 920 * it is impossible to rebuild a drive. 921 * 922 * Even if there is metadata, the on-disk information may 923 * indicate that the array is not in-sync and it will then 924 * fail at that time. 925 * 926 * User could specify 'nosync' option if desperate. 927 */ 928 rs->ti->error = "Unable to rebuild drive while array is not in-sync"; 929 return -EINVAL; 930 } 931 932 return 0; 933 } 934 935 /* 936 * validate_region_size 937 * @rs 938 * @region_size: region size in sectors. If 0, pick a size (4MiB default). 939 * 940 * Set rs->md.bitmap_info.chunksize (which really refers to 'region size'). 941 * Ensure that (ti->len/region_size < 2^21) - required by MD bitmap. 942 * 943 * Returns: 0 on success, -EINVAL on failure. 944 */ 945 static int validate_region_size(struct raid_set *rs, unsigned long region_size) 946 { 947 unsigned long min_region_size = rs->ti->len / (1 << 21); 948 949 if (rs_is_raid0(rs)) 950 return 0; 951 952 if (!region_size) { 953 /* 954 * Choose a reasonable default. All figures in sectors. 955 */ 956 if (min_region_size > (1 << 13)) { 957 /* If not a power of 2, make it the next power of 2 */ 958 region_size = roundup_pow_of_two(min_region_size); 959 DMINFO("Choosing default region size of %lu sectors", 960 region_size); 961 } else { 962 DMINFO("Choosing default region size of 4MiB"); 963 region_size = 1 << 13; /* sectors */ 964 } 965 } else { 966 /* 967 * Validate user-supplied value. 968 */ 969 if (region_size > rs->ti->len) { 970 rs->ti->error = "Supplied region size is too large"; 971 return -EINVAL; 972 } 973 974 if (region_size < min_region_size) { 975 DMERR("Supplied region_size (%lu sectors) below minimum (%lu)", 976 region_size, min_region_size); 977 rs->ti->error = "Supplied region size is too small"; 978 return -EINVAL; 979 } 980 981 if (!is_power_of_2(region_size)) { 982 rs->ti->error = "Region size is not a power of 2"; 983 return -EINVAL; 984 } 985 986 if (region_size < rs->md.chunk_sectors) { 987 rs->ti->error = "Region size is smaller than the chunk size"; 988 return -EINVAL; 989 } 990 } 991 992 /* 993 * Convert sectors to bytes. 994 */ 995 rs->md.bitmap_info.chunksize = to_bytes(region_size); 996 997 return 0; 998 } 999 1000 /* 1001 * validate_raid_redundancy 1002 * @rs 1003 * 1004 * Determine if there are enough devices in the array that haven't 1005 * failed (or are being rebuilt) to form a usable array. 1006 * 1007 * Returns: 0 on success, -EINVAL on failure. 1008 */ 1009 static int validate_raid_redundancy(struct raid_set *rs) 1010 { 1011 unsigned int i, rebuild_cnt = 0; 1012 unsigned int rebuilds_per_group = 0, copies, raid_disks; 1013 unsigned int group_size, last_group_start; 1014 1015 for (i = 0; i < rs->raid_disks; i++) 1016 if (!test_bit(FirstUse, &rs->dev[i].rdev.flags) && 1017 ((!test_bit(In_sync, &rs->dev[i].rdev.flags) || 1018 !rs->dev[i].rdev.sb_page))) 1019 rebuild_cnt++; 1020 1021 switch (rs->md.level) { 1022 case 0: 1023 break; 1024 case 1: 1025 if (rebuild_cnt >= rs->md.raid_disks) 1026 goto too_many; 1027 break; 1028 case 4: 1029 case 5: 1030 case 6: 1031 if (rebuild_cnt > rs->raid_type->parity_devs) 1032 goto too_many; 1033 break; 1034 case 10: 1035 copies = raid10_md_layout_to_copies(rs->md.new_layout); 1036 if (copies < 2) { 1037 DMERR("Bogus raid10 data copies < 2!"); 1038 return -EINVAL; 1039 } 1040 1041 if (rebuild_cnt < copies) 1042 break; 1043 1044 /* 1045 * It is possible to have a higher rebuild count for RAID10, 1046 * as long as the failed devices occur in different mirror 1047 * groups (i.e. different stripes). 1048 * 1049 * When checking "near" format, make sure no adjacent devices 1050 * have failed beyond what can be handled. In addition to the 1051 * simple case where the number of devices is a multiple of the 1052 * number of copies, we must also handle cases where the number 1053 * of devices is not a multiple of the number of copies. 1054 * E.g. dev1 dev2 dev3 dev4 dev5 1055 * A A B B C 1056 * C D D E E 1057 */ 1058 raid_disks = min(rs->raid_disks, rs->md.raid_disks); 1059 if (__is_raid10_near(rs->md.new_layout)) { 1060 for (i = 0; i < raid_disks; i++) { 1061 if (!(i % copies)) 1062 rebuilds_per_group = 0; 1063 if ((!rs->dev[i].rdev.sb_page || 1064 !test_bit(In_sync, &rs->dev[i].rdev.flags)) && 1065 (++rebuilds_per_group >= copies)) 1066 goto too_many; 1067 } 1068 break; 1069 } 1070 1071 /* 1072 * When checking "far" and "offset" formats, we need to ensure 1073 * that the device that holds its copy is not also dead or 1074 * being rebuilt. (Note that "far" and "offset" formats only 1075 * support two copies right now. These formats also only ever 1076 * use the 'use_far_sets' variant.) 1077 * 1078 * This check is somewhat complicated by the need to account 1079 * for arrays that are not a multiple of (far) copies. This 1080 * results in the need to treat the last (potentially larger) 1081 * set differently. 1082 */ 1083 group_size = (raid_disks / copies); 1084 last_group_start = (raid_disks / group_size) - 1; 1085 last_group_start *= group_size; 1086 for (i = 0; i < raid_disks; i++) { 1087 if (!(i % copies) && !(i > last_group_start)) 1088 rebuilds_per_group = 0; 1089 if ((!rs->dev[i].rdev.sb_page || 1090 !test_bit(In_sync, &rs->dev[i].rdev.flags)) && 1091 (++rebuilds_per_group >= copies)) 1092 goto too_many; 1093 } 1094 break; 1095 default: 1096 if (rebuild_cnt) 1097 return -EINVAL; 1098 } 1099 1100 return 0; 1101 1102 too_many: 1103 return -EINVAL; 1104 } 1105 1106 /* 1107 * Possible arguments are... 1108 * <chunk_size> [optional_args] 1109 * 1110 * Argument definitions 1111 * <chunk_size> The number of sectors per disk that 1112 * will form the "stripe" 1113 * [[no]sync] Force or prevent recovery of the 1114 * entire array 1115 * [rebuild <idx>] Rebuild the drive indicated by the index 1116 * [daemon_sleep <ms>] Time between bitmap daemon work to 1117 * clear bits 1118 * [min_recovery_rate <kB/sec/disk>] Throttle RAID initialization 1119 * [max_recovery_rate <kB/sec/disk>] Throttle RAID initialization 1120 * [write_mostly <idx>] Indicate a write mostly drive via index 1121 * [max_write_behind <sectors>] See '-write-behind=' (man mdadm) 1122 * [stripe_cache <sectors>] Stripe cache size for higher RAIDs 1123 * [region_size <sectors>] Defines granularity of bitmap 1124 * [journal_dev <dev>] raid4/5/6 journaling deviice 1125 * (i.e. write hole closing log) 1126 * 1127 * RAID10-only options: 1128 * [raid10_copies <# copies>] Number of copies. (Default: 2) 1129 * [raid10_format <near|far|offset>] Layout algorithm. (Default: near) 1130 */ 1131 static int parse_raid_params(struct raid_set *rs, struct dm_arg_set *as, 1132 unsigned int num_raid_params) 1133 { 1134 int value, raid10_format = ALGORITHM_RAID10_DEFAULT; 1135 unsigned int raid10_copies = 2; 1136 unsigned int i, write_mostly = 0; 1137 unsigned int region_size = 0; 1138 sector_t max_io_len; 1139 const char *arg, *key; 1140 struct raid_dev *rd; 1141 struct raid_type *rt = rs->raid_type; 1142 1143 arg = dm_shift_arg(as); 1144 num_raid_params--; /* Account for chunk_size argument */ 1145 1146 if (kstrtoint(arg, 10, &value) < 0) { 1147 rs->ti->error = "Bad numerical argument given for chunk_size"; 1148 return -EINVAL; 1149 } 1150 1151 /* 1152 * First, parse the in-order required arguments 1153 * "chunk_size" is the only argument of this type. 1154 */ 1155 if (rt_is_raid1(rt)) { 1156 if (value) 1157 DMERR("Ignoring chunk size parameter for RAID 1"); 1158 value = 0; 1159 } else if (!is_power_of_2(value)) { 1160 rs->ti->error = "Chunk size must be a power of 2"; 1161 return -EINVAL; 1162 } else if (value < 8) { 1163 rs->ti->error = "Chunk size value is too small"; 1164 return -EINVAL; 1165 } 1166 1167 rs->md.new_chunk_sectors = rs->md.chunk_sectors = value; 1168 1169 /* 1170 * We set each individual device as In_sync with a completed 1171 * 'recovery_offset'. If there has been a device failure or 1172 * replacement then one of the following cases applies: 1173 * 1174 * 1) User specifies 'rebuild'. 1175 * - Device is reset when param is read. 1176 * 2) A new device is supplied. 1177 * - No matching superblock found, resets device. 1178 * 3) Device failure was transient and returns on reload. 1179 * - Failure noticed, resets device for bitmap replay. 1180 * 4) Device hadn't completed recovery after previous failure. 1181 * - Superblock is read and overrides recovery_offset. 1182 * 1183 * What is found in the superblocks of the devices is always 1184 * authoritative, unless 'rebuild' or '[no]sync' was specified. 1185 */ 1186 for (i = 0; i < rs->raid_disks; i++) { 1187 set_bit(In_sync, &rs->dev[i].rdev.flags); 1188 rs->dev[i].rdev.recovery_offset = MaxSector; 1189 } 1190 1191 /* 1192 * Second, parse the unordered optional arguments 1193 */ 1194 for (i = 0; i < num_raid_params; i++) { 1195 key = dm_shift_arg(as); 1196 if (!key) { 1197 rs->ti->error = "Not enough raid parameters given"; 1198 return -EINVAL; 1199 } 1200 1201 if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_NOSYNC))) { 1202 if (test_and_set_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags)) { 1203 rs->ti->error = "Only one 'nosync' argument allowed"; 1204 return -EINVAL; 1205 } 1206 continue; 1207 } 1208 if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_SYNC))) { 1209 if (test_and_set_bit(__CTR_FLAG_SYNC, &rs->ctr_flags)) { 1210 rs->ti->error = "Only one 'sync' argument allowed"; 1211 return -EINVAL; 1212 } 1213 continue; 1214 } 1215 if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_USE_NEAR_SETS))) { 1216 if (test_and_set_bit(__CTR_FLAG_RAID10_USE_NEAR_SETS, &rs->ctr_flags)) { 1217 rs->ti->error = "Only one 'raid10_use_new_sets' argument allowed"; 1218 return -EINVAL; 1219 } 1220 continue; 1221 } 1222 1223 arg = dm_shift_arg(as); 1224 i++; /* Account for the argument pairs */ 1225 if (!arg) { 1226 rs->ti->error = "Wrong number of raid parameters given"; 1227 return -EINVAL; 1228 } 1229 1230 /* 1231 * Parameters that take a string value are checked here. 1232 */ 1233 /* "raid10_format {near|offset|far} */ 1234 if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_FORMAT))) { 1235 if (test_and_set_bit(__CTR_FLAG_RAID10_FORMAT, &rs->ctr_flags)) { 1236 rs->ti->error = "Only one 'raid10_format' argument pair allowed"; 1237 return -EINVAL; 1238 } 1239 if (!rt_is_raid10(rt)) { 1240 rs->ti->error = "'raid10_format' is an invalid parameter for this RAID type"; 1241 return -EINVAL; 1242 } 1243 raid10_format = raid10_name_to_format(arg); 1244 if (raid10_format < 0) { 1245 rs->ti->error = "Invalid 'raid10_format' value given"; 1246 return raid10_format; 1247 } 1248 continue; 1249 } 1250 1251 /* "journal_dev <dev>" */ 1252 if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_JOURNAL_DEV))) { 1253 int r; 1254 struct md_rdev *jdev; 1255 1256 if (test_and_set_bit(__CTR_FLAG_JOURNAL_DEV, &rs->ctr_flags)) { 1257 rs->ti->error = "Only one raid4/5/6 set journaling device allowed"; 1258 return -EINVAL; 1259 } 1260 if (!rt_is_raid456(rt)) { 1261 rs->ti->error = "'journal_dev' is an invalid parameter for this RAID type"; 1262 return -EINVAL; 1263 } 1264 r = dm_get_device(rs->ti, arg, dm_table_get_mode(rs->ti->table), 1265 &rs->journal_dev.dev); 1266 if (r) { 1267 rs->ti->error = "raid4/5/6 journal device lookup failure"; 1268 return r; 1269 } 1270 jdev = &rs->journal_dev.rdev; 1271 md_rdev_init(jdev); 1272 jdev->mddev = &rs->md; 1273 jdev->bdev = rs->journal_dev.dev->bdev; 1274 jdev->sectors = bdev_nr_sectors(jdev->bdev); 1275 if (jdev->sectors < MIN_RAID456_JOURNAL_SPACE) { 1276 rs->ti->error = "No space for raid4/5/6 journal"; 1277 return -ENOSPC; 1278 } 1279 rs->journal_dev.mode = R5C_JOURNAL_MODE_WRITE_THROUGH; 1280 set_bit(Journal, &jdev->flags); 1281 continue; 1282 } 1283 1284 /* "journal_mode <mode>" ("journal_dev" mandatory!) */ 1285 if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_JOURNAL_MODE))) { 1286 int r; 1287 1288 if (!test_bit(__CTR_FLAG_JOURNAL_DEV, &rs->ctr_flags)) { 1289 rs->ti->error = "raid4/5/6 'journal_mode' is invalid without 'journal_dev'"; 1290 return -EINVAL; 1291 } 1292 if (test_and_set_bit(__CTR_FLAG_JOURNAL_MODE, &rs->ctr_flags)) { 1293 rs->ti->error = "Only one raid4/5/6 'journal_mode' argument allowed"; 1294 return -EINVAL; 1295 } 1296 r = dm_raid_journal_mode_to_md(arg); 1297 if (r < 0) { 1298 rs->ti->error = "Invalid 'journal_mode' argument"; 1299 return r; 1300 } 1301 rs->journal_dev.mode = r; 1302 continue; 1303 } 1304 1305 /* 1306 * Parameters with number values from here on. 1307 */ 1308 if (kstrtoint(arg, 10, &value) < 0) { 1309 rs->ti->error = "Bad numerical argument given in raid params"; 1310 return -EINVAL; 1311 } 1312 1313 if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_REBUILD))) { 1314 /* 1315 * "rebuild" is being passed in by userspace to provide 1316 * indexes of replaced devices and to set up additional 1317 * devices on raid level takeover. 1318 */ 1319 if (!__within_range(value, 0, rs->raid_disks - 1)) { 1320 rs->ti->error = "Invalid rebuild index given"; 1321 return -EINVAL; 1322 } 1323 1324 if (test_and_set_bit(value, (void *) rs->rebuild_disks)) { 1325 rs->ti->error = "rebuild for this index already given"; 1326 return -EINVAL; 1327 } 1328 1329 rd = rs->dev + value; 1330 clear_bit(In_sync, &rd->rdev.flags); 1331 clear_bit(Faulty, &rd->rdev.flags); 1332 rd->rdev.recovery_offset = 0; 1333 set_bit(__CTR_FLAG_REBUILD, &rs->ctr_flags); 1334 } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_WRITE_MOSTLY))) { 1335 if (!rt_is_raid1(rt)) { 1336 rs->ti->error = "write_mostly option is only valid for RAID1"; 1337 return -EINVAL; 1338 } 1339 1340 if (!__within_range(value, 0, rs->md.raid_disks - 1)) { 1341 rs->ti->error = "Invalid write_mostly index given"; 1342 return -EINVAL; 1343 } 1344 1345 write_mostly++; 1346 set_bit(WriteMostly, &rs->dev[value].rdev.flags); 1347 set_bit(__CTR_FLAG_WRITE_MOSTLY, &rs->ctr_flags); 1348 } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_MAX_WRITE_BEHIND))) { 1349 if (!rt_is_raid1(rt)) { 1350 rs->ti->error = "max_write_behind option is only valid for RAID1"; 1351 return -EINVAL; 1352 } 1353 1354 if (test_and_set_bit(__CTR_FLAG_MAX_WRITE_BEHIND, &rs->ctr_flags)) { 1355 rs->ti->error = "Only one max_write_behind argument pair allowed"; 1356 return -EINVAL; 1357 } 1358 1359 /* 1360 * In device-mapper, we specify things in sectors, but 1361 * MD records this value in kB 1362 */ 1363 if (value < 0 || value / 2 > COUNTER_MAX) { 1364 rs->ti->error = "Max write-behind limit out of range"; 1365 return -EINVAL; 1366 } 1367 1368 rs->md.bitmap_info.max_write_behind = value / 2; 1369 } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_DAEMON_SLEEP))) { 1370 if (test_and_set_bit(__CTR_FLAG_DAEMON_SLEEP, &rs->ctr_flags)) { 1371 rs->ti->error = "Only one daemon_sleep argument pair allowed"; 1372 return -EINVAL; 1373 } 1374 if (value < 0) { 1375 rs->ti->error = "daemon sleep period out of range"; 1376 return -EINVAL; 1377 } 1378 rs->md.bitmap_info.daemon_sleep = value; 1379 } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_DATA_OFFSET))) { 1380 /* Userspace passes new data_offset after having extended the data image LV */ 1381 if (test_and_set_bit(__CTR_FLAG_DATA_OFFSET, &rs->ctr_flags)) { 1382 rs->ti->error = "Only one data_offset argument pair allowed"; 1383 return -EINVAL; 1384 } 1385 /* Ensure sensible data offset */ 1386 if (value < 0 || 1387 (value && (value < MIN_FREE_RESHAPE_SPACE || value % to_sector(PAGE_SIZE)))) { 1388 rs->ti->error = "Bogus data_offset value"; 1389 return -EINVAL; 1390 } 1391 rs->data_offset = value; 1392 } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_DELTA_DISKS))) { 1393 /* Define the +/-# of disks to add to/remove from the given raid set */ 1394 if (test_and_set_bit(__CTR_FLAG_DELTA_DISKS, &rs->ctr_flags)) { 1395 rs->ti->error = "Only one delta_disks argument pair allowed"; 1396 return -EINVAL; 1397 } 1398 /* Ensure MAX_RAID_DEVICES and raid type minimal_devs! */ 1399 if (!__within_range(abs(value), 1, MAX_RAID_DEVICES - rt->minimal_devs)) { 1400 rs->ti->error = "Too many delta_disk requested"; 1401 return -EINVAL; 1402 } 1403 1404 rs->delta_disks = value; 1405 } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_STRIPE_CACHE))) { 1406 if (test_and_set_bit(__CTR_FLAG_STRIPE_CACHE, &rs->ctr_flags)) { 1407 rs->ti->error = "Only one stripe_cache argument pair allowed"; 1408 return -EINVAL; 1409 } 1410 1411 if (!rt_is_raid456(rt)) { 1412 rs->ti->error = "Inappropriate argument: stripe_cache"; 1413 return -EINVAL; 1414 } 1415 1416 if (value < 0) { 1417 rs->ti->error = "Bogus stripe cache entries value"; 1418 return -EINVAL; 1419 } 1420 rs->stripe_cache_entries = value; 1421 } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_MIN_RECOVERY_RATE))) { 1422 if (test_and_set_bit(__CTR_FLAG_MIN_RECOVERY_RATE, &rs->ctr_flags)) { 1423 rs->ti->error = "Only one min_recovery_rate argument pair allowed"; 1424 return -EINVAL; 1425 } 1426 1427 if (value < 0) { 1428 rs->ti->error = "min_recovery_rate out of range"; 1429 return -EINVAL; 1430 } 1431 rs->md.sync_speed_min = value; 1432 } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_MAX_RECOVERY_RATE))) { 1433 if (test_and_set_bit(__CTR_FLAG_MAX_RECOVERY_RATE, &rs->ctr_flags)) { 1434 rs->ti->error = "Only one max_recovery_rate argument pair allowed"; 1435 return -EINVAL; 1436 } 1437 1438 if (value < 0) { 1439 rs->ti->error = "max_recovery_rate out of range"; 1440 return -EINVAL; 1441 } 1442 rs->md.sync_speed_max = value; 1443 } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_REGION_SIZE))) { 1444 if (test_and_set_bit(__CTR_FLAG_REGION_SIZE, &rs->ctr_flags)) { 1445 rs->ti->error = "Only one region_size argument pair allowed"; 1446 return -EINVAL; 1447 } 1448 1449 region_size = value; 1450 rs->requested_bitmap_chunk_sectors = value; 1451 } else if (!strcasecmp(key, dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_COPIES))) { 1452 if (test_and_set_bit(__CTR_FLAG_RAID10_COPIES, &rs->ctr_flags)) { 1453 rs->ti->error = "Only one raid10_copies argument pair allowed"; 1454 return -EINVAL; 1455 } 1456 1457 if (!__within_range(value, 2, rs->md.raid_disks)) { 1458 rs->ti->error = "Bad value for 'raid10_copies'"; 1459 return -EINVAL; 1460 } 1461 1462 raid10_copies = value; 1463 } else { 1464 DMERR("Unable to parse RAID parameter: %s", key); 1465 rs->ti->error = "Unable to parse RAID parameter"; 1466 return -EINVAL; 1467 } 1468 } 1469 1470 if (test_bit(__CTR_FLAG_SYNC, &rs->ctr_flags) && 1471 test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags)) { 1472 rs->ti->error = "sync and nosync are mutually exclusive"; 1473 return -EINVAL; 1474 } 1475 1476 if (test_bit(__CTR_FLAG_REBUILD, &rs->ctr_flags) && 1477 (test_bit(__CTR_FLAG_SYNC, &rs->ctr_flags) || 1478 test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags))) { 1479 rs->ti->error = "sync/nosync and rebuild are mutually exclusive"; 1480 return -EINVAL; 1481 } 1482 1483 if (write_mostly >= rs->md.raid_disks) { 1484 rs->ti->error = "Can't set all raid1 devices to write_mostly"; 1485 return -EINVAL; 1486 } 1487 1488 if (rs->md.sync_speed_max && 1489 rs->md.sync_speed_min > rs->md.sync_speed_max) { 1490 rs->ti->error = "Bogus recovery rates"; 1491 return -EINVAL; 1492 } 1493 1494 if (validate_region_size(rs, region_size)) 1495 return -EINVAL; 1496 1497 if (rs->md.chunk_sectors) 1498 max_io_len = rs->md.chunk_sectors; 1499 else 1500 max_io_len = region_size; 1501 1502 if (dm_set_target_max_io_len(rs->ti, max_io_len)) 1503 return -EINVAL; 1504 1505 if (rt_is_raid10(rt)) { 1506 if (raid10_copies > rs->md.raid_disks) { 1507 rs->ti->error = "Not enough devices to satisfy specification"; 1508 return -EINVAL; 1509 } 1510 1511 rs->md.new_layout = raid10_format_to_md_layout(rs, raid10_format, raid10_copies); 1512 if (rs->md.new_layout < 0) { 1513 rs->ti->error = "Error getting raid10 format"; 1514 return rs->md.new_layout; 1515 } 1516 1517 rt = get_raid_type_by_ll(10, rs->md.new_layout); 1518 if (!rt) { 1519 rs->ti->error = "Failed to recognize new raid10 layout"; 1520 return -EINVAL; 1521 } 1522 1523 if ((rt->algorithm == ALGORITHM_RAID10_DEFAULT || 1524 rt->algorithm == ALGORITHM_RAID10_NEAR) && 1525 test_bit(__CTR_FLAG_RAID10_USE_NEAR_SETS, &rs->ctr_flags)) { 1526 rs->ti->error = "RAID10 format 'near' and 'raid10_use_near_sets' are incompatible"; 1527 return -EINVAL; 1528 } 1529 } 1530 1531 rs->raid10_copies = raid10_copies; 1532 1533 /* Assume there are no metadata devices until the drives are parsed */ 1534 rs->md.persistent = 0; 1535 rs->md.external = 1; 1536 1537 /* Check, if any invalid ctr arguments have been passed in for the raid level */ 1538 return rs_check_for_valid_flags(rs); 1539 } 1540 1541 /* Set raid4/5/6 cache size */ 1542 static int rs_set_raid456_stripe_cache(struct raid_set *rs) 1543 { 1544 int r; 1545 struct r5conf *conf; 1546 struct mddev *mddev = &rs->md; 1547 uint32_t min_stripes = max(mddev->chunk_sectors, mddev->new_chunk_sectors) / 2; 1548 uint32_t nr_stripes = rs->stripe_cache_entries; 1549 1550 if (!rt_is_raid456(rs->raid_type)) { 1551 rs->ti->error = "Inappropriate raid level; cannot change stripe_cache size"; 1552 return -EINVAL; 1553 } 1554 1555 if (nr_stripes < min_stripes) { 1556 DMINFO("Adjusting requested %u stripe cache entries to %u to suit stripe size", 1557 nr_stripes, min_stripes); 1558 nr_stripes = min_stripes; 1559 } 1560 1561 conf = mddev->private; 1562 if (!conf) { 1563 rs->ti->error = "Cannot change stripe_cache size on inactive RAID set"; 1564 return -EINVAL; 1565 } 1566 1567 /* Try setting number of stripes in raid456 stripe cache */ 1568 if (conf->min_nr_stripes != nr_stripes) { 1569 r = raid5_set_cache_size(mddev, nr_stripes); 1570 if (r) { 1571 rs->ti->error = "Failed to set raid4/5/6 stripe cache size"; 1572 return r; 1573 } 1574 1575 DMINFO("%u stripe cache entries", nr_stripes); 1576 } 1577 1578 return 0; 1579 } 1580 1581 /* Return # of data stripes as kept in mddev as of @rs (i.e. as of superblock) */ 1582 static unsigned int mddev_data_stripes(struct raid_set *rs) 1583 { 1584 return rs->md.raid_disks - rs->raid_type->parity_devs; 1585 } 1586 1587 /* Return # of data stripes of @rs (i.e. as of ctr) */ 1588 static unsigned int rs_data_stripes(struct raid_set *rs) 1589 { 1590 return rs->raid_disks - rs->raid_type->parity_devs; 1591 } 1592 1593 /* 1594 * Retrieve rdev->sectors from any valid raid device of @rs 1595 * to allow userpace to pass in arbitray "- -" device tupples. 1596 */ 1597 static sector_t __rdev_sectors(struct raid_set *rs) 1598 { 1599 int i; 1600 1601 for (i = 0; i < rs->raid_disks; i++) { 1602 struct md_rdev *rdev = &rs->dev[i].rdev; 1603 1604 if (!test_bit(Journal, &rdev->flags) && 1605 rdev->bdev && rdev->sectors) 1606 return rdev->sectors; 1607 } 1608 1609 return 0; 1610 } 1611 1612 /* Check that calculated dev_sectors fits all component devices. */ 1613 static int _check_data_dev_sectors(struct raid_set *rs) 1614 { 1615 sector_t ds = ~0; 1616 struct md_rdev *rdev; 1617 1618 rdev_for_each(rdev, &rs->md) 1619 if (!test_bit(Journal, &rdev->flags) && rdev->bdev) { 1620 ds = min(ds, bdev_nr_sectors(rdev->bdev)); 1621 if (ds < rs->md.dev_sectors) { 1622 rs->ti->error = "Component device(s) too small"; 1623 return -EINVAL; 1624 } 1625 } 1626 1627 return 0; 1628 } 1629 1630 /* Get reshape sectors from data_offsets or raid set */ 1631 static sector_t _get_reshape_sectors(struct raid_set *rs) 1632 { 1633 struct md_rdev *rdev; 1634 sector_t reshape_sectors = 0; 1635 1636 rdev_for_each(rdev, &rs->md) 1637 if (!test_bit(Journal, &rdev->flags)) { 1638 reshape_sectors = (rdev->data_offset > rdev->new_data_offset) ? 1639 rdev->data_offset - rdev->new_data_offset : 1640 rdev->new_data_offset - rdev->data_offset; 1641 break; 1642 } 1643 1644 return max(reshape_sectors, (sector_t) rs->data_offset); 1645 } 1646 1647 /* Calculate the sectors per device and per array used for @rs */ 1648 static int rs_set_dev_and_array_sectors(struct raid_set *rs, sector_t sectors, bool use_mddev) 1649 { 1650 int delta_disks; 1651 unsigned int data_stripes; 1652 sector_t array_sectors = sectors, dev_sectors = sectors; 1653 struct mddev *mddev = &rs->md; 1654 1655 if (use_mddev) { 1656 delta_disks = mddev->delta_disks; 1657 data_stripes = mddev_data_stripes(rs); 1658 } else { 1659 delta_disks = rs->delta_disks; 1660 data_stripes = rs_data_stripes(rs); 1661 } 1662 1663 /* Special raid1 case w/o delta_disks support (yet) */ 1664 if (rt_is_raid1(rs->raid_type)) 1665 ; 1666 else if (rt_is_raid10(rs->raid_type)) { 1667 if (rs->raid10_copies < 2 || 1668 delta_disks < 0) { 1669 rs->ti->error = "Bogus raid10 data copies or delta disks"; 1670 return -EINVAL; 1671 } 1672 1673 dev_sectors *= rs->raid10_copies; 1674 if (sector_div(dev_sectors, data_stripes)) 1675 goto bad; 1676 1677 array_sectors = (data_stripes + delta_disks) * (dev_sectors - _get_reshape_sectors(rs)); 1678 if (sector_div(array_sectors, rs->raid10_copies)) 1679 goto bad; 1680 1681 } else if (sector_div(dev_sectors, data_stripes)) 1682 goto bad; 1683 1684 else 1685 /* Striped layouts */ 1686 array_sectors = (data_stripes + delta_disks) * (dev_sectors - _get_reshape_sectors(rs)); 1687 1688 mddev->array_sectors = array_sectors; 1689 mddev->dev_sectors = dev_sectors; 1690 rs_set_rdev_sectors(rs); 1691 1692 return _check_data_dev_sectors(rs); 1693 bad: 1694 rs->ti->error = "Target length not divisible by number of data devices"; 1695 return -EINVAL; 1696 } 1697 1698 /* Setup recovery on @rs */ 1699 static void rs_setup_recovery(struct raid_set *rs, sector_t dev_sectors) 1700 { 1701 /* raid0 does not recover */ 1702 if (rs_is_raid0(rs)) 1703 rs->md.recovery_cp = MaxSector; 1704 /* 1705 * A raid6 set has to be recovered either 1706 * completely or for the grown part to 1707 * ensure proper parity and Q-Syndrome 1708 */ 1709 else if (rs_is_raid6(rs)) 1710 rs->md.recovery_cp = dev_sectors; 1711 /* 1712 * Other raid set types may skip recovery 1713 * depending on the 'nosync' flag. 1714 */ 1715 else 1716 rs->md.recovery_cp = test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags) 1717 ? MaxSector : dev_sectors; 1718 } 1719 1720 static void do_table_event(struct work_struct *ws) 1721 { 1722 struct raid_set *rs = container_of(ws, struct raid_set, md.event_work); 1723 1724 smp_rmb(); /* Make sure we access most actual mddev properties */ 1725 1726 /* Only grow size resulting from added stripe(s) after reshape ended. */ 1727 if (!rs_is_reshaping(rs) && 1728 rs->array_sectors > rs->md.array_sectors && 1729 !rs->md.delta_disks && 1730 rs->md.raid_disks == rs->raid_disks) { 1731 /* The raid10 personality doesn't provide proper device sizes -> correct. */ 1732 if (rs_is_raid10(rs)) 1733 rs_set_rdev_sectors(rs); 1734 1735 rs->md.array_sectors = rs->array_sectors; 1736 rs_set_capacity(rs); 1737 } 1738 1739 dm_table_event(rs->ti->table); 1740 } 1741 1742 /* 1743 * Make sure a valid takover (level switch) is being requested on @rs 1744 * 1745 * Conversions of raid sets from one MD personality to another 1746 * have to conform to restrictions which are enforced here. 1747 */ 1748 static int rs_check_takeover(struct raid_set *rs) 1749 { 1750 struct mddev *mddev = &rs->md; 1751 unsigned int near_copies; 1752 1753 if (rs->md.degraded) { 1754 rs->ti->error = "Can't takeover degraded raid set"; 1755 return -EPERM; 1756 } 1757 1758 if (rs_is_reshaping(rs)) { 1759 rs->ti->error = "Can't takeover reshaping raid set"; 1760 return -EPERM; 1761 } 1762 1763 switch (mddev->level) { 1764 case 0: 1765 /* raid0 -> raid1/5 with one disk */ 1766 if ((mddev->new_level == 1 || mddev->new_level == 5) && 1767 mddev->raid_disks == 1) 1768 return 0; 1769 1770 /* raid0 -> raid10 */ 1771 if (mddev->new_level == 10 && 1772 !(rs->raid_disks % mddev->raid_disks)) 1773 return 0; 1774 1775 /* raid0 with multiple disks -> raid4/5/6 */ 1776 if (__within_range(mddev->new_level, 4, 6) && 1777 mddev->new_layout == ALGORITHM_PARITY_N && 1778 mddev->raid_disks > 1) 1779 return 0; 1780 1781 break; 1782 1783 case 10: 1784 /* Can't takeover raid10_offset! */ 1785 if (__is_raid10_offset(mddev->layout)) 1786 break; 1787 1788 near_copies = __raid10_near_copies(mddev->layout); 1789 1790 /* raid10* -> raid0 */ 1791 if (mddev->new_level == 0) { 1792 /* Can takeover raid10_near with raid disks divisable by data copies! */ 1793 if (near_copies > 1 && 1794 !(mddev->raid_disks % near_copies)) { 1795 mddev->raid_disks /= near_copies; 1796 mddev->delta_disks = mddev->raid_disks; 1797 return 0; 1798 } 1799 1800 /* Can takeover raid10_far */ 1801 if (near_copies == 1 && 1802 __raid10_far_copies(mddev->layout) > 1) 1803 return 0; 1804 1805 break; 1806 } 1807 1808 /* raid10_{near,far} -> raid1 */ 1809 if (mddev->new_level == 1 && 1810 max(near_copies, __raid10_far_copies(mddev->layout)) == mddev->raid_disks) 1811 return 0; 1812 1813 /* raid10_{near,far} with 2 disks -> raid4/5 */ 1814 if (__within_range(mddev->new_level, 4, 5) && 1815 mddev->raid_disks == 2) 1816 return 0; 1817 break; 1818 1819 case 1: 1820 /* raid1 with 2 disks -> raid4/5 */ 1821 if (__within_range(mddev->new_level, 4, 5) && 1822 mddev->raid_disks == 2) { 1823 mddev->degraded = 1; 1824 return 0; 1825 } 1826 1827 /* raid1 -> raid0 */ 1828 if (mddev->new_level == 0 && 1829 mddev->raid_disks == 1) 1830 return 0; 1831 1832 /* raid1 -> raid10 */ 1833 if (mddev->new_level == 10) 1834 return 0; 1835 break; 1836 1837 case 4: 1838 /* raid4 -> raid0 */ 1839 if (mddev->new_level == 0) 1840 return 0; 1841 1842 /* raid4 -> raid1/5 with 2 disks */ 1843 if ((mddev->new_level == 1 || mddev->new_level == 5) && 1844 mddev->raid_disks == 2) 1845 return 0; 1846 1847 /* raid4 -> raid5/6 with parity N */ 1848 if (__within_range(mddev->new_level, 5, 6) && 1849 mddev->layout == ALGORITHM_PARITY_N) 1850 return 0; 1851 break; 1852 1853 case 5: 1854 /* raid5 with parity N -> raid0 */ 1855 if (mddev->new_level == 0 && 1856 mddev->layout == ALGORITHM_PARITY_N) 1857 return 0; 1858 1859 /* raid5 with parity N -> raid4 */ 1860 if (mddev->new_level == 4 && 1861 mddev->layout == ALGORITHM_PARITY_N) 1862 return 0; 1863 1864 /* raid5 with 2 disks -> raid1/4/10 */ 1865 if ((mddev->new_level == 1 || mddev->new_level == 4 || mddev->new_level == 10) && 1866 mddev->raid_disks == 2) 1867 return 0; 1868 1869 /* raid5_* -> raid6_*_6 with Q-Syndrome N (e.g. raid5_ra -> raid6_ra_6 */ 1870 if (mddev->new_level == 6 && 1871 ((mddev->layout == ALGORITHM_PARITY_N && mddev->new_layout == ALGORITHM_PARITY_N) || 1872 __within_range(mddev->new_layout, ALGORITHM_LEFT_ASYMMETRIC_6, ALGORITHM_RIGHT_SYMMETRIC_6))) 1873 return 0; 1874 break; 1875 1876 case 6: 1877 /* raid6 with parity N -> raid0 */ 1878 if (mddev->new_level == 0 && 1879 mddev->layout == ALGORITHM_PARITY_N) 1880 return 0; 1881 1882 /* raid6 with parity N -> raid4 */ 1883 if (mddev->new_level == 4 && 1884 mddev->layout == ALGORITHM_PARITY_N) 1885 return 0; 1886 1887 /* raid6_*_n with Q-Syndrome N -> raid5_* */ 1888 if (mddev->new_level == 5 && 1889 ((mddev->layout == ALGORITHM_PARITY_N && mddev->new_layout == ALGORITHM_PARITY_N) || 1890 __within_range(mddev->new_layout, ALGORITHM_LEFT_ASYMMETRIC, ALGORITHM_RIGHT_SYMMETRIC))) 1891 return 0; 1892 break; 1893 1894 default: 1895 break; 1896 } 1897 1898 rs->ti->error = "takeover not possible"; 1899 return -EINVAL; 1900 } 1901 1902 /* True if @rs requested to be taken over */ 1903 static bool rs_takeover_requested(struct raid_set *rs) 1904 { 1905 return rs->md.new_level != rs->md.level; 1906 } 1907 1908 /* True if layout is set to reshape. */ 1909 static bool rs_is_layout_change(struct raid_set *rs, bool use_mddev) 1910 { 1911 return (use_mddev ? rs->md.delta_disks : rs->delta_disks) || 1912 rs->md.new_layout != rs->md.layout || 1913 rs->md.new_chunk_sectors != rs->md.chunk_sectors; 1914 } 1915 1916 /* True if @rs is requested to reshape by ctr */ 1917 static bool rs_reshape_requested(struct raid_set *rs) 1918 { 1919 bool change; 1920 struct mddev *mddev = &rs->md; 1921 1922 if (rs_takeover_requested(rs)) 1923 return false; 1924 1925 if (rs_is_raid0(rs)) 1926 return false; 1927 1928 change = rs_is_layout_change(rs, false); 1929 1930 /* Historical case to support raid1 reshape without delta disks */ 1931 if (rs_is_raid1(rs)) { 1932 if (rs->delta_disks) 1933 return !!rs->delta_disks; 1934 1935 return !change && 1936 mddev->raid_disks != rs->raid_disks; 1937 } 1938 1939 if (rs_is_raid10(rs)) 1940 return change && 1941 !__is_raid10_far(mddev->new_layout) && 1942 rs->delta_disks >= 0; 1943 1944 return change; 1945 } 1946 1947 /* Features */ 1948 #define FEATURE_FLAG_SUPPORTS_V190 0x1 /* Supports extended superblock */ 1949 1950 /* State flags for sb->flags */ 1951 #define SB_FLAG_RESHAPE_ACTIVE 0x1 1952 #define SB_FLAG_RESHAPE_BACKWARDS 0x2 1953 1954 /* 1955 * This structure is never routinely used by userspace, unlike md superblocks. 1956 * Devices with this superblock should only ever be accessed via device-mapper. 1957 */ 1958 #define DM_RAID_MAGIC 0x64526D44 1959 struct dm_raid_superblock { 1960 __le32 magic; /* "DmRd" */ 1961 __le32 compat_features; /* Used to indicate compatible features (like 1.9.0 ondisk metadata extension) */ 1962 1963 __le32 num_devices; /* Number of devices in this raid set. (Max 64) */ 1964 __le32 array_position; /* The position of this drive in the raid set */ 1965 1966 __le64 events; /* Incremented by md when superblock updated */ 1967 __le64 failed_devices; /* Pre 1.9.0 part of bit field of devices to */ 1968 /* indicate failures (see extension below) */ 1969 1970 /* 1971 * This offset tracks the progress of the repair or replacement of 1972 * an individual drive. 1973 */ 1974 __le64 disk_recovery_offset; 1975 1976 /* 1977 * This offset tracks the progress of the initial raid set 1978 * synchronisation/parity calculation. 1979 */ 1980 __le64 array_resync_offset; 1981 1982 /* 1983 * raid characteristics 1984 */ 1985 __le32 level; 1986 __le32 layout; 1987 __le32 stripe_sectors; 1988 1989 /******************************************************************** 1990 * BELOW FOLLOW V1.9.0 EXTENSIONS TO THE PRISTINE SUPERBLOCK FORMAT!!! 1991 * 1992 * FEATURE_FLAG_SUPPORTS_V190 in the compat_features member indicates that those exist 1993 */ 1994 1995 __le32 flags; /* Flags defining array states for reshaping */ 1996 1997 /* 1998 * This offset tracks the progress of a raid 1999 * set reshape in order to be able to restart it 2000 */ 2001 __le64 reshape_position; 2002 2003 /* 2004 * These define the properties of the array in case of an interrupted reshape 2005 */ 2006 __le32 new_level; 2007 __le32 new_layout; 2008 __le32 new_stripe_sectors; 2009 __le32 delta_disks; 2010 2011 __le64 array_sectors; /* Array size in sectors */ 2012 2013 /* 2014 * Sector offsets to data on devices (reshaping). 2015 * Needed to support out of place reshaping, thus 2016 * not writing over any stripes whilst converting 2017 * them from old to new layout 2018 */ 2019 __le64 data_offset; 2020 __le64 new_data_offset; 2021 2022 __le64 sectors; /* Used device size in sectors */ 2023 2024 /* 2025 * Additional Bit field of devices indicating failures to support 2026 * up to 256 devices with the 1.9.0 on-disk metadata format 2027 */ 2028 __le64 extended_failed_devices[DISKS_ARRAY_ELEMS - 1]; 2029 2030 __le32 incompat_features; /* Used to indicate any incompatible features */ 2031 2032 /* Always set rest up to logical block size to 0 when writing (see get_metadata_device() below). */ 2033 } __packed; 2034 2035 /* 2036 * Check for reshape constraints on raid set @rs: 2037 * 2038 * - reshape function non-existent 2039 * - degraded set 2040 * - ongoing recovery 2041 * - ongoing reshape 2042 * 2043 * Returns 0 if none or -EPERM if given constraint 2044 * and error message reference in @errmsg 2045 */ 2046 static int rs_check_reshape(struct raid_set *rs) 2047 { 2048 struct mddev *mddev = &rs->md; 2049 2050 if (!mddev->pers || !mddev->pers->check_reshape) 2051 rs->ti->error = "Reshape not supported"; 2052 else if (mddev->degraded) 2053 rs->ti->error = "Can't reshape degraded raid set"; 2054 else if (rs_is_recovering(rs)) 2055 rs->ti->error = "Convert request on recovering raid set prohibited"; 2056 else if (rs_is_reshaping(rs)) 2057 rs->ti->error = "raid set already reshaping!"; 2058 else if (!(rs_is_raid1(rs) || rs_is_raid10(rs) || rs_is_raid456(rs))) 2059 rs->ti->error = "Reshaping only supported for raid1/4/5/6/10"; 2060 else 2061 return 0; 2062 2063 return -EPERM; 2064 } 2065 2066 static int read_disk_sb(struct md_rdev *rdev, int size, bool force_reload) 2067 { 2068 BUG_ON(!rdev->sb_page); 2069 2070 if (rdev->sb_loaded && !force_reload) 2071 return 0; 2072 2073 rdev->sb_loaded = 0; 2074 2075 if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, true)) { 2076 DMERR("Failed to read superblock of device at position %d", 2077 rdev->raid_disk); 2078 md_error(rdev->mddev, rdev); 2079 set_bit(Faulty, &rdev->flags); 2080 return -EIO; 2081 } 2082 2083 rdev->sb_loaded = 1; 2084 2085 return 0; 2086 } 2087 2088 static void sb_retrieve_failed_devices(struct dm_raid_superblock *sb, uint64_t *failed_devices) 2089 { 2090 failed_devices[0] = le64_to_cpu(sb->failed_devices); 2091 memset(failed_devices + 1, 0, sizeof(sb->extended_failed_devices)); 2092 2093 if (le32_to_cpu(sb->compat_features) & FEATURE_FLAG_SUPPORTS_V190) { 2094 int i = ARRAY_SIZE(sb->extended_failed_devices); 2095 2096 while (i--) 2097 failed_devices[i+1] = le64_to_cpu(sb->extended_failed_devices[i]); 2098 } 2099 } 2100 2101 static void sb_update_failed_devices(struct dm_raid_superblock *sb, uint64_t *failed_devices) 2102 { 2103 int i = ARRAY_SIZE(sb->extended_failed_devices); 2104 2105 sb->failed_devices = cpu_to_le64(failed_devices[0]); 2106 while (i--) 2107 sb->extended_failed_devices[i] = cpu_to_le64(failed_devices[i+1]); 2108 } 2109 2110 /* 2111 * Synchronize the superblock members with the raid set properties 2112 * 2113 * All superblock data is little endian. 2114 */ 2115 static void super_sync(struct mddev *mddev, struct md_rdev *rdev) 2116 { 2117 bool update_failed_devices = false; 2118 unsigned int i; 2119 uint64_t failed_devices[DISKS_ARRAY_ELEMS]; 2120 struct dm_raid_superblock *sb; 2121 struct raid_set *rs = container_of(mddev, struct raid_set, md); 2122 2123 /* No metadata device, no superblock */ 2124 if (!rdev->meta_bdev) 2125 return; 2126 2127 BUG_ON(!rdev->sb_page); 2128 2129 sb = page_address(rdev->sb_page); 2130 2131 sb_retrieve_failed_devices(sb, failed_devices); 2132 2133 for (i = 0; i < rs->raid_disks; i++) 2134 if (!rs->dev[i].data_dev || test_bit(Faulty, &rs->dev[i].rdev.flags)) { 2135 update_failed_devices = true; 2136 set_bit(i, (void *) failed_devices); 2137 } 2138 2139 if (update_failed_devices) 2140 sb_update_failed_devices(sb, failed_devices); 2141 2142 sb->magic = cpu_to_le32(DM_RAID_MAGIC); 2143 sb->compat_features = cpu_to_le32(FEATURE_FLAG_SUPPORTS_V190); 2144 2145 sb->num_devices = cpu_to_le32(mddev->raid_disks); 2146 sb->array_position = cpu_to_le32(rdev->raid_disk); 2147 2148 sb->events = cpu_to_le64(mddev->events); 2149 2150 sb->disk_recovery_offset = cpu_to_le64(rdev->recovery_offset); 2151 sb->array_resync_offset = cpu_to_le64(mddev->recovery_cp); 2152 2153 sb->level = cpu_to_le32(mddev->level); 2154 sb->layout = cpu_to_le32(mddev->layout); 2155 sb->stripe_sectors = cpu_to_le32(mddev->chunk_sectors); 2156 2157 /******************************************************************** 2158 * BELOW FOLLOW V1.9.0 EXTENSIONS TO THE PRISTINE SUPERBLOCK FORMAT!!! 2159 * 2160 * FEATURE_FLAG_SUPPORTS_V190 in the compat_features member indicates that those exist 2161 */ 2162 sb->new_level = cpu_to_le32(mddev->new_level); 2163 sb->new_layout = cpu_to_le32(mddev->new_layout); 2164 sb->new_stripe_sectors = cpu_to_le32(mddev->new_chunk_sectors); 2165 2166 sb->delta_disks = cpu_to_le32(mddev->delta_disks); 2167 2168 smp_rmb(); /* Make sure we access most recent reshape position */ 2169 sb->reshape_position = cpu_to_le64(mddev->reshape_position); 2170 if (le64_to_cpu(sb->reshape_position) != MaxSector) { 2171 /* Flag ongoing reshape */ 2172 sb->flags |= cpu_to_le32(SB_FLAG_RESHAPE_ACTIVE); 2173 2174 if (mddev->delta_disks < 0 || mddev->reshape_backwards) 2175 sb->flags |= cpu_to_le32(SB_FLAG_RESHAPE_BACKWARDS); 2176 } else { 2177 /* Clear reshape flags */ 2178 sb->flags &= ~(cpu_to_le32(SB_FLAG_RESHAPE_ACTIVE|SB_FLAG_RESHAPE_BACKWARDS)); 2179 } 2180 2181 sb->array_sectors = cpu_to_le64(mddev->array_sectors); 2182 sb->data_offset = cpu_to_le64(rdev->data_offset); 2183 sb->new_data_offset = cpu_to_le64(rdev->new_data_offset); 2184 sb->sectors = cpu_to_le64(rdev->sectors); 2185 sb->incompat_features = cpu_to_le32(0); 2186 2187 /* Zero out the rest of the payload after the size of the superblock */ 2188 memset(sb + 1, 0, rdev->sb_size - sizeof(*sb)); 2189 } 2190 2191 /* 2192 * super_load 2193 * 2194 * This function creates a superblock if one is not found on the device 2195 * and will decide which superblock to use if there's a choice. 2196 * 2197 * Return: 1 if use rdev, 0 if use refdev, -Exxx otherwise 2198 */ 2199 static int super_load(struct md_rdev *rdev, struct md_rdev *refdev) 2200 { 2201 int r; 2202 struct dm_raid_superblock *sb; 2203 struct dm_raid_superblock *refsb; 2204 uint64_t events_sb, events_refsb; 2205 2206 r = read_disk_sb(rdev, rdev->sb_size, false); 2207 if (r) 2208 return r; 2209 2210 sb = page_address(rdev->sb_page); 2211 2212 /* 2213 * Two cases that we want to write new superblocks and rebuild: 2214 * 1) New device (no matching magic number) 2215 * 2) Device specified for rebuild (!In_sync w/ offset == 0) 2216 */ 2217 if ((sb->magic != cpu_to_le32(DM_RAID_MAGIC)) || 2218 (!test_bit(In_sync, &rdev->flags) && !rdev->recovery_offset)) { 2219 super_sync(rdev->mddev, rdev); 2220 2221 set_bit(FirstUse, &rdev->flags); 2222 sb->compat_features = cpu_to_le32(FEATURE_FLAG_SUPPORTS_V190); 2223 2224 /* Force writing of superblocks to disk */ 2225 set_bit(MD_SB_CHANGE_DEVS, &rdev->mddev->sb_flags); 2226 2227 /* Any superblock is better than none, choose that if given */ 2228 return refdev ? 0 : 1; 2229 } 2230 2231 if (!refdev) 2232 return 1; 2233 2234 events_sb = le64_to_cpu(sb->events); 2235 2236 refsb = page_address(refdev->sb_page); 2237 events_refsb = le64_to_cpu(refsb->events); 2238 2239 return (events_sb > events_refsb) ? 1 : 0; 2240 } 2241 2242 static int super_init_validation(struct raid_set *rs, struct md_rdev *rdev) 2243 { 2244 int role; 2245 struct mddev *mddev = &rs->md; 2246 uint64_t events_sb; 2247 uint64_t failed_devices[DISKS_ARRAY_ELEMS]; 2248 struct dm_raid_superblock *sb; 2249 uint32_t new_devs = 0, rebuild_and_new = 0, rebuilds = 0; 2250 struct md_rdev *r; 2251 struct dm_raid_superblock *sb2; 2252 2253 sb = page_address(rdev->sb_page); 2254 events_sb = le64_to_cpu(sb->events); 2255 2256 /* 2257 * Initialise to 1 if this is a new superblock. 2258 */ 2259 mddev->events = events_sb ? : 1; 2260 2261 mddev->reshape_position = MaxSector; 2262 2263 mddev->raid_disks = le32_to_cpu(sb->num_devices); 2264 mddev->level = le32_to_cpu(sb->level); 2265 mddev->layout = le32_to_cpu(sb->layout); 2266 mddev->chunk_sectors = le32_to_cpu(sb->stripe_sectors); 2267 2268 /* 2269 * Reshaping is supported, e.g. reshape_position is valid 2270 * in superblock and superblock content is authoritative. 2271 */ 2272 if (le32_to_cpu(sb->compat_features) & FEATURE_FLAG_SUPPORTS_V190) { 2273 /* Superblock is authoritative wrt given raid set layout! */ 2274 mddev->new_level = le32_to_cpu(sb->new_level); 2275 mddev->new_layout = le32_to_cpu(sb->new_layout); 2276 mddev->new_chunk_sectors = le32_to_cpu(sb->new_stripe_sectors); 2277 mddev->delta_disks = le32_to_cpu(sb->delta_disks); 2278 mddev->array_sectors = le64_to_cpu(sb->array_sectors); 2279 2280 /* raid was reshaping and got interrupted */ 2281 if (le32_to_cpu(sb->flags) & SB_FLAG_RESHAPE_ACTIVE) { 2282 if (test_bit(__CTR_FLAG_DELTA_DISKS, &rs->ctr_flags)) { 2283 DMERR("Reshape requested but raid set is still reshaping"); 2284 return -EINVAL; 2285 } 2286 2287 if (mddev->delta_disks < 0 || 2288 (!mddev->delta_disks && (le32_to_cpu(sb->flags) & SB_FLAG_RESHAPE_BACKWARDS))) 2289 mddev->reshape_backwards = 1; 2290 else 2291 mddev->reshape_backwards = 0; 2292 2293 mddev->reshape_position = le64_to_cpu(sb->reshape_position); 2294 rs->raid_type = get_raid_type_by_ll(mddev->level, mddev->layout); 2295 } 2296 2297 } else { 2298 /* 2299 * No takeover/reshaping, because we don't have the extended v1.9.0 metadata 2300 */ 2301 struct raid_type *rt_cur = get_raid_type_by_ll(mddev->level, mddev->layout); 2302 struct raid_type *rt_new = get_raid_type_by_ll(mddev->new_level, mddev->new_layout); 2303 2304 if (rs_takeover_requested(rs)) { 2305 if (rt_cur && rt_new) 2306 DMERR("Takeover raid sets from %s to %s not yet supported by metadata. (raid level change)", 2307 rt_cur->name, rt_new->name); 2308 else 2309 DMERR("Takeover raid sets not yet supported by metadata. (raid level change)"); 2310 return -EINVAL; 2311 } else if (rs_reshape_requested(rs)) { 2312 DMERR("Reshaping raid sets not yet supported by metadata. (raid layout change keeping level)"); 2313 if (mddev->layout != mddev->new_layout) { 2314 if (rt_cur && rt_new) 2315 DMERR(" current layout %s vs new layout %s", 2316 rt_cur->name, rt_new->name); 2317 else 2318 DMERR(" current layout 0x%X vs new layout 0x%X", 2319 le32_to_cpu(sb->layout), mddev->new_layout); 2320 } 2321 if (mddev->chunk_sectors != mddev->new_chunk_sectors) 2322 DMERR(" current stripe sectors %u vs new stripe sectors %u", 2323 mddev->chunk_sectors, mddev->new_chunk_sectors); 2324 if (rs->delta_disks) 2325 DMERR(" current %u disks vs new %u disks", 2326 mddev->raid_disks, mddev->raid_disks + rs->delta_disks); 2327 if (rs_is_raid10(rs)) { 2328 DMERR(" Old layout: %s w/ %u copies", 2329 raid10_md_layout_to_format(mddev->layout), 2330 raid10_md_layout_to_copies(mddev->layout)); 2331 DMERR(" New layout: %s w/ %u copies", 2332 raid10_md_layout_to_format(mddev->new_layout), 2333 raid10_md_layout_to_copies(mddev->new_layout)); 2334 } 2335 return -EINVAL; 2336 } 2337 2338 DMINFO("Discovered old metadata format; upgrading to extended metadata format"); 2339 } 2340 2341 if (!test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags)) 2342 mddev->recovery_cp = le64_to_cpu(sb->array_resync_offset); 2343 2344 /* 2345 * During load, we set FirstUse if a new superblock was written. 2346 * There are two reasons we might not have a superblock: 2347 * 1) The raid set is brand new - in which case, all of the 2348 * devices must have their In_sync bit set. Also, 2349 * recovery_cp must be 0, unless forced. 2350 * 2) This is a new device being added to an old raid set 2351 * and the new device needs to be rebuilt - in which 2352 * case the In_sync bit will /not/ be set and 2353 * recovery_cp must be MaxSector. 2354 * 3) This is/are a new device(s) being added to an old 2355 * raid set during takeover to a higher raid level 2356 * to provide capacity for redundancy or during reshape 2357 * to add capacity to grow the raid set. 2358 */ 2359 rdev_for_each(r, mddev) { 2360 if (test_bit(Journal, &rdev->flags)) 2361 continue; 2362 2363 if (test_bit(FirstUse, &r->flags)) 2364 new_devs++; 2365 2366 if (!test_bit(In_sync, &r->flags)) { 2367 DMINFO("Device %d specified for rebuild; clearing superblock", 2368 r->raid_disk); 2369 rebuilds++; 2370 2371 if (test_bit(FirstUse, &r->flags)) 2372 rebuild_and_new++; 2373 } 2374 } 2375 2376 if (new_devs == rs->raid_disks || !rebuilds) { 2377 /* Replace a broken device */ 2378 if (new_devs == rs->raid_disks) { 2379 DMINFO("Superblocks created for new raid set"); 2380 set_bit(MD_ARRAY_FIRST_USE, &mddev->flags); 2381 } else if (new_devs != rebuilds && 2382 new_devs != rs->delta_disks) { 2383 DMERR("New device injected into existing raid set without " 2384 "'delta_disks' or 'rebuild' parameter specified"); 2385 return -EINVAL; 2386 } 2387 } else if (new_devs && new_devs != rebuilds) { 2388 DMERR("%u 'rebuild' devices cannot be injected into" 2389 " a raid set with %u other first-time devices", 2390 rebuilds, new_devs); 2391 return -EINVAL; 2392 } else if (rebuilds) { 2393 if (rebuild_and_new && rebuilds != rebuild_and_new) { 2394 DMERR("new device%s provided without 'rebuild'", 2395 new_devs > 1 ? "s" : ""); 2396 return -EINVAL; 2397 } else if (!test_bit(__CTR_FLAG_REBUILD, &rs->ctr_flags) && rs_is_recovering(rs)) { 2398 DMERR("'rebuild' specified while raid set is not in-sync (recovery_cp=%llu)", 2399 (unsigned long long) mddev->recovery_cp); 2400 return -EINVAL; 2401 } else if (rs_is_reshaping(rs)) { 2402 DMERR("'rebuild' specified while raid set is being reshaped (reshape_position=%llu)", 2403 (unsigned long long) mddev->reshape_position); 2404 return -EINVAL; 2405 } 2406 } 2407 2408 /* 2409 * Now we set the Faulty bit for those devices that are 2410 * recorded in the superblock as failed. 2411 */ 2412 sb_retrieve_failed_devices(sb, failed_devices); 2413 rdev_for_each(r, mddev) { 2414 if (test_bit(Journal, &rdev->flags) || 2415 !r->sb_page) 2416 continue; 2417 sb2 = page_address(r->sb_page); 2418 sb2->failed_devices = 0; 2419 memset(sb2->extended_failed_devices, 0, sizeof(sb2->extended_failed_devices)); 2420 2421 /* 2422 * Check for any device re-ordering. 2423 */ 2424 if (!test_bit(FirstUse, &r->flags) && (r->raid_disk >= 0)) { 2425 role = le32_to_cpu(sb2->array_position); 2426 if (role < 0) 2427 continue; 2428 2429 if (role != r->raid_disk) { 2430 if (rs_is_raid10(rs) && __is_raid10_near(mddev->layout)) { 2431 if (mddev->raid_disks % __raid10_near_copies(mddev->layout) || 2432 rs->raid_disks % rs->raid10_copies) { 2433 rs->ti->error = 2434 "Cannot change raid10 near set to odd # of devices!"; 2435 return -EINVAL; 2436 } 2437 2438 sb2->array_position = cpu_to_le32(r->raid_disk); 2439 2440 } else if (!(rs_is_raid10(rs) && rt_is_raid0(rs->raid_type)) && 2441 !(rs_is_raid0(rs) && rt_is_raid10(rs->raid_type)) && 2442 !rt_is_raid1(rs->raid_type)) { 2443 rs->ti->error = "Cannot change device positions in raid set"; 2444 return -EINVAL; 2445 } 2446 2447 DMINFO("raid device #%d now at position #%d", role, r->raid_disk); 2448 } 2449 2450 /* 2451 * Partial recovery is performed on 2452 * returning failed devices. 2453 */ 2454 if (test_bit(role, (void *) failed_devices)) 2455 set_bit(Faulty, &r->flags); 2456 } 2457 } 2458 2459 return 0; 2460 } 2461 2462 static int super_validate(struct raid_set *rs, struct md_rdev *rdev) 2463 { 2464 struct mddev *mddev = &rs->md; 2465 struct dm_raid_superblock *sb; 2466 2467 if (rs_is_raid0(rs) || !rdev->sb_page || rdev->raid_disk < 0) 2468 return 0; 2469 2470 sb = page_address(rdev->sb_page); 2471 2472 /* 2473 * If mddev->events is not set, we know we have not yet initialized 2474 * the array. 2475 */ 2476 if (!mddev->events && super_init_validation(rs, rdev)) 2477 return -EINVAL; 2478 2479 if (le32_to_cpu(sb->compat_features) && 2480 le32_to_cpu(sb->compat_features) != FEATURE_FLAG_SUPPORTS_V190) { 2481 rs->ti->error = "Unable to assemble array: Unknown flag(s) in compatible feature flags"; 2482 return -EINVAL; 2483 } 2484 2485 if (sb->incompat_features) { 2486 rs->ti->error = "Unable to assemble array: No incompatible feature flags supported yet"; 2487 return -EINVAL; 2488 } 2489 2490 /* Enable bitmap creation on @rs unless no metadevs or raid0 or journaled raid4/5/6 set. */ 2491 mddev->bitmap_info.offset = (rt_is_raid0(rs->raid_type) || rs->journal_dev.dev) ? 0 : to_sector(4096); 2492 mddev->bitmap_info.default_offset = mddev->bitmap_info.offset; 2493 2494 if (!test_and_clear_bit(FirstUse, &rdev->flags)) { 2495 /* 2496 * Retrieve rdev size stored in superblock to be prepared for shrink. 2497 * Check extended superblock members are present otherwise the size 2498 * will not be set! 2499 */ 2500 if (le32_to_cpu(sb->compat_features) & FEATURE_FLAG_SUPPORTS_V190) 2501 rdev->sectors = le64_to_cpu(sb->sectors); 2502 2503 rdev->recovery_offset = le64_to_cpu(sb->disk_recovery_offset); 2504 if (rdev->recovery_offset == MaxSector) 2505 set_bit(In_sync, &rdev->flags); 2506 /* 2507 * If no reshape in progress -> we're recovering single 2508 * disk(s) and have to set the device(s) to out-of-sync 2509 */ 2510 else if (!rs_is_reshaping(rs)) 2511 clear_bit(In_sync, &rdev->flags); /* Mandatory for recovery */ 2512 } 2513 2514 /* 2515 * If a device comes back, set it as not In_sync and no longer faulty. 2516 */ 2517 if (test_and_clear_bit(Faulty, &rdev->flags)) { 2518 rdev->recovery_offset = 0; 2519 clear_bit(In_sync, &rdev->flags); 2520 rdev->saved_raid_disk = rdev->raid_disk; 2521 } 2522 2523 /* Reshape support -> restore respective data offsets */ 2524 rdev->data_offset = le64_to_cpu(sb->data_offset); 2525 rdev->new_data_offset = le64_to_cpu(sb->new_data_offset); 2526 2527 return 0; 2528 } 2529 2530 /* 2531 * Analyse superblocks and select the freshest. 2532 */ 2533 static int analyse_superblocks(struct dm_target *ti, struct raid_set *rs) 2534 { 2535 int r; 2536 struct md_rdev *rdev, *freshest; 2537 struct mddev *mddev = &rs->md; 2538 2539 freshest = NULL; 2540 rdev_for_each(rdev, mddev) { 2541 if (test_bit(Journal, &rdev->flags)) 2542 continue; 2543 2544 if (!rdev->meta_bdev) 2545 continue; 2546 2547 /* Set superblock offset/size for metadata device. */ 2548 rdev->sb_start = 0; 2549 rdev->sb_size = bdev_logical_block_size(rdev->meta_bdev); 2550 if (rdev->sb_size < sizeof(struct dm_raid_superblock) || rdev->sb_size > PAGE_SIZE) { 2551 DMERR("superblock size of a logical block is no longer valid"); 2552 return -EINVAL; 2553 } 2554 2555 /* 2556 * Skipping super_load due to CTR_FLAG_SYNC will cause 2557 * the array to undergo initialization again as 2558 * though it were new. This is the intended effect 2559 * of the "sync" directive. 2560 * 2561 * With reshaping capability added, we must ensure that 2562 * the "sync" directive is disallowed during the reshape. 2563 */ 2564 if (test_bit(__CTR_FLAG_SYNC, &rs->ctr_flags)) 2565 continue; 2566 2567 r = super_load(rdev, freshest); 2568 2569 switch (r) { 2570 case 1: 2571 freshest = rdev; 2572 break; 2573 case 0: 2574 break; 2575 default: 2576 /* This is a failure to read the superblock from the metadata device. */ 2577 /* 2578 * We have to keep any raid0 data/metadata device pairs or 2579 * the MD raid0 personality will fail to start the array. 2580 */ 2581 if (rs_is_raid0(rs)) 2582 continue; 2583 2584 /* 2585 * We keep the dm_devs to be able to emit the device tuple 2586 * properly on the table line in raid_status() (rather than 2587 * mistakenly acting as if '- -' got passed into the constructor). 2588 * 2589 * The rdev has to stay on the same_set list to allow for 2590 * the attempt to restore faulty devices on second resume. 2591 */ 2592 rdev->raid_disk = rdev->saved_raid_disk = -1; 2593 break; 2594 } 2595 } 2596 2597 if (!freshest) 2598 return 0; 2599 2600 /* 2601 * Validation of the freshest device provides the source of 2602 * validation for the remaining devices. 2603 */ 2604 rs->ti->error = "Unable to assemble array: Invalid superblocks"; 2605 if (super_validate(rs, freshest)) 2606 return -EINVAL; 2607 2608 if (validate_raid_redundancy(rs)) { 2609 rs->ti->error = "Insufficient redundancy to activate array"; 2610 return -EINVAL; 2611 } 2612 2613 rdev_for_each(rdev, mddev) 2614 if (!test_bit(Journal, &rdev->flags) && 2615 rdev != freshest && 2616 super_validate(rs, rdev)) 2617 return -EINVAL; 2618 return 0; 2619 } 2620 2621 /* 2622 * Adjust data_offset and new_data_offset on all disk members of @rs 2623 * for out of place reshaping if requested by constructor 2624 * 2625 * We need free space at the beginning of each raid disk for forward 2626 * and at the end for backward reshapes which userspace has to provide 2627 * via remapping/reordering of space. 2628 */ 2629 static int rs_adjust_data_offsets(struct raid_set *rs) 2630 { 2631 sector_t data_offset = 0, new_data_offset = 0; 2632 struct md_rdev *rdev; 2633 2634 /* Constructor did not request data offset change */ 2635 if (!test_bit(__CTR_FLAG_DATA_OFFSET, &rs->ctr_flags)) { 2636 if (!rs_is_reshapable(rs)) 2637 goto out; 2638 2639 return 0; 2640 } 2641 2642 /* HM FIXME: get In_Sync raid_dev? */ 2643 rdev = &rs->dev[0].rdev; 2644 2645 if (rs->delta_disks < 0) { 2646 /* 2647 * Removing disks (reshaping backwards): 2648 * 2649 * - before reshape: data is at offset 0 and free space 2650 * is at end of each component LV 2651 * 2652 * - after reshape: data is at offset rs->data_offset != 0 on each component LV 2653 */ 2654 data_offset = 0; 2655 new_data_offset = rs->data_offset; 2656 2657 } else if (rs->delta_disks > 0) { 2658 /* 2659 * Adding disks (reshaping forwards): 2660 * 2661 * - before reshape: data is at offset rs->data_offset != 0 and 2662 * free space is at begin of each component LV 2663 * 2664 * - after reshape: data is at offset 0 on each component LV 2665 */ 2666 data_offset = rs->data_offset; 2667 new_data_offset = 0; 2668 2669 } else { 2670 /* 2671 * User space passes in 0 for data offset after having removed reshape space 2672 * 2673 * - or - (data offset != 0) 2674 * 2675 * Changing RAID layout or chunk size -> toggle offsets 2676 * 2677 * - before reshape: data is at offset rs->data_offset 0 and 2678 * free space is at end of each component LV 2679 * -or- 2680 * data is at offset rs->data_offset != 0 and 2681 * free space is at begin of each component LV 2682 * 2683 * - after reshape: data is at offset 0 if it was at offset != 0 2684 * or at offset != 0 if it was at offset 0 2685 * on each component LV 2686 * 2687 */ 2688 data_offset = rs->data_offset ? rdev->data_offset : 0; 2689 new_data_offset = data_offset ? 0 : rs->data_offset; 2690 set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags); 2691 } 2692 2693 /* 2694 * Make sure we got a minimum amount of free sectors per device 2695 */ 2696 if (rs->data_offset && 2697 bdev_nr_sectors(rdev->bdev) - rs->md.dev_sectors < MIN_FREE_RESHAPE_SPACE) { 2698 rs->ti->error = data_offset ? "No space for forward reshape" : 2699 "No space for backward reshape"; 2700 return -ENOSPC; 2701 } 2702 out: 2703 /* 2704 * Raise recovery_cp in case data_offset != 0 to 2705 * avoid false recovery positives in the constructor. 2706 */ 2707 if (rs->md.recovery_cp < rs->md.dev_sectors) 2708 rs->md.recovery_cp += rs->dev[0].rdev.data_offset; 2709 2710 /* Adjust data offsets on all rdevs but on any raid4/5/6 journal device */ 2711 rdev_for_each(rdev, &rs->md) { 2712 if (!test_bit(Journal, &rdev->flags)) { 2713 rdev->data_offset = data_offset; 2714 rdev->new_data_offset = new_data_offset; 2715 } 2716 } 2717 2718 return 0; 2719 } 2720 2721 /* Userpace reordered disks -> adjust raid_disk indexes in @rs */ 2722 static void __reorder_raid_disk_indexes(struct raid_set *rs) 2723 { 2724 int i = 0; 2725 struct md_rdev *rdev; 2726 2727 rdev_for_each(rdev, &rs->md) { 2728 if (!test_bit(Journal, &rdev->flags)) { 2729 rdev->raid_disk = i++; 2730 rdev->saved_raid_disk = rdev->new_raid_disk = -1; 2731 } 2732 } 2733 } 2734 2735 /* 2736 * Setup @rs for takeover by a different raid level 2737 */ 2738 static int rs_setup_takeover(struct raid_set *rs) 2739 { 2740 struct mddev *mddev = &rs->md; 2741 struct md_rdev *rdev; 2742 unsigned int d = mddev->raid_disks = rs->raid_disks; 2743 sector_t new_data_offset = rs->dev[0].rdev.data_offset ? 0 : rs->data_offset; 2744 2745 if (rt_is_raid10(rs->raid_type)) { 2746 if (rs_is_raid0(rs)) { 2747 /* Userpace reordered disks -> adjust raid_disk indexes */ 2748 __reorder_raid_disk_indexes(rs); 2749 2750 /* raid0 -> raid10_far layout */ 2751 mddev->layout = raid10_format_to_md_layout(rs, ALGORITHM_RAID10_FAR, 2752 rs->raid10_copies); 2753 } else if (rs_is_raid1(rs)) 2754 /* raid1 -> raid10_near layout */ 2755 mddev->layout = raid10_format_to_md_layout(rs, ALGORITHM_RAID10_NEAR, 2756 rs->raid_disks); 2757 else 2758 return -EINVAL; 2759 2760 } 2761 2762 clear_bit(MD_ARRAY_FIRST_USE, &mddev->flags); 2763 mddev->recovery_cp = MaxSector; 2764 2765 while (d--) { 2766 rdev = &rs->dev[d].rdev; 2767 2768 if (test_bit(d, (void *) rs->rebuild_disks)) { 2769 clear_bit(In_sync, &rdev->flags); 2770 clear_bit(Faulty, &rdev->flags); 2771 mddev->recovery_cp = rdev->recovery_offset = 0; 2772 /* Bitmap has to be created when we do an "up" takeover */ 2773 set_bit(MD_ARRAY_FIRST_USE, &mddev->flags); 2774 } 2775 2776 rdev->new_data_offset = new_data_offset; 2777 } 2778 2779 return 0; 2780 } 2781 2782 /* Prepare @rs for reshape */ 2783 static int rs_prepare_reshape(struct raid_set *rs) 2784 { 2785 bool reshape; 2786 struct mddev *mddev = &rs->md; 2787 2788 if (rs_is_raid10(rs)) { 2789 if (rs->raid_disks != mddev->raid_disks && 2790 __is_raid10_near(mddev->layout) && 2791 rs->raid10_copies && 2792 rs->raid10_copies != __raid10_near_copies(mddev->layout)) { 2793 /* 2794 * raid disk have to be multiple of data copies to allow this conversion, 2795 * 2796 * This is actually not a reshape it is a 2797 * rebuild of any additional mirrors per group 2798 */ 2799 if (rs->raid_disks % rs->raid10_copies) { 2800 rs->ti->error = "Can't reshape raid10 mirror groups"; 2801 return -EINVAL; 2802 } 2803 2804 /* Userpace reordered disks to add/remove mirrors -> adjust raid_disk indexes */ 2805 __reorder_raid_disk_indexes(rs); 2806 mddev->layout = raid10_format_to_md_layout(rs, ALGORITHM_RAID10_NEAR, 2807 rs->raid10_copies); 2808 mddev->new_layout = mddev->layout; 2809 reshape = false; 2810 } else 2811 reshape = true; 2812 2813 } else if (rs_is_raid456(rs)) 2814 reshape = true; 2815 2816 else if (rs_is_raid1(rs)) { 2817 if (rs->delta_disks) { 2818 /* Process raid1 via delta_disks */ 2819 mddev->degraded = rs->delta_disks < 0 ? -rs->delta_disks : rs->delta_disks; 2820 reshape = true; 2821 } else { 2822 /* Process raid1 without delta_disks */ 2823 mddev->raid_disks = rs->raid_disks; 2824 reshape = false; 2825 } 2826 } else { 2827 rs->ti->error = "Called with bogus raid type"; 2828 return -EINVAL; 2829 } 2830 2831 if (reshape) { 2832 set_bit(RT_FLAG_RESHAPE_RS, &rs->runtime_flags); 2833 set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags); 2834 } else if (mddev->raid_disks < rs->raid_disks) 2835 /* Create new superblocks and bitmaps, if any new disks */ 2836 set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags); 2837 2838 return 0; 2839 } 2840 2841 /* 2842 * Reshape: 2843 * - change raid layout 2844 * - change chunk size 2845 * - add disks 2846 * - remove disks 2847 */ 2848 static int rs_setup_reshape(struct raid_set *rs) 2849 { 2850 int r = 0; 2851 unsigned int cur_raid_devs, d; 2852 sector_t reshape_sectors = _get_reshape_sectors(rs); 2853 struct mddev *mddev = &rs->md; 2854 struct md_rdev *rdev; 2855 2856 mddev->delta_disks = rs->delta_disks; 2857 cur_raid_devs = mddev->raid_disks; 2858 2859 /* Ignore impossible layout change whilst adding/removing disks */ 2860 if (mddev->delta_disks && 2861 mddev->layout != mddev->new_layout) { 2862 DMINFO("Ignoring invalid layout change with delta_disks=%d", rs->delta_disks); 2863 mddev->new_layout = mddev->layout; 2864 } 2865 2866 /* 2867 * Adjust array size: 2868 * 2869 * - in case of adding disk(s), array size has 2870 * to grow after the disk adding reshape, 2871 * which'll happen in the event handler; 2872 * reshape will happen forward, so space has to 2873 * be available at the beginning of each disk 2874 * 2875 * - in case of removing disk(s), array size 2876 * has to shrink before starting the reshape, 2877 * which'll happen here; 2878 * reshape will happen backward, so space has to 2879 * be available at the end of each disk 2880 * 2881 * - data_offset and new_data_offset are 2882 * adjusted for aforementioned out of place 2883 * reshaping based on userspace passing in 2884 * the "data_offset <sectors>" key/value 2885 * pair via the constructor 2886 */ 2887 2888 /* Add disk(s) */ 2889 if (rs->delta_disks > 0) { 2890 /* Prepare disks for check in raid4/5/6/10 {check|start}_reshape */ 2891 for (d = cur_raid_devs; d < rs->raid_disks; d++) { 2892 rdev = &rs->dev[d].rdev; 2893 clear_bit(In_sync, &rdev->flags); 2894 2895 /* 2896 * save_raid_disk needs to be -1, or recovery_offset will be set to 0 2897 * by md, which'll store that erroneously in the superblock on reshape 2898 */ 2899 rdev->saved_raid_disk = -1; 2900 rdev->raid_disk = d; 2901 2902 rdev->sectors = mddev->dev_sectors; 2903 rdev->recovery_offset = rs_is_raid1(rs) ? 0 : MaxSector; 2904 } 2905 2906 mddev->reshape_backwards = 0; /* adding disk(s) -> forward reshape */ 2907 2908 /* Remove disk(s) */ 2909 } else if (rs->delta_disks < 0) { 2910 r = rs_set_dev_and_array_sectors(rs, rs->ti->len, true); 2911 mddev->reshape_backwards = 1; /* removing disk(s) -> backward reshape */ 2912 2913 /* Change layout and/or chunk size */ 2914 } else { 2915 /* 2916 * Reshape layout (e.g. raid5_ls -> raid5_n) and/or chunk size: 2917 * 2918 * keeping number of disks and do layout change -> 2919 * 2920 * toggle reshape_backward depending on data_offset: 2921 * 2922 * - free space upfront -> reshape forward 2923 * 2924 * - free space at the end -> reshape backward 2925 * 2926 * 2927 * This utilizes free reshape space avoiding the need 2928 * for userspace to move (parts of) LV segments in 2929 * case of layout/chunksize change (for disk 2930 * adding/removing reshape space has to be at 2931 * the proper address (see above with delta_disks): 2932 * 2933 * add disk(s) -> begin 2934 * remove disk(s)-> end 2935 */ 2936 mddev->reshape_backwards = rs->dev[0].rdev.data_offset ? 0 : 1; 2937 } 2938 2939 /* 2940 * Adjust device size for forward reshape 2941 * because md_finish_reshape() reduces it. 2942 */ 2943 if (!mddev->reshape_backwards) 2944 rdev_for_each(rdev, &rs->md) 2945 if (!test_bit(Journal, &rdev->flags)) 2946 rdev->sectors += reshape_sectors; 2947 2948 return r; 2949 } 2950 2951 /* 2952 * If the md resync thread has updated superblock with max reshape position 2953 * at the end of a reshape but not (yet) reset the layout configuration 2954 * changes -> reset the latter. 2955 */ 2956 static void rs_reset_inconclusive_reshape(struct raid_set *rs) 2957 { 2958 if (!rs_is_reshaping(rs) && rs_is_layout_change(rs, true)) { 2959 rs_set_cur(rs); 2960 rs->md.delta_disks = 0; 2961 rs->md.reshape_backwards = 0; 2962 } 2963 } 2964 2965 /* 2966 * Enable/disable discard support on RAID set depending on 2967 * RAID level and discard properties of underlying RAID members. 2968 */ 2969 static void configure_discard_support(struct raid_set *rs) 2970 { 2971 int i; 2972 bool raid456; 2973 struct dm_target *ti = rs->ti; 2974 2975 /* 2976 * XXX: RAID level 4,5,6 require zeroing for safety. 2977 */ 2978 raid456 = rs_is_raid456(rs); 2979 2980 for (i = 0; i < rs->raid_disks; i++) { 2981 if (!rs->dev[i].rdev.bdev || 2982 !bdev_max_discard_sectors(rs->dev[i].rdev.bdev)) 2983 return; 2984 2985 if (raid456) { 2986 if (!devices_handle_discard_safely) { 2987 DMERR("raid456 discard support disabled due to discard_zeroes_data uncertainty."); 2988 DMERR("Set dm-raid.devices_handle_discard_safely=Y to override."); 2989 return; 2990 } 2991 } 2992 } 2993 2994 ti->num_discard_bios = 1; 2995 } 2996 2997 /* 2998 * Construct a RAID0/1/10/4/5/6 mapping: 2999 * Args: 3000 * <raid_type> <#raid_params> <raid_params>{0,} \ 3001 * <#raid_devs> [<meta_dev1> <dev1>]{1,} 3002 * 3003 * <raid_params> varies by <raid_type>. See 'parse_raid_params' for 3004 * details on possible <raid_params>. 3005 * 3006 * Userspace is free to initialize the metadata devices, hence the superblocks to 3007 * enforce recreation based on the passed in table parameters. 3008 * 3009 */ 3010 static int raid_ctr(struct dm_target *ti, unsigned int argc, char **argv) 3011 { 3012 int r; 3013 bool resize = false; 3014 struct raid_type *rt; 3015 unsigned int num_raid_params, num_raid_devs; 3016 sector_t sb_array_sectors, rdev_sectors, reshape_sectors; 3017 struct raid_set *rs = NULL; 3018 const char *arg; 3019 struct rs_layout rs_layout; 3020 struct dm_arg_set as = { argc, argv }, as_nrd; 3021 struct dm_arg _args[] = { 3022 { 0, as.argc, "Cannot understand number of raid parameters" }, 3023 { 1, 254, "Cannot understand number of raid devices parameters" } 3024 }; 3025 3026 arg = dm_shift_arg(&as); 3027 if (!arg) { 3028 ti->error = "No arguments"; 3029 return -EINVAL; 3030 } 3031 3032 rt = get_raid_type(arg); 3033 if (!rt) { 3034 ti->error = "Unrecognised raid_type"; 3035 return -EINVAL; 3036 } 3037 3038 /* Must have <#raid_params> */ 3039 if (dm_read_arg_group(_args, &as, &num_raid_params, &ti->error)) 3040 return -EINVAL; 3041 3042 /* number of raid device tupples <meta_dev data_dev> */ 3043 as_nrd = as; 3044 dm_consume_args(&as_nrd, num_raid_params); 3045 _args[1].max = (as_nrd.argc - 1) / 2; 3046 if (dm_read_arg(_args + 1, &as_nrd, &num_raid_devs, &ti->error)) 3047 return -EINVAL; 3048 3049 if (!__within_range(num_raid_devs, 1, MAX_RAID_DEVICES)) { 3050 ti->error = "Invalid number of supplied raid devices"; 3051 return -EINVAL; 3052 } 3053 3054 rs = raid_set_alloc(ti, rt, num_raid_devs); 3055 if (IS_ERR(rs)) 3056 return PTR_ERR(rs); 3057 3058 r = parse_raid_params(rs, &as, num_raid_params); 3059 if (r) 3060 goto bad; 3061 3062 r = parse_dev_params(rs, &as); 3063 if (r) 3064 goto bad; 3065 3066 rs->md.sync_super = super_sync; 3067 3068 /* 3069 * Calculate ctr requested array and device sizes to allow 3070 * for superblock analysis needing device sizes defined. 3071 * 3072 * Any existing superblock will overwrite the array and device sizes 3073 */ 3074 r = rs_set_dev_and_array_sectors(rs, rs->ti->len, false); 3075 if (r) 3076 goto bad; 3077 3078 /* Memorize just calculated, potentially larger sizes to grow the raid set in preresume */ 3079 rs->array_sectors = rs->md.array_sectors; 3080 rs->dev_sectors = rs->md.dev_sectors; 3081 3082 /* 3083 * Backup any new raid set level, layout, ... 3084 * requested to be able to compare to superblock 3085 * members for conversion decisions. 3086 */ 3087 rs_config_backup(rs, &rs_layout); 3088 3089 r = analyse_superblocks(ti, rs); 3090 if (r) 3091 goto bad; 3092 3093 /* All in-core metadata now as of current superblocks after calling analyse_superblocks() */ 3094 sb_array_sectors = rs->md.array_sectors; 3095 rdev_sectors = __rdev_sectors(rs); 3096 if (!rdev_sectors) { 3097 ti->error = "Invalid rdev size"; 3098 r = -EINVAL; 3099 goto bad; 3100 } 3101 3102 3103 reshape_sectors = _get_reshape_sectors(rs); 3104 if (rs->dev_sectors != rdev_sectors) { 3105 resize = (rs->dev_sectors != rdev_sectors - reshape_sectors); 3106 if (rs->dev_sectors > rdev_sectors - reshape_sectors) 3107 set_bit(RT_FLAG_RS_GROW, &rs->runtime_flags); 3108 } 3109 3110 INIT_WORK(&rs->md.event_work, do_table_event); 3111 ti->private = rs; 3112 ti->num_flush_bios = 1; 3113 ti->needs_bio_set_dev = true; 3114 3115 /* Restore any requested new layout for conversion decision */ 3116 rs_config_restore(rs, &rs_layout); 3117 3118 /* 3119 * Now that we have any superblock metadata available, 3120 * check for new, recovering, reshaping, to be taken over, 3121 * to be reshaped or an existing, unchanged raid set to 3122 * run in sequence. 3123 */ 3124 if (test_bit(MD_ARRAY_FIRST_USE, &rs->md.flags)) { 3125 /* A new raid6 set has to be recovered to ensure proper parity and Q-Syndrome */ 3126 if (rs_is_raid6(rs) && 3127 test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags)) { 3128 ti->error = "'nosync' not allowed for new raid6 set"; 3129 r = -EINVAL; 3130 goto bad; 3131 } 3132 rs_setup_recovery(rs, 0); 3133 set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags); 3134 rs_set_new(rs); 3135 } else if (rs_is_recovering(rs)) { 3136 /* A recovering raid set may be resized */ 3137 goto size_check; 3138 } else if (rs_is_reshaping(rs)) { 3139 /* Have to reject size change request during reshape */ 3140 if (resize) { 3141 ti->error = "Can't resize a reshaping raid set"; 3142 r = -EPERM; 3143 goto bad; 3144 } 3145 /* skip setup rs */ 3146 } else if (rs_takeover_requested(rs)) { 3147 if (rs_is_reshaping(rs)) { 3148 ti->error = "Can't takeover a reshaping raid set"; 3149 r = -EPERM; 3150 goto bad; 3151 } 3152 3153 /* We can't takeover a journaled raid4/5/6 */ 3154 if (test_bit(__CTR_FLAG_JOURNAL_DEV, &rs->ctr_flags)) { 3155 ti->error = "Can't takeover a journaled raid4/5/6 set"; 3156 r = -EPERM; 3157 goto bad; 3158 } 3159 3160 /* 3161 * If a takeover is needed, userspace sets any additional 3162 * devices to rebuild and we can check for a valid request here. 3163 * 3164 * If acceptable, set the level to the new requested 3165 * one, prohibit requesting recovery, allow the raid 3166 * set to run and store superblocks during resume. 3167 */ 3168 r = rs_check_takeover(rs); 3169 if (r) 3170 goto bad; 3171 3172 r = rs_setup_takeover(rs); 3173 if (r) 3174 goto bad; 3175 3176 set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags); 3177 /* Takeover ain't recovery, so disable recovery */ 3178 rs_setup_recovery(rs, MaxSector); 3179 rs_set_new(rs); 3180 } else if (rs_reshape_requested(rs)) { 3181 /* Only request grow on raid set size extensions, not on reshapes. */ 3182 clear_bit(RT_FLAG_RS_GROW, &rs->runtime_flags); 3183 3184 /* 3185 * No need to check for 'ongoing' takeover here, because takeover 3186 * is an instant operation as oposed to an ongoing reshape. 3187 */ 3188 3189 /* We can't reshape a journaled raid4/5/6 */ 3190 if (test_bit(__CTR_FLAG_JOURNAL_DEV, &rs->ctr_flags)) { 3191 ti->error = "Can't reshape a journaled raid4/5/6 set"; 3192 r = -EPERM; 3193 goto bad; 3194 } 3195 3196 /* Out-of-place space has to be available to allow for a reshape unless raid1! */ 3197 if (reshape_sectors || rs_is_raid1(rs)) { 3198 /* 3199 * We can only prepare for a reshape here, because the 3200 * raid set needs to run to provide the respective reshape 3201 * check functions via its MD personality instance. 3202 * 3203 * So do the reshape check after md_run() succeeded. 3204 */ 3205 r = rs_prepare_reshape(rs); 3206 if (r) 3207 goto bad; 3208 3209 /* Reshaping ain't recovery, so disable recovery */ 3210 rs_setup_recovery(rs, MaxSector); 3211 } 3212 rs_set_cur(rs); 3213 } else { 3214 size_check: 3215 /* May not set recovery when a device rebuild is requested */ 3216 if (test_bit(__CTR_FLAG_REBUILD, &rs->ctr_flags)) { 3217 clear_bit(RT_FLAG_RS_GROW, &rs->runtime_flags); 3218 set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags); 3219 rs_setup_recovery(rs, MaxSector); 3220 } else if (test_bit(RT_FLAG_RS_GROW, &rs->runtime_flags)) { 3221 /* 3222 * Set raid set to current size, i.e. size as of 3223 * superblocks to grow to larger size in preresume. 3224 */ 3225 r = rs_set_dev_and_array_sectors(rs, sb_array_sectors, false); 3226 if (r) 3227 goto bad; 3228 3229 rs_setup_recovery(rs, rs->md.recovery_cp < rs->md.dev_sectors ? rs->md.recovery_cp : rs->md.dev_sectors); 3230 } else { 3231 /* This is no size change or it is shrinking, update size and record in superblocks */ 3232 r = rs_set_dev_and_array_sectors(rs, rs->ti->len, false); 3233 if (r) 3234 goto bad; 3235 3236 if (sb_array_sectors > rs->array_sectors) 3237 set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags); 3238 } 3239 rs_set_cur(rs); 3240 } 3241 3242 /* If constructor requested it, change data and new_data offsets */ 3243 r = rs_adjust_data_offsets(rs); 3244 if (r) 3245 goto bad; 3246 3247 /* Catch any inconclusive reshape superblock content. */ 3248 rs_reset_inconclusive_reshape(rs); 3249 3250 /* Start raid set read-only and assumed clean to change in raid_resume() */ 3251 rs->md.ro = 1; 3252 rs->md.in_sync = 1; 3253 3254 /* Has to be held on running the array */ 3255 mddev_suspend_and_lock_nointr(&rs->md); 3256 3257 /* Keep array frozen until resume. */ 3258 md_frozen_sync_thread(&rs->md); 3259 3260 r = md_run(&rs->md); 3261 rs->md.in_sync = 0; /* Assume already marked dirty */ 3262 if (r) { 3263 ti->error = "Failed to run raid array"; 3264 mddev_unlock(&rs->md); 3265 goto bad; 3266 } 3267 3268 r = md_start(&rs->md); 3269 if (r) { 3270 ti->error = "Failed to start raid array"; 3271 goto bad_unlock; 3272 } 3273 3274 /* If raid4/5/6 journal mode explicitly requested (only possible with journal dev) -> set it */ 3275 if (test_bit(__CTR_FLAG_JOURNAL_MODE, &rs->ctr_flags)) { 3276 r = r5c_journal_mode_set(&rs->md, rs->journal_dev.mode); 3277 if (r) { 3278 ti->error = "Failed to set raid4/5/6 journal mode"; 3279 goto bad_unlock; 3280 } 3281 } 3282 3283 set_bit(RT_FLAG_RS_SUSPENDED, &rs->runtime_flags); 3284 3285 /* Try to adjust the raid4/5/6 stripe cache size to the stripe size */ 3286 if (rs_is_raid456(rs)) { 3287 r = rs_set_raid456_stripe_cache(rs); 3288 if (r) 3289 goto bad_unlock; 3290 } 3291 3292 /* Now do an early reshape check */ 3293 if (test_bit(RT_FLAG_RESHAPE_RS, &rs->runtime_flags)) { 3294 r = rs_check_reshape(rs); 3295 if (r) 3296 goto bad_unlock; 3297 3298 /* Restore new, ctr requested layout to perform check */ 3299 rs_config_restore(rs, &rs_layout); 3300 3301 if (rs->md.pers->start_reshape) { 3302 r = rs->md.pers->check_reshape(&rs->md); 3303 if (r) { 3304 ti->error = "Reshape check failed"; 3305 goto bad_unlock; 3306 } 3307 } 3308 } 3309 3310 /* Disable/enable discard support on raid set. */ 3311 configure_discard_support(rs); 3312 rs->md.dm_gendisk = ti->table->md->disk; 3313 3314 mddev_unlock(&rs->md); 3315 return 0; 3316 3317 bad_unlock: 3318 md_stop(&rs->md); 3319 mddev_unlock(&rs->md); 3320 bad: 3321 raid_set_free(rs); 3322 3323 return r; 3324 } 3325 3326 static void raid_dtr(struct dm_target *ti) 3327 { 3328 struct raid_set *rs = ti->private; 3329 3330 mddev_lock_nointr(&rs->md); 3331 md_stop(&rs->md); 3332 rs->md.dm_gendisk = NULL; 3333 mddev_unlock(&rs->md); 3334 3335 if (work_pending(&rs->md.event_work)) 3336 flush_work(&rs->md.event_work); 3337 raid_set_free(rs); 3338 } 3339 3340 static int raid_map(struct dm_target *ti, struct bio *bio) 3341 { 3342 struct raid_set *rs = ti->private; 3343 struct mddev *mddev = &rs->md; 3344 3345 /* 3346 * If we're reshaping to add disk(s), ti->len and 3347 * mddev->array_sectors will differ during the process 3348 * (ti->len > mddev->array_sectors), so we have to requeue 3349 * bios with addresses > mddev->array_sectors here or 3350 * there will occur accesses past EOD of the component 3351 * data images thus erroring the raid set. 3352 */ 3353 if (unlikely(bio_has_data(bio) && bio_end_sector(bio) > mddev->array_sectors)) 3354 return DM_MAPIO_REQUEUE; 3355 3356 if (unlikely(!md_handle_request(mddev, bio))) 3357 return DM_MAPIO_REQUEUE; 3358 3359 return DM_MAPIO_SUBMITTED; 3360 } 3361 3362 /* Return sync state string for @state */ 3363 enum sync_state { st_frozen, st_reshape, st_resync, st_check, st_repair, st_recover, st_idle }; 3364 static const char *sync_str(enum sync_state state) 3365 { 3366 /* Has to be in above sync_state order! */ 3367 static const char *sync_strs[] = { 3368 "frozen", 3369 "reshape", 3370 "resync", 3371 "check", 3372 "repair", 3373 "recover", 3374 "idle" 3375 }; 3376 3377 return __within_range(state, 0, ARRAY_SIZE(sync_strs) - 1) ? sync_strs[state] : "undef"; 3378 }; 3379 3380 /* Return enum sync_state for @mddev derived from @recovery flags */ 3381 static enum sync_state decipher_sync_action(struct mddev *mddev, unsigned long recovery) 3382 { 3383 if (test_bit(MD_RECOVERY_FROZEN, &recovery)) 3384 return st_frozen; 3385 3386 /* The MD sync thread can be done with io or be interrupted but still be running */ 3387 if (!test_bit(MD_RECOVERY_DONE, &recovery) && 3388 (test_bit(MD_RECOVERY_RUNNING, &recovery) || 3389 (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery)))) { 3390 if (test_bit(MD_RECOVERY_RESHAPE, &recovery)) 3391 return st_reshape; 3392 3393 if (test_bit(MD_RECOVERY_SYNC, &recovery)) { 3394 if (!test_bit(MD_RECOVERY_REQUESTED, &recovery)) 3395 return st_resync; 3396 if (test_bit(MD_RECOVERY_CHECK, &recovery)) 3397 return st_check; 3398 return st_repair; 3399 } 3400 3401 if (test_bit(MD_RECOVERY_RECOVER, &recovery)) 3402 return st_recover; 3403 3404 if (mddev->reshape_position != MaxSector) 3405 return st_reshape; 3406 } 3407 3408 return st_idle; 3409 } 3410 3411 /* 3412 * Return status string for @rdev 3413 * 3414 * Status characters: 3415 * 3416 * 'D' = Dead/Failed raid set component or raid4/5/6 journal device 3417 * 'a' = Alive but not in-sync raid set component _or_ alive raid4/5/6 'write_back' journal device 3418 * 'A' = Alive and in-sync raid set component _or_ alive raid4/5/6 'write_through' journal device 3419 * '-' = Non-existing device (i.e. uspace passed '- -' into the ctr) 3420 */ 3421 static const char *__raid_dev_status(struct raid_set *rs, struct md_rdev *rdev) 3422 { 3423 if (!rdev->bdev) 3424 return "-"; 3425 else if (test_bit(Faulty, &rdev->flags)) 3426 return "D"; 3427 else if (test_bit(Journal, &rdev->flags)) 3428 return (rs->journal_dev.mode == R5C_JOURNAL_MODE_WRITE_THROUGH) ? "A" : "a"; 3429 else if (test_bit(RT_FLAG_RS_RESYNCING, &rs->runtime_flags) || 3430 (!test_bit(RT_FLAG_RS_IN_SYNC, &rs->runtime_flags) && 3431 !test_bit(In_sync, &rdev->flags))) 3432 return "a"; 3433 else 3434 return "A"; 3435 } 3436 3437 /* Helper to return resync/reshape progress for @rs and runtime flags for raid set in sync / resynching */ 3438 static sector_t rs_get_progress(struct raid_set *rs, unsigned long recovery, 3439 enum sync_state state, sector_t resync_max_sectors) 3440 { 3441 sector_t r; 3442 struct mddev *mddev = &rs->md; 3443 3444 clear_bit(RT_FLAG_RS_IN_SYNC, &rs->runtime_flags); 3445 clear_bit(RT_FLAG_RS_RESYNCING, &rs->runtime_flags); 3446 3447 if (rs_is_raid0(rs)) { 3448 r = resync_max_sectors; 3449 set_bit(RT_FLAG_RS_IN_SYNC, &rs->runtime_flags); 3450 3451 } else { 3452 if (state == st_idle && !test_bit(MD_RECOVERY_INTR, &recovery)) 3453 r = mddev->recovery_cp; 3454 else 3455 r = mddev->curr_resync_completed; 3456 3457 if (state == st_idle && r >= resync_max_sectors) { 3458 /* 3459 * Sync complete. 3460 */ 3461 /* In case we have finished recovering, the array is in sync. */ 3462 if (test_bit(MD_RECOVERY_RECOVER, &recovery)) 3463 set_bit(RT_FLAG_RS_IN_SYNC, &rs->runtime_flags); 3464 3465 } else if (state == st_recover) 3466 /* 3467 * In case we are recovering, the array is not in sync 3468 * and health chars should show the recovering legs. 3469 * 3470 * Already retrieved recovery offset from curr_resync_completed above. 3471 */ 3472 ; 3473 3474 else if (state == st_resync || state == st_reshape) 3475 /* 3476 * If "resync/reshape" is occurring, the raid set 3477 * is or may be out of sync hence the health 3478 * characters shall be 'a'. 3479 */ 3480 set_bit(RT_FLAG_RS_RESYNCING, &rs->runtime_flags); 3481 3482 else if (state == st_check || state == st_repair) 3483 /* 3484 * If "check" or "repair" is occurring, the raid set has 3485 * undergone an initial sync and the health characters 3486 * should not be 'a' anymore. 3487 */ 3488 set_bit(RT_FLAG_RS_IN_SYNC, &rs->runtime_flags); 3489 3490 else if (test_bit(MD_RECOVERY_NEEDED, &recovery)) 3491 /* 3492 * We are idle and recovery is needed, prevent 'A' chars race 3493 * caused by components still set to in-sync by constructor. 3494 */ 3495 set_bit(RT_FLAG_RS_RESYNCING, &rs->runtime_flags); 3496 3497 else { 3498 /* 3499 * We are idle and the raid set may be doing an initial 3500 * sync, or it may be rebuilding individual components. 3501 * If all the devices are In_sync, then it is the raid set 3502 * that is being initialized. 3503 */ 3504 struct md_rdev *rdev; 3505 3506 set_bit(RT_FLAG_RS_IN_SYNC, &rs->runtime_flags); 3507 rdev_for_each(rdev, mddev) 3508 if (!test_bit(Journal, &rdev->flags) && 3509 !test_bit(In_sync, &rdev->flags)) { 3510 clear_bit(RT_FLAG_RS_IN_SYNC, &rs->runtime_flags); 3511 break; 3512 } 3513 } 3514 } 3515 3516 return min(r, resync_max_sectors); 3517 } 3518 3519 /* Helper to return @dev name or "-" if !@dev */ 3520 static const char *__get_dev_name(struct dm_dev *dev) 3521 { 3522 return dev ? dev->name : "-"; 3523 } 3524 3525 static void raid_status(struct dm_target *ti, status_type_t type, 3526 unsigned int status_flags, char *result, unsigned int maxlen) 3527 { 3528 struct raid_set *rs = ti->private; 3529 struct mddev *mddev = &rs->md; 3530 struct r5conf *conf = rs_is_raid456(rs) ? mddev->private : NULL; 3531 int i, max_nr_stripes = conf ? conf->max_nr_stripes : 0; 3532 unsigned long recovery; 3533 unsigned int raid_param_cnt = 1; /* at least 1 for chunksize */ 3534 unsigned int sz = 0; 3535 unsigned int rebuild_writemostly_count = 0; 3536 sector_t progress, resync_max_sectors, resync_mismatches; 3537 enum sync_state state; 3538 struct raid_type *rt; 3539 3540 switch (type) { 3541 case STATUSTYPE_INFO: 3542 /* *Should* always succeed */ 3543 rt = get_raid_type_by_ll(mddev->new_level, mddev->new_layout); 3544 if (!rt) 3545 return; 3546 3547 DMEMIT("%s %d ", rt->name, mddev->raid_disks); 3548 3549 /* Access most recent mddev properties for status output */ 3550 smp_rmb(); 3551 /* Get sensible max sectors even if raid set not yet started */ 3552 resync_max_sectors = test_bit(RT_FLAG_RS_PRERESUMED, &rs->runtime_flags) ? 3553 mddev->resync_max_sectors : mddev->dev_sectors; 3554 recovery = rs->md.recovery; 3555 state = decipher_sync_action(mddev, recovery); 3556 progress = rs_get_progress(rs, recovery, state, resync_max_sectors); 3557 resync_mismatches = mddev->last_sync_action == ACTION_CHECK ? 3558 atomic64_read(&mddev->resync_mismatches) : 0; 3559 3560 /* HM FIXME: do we want another state char for raid0? It shows 'D'/'A'/'-' now */ 3561 for (i = 0; i < rs->raid_disks; i++) 3562 DMEMIT(__raid_dev_status(rs, &rs->dev[i].rdev)); 3563 3564 /* 3565 * In-sync/Reshape ratio: 3566 * The in-sync ratio shows the progress of: 3567 * - Initializing the raid set 3568 * - Rebuilding a subset of devices of the raid set 3569 * The user can distinguish between the two by referring 3570 * to the status characters. 3571 * 3572 * The reshape ratio shows the progress of 3573 * changing the raid layout or the number of 3574 * disks of a raid set 3575 */ 3576 DMEMIT(" %llu/%llu", (unsigned long long) progress, 3577 (unsigned long long) resync_max_sectors); 3578 3579 /* 3580 * v1.5.0+: 3581 * 3582 * Sync action: 3583 * See Documentation/admin-guide/device-mapper/dm-raid.rst for 3584 * information on each of these states. 3585 */ 3586 DMEMIT(" %s", sync_str(state)); 3587 3588 /* 3589 * v1.5.0+: 3590 * 3591 * resync_mismatches/mismatch_cnt 3592 * This field shows the number of discrepancies found when 3593 * performing a "check" of the raid set. 3594 */ 3595 DMEMIT(" %llu", (unsigned long long) resync_mismatches); 3596 3597 /* 3598 * v1.9.0+: 3599 * 3600 * data_offset (needed for out of space reshaping) 3601 * This field shows the data offset into the data 3602 * image LV where the first stripes data starts. 3603 * 3604 * We keep data_offset equal on all raid disks of the set, 3605 * so retrieving it from the first raid disk is sufficient. 3606 */ 3607 DMEMIT(" %llu", (unsigned long long) rs->dev[0].rdev.data_offset); 3608 3609 /* 3610 * v1.10.0+: 3611 */ 3612 DMEMIT(" %s", test_bit(__CTR_FLAG_JOURNAL_DEV, &rs->ctr_flags) ? 3613 __raid_dev_status(rs, &rs->journal_dev.rdev) : "-"); 3614 break; 3615 3616 case STATUSTYPE_TABLE: 3617 /* Report the table line string you would use to construct this raid set */ 3618 3619 /* 3620 * Count any rebuild or writemostly argument pairs and subtract the 3621 * hweight count being added below of any rebuild and writemostly ctr flags. 3622 */ 3623 for (i = 0; i < rs->raid_disks; i++) { 3624 rebuild_writemostly_count += (test_bit(i, (void *) rs->rebuild_disks) ? 2 : 0) + 3625 (test_bit(WriteMostly, &rs->dev[i].rdev.flags) ? 2 : 0); 3626 } 3627 rebuild_writemostly_count -= (test_bit(__CTR_FLAG_REBUILD, &rs->ctr_flags) ? 2 : 0) + 3628 (test_bit(__CTR_FLAG_WRITE_MOSTLY, &rs->ctr_flags) ? 2 : 0); 3629 /* Calculate raid parameter count based on ^ rebuild/writemostly argument counts and ctr flags set. */ 3630 raid_param_cnt += rebuild_writemostly_count + 3631 hweight32(rs->ctr_flags & CTR_FLAG_OPTIONS_NO_ARGS) + 3632 hweight32(rs->ctr_flags & CTR_FLAG_OPTIONS_ONE_ARG) * 2; 3633 /* Emit table line */ 3634 /* This has to be in the documented order for userspace! */ 3635 DMEMIT("%s %u %u", rs->raid_type->name, raid_param_cnt, mddev->new_chunk_sectors); 3636 if (test_bit(__CTR_FLAG_SYNC, &rs->ctr_flags)) 3637 DMEMIT(" %s", dm_raid_arg_name_by_flag(CTR_FLAG_SYNC)); 3638 if (test_bit(__CTR_FLAG_NOSYNC, &rs->ctr_flags)) 3639 DMEMIT(" %s", dm_raid_arg_name_by_flag(CTR_FLAG_NOSYNC)); 3640 if (test_bit(__CTR_FLAG_REBUILD, &rs->ctr_flags)) 3641 for (i = 0; i < rs->raid_disks; i++) 3642 if (test_bit(i, (void *) rs->rebuild_disks)) 3643 DMEMIT(" %s %u", dm_raid_arg_name_by_flag(CTR_FLAG_REBUILD), i); 3644 if (test_bit(__CTR_FLAG_DAEMON_SLEEP, &rs->ctr_flags)) 3645 DMEMIT(" %s %lu", dm_raid_arg_name_by_flag(CTR_FLAG_DAEMON_SLEEP), 3646 mddev->bitmap_info.daemon_sleep); 3647 if (test_bit(__CTR_FLAG_MIN_RECOVERY_RATE, &rs->ctr_flags)) 3648 DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_MIN_RECOVERY_RATE), 3649 mddev->sync_speed_min); 3650 if (test_bit(__CTR_FLAG_MAX_RECOVERY_RATE, &rs->ctr_flags)) 3651 DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_MAX_RECOVERY_RATE), 3652 mddev->sync_speed_max); 3653 if (test_bit(__CTR_FLAG_WRITE_MOSTLY, &rs->ctr_flags)) 3654 for (i = 0; i < rs->raid_disks; i++) 3655 if (test_bit(WriteMostly, &rs->dev[i].rdev.flags)) 3656 DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_WRITE_MOSTLY), 3657 rs->dev[i].rdev.raid_disk); 3658 if (test_bit(__CTR_FLAG_MAX_WRITE_BEHIND, &rs->ctr_flags)) 3659 DMEMIT(" %s %lu", dm_raid_arg_name_by_flag(CTR_FLAG_MAX_WRITE_BEHIND), 3660 mddev->bitmap_info.max_write_behind); 3661 if (test_bit(__CTR_FLAG_STRIPE_CACHE, &rs->ctr_flags)) 3662 DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_STRIPE_CACHE), 3663 max_nr_stripes); 3664 if (test_bit(__CTR_FLAG_REGION_SIZE, &rs->ctr_flags)) 3665 DMEMIT(" %s %llu", dm_raid_arg_name_by_flag(CTR_FLAG_REGION_SIZE), 3666 (unsigned long long) to_sector(mddev->bitmap_info.chunksize)); 3667 if (test_bit(__CTR_FLAG_RAID10_COPIES, &rs->ctr_flags)) 3668 DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_COPIES), 3669 raid10_md_layout_to_copies(mddev->layout)); 3670 if (test_bit(__CTR_FLAG_RAID10_FORMAT, &rs->ctr_flags)) 3671 DMEMIT(" %s %s", dm_raid_arg_name_by_flag(CTR_FLAG_RAID10_FORMAT), 3672 raid10_md_layout_to_format(mddev->layout)); 3673 if (test_bit(__CTR_FLAG_DELTA_DISKS, &rs->ctr_flags)) 3674 DMEMIT(" %s %d", dm_raid_arg_name_by_flag(CTR_FLAG_DELTA_DISKS), 3675 max(rs->delta_disks, mddev->delta_disks)); 3676 if (test_bit(__CTR_FLAG_DATA_OFFSET, &rs->ctr_flags)) 3677 DMEMIT(" %s %llu", dm_raid_arg_name_by_flag(CTR_FLAG_DATA_OFFSET), 3678 (unsigned long long) rs->data_offset); 3679 if (test_bit(__CTR_FLAG_JOURNAL_DEV, &rs->ctr_flags)) 3680 DMEMIT(" %s %s", dm_raid_arg_name_by_flag(CTR_FLAG_JOURNAL_DEV), 3681 __get_dev_name(rs->journal_dev.dev)); 3682 if (test_bit(__CTR_FLAG_JOURNAL_MODE, &rs->ctr_flags)) 3683 DMEMIT(" %s %s", dm_raid_arg_name_by_flag(CTR_FLAG_JOURNAL_MODE), 3684 md_journal_mode_to_dm_raid(rs->journal_dev.mode)); 3685 DMEMIT(" %d", rs->raid_disks); 3686 for (i = 0; i < rs->raid_disks; i++) 3687 DMEMIT(" %s %s", __get_dev_name(rs->dev[i].meta_dev), 3688 __get_dev_name(rs->dev[i].data_dev)); 3689 break; 3690 3691 case STATUSTYPE_IMA: 3692 rt = get_raid_type_by_ll(mddev->new_level, mddev->new_layout); 3693 if (!rt) 3694 return; 3695 3696 DMEMIT_TARGET_NAME_VERSION(ti->type); 3697 DMEMIT(",raid_type=%s,raid_disks=%d", rt->name, mddev->raid_disks); 3698 3699 /* Access most recent mddev properties for status output */ 3700 smp_rmb(); 3701 recovery = rs->md.recovery; 3702 state = decipher_sync_action(mddev, recovery); 3703 DMEMIT(",raid_state=%s", sync_str(state)); 3704 3705 for (i = 0; i < rs->raid_disks; i++) { 3706 DMEMIT(",raid_device_%d_status=", i); 3707 DMEMIT(__raid_dev_status(rs, &rs->dev[i].rdev)); 3708 } 3709 3710 if (rt_is_raid456(rt)) { 3711 DMEMIT(",journal_dev_mode="); 3712 switch (rs->journal_dev.mode) { 3713 case R5C_JOURNAL_MODE_WRITE_THROUGH: 3714 DMEMIT("%s", 3715 _raid456_journal_mode[R5C_JOURNAL_MODE_WRITE_THROUGH].param); 3716 break; 3717 case R5C_JOURNAL_MODE_WRITE_BACK: 3718 DMEMIT("%s", 3719 _raid456_journal_mode[R5C_JOURNAL_MODE_WRITE_BACK].param); 3720 break; 3721 default: 3722 DMEMIT("invalid"); 3723 break; 3724 } 3725 } 3726 DMEMIT(";"); 3727 break; 3728 } 3729 } 3730 3731 static int raid_message(struct dm_target *ti, unsigned int argc, char **argv, 3732 char *result, unsigned int maxlen) 3733 { 3734 struct raid_set *rs = ti->private; 3735 struct mddev *mddev = &rs->md; 3736 int ret = 0; 3737 3738 if (!mddev->pers || !mddev->pers->sync_request) 3739 return -EINVAL; 3740 3741 if (test_bit(RT_FLAG_RS_SUSPENDED, &rs->runtime_flags) || 3742 test_bit(RT_FLAG_RS_FROZEN, &rs->runtime_flags)) 3743 return -EBUSY; 3744 3745 if (!strcasecmp(argv[0], "frozen")) { 3746 ret = mddev_lock(mddev); 3747 if (ret) 3748 return ret; 3749 3750 md_frozen_sync_thread(mddev); 3751 mddev_unlock(mddev); 3752 } else if (!strcasecmp(argv[0], "idle")) { 3753 ret = mddev_lock(mddev); 3754 if (ret) 3755 return ret; 3756 3757 md_idle_sync_thread(mddev); 3758 mddev_unlock(mddev); 3759 } 3760 3761 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 3762 if (decipher_sync_action(mddev, mddev->recovery) != st_idle) 3763 return -EBUSY; 3764 else if (!strcasecmp(argv[0], "resync")) 3765 ; /* MD_RECOVERY_NEEDED set below */ 3766 else if (!strcasecmp(argv[0], "recover")) 3767 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 3768 else { 3769 if (!strcasecmp(argv[0], "check")) { 3770 set_bit(MD_RECOVERY_CHECK, &mddev->recovery); 3771 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); 3772 set_bit(MD_RECOVERY_SYNC, &mddev->recovery); 3773 } else if (!strcasecmp(argv[0], "repair")) { 3774 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); 3775 set_bit(MD_RECOVERY_SYNC, &mddev->recovery); 3776 } else 3777 return -EINVAL; 3778 } 3779 if (mddev->ro == 2) { 3780 /* A write to sync_action is enough to justify 3781 * canceling read-auto mode 3782 */ 3783 mddev->ro = 0; 3784 if (!mddev->suspended) 3785 md_wakeup_thread(mddev->sync_thread); 3786 } 3787 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 3788 if (!mddev->suspended) 3789 md_wakeup_thread(mddev->thread); 3790 3791 return 0; 3792 } 3793 3794 static int raid_iterate_devices(struct dm_target *ti, 3795 iterate_devices_callout_fn fn, void *data) 3796 { 3797 struct raid_set *rs = ti->private; 3798 unsigned int i; 3799 int r = 0; 3800 3801 for (i = 0; !r && i < rs->raid_disks; i++) { 3802 if (rs->dev[i].data_dev) { 3803 r = fn(ti, rs->dev[i].data_dev, 3804 0, /* No offset on data devs */ 3805 rs->md.dev_sectors, data); 3806 } 3807 } 3808 3809 return r; 3810 } 3811 3812 static void raid_io_hints(struct dm_target *ti, struct queue_limits *limits) 3813 { 3814 struct raid_set *rs = ti->private; 3815 unsigned int chunk_size_bytes = to_bytes(rs->md.chunk_sectors); 3816 3817 limits->io_min = chunk_size_bytes; 3818 limits->io_opt = chunk_size_bytes * mddev_data_stripes(rs); 3819 } 3820 3821 static void raid_presuspend(struct dm_target *ti) 3822 { 3823 struct raid_set *rs = ti->private; 3824 struct mddev *mddev = &rs->md; 3825 3826 /* 3827 * From now on, disallow raid_message() to change sync_thread until 3828 * resume, raid_postsuspend() is too late. 3829 */ 3830 set_bit(RT_FLAG_RS_FROZEN, &rs->runtime_flags); 3831 3832 if (!reshape_interrupted(mddev)) 3833 return; 3834 3835 /* 3836 * For raid456, if reshape is interrupted, IO across reshape position 3837 * will never make progress, while caller will wait for IO to be done. 3838 * Inform raid456 to handle those IO to prevent deadlock. 3839 */ 3840 if (mddev->pers && mddev->pers->prepare_suspend) 3841 mddev->pers->prepare_suspend(mddev); 3842 } 3843 3844 static void raid_presuspend_undo(struct dm_target *ti) 3845 { 3846 struct raid_set *rs = ti->private; 3847 3848 clear_bit(RT_FLAG_RS_FROZEN, &rs->runtime_flags); 3849 } 3850 3851 static void raid_postsuspend(struct dm_target *ti) 3852 { 3853 struct raid_set *rs = ti->private; 3854 3855 if (!test_and_set_bit(RT_FLAG_RS_SUSPENDED, &rs->runtime_flags)) { 3856 /* 3857 * sync_thread must be stopped during suspend, and writes have 3858 * to be stopped before suspending to avoid deadlocks. 3859 */ 3860 md_stop_writes(&rs->md); 3861 mddev_suspend(&rs->md, false); 3862 } 3863 } 3864 3865 static void attempt_restore_of_faulty_devices(struct raid_set *rs) 3866 { 3867 int i; 3868 uint64_t cleared_failed_devices[DISKS_ARRAY_ELEMS]; 3869 unsigned long flags; 3870 bool cleared = false; 3871 struct dm_raid_superblock *sb; 3872 struct mddev *mddev = &rs->md; 3873 struct md_rdev *r; 3874 3875 /* RAID personalities have to provide hot add/remove methods or we need to bail out. */ 3876 if (!mddev->pers || !mddev->pers->hot_add_disk || !mddev->pers->hot_remove_disk) 3877 return; 3878 3879 memset(cleared_failed_devices, 0, sizeof(cleared_failed_devices)); 3880 3881 for (i = 0; i < rs->raid_disks; i++) { 3882 r = &rs->dev[i].rdev; 3883 /* HM FIXME: enhance journal device recovery processing */ 3884 if (test_bit(Journal, &r->flags)) 3885 continue; 3886 3887 if (test_bit(Faulty, &r->flags) && 3888 r->meta_bdev && !read_disk_sb(r, r->sb_size, true)) { 3889 DMINFO("Faulty %s device #%d has readable super block." 3890 " Attempting to revive it.", 3891 rs->raid_type->name, i); 3892 3893 /* 3894 * Faulty bit may be set, but sometimes the array can 3895 * be suspended before the personalities can respond 3896 * by removing the device from the array (i.e. calling 3897 * 'hot_remove_disk'). If they haven't yet removed 3898 * the failed device, its 'raid_disk' number will be 3899 * '>= 0' - meaning we must call this function 3900 * ourselves. 3901 */ 3902 flags = r->flags; 3903 clear_bit(In_sync, &r->flags); /* Mandatory for hot remove. */ 3904 if (r->raid_disk >= 0) { 3905 if (mddev->pers->hot_remove_disk(mddev, r)) { 3906 /* Failed to revive this device, try next */ 3907 r->flags = flags; 3908 continue; 3909 } 3910 } else 3911 r->raid_disk = r->saved_raid_disk = i; 3912 3913 clear_bit(Faulty, &r->flags); 3914 clear_bit(WriteErrorSeen, &r->flags); 3915 3916 if (mddev->pers->hot_add_disk(mddev, r)) { 3917 /* Failed to revive this device, try next */ 3918 r->raid_disk = r->saved_raid_disk = -1; 3919 r->flags = flags; 3920 } else { 3921 clear_bit(In_sync, &r->flags); 3922 r->recovery_offset = 0; 3923 set_bit(i, (void *) cleared_failed_devices); 3924 cleared = true; 3925 } 3926 } 3927 } 3928 3929 /* If any failed devices could be cleared, update all sbs failed_devices bits */ 3930 if (cleared) { 3931 uint64_t failed_devices[DISKS_ARRAY_ELEMS]; 3932 3933 rdev_for_each(r, &rs->md) { 3934 if (test_bit(Journal, &r->flags)) 3935 continue; 3936 3937 sb = page_address(r->sb_page); 3938 sb_retrieve_failed_devices(sb, failed_devices); 3939 3940 for (i = 0; i < DISKS_ARRAY_ELEMS; i++) 3941 failed_devices[i] &= ~cleared_failed_devices[i]; 3942 3943 sb_update_failed_devices(sb, failed_devices); 3944 } 3945 } 3946 } 3947 3948 static int __load_dirty_region_bitmap(struct raid_set *rs) 3949 { 3950 int r = 0; 3951 3952 /* Try loading the bitmap unless "raid0", which does not have one */ 3953 if (!rs_is_raid0(rs) && 3954 !test_and_set_bit(RT_FLAG_RS_BITMAP_LOADED, &rs->runtime_flags)) { 3955 struct mddev *mddev = &rs->md; 3956 3957 r = mddev->bitmap_ops->load(mddev); 3958 if (r) 3959 DMERR("Failed to load bitmap"); 3960 } 3961 3962 return r; 3963 } 3964 3965 /* Enforce updating all superblocks */ 3966 static void rs_update_sbs(struct raid_set *rs) 3967 { 3968 struct mddev *mddev = &rs->md; 3969 int ro = mddev->ro; 3970 3971 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 3972 mddev->ro = 0; 3973 md_update_sb(mddev, 1); 3974 mddev->ro = ro; 3975 } 3976 3977 /* 3978 * Reshape changes raid algorithm of @rs to new one within personality 3979 * (e.g. raid6_zr -> raid6_nc), changes stripe size, adds/removes 3980 * disks from a raid set thus growing/shrinking it or resizes the set 3981 * 3982 * Call mddev_lock_nointr() before! 3983 */ 3984 static int rs_start_reshape(struct raid_set *rs) 3985 { 3986 int r; 3987 struct mddev *mddev = &rs->md; 3988 struct md_personality *pers = mddev->pers; 3989 3990 /* Don't allow the sync thread to work until the table gets reloaded. */ 3991 set_bit(MD_RECOVERY_WAIT, &mddev->recovery); 3992 3993 r = rs_setup_reshape(rs); 3994 if (r) 3995 return r; 3996 3997 /* 3998 * Check any reshape constraints enforced by the personalility 3999 * 4000 * May as well already kick the reshape off so that * pers->start_reshape() becomes optional. 4001 */ 4002 r = pers->check_reshape(mddev); 4003 if (r) { 4004 rs->ti->error = "pers->check_reshape() failed"; 4005 return r; 4006 } 4007 4008 /* 4009 * Personality may not provide start reshape method in which 4010 * case check_reshape above has already covered everything 4011 */ 4012 if (pers->start_reshape) { 4013 r = pers->start_reshape(mddev); 4014 if (r) { 4015 rs->ti->error = "pers->start_reshape() failed"; 4016 return r; 4017 } 4018 } 4019 4020 /* 4021 * Now reshape got set up, update superblocks to 4022 * reflect the fact so that a table reload will 4023 * access proper superblock content in the ctr. 4024 */ 4025 rs_update_sbs(rs); 4026 4027 return 0; 4028 } 4029 4030 static int raid_preresume(struct dm_target *ti) 4031 { 4032 int r; 4033 struct raid_set *rs = ti->private; 4034 struct mddev *mddev = &rs->md; 4035 4036 /* This is a resume after a suspend of the set -> it's already started. */ 4037 if (test_and_set_bit(RT_FLAG_RS_PRERESUMED, &rs->runtime_flags)) 4038 return 0; 4039 4040 /* If different and no explicit grow request, expose MD array size as of superblock. */ 4041 if (!test_bit(RT_FLAG_RS_GROW, &rs->runtime_flags) && 4042 rs->array_sectors != mddev->array_sectors) 4043 rs_set_capacity(rs); 4044 4045 /* 4046 * The superblocks need to be updated on disk if the 4047 * array is new or new devices got added (thus zeroed 4048 * out by userspace) or __load_dirty_region_bitmap 4049 * will overwrite them in core with old data or fail. 4050 */ 4051 if (test_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags)) 4052 rs_update_sbs(rs); 4053 4054 /* Load the bitmap from disk unless raid0 */ 4055 r = __load_dirty_region_bitmap(rs); 4056 if (r) 4057 return r; 4058 4059 /* We are extending the raid set size, adjust mddev/md_rdev sizes and set capacity. */ 4060 if (test_bit(RT_FLAG_RS_GROW, &rs->runtime_flags)) { 4061 mddev->array_sectors = rs->array_sectors; 4062 mddev->dev_sectors = rs->dev_sectors; 4063 rs_set_rdev_sectors(rs); 4064 rs_set_capacity(rs); 4065 } 4066 4067 /* Resize bitmap to adjust to changed region size (aka MD bitmap chunksize) or grown device size */ 4068 if (test_bit(RT_FLAG_RS_BITMAP_LOADED, &rs->runtime_flags) && mddev->bitmap && 4069 (test_bit(RT_FLAG_RS_GROW, &rs->runtime_flags) || 4070 (rs->requested_bitmap_chunk_sectors && 4071 mddev->bitmap_info.chunksize != to_bytes(rs->requested_bitmap_chunk_sectors)))) { 4072 int chunksize = to_bytes(rs->requested_bitmap_chunk_sectors) ?: mddev->bitmap_info.chunksize; 4073 4074 r = mddev->bitmap_ops->resize(mddev, mddev->dev_sectors, 4075 chunksize, false); 4076 if (r) 4077 DMERR("Failed to resize bitmap"); 4078 } 4079 4080 /* Check for any resize/reshape on @rs and adjust/initiate */ 4081 if (mddev->recovery_cp && mddev->recovery_cp < MaxSector) { 4082 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); 4083 mddev->resync_min = mddev->recovery_cp; 4084 if (test_bit(RT_FLAG_RS_GROW, &rs->runtime_flags)) 4085 mddev->resync_max_sectors = mddev->dev_sectors; 4086 } 4087 4088 /* Check for any reshape request unless new raid set */ 4089 if (test_bit(RT_FLAG_RESHAPE_RS, &rs->runtime_flags)) { 4090 /* Initiate a reshape. */ 4091 rs_set_rdev_sectors(rs); 4092 mddev_lock_nointr(mddev); 4093 r = rs_start_reshape(rs); 4094 mddev_unlock(mddev); 4095 if (r) 4096 DMWARN("Failed to check/start reshape, continuing without change"); 4097 r = 0; 4098 } 4099 4100 return r; 4101 } 4102 4103 static void raid_resume(struct dm_target *ti) 4104 { 4105 struct raid_set *rs = ti->private; 4106 struct mddev *mddev = &rs->md; 4107 4108 if (test_and_set_bit(RT_FLAG_RS_RESUMED, &rs->runtime_flags)) { 4109 /* 4110 * A secondary resume while the device is active. 4111 * Take this opportunity to check whether any failed 4112 * devices are reachable again. 4113 */ 4114 mddev_lock_nointr(mddev); 4115 attempt_restore_of_faulty_devices(rs); 4116 mddev_unlock(mddev); 4117 } 4118 4119 if (test_and_clear_bit(RT_FLAG_RS_SUSPENDED, &rs->runtime_flags)) { 4120 /* Only reduce raid set size before running a disk removing reshape. */ 4121 if (mddev->delta_disks < 0) 4122 rs_set_capacity(rs); 4123 4124 mddev_lock_nointr(mddev); 4125 WARN_ON_ONCE(!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)); 4126 WARN_ON_ONCE(rcu_dereference_protected(mddev->sync_thread, 4127 lockdep_is_held(&mddev->reconfig_mutex))); 4128 clear_bit(RT_FLAG_RS_FROZEN, &rs->runtime_flags); 4129 mddev->ro = 0; 4130 mddev->in_sync = 0; 4131 md_unfrozen_sync_thread(mddev); 4132 mddev_unlock_and_resume(mddev); 4133 } 4134 } 4135 4136 static struct target_type raid_target = { 4137 .name = "raid", 4138 .version = {1, 15, 1}, 4139 .module = THIS_MODULE, 4140 .ctr = raid_ctr, 4141 .dtr = raid_dtr, 4142 .map = raid_map, 4143 .status = raid_status, 4144 .message = raid_message, 4145 .iterate_devices = raid_iterate_devices, 4146 .io_hints = raid_io_hints, 4147 .presuspend = raid_presuspend, 4148 .presuspend_undo = raid_presuspend_undo, 4149 .postsuspend = raid_postsuspend, 4150 .preresume = raid_preresume, 4151 .resume = raid_resume, 4152 }; 4153 module_dm(raid); 4154 4155 module_param(devices_handle_discard_safely, bool, 0644); 4156 MODULE_PARM_DESC(devices_handle_discard_safely, 4157 "Set to Y if all devices in each array reliably return zeroes on reads from discarded regions"); 4158 4159 MODULE_DESCRIPTION(DM_NAME " raid0/1/10/4/5/6 target"); 4160 MODULE_ALIAS("dm-raid0"); 4161 MODULE_ALIAS("dm-raid1"); 4162 MODULE_ALIAS("dm-raid10"); 4163 MODULE_ALIAS("dm-raid4"); 4164 MODULE_ALIAS("dm-raid5"); 4165 MODULE_ALIAS("dm-raid6"); 4166 MODULE_AUTHOR("Neil Brown <dm-devel@lists.linux.dev>"); 4167 MODULE_AUTHOR("Heinz Mauelshagen <dm-devel@lists.linux.dev>"); 4168 MODULE_LICENSE("GPL"); 4169