1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 md.c : Multiple Devices driver for Linux 4 Copyright (C) 1998, 1999, 2000 Ingo Molnar 5 6 completely rewritten, based on the MD driver code from Marc Zyngier 7 8 Changes: 9 10 - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar 11 - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com> 12 - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net> 13 - kerneld support by Boris Tobotras <boris@xtalk.msk.su> 14 - kmod support by: Cyrus Durgin 15 - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com> 16 - Devfs support by Richard Gooch <rgooch@atnf.csiro.au> 17 18 - lots of fixes and improvements to the RAID1/RAID5 and generic 19 RAID code (such as request based resynchronization): 20 21 Neil Brown <neilb@cse.unsw.edu.au>. 22 23 - persistent bitmap code 24 Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc. 25 26 27 Errors, Warnings, etc. 28 Please use: 29 pr_crit() for error conditions that risk data loss 30 pr_err() for error conditions that are unexpected, like an IO error 31 or internal inconsistency 32 pr_warn() for error conditions that could have been predicated, like 33 adding a device to an array when it has incompatible metadata 34 pr_info() for every interesting, very rare events, like an array starting 35 or stopping, or resync starting or stopping 36 pr_debug() for everything else. 37 38 */ 39 40 #include <linux/sched/mm.h> 41 #include <linux/sched/signal.h> 42 #include <linux/kthread.h> 43 #include <linux/blkdev.h> 44 #include <linux/badblocks.h> 45 #include <linux/sysctl.h> 46 #include <linux/seq_file.h> 47 #include <linux/fs.h> 48 #include <linux/poll.h> 49 #include <linux/ctype.h> 50 #include <linux/string.h> 51 #include <linux/hdreg.h> 52 #include <linux/proc_fs.h> 53 #include <linux/random.h> 54 #include <linux/module.h> 55 #include <linux/reboot.h> 56 #include <linux/file.h> 57 #include <linux/compat.h> 58 #include <linux/delay.h> 59 #include <linux/raid/md_p.h> 60 #include <linux/raid/md_u.h> 61 #include <linux/slab.h> 62 #include <linux/percpu-refcount.h> 63 64 #include <trace/events/block.h> 65 #include "md.h" 66 #include "md-bitmap.h" 67 #include "md-cluster.h" 68 69 #ifndef MODULE 70 static void autostart_arrays(int part); 71 #endif 72 73 /* pers_list is a list of registered personalities protected 74 * by pers_lock. 75 * pers_lock does extra service to protect accesses to 76 * mddev->thread when the mutex cannot be held. 77 */ 78 static LIST_HEAD(pers_list); 79 static DEFINE_SPINLOCK(pers_lock); 80 81 static struct kobj_type md_ktype; 82 83 struct md_cluster_operations *md_cluster_ops; 84 EXPORT_SYMBOL(md_cluster_ops); 85 static struct module *md_cluster_mod; 86 87 static DECLARE_WAIT_QUEUE_HEAD(resync_wait); 88 static struct workqueue_struct *md_wq; 89 static struct workqueue_struct *md_misc_wq; 90 91 static int remove_and_add_spares(struct mddev *mddev, 92 struct md_rdev *this); 93 static void mddev_detach(struct mddev *mddev); 94 95 /* 96 * Default number of read corrections we'll attempt on an rdev 97 * before ejecting it from the array. We divide the read error 98 * count by 2 for every hour elapsed between read errors. 99 */ 100 #define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20 101 /* 102 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit' 103 * is 1000 KB/sec, so the extra system load does not show up that much. 104 * Increase it if you want to have more _guaranteed_ speed. Note that 105 * the RAID driver will use the maximum available bandwidth if the IO 106 * subsystem is idle. There is also an 'absolute maximum' reconstruction 107 * speed limit - in case reconstruction slows down your system despite 108 * idle IO detection. 109 * 110 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max. 111 * or /sys/block/mdX/md/sync_speed_{min,max} 112 */ 113 114 static int sysctl_speed_limit_min = 1000; 115 static int sysctl_speed_limit_max = 200000; 116 static inline int speed_min(struct mddev *mddev) 117 { 118 return mddev->sync_speed_min ? 119 mddev->sync_speed_min : sysctl_speed_limit_min; 120 } 121 122 static inline int speed_max(struct mddev *mddev) 123 { 124 return mddev->sync_speed_max ? 125 mddev->sync_speed_max : sysctl_speed_limit_max; 126 } 127 128 static int rdev_init_wb(struct md_rdev *rdev) 129 { 130 if (rdev->bdev->bd_queue->nr_hw_queues == 1) 131 return 0; 132 133 spin_lock_init(&rdev->wb_list_lock); 134 INIT_LIST_HEAD(&rdev->wb_list); 135 init_waitqueue_head(&rdev->wb_io_wait); 136 set_bit(WBCollisionCheck, &rdev->flags); 137 138 return 1; 139 } 140 141 /* 142 * Create wb_info_pool if rdev is the first multi-queue device flaged 143 * with writemostly, also write-behind mode is enabled. 144 */ 145 void mddev_create_wb_pool(struct mddev *mddev, struct md_rdev *rdev, 146 bool is_suspend) 147 { 148 if (mddev->bitmap_info.max_write_behind == 0) 149 return; 150 151 if (!test_bit(WriteMostly, &rdev->flags) || !rdev_init_wb(rdev)) 152 return; 153 154 if (mddev->wb_info_pool == NULL) { 155 unsigned int noio_flag; 156 157 if (!is_suspend) 158 mddev_suspend(mddev); 159 noio_flag = memalloc_noio_save(); 160 mddev->wb_info_pool = mempool_create_kmalloc_pool(NR_WB_INFOS, 161 sizeof(struct wb_info)); 162 memalloc_noio_restore(noio_flag); 163 if (!mddev->wb_info_pool) 164 pr_err("can't alloc memory pool for writemostly\n"); 165 if (!is_suspend) 166 mddev_resume(mddev); 167 } 168 } 169 EXPORT_SYMBOL_GPL(mddev_create_wb_pool); 170 171 /* 172 * destroy wb_info_pool if rdev is the last device flaged with WBCollisionCheck. 173 */ 174 static void mddev_destroy_wb_pool(struct mddev *mddev, struct md_rdev *rdev) 175 { 176 if (!test_and_clear_bit(WBCollisionCheck, &rdev->flags)) 177 return; 178 179 if (mddev->wb_info_pool) { 180 struct md_rdev *temp; 181 int num = 0; 182 183 /* 184 * Check if other rdevs need wb_info_pool. 185 */ 186 rdev_for_each(temp, mddev) 187 if (temp != rdev && 188 test_bit(WBCollisionCheck, &temp->flags)) 189 num++; 190 if (!num) { 191 mddev_suspend(rdev->mddev); 192 mempool_destroy(mddev->wb_info_pool); 193 mddev->wb_info_pool = NULL; 194 mddev_resume(rdev->mddev); 195 } 196 } 197 } 198 199 static struct ctl_table_header *raid_table_header; 200 201 static struct ctl_table raid_table[] = { 202 { 203 .procname = "speed_limit_min", 204 .data = &sysctl_speed_limit_min, 205 .maxlen = sizeof(int), 206 .mode = S_IRUGO|S_IWUSR, 207 .proc_handler = proc_dointvec, 208 }, 209 { 210 .procname = "speed_limit_max", 211 .data = &sysctl_speed_limit_max, 212 .maxlen = sizeof(int), 213 .mode = S_IRUGO|S_IWUSR, 214 .proc_handler = proc_dointvec, 215 }, 216 { } 217 }; 218 219 static struct ctl_table raid_dir_table[] = { 220 { 221 .procname = "raid", 222 .maxlen = 0, 223 .mode = S_IRUGO|S_IXUGO, 224 .child = raid_table, 225 }, 226 { } 227 }; 228 229 static struct ctl_table raid_root_table[] = { 230 { 231 .procname = "dev", 232 .maxlen = 0, 233 .mode = 0555, 234 .child = raid_dir_table, 235 }, 236 { } 237 }; 238 239 static const struct block_device_operations md_fops; 240 241 static int start_readonly; 242 243 /* 244 * The original mechanism for creating an md device is to create 245 * a device node in /dev and to open it. This causes races with device-close. 246 * The preferred method is to write to the "new_array" module parameter. 247 * This can avoid races. 248 * Setting create_on_open to false disables the original mechanism 249 * so all the races disappear. 250 */ 251 static bool create_on_open = true; 252 253 struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs, 254 struct mddev *mddev) 255 { 256 if (!mddev || !bioset_initialized(&mddev->bio_set)) 257 return bio_alloc(gfp_mask, nr_iovecs); 258 259 return bio_alloc_bioset(gfp_mask, nr_iovecs, &mddev->bio_set); 260 } 261 EXPORT_SYMBOL_GPL(bio_alloc_mddev); 262 263 static struct bio *md_bio_alloc_sync(struct mddev *mddev) 264 { 265 if (!mddev || !bioset_initialized(&mddev->sync_set)) 266 return bio_alloc(GFP_NOIO, 1); 267 268 return bio_alloc_bioset(GFP_NOIO, 1, &mddev->sync_set); 269 } 270 271 /* 272 * We have a system wide 'event count' that is incremented 273 * on any 'interesting' event, and readers of /proc/mdstat 274 * can use 'poll' or 'select' to find out when the event 275 * count increases. 276 * 277 * Events are: 278 * start array, stop array, error, add device, remove device, 279 * start build, activate spare 280 */ 281 static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters); 282 static atomic_t md_event_count; 283 void md_new_event(struct mddev *mddev) 284 { 285 atomic_inc(&md_event_count); 286 wake_up(&md_event_waiters); 287 } 288 EXPORT_SYMBOL_GPL(md_new_event); 289 290 /* 291 * Enables to iterate over all existing md arrays 292 * all_mddevs_lock protects this list. 293 */ 294 static LIST_HEAD(all_mddevs); 295 static DEFINE_SPINLOCK(all_mddevs_lock); 296 297 /* 298 * iterates through all used mddevs in the system. 299 * We take care to grab the all_mddevs_lock whenever navigating 300 * the list, and to always hold a refcount when unlocked. 301 * Any code which breaks out of this loop while own 302 * a reference to the current mddev and must mddev_put it. 303 */ 304 #define for_each_mddev(_mddev,_tmp) \ 305 \ 306 for (({ spin_lock(&all_mddevs_lock); \ 307 _tmp = all_mddevs.next; \ 308 _mddev = NULL;}); \ 309 ({ if (_tmp != &all_mddevs) \ 310 mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\ 311 spin_unlock(&all_mddevs_lock); \ 312 if (_mddev) mddev_put(_mddev); \ 313 _mddev = list_entry(_tmp, struct mddev, all_mddevs); \ 314 _tmp != &all_mddevs;}); \ 315 ({ spin_lock(&all_mddevs_lock); \ 316 _tmp = _tmp->next;}) \ 317 ) 318 319 /* Rather than calling directly into the personality make_request function, 320 * IO requests come here first so that we can check if the device is 321 * being suspended pending a reconfiguration. 322 * We hold a refcount over the call to ->make_request. By the time that 323 * call has finished, the bio has been linked into some internal structure 324 * and so is visible to ->quiesce(), so we don't need the refcount any more. 325 */ 326 static bool is_suspended(struct mddev *mddev, struct bio *bio) 327 { 328 if (mddev->suspended) 329 return true; 330 if (bio_data_dir(bio) != WRITE) 331 return false; 332 if (mddev->suspend_lo >= mddev->suspend_hi) 333 return false; 334 if (bio->bi_iter.bi_sector >= mddev->suspend_hi) 335 return false; 336 if (bio_end_sector(bio) < mddev->suspend_lo) 337 return false; 338 return true; 339 } 340 341 void md_handle_request(struct mddev *mddev, struct bio *bio) 342 { 343 check_suspended: 344 rcu_read_lock(); 345 if (is_suspended(mddev, bio)) { 346 DEFINE_WAIT(__wait); 347 for (;;) { 348 prepare_to_wait(&mddev->sb_wait, &__wait, 349 TASK_UNINTERRUPTIBLE); 350 if (!is_suspended(mddev, bio)) 351 break; 352 rcu_read_unlock(); 353 schedule(); 354 rcu_read_lock(); 355 } 356 finish_wait(&mddev->sb_wait, &__wait); 357 } 358 atomic_inc(&mddev->active_io); 359 rcu_read_unlock(); 360 361 if (!mddev->pers->make_request(mddev, bio)) { 362 atomic_dec(&mddev->active_io); 363 wake_up(&mddev->sb_wait); 364 goto check_suspended; 365 } 366 367 if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended) 368 wake_up(&mddev->sb_wait); 369 } 370 EXPORT_SYMBOL(md_handle_request); 371 372 static blk_qc_t md_make_request(struct request_queue *q, struct bio *bio) 373 { 374 const int rw = bio_data_dir(bio); 375 const int sgrp = op_stat_group(bio_op(bio)); 376 struct mddev *mddev = q->queuedata; 377 unsigned int sectors; 378 379 blk_queue_split(q, &bio); 380 381 if (mddev == NULL || mddev->pers == NULL) { 382 bio_io_error(bio); 383 return BLK_QC_T_NONE; 384 } 385 if (mddev->ro == 1 && unlikely(rw == WRITE)) { 386 if (bio_sectors(bio) != 0) 387 bio->bi_status = BLK_STS_IOERR; 388 bio_endio(bio); 389 return BLK_QC_T_NONE; 390 } 391 392 /* 393 * save the sectors now since our bio can 394 * go away inside make_request 395 */ 396 sectors = bio_sectors(bio); 397 /* bio could be mergeable after passing to underlayer */ 398 bio->bi_opf &= ~REQ_NOMERGE; 399 400 md_handle_request(mddev, bio); 401 402 part_stat_lock(); 403 part_stat_inc(&mddev->gendisk->part0, ios[sgrp]); 404 part_stat_add(&mddev->gendisk->part0, sectors[sgrp], sectors); 405 part_stat_unlock(); 406 407 return BLK_QC_T_NONE; 408 } 409 410 /* mddev_suspend makes sure no new requests are submitted 411 * to the device, and that any requests that have been submitted 412 * are completely handled. 413 * Once mddev_detach() is called and completes, the module will be 414 * completely unused. 415 */ 416 void mddev_suspend(struct mddev *mddev) 417 { 418 WARN_ON_ONCE(mddev->thread && current == mddev->thread->tsk); 419 lockdep_assert_held(&mddev->reconfig_mutex); 420 if (mddev->suspended++) 421 return; 422 synchronize_rcu(); 423 wake_up(&mddev->sb_wait); 424 set_bit(MD_ALLOW_SB_UPDATE, &mddev->flags); 425 smp_mb__after_atomic(); 426 wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0); 427 mddev->pers->quiesce(mddev, 1); 428 clear_bit_unlock(MD_ALLOW_SB_UPDATE, &mddev->flags); 429 wait_event(mddev->sb_wait, !test_bit(MD_UPDATING_SB, &mddev->flags)); 430 431 del_timer_sync(&mddev->safemode_timer); 432 } 433 EXPORT_SYMBOL_GPL(mddev_suspend); 434 435 void mddev_resume(struct mddev *mddev) 436 { 437 lockdep_assert_held(&mddev->reconfig_mutex); 438 if (--mddev->suspended) 439 return; 440 wake_up(&mddev->sb_wait); 441 mddev->pers->quiesce(mddev, 0); 442 443 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 444 md_wakeup_thread(mddev->thread); 445 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */ 446 } 447 EXPORT_SYMBOL_GPL(mddev_resume); 448 449 int mddev_congested(struct mddev *mddev, int bits) 450 { 451 struct md_personality *pers = mddev->pers; 452 int ret = 0; 453 454 rcu_read_lock(); 455 if (mddev->suspended) 456 ret = 1; 457 else if (pers && pers->congested) 458 ret = pers->congested(mddev, bits); 459 rcu_read_unlock(); 460 return ret; 461 } 462 EXPORT_SYMBOL_GPL(mddev_congested); 463 static int md_congested(void *data, int bits) 464 { 465 struct mddev *mddev = data; 466 return mddev_congested(mddev, bits); 467 } 468 469 /* 470 * Generic flush handling for md 471 */ 472 473 static void md_end_flush(struct bio *bio) 474 { 475 struct md_rdev *rdev = bio->bi_private; 476 struct mddev *mddev = rdev->mddev; 477 478 rdev_dec_pending(rdev, mddev); 479 480 if (atomic_dec_and_test(&mddev->flush_pending)) { 481 /* The pre-request flush has finished */ 482 queue_work(md_wq, &mddev->flush_work); 483 } 484 bio_put(bio); 485 } 486 487 static void md_submit_flush_data(struct work_struct *ws); 488 489 static void submit_flushes(struct work_struct *ws) 490 { 491 struct mddev *mddev = container_of(ws, struct mddev, flush_work); 492 struct md_rdev *rdev; 493 494 mddev->start_flush = ktime_get_boottime(); 495 INIT_WORK(&mddev->flush_work, md_submit_flush_data); 496 atomic_set(&mddev->flush_pending, 1); 497 rcu_read_lock(); 498 rdev_for_each_rcu(rdev, mddev) 499 if (rdev->raid_disk >= 0 && 500 !test_bit(Faulty, &rdev->flags)) { 501 /* Take two references, one is dropped 502 * when request finishes, one after 503 * we reclaim rcu_read_lock 504 */ 505 struct bio *bi; 506 atomic_inc(&rdev->nr_pending); 507 atomic_inc(&rdev->nr_pending); 508 rcu_read_unlock(); 509 bi = bio_alloc_mddev(GFP_NOIO, 0, mddev); 510 bi->bi_end_io = md_end_flush; 511 bi->bi_private = rdev; 512 bio_set_dev(bi, rdev->bdev); 513 bi->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH; 514 atomic_inc(&mddev->flush_pending); 515 submit_bio(bi); 516 rcu_read_lock(); 517 rdev_dec_pending(rdev, mddev); 518 } 519 rcu_read_unlock(); 520 if (atomic_dec_and_test(&mddev->flush_pending)) 521 queue_work(md_wq, &mddev->flush_work); 522 } 523 524 static void md_submit_flush_data(struct work_struct *ws) 525 { 526 struct mddev *mddev = container_of(ws, struct mddev, flush_work); 527 struct bio *bio = mddev->flush_bio; 528 529 /* 530 * must reset flush_bio before calling into md_handle_request to avoid a 531 * deadlock, because other bios passed md_handle_request suspend check 532 * could wait for this and below md_handle_request could wait for those 533 * bios because of suspend check 534 */ 535 mddev->last_flush = mddev->start_flush; 536 mddev->flush_bio = NULL; 537 wake_up(&mddev->sb_wait); 538 539 if (bio->bi_iter.bi_size == 0) { 540 /* an empty barrier - all done */ 541 bio_endio(bio); 542 } else { 543 bio->bi_opf &= ~REQ_PREFLUSH; 544 md_handle_request(mddev, bio); 545 } 546 } 547 548 void md_flush_request(struct mddev *mddev, struct bio *bio) 549 { 550 ktime_t start = ktime_get_boottime(); 551 spin_lock_irq(&mddev->lock); 552 wait_event_lock_irq(mddev->sb_wait, 553 !mddev->flush_bio || 554 ktime_after(mddev->last_flush, start), 555 mddev->lock); 556 if (!ktime_after(mddev->last_flush, start)) { 557 WARN_ON(mddev->flush_bio); 558 mddev->flush_bio = bio; 559 bio = NULL; 560 } 561 spin_unlock_irq(&mddev->lock); 562 563 if (!bio) { 564 INIT_WORK(&mddev->flush_work, submit_flushes); 565 queue_work(md_wq, &mddev->flush_work); 566 } else { 567 /* flush was performed for some other bio while we waited. */ 568 if (bio->bi_iter.bi_size == 0) 569 /* an empty barrier - all done */ 570 bio_endio(bio); 571 else { 572 bio->bi_opf &= ~REQ_PREFLUSH; 573 mddev->pers->make_request(mddev, bio); 574 } 575 } 576 } 577 EXPORT_SYMBOL(md_flush_request); 578 579 static inline struct mddev *mddev_get(struct mddev *mddev) 580 { 581 atomic_inc(&mddev->active); 582 return mddev; 583 } 584 585 static void mddev_delayed_delete(struct work_struct *ws); 586 587 static void mddev_put(struct mddev *mddev) 588 { 589 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock)) 590 return; 591 if (!mddev->raid_disks && list_empty(&mddev->disks) && 592 mddev->ctime == 0 && !mddev->hold_active) { 593 /* Array is not configured at all, and not held active, 594 * so destroy it */ 595 list_del_init(&mddev->all_mddevs); 596 597 /* 598 * Call queue_work inside the spinlock so that 599 * flush_workqueue() after mddev_find will succeed in waiting 600 * for the work to be done. 601 */ 602 INIT_WORK(&mddev->del_work, mddev_delayed_delete); 603 queue_work(md_misc_wq, &mddev->del_work); 604 } 605 spin_unlock(&all_mddevs_lock); 606 } 607 608 static void md_safemode_timeout(struct timer_list *t); 609 610 void mddev_init(struct mddev *mddev) 611 { 612 kobject_init(&mddev->kobj, &md_ktype); 613 mutex_init(&mddev->open_mutex); 614 mutex_init(&mddev->reconfig_mutex); 615 mutex_init(&mddev->bitmap_info.mutex); 616 INIT_LIST_HEAD(&mddev->disks); 617 INIT_LIST_HEAD(&mddev->all_mddevs); 618 timer_setup(&mddev->safemode_timer, md_safemode_timeout, 0); 619 atomic_set(&mddev->active, 1); 620 atomic_set(&mddev->openers, 0); 621 atomic_set(&mddev->active_io, 0); 622 spin_lock_init(&mddev->lock); 623 atomic_set(&mddev->flush_pending, 0); 624 init_waitqueue_head(&mddev->sb_wait); 625 init_waitqueue_head(&mddev->recovery_wait); 626 mddev->reshape_position = MaxSector; 627 mddev->reshape_backwards = 0; 628 mddev->last_sync_action = "none"; 629 mddev->resync_min = 0; 630 mddev->resync_max = MaxSector; 631 mddev->level = LEVEL_NONE; 632 } 633 EXPORT_SYMBOL_GPL(mddev_init); 634 635 static struct mddev *mddev_find(dev_t unit) 636 { 637 struct mddev *mddev, *new = NULL; 638 639 if (unit && MAJOR(unit) != MD_MAJOR) 640 unit &= ~((1<<MdpMinorShift)-1); 641 642 retry: 643 spin_lock(&all_mddevs_lock); 644 645 if (unit) { 646 list_for_each_entry(mddev, &all_mddevs, all_mddevs) 647 if (mddev->unit == unit) { 648 mddev_get(mddev); 649 spin_unlock(&all_mddevs_lock); 650 kfree(new); 651 return mddev; 652 } 653 654 if (new) { 655 list_add(&new->all_mddevs, &all_mddevs); 656 spin_unlock(&all_mddevs_lock); 657 new->hold_active = UNTIL_IOCTL; 658 return new; 659 } 660 } else if (new) { 661 /* find an unused unit number */ 662 static int next_minor = 512; 663 int start = next_minor; 664 int is_free = 0; 665 int dev = 0; 666 while (!is_free) { 667 dev = MKDEV(MD_MAJOR, next_minor); 668 next_minor++; 669 if (next_minor > MINORMASK) 670 next_minor = 0; 671 if (next_minor == start) { 672 /* Oh dear, all in use. */ 673 spin_unlock(&all_mddevs_lock); 674 kfree(new); 675 return NULL; 676 } 677 678 is_free = 1; 679 list_for_each_entry(mddev, &all_mddevs, all_mddevs) 680 if (mddev->unit == dev) { 681 is_free = 0; 682 break; 683 } 684 } 685 new->unit = dev; 686 new->md_minor = MINOR(dev); 687 new->hold_active = UNTIL_STOP; 688 list_add(&new->all_mddevs, &all_mddevs); 689 spin_unlock(&all_mddevs_lock); 690 return new; 691 } 692 spin_unlock(&all_mddevs_lock); 693 694 new = kzalloc(sizeof(*new), GFP_KERNEL); 695 if (!new) 696 return NULL; 697 698 new->unit = unit; 699 if (MAJOR(unit) == MD_MAJOR) 700 new->md_minor = MINOR(unit); 701 else 702 new->md_minor = MINOR(unit) >> MdpMinorShift; 703 704 mddev_init(new); 705 706 goto retry; 707 } 708 709 static struct attribute_group md_redundancy_group; 710 711 void mddev_unlock(struct mddev *mddev) 712 { 713 if (mddev->to_remove) { 714 /* These cannot be removed under reconfig_mutex as 715 * an access to the files will try to take reconfig_mutex 716 * while holding the file unremovable, which leads to 717 * a deadlock. 718 * So hold set sysfs_active while the remove in happeing, 719 * and anything else which might set ->to_remove or my 720 * otherwise change the sysfs namespace will fail with 721 * -EBUSY if sysfs_active is still set. 722 * We set sysfs_active under reconfig_mutex and elsewhere 723 * test it under the same mutex to ensure its correct value 724 * is seen. 725 */ 726 struct attribute_group *to_remove = mddev->to_remove; 727 mddev->to_remove = NULL; 728 mddev->sysfs_active = 1; 729 mutex_unlock(&mddev->reconfig_mutex); 730 731 if (mddev->kobj.sd) { 732 if (to_remove != &md_redundancy_group) 733 sysfs_remove_group(&mddev->kobj, to_remove); 734 if (mddev->pers == NULL || 735 mddev->pers->sync_request == NULL) { 736 sysfs_remove_group(&mddev->kobj, &md_redundancy_group); 737 if (mddev->sysfs_action) 738 sysfs_put(mddev->sysfs_action); 739 mddev->sysfs_action = NULL; 740 } 741 } 742 mddev->sysfs_active = 0; 743 } else 744 mutex_unlock(&mddev->reconfig_mutex); 745 746 /* As we've dropped the mutex we need a spinlock to 747 * make sure the thread doesn't disappear 748 */ 749 spin_lock(&pers_lock); 750 md_wakeup_thread(mddev->thread); 751 wake_up(&mddev->sb_wait); 752 spin_unlock(&pers_lock); 753 } 754 EXPORT_SYMBOL_GPL(mddev_unlock); 755 756 struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr) 757 { 758 struct md_rdev *rdev; 759 760 rdev_for_each_rcu(rdev, mddev) 761 if (rdev->desc_nr == nr) 762 return rdev; 763 764 return NULL; 765 } 766 EXPORT_SYMBOL_GPL(md_find_rdev_nr_rcu); 767 768 static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev) 769 { 770 struct md_rdev *rdev; 771 772 rdev_for_each(rdev, mddev) 773 if (rdev->bdev->bd_dev == dev) 774 return rdev; 775 776 return NULL; 777 } 778 779 struct md_rdev *md_find_rdev_rcu(struct mddev *mddev, dev_t dev) 780 { 781 struct md_rdev *rdev; 782 783 rdev_for_each_rcu(rdev, mddev) 784 if (rdev->bdev->bd_dev == dev) 785 return rdev; 786 787 return NULL; 788 } 789 EXPORT_SYMBOL_GPL(md_find_rdev_rcu); 790 791 static struct md_personality *find_pers(int level, char *clevel) 792 { 793 struct md_personality *pers; 794 list_for_each_entry(pers, &pers_list, list) { 795 if (level != LEVEL_NONE && pers->level == level) 796 return pers; 797 if (strcmp(pers->name, clevel)==0) 798 return pers; 799 } 800 return NULL; 801 } 802 803 /* return the offset of the super block in 512byte sectors */ 804 static inline sector_t calc_dev_sboffset(struct md_rdev *rdev) 805 { 806 sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512; 807 return MD_NEW_SIZE_SECTORS(num_sectors); 808 } 809 810 static int alloc_disk_sb(struct md_rdev *rdev) 811 { 812 rdev->sb_page = alloc_page(GFP_KERNEL); 813 if (!rdev->sb_page) 814 return -ENOMEM; 815 return 0; 816 } 817 818 void md_rdev_clear(struct md_rdev *rdev) 819 { 820 if (rdev->sb_page) { 821 put_page(rdev->sb_page); 822 rdev->sb_loaded = 0; 823 rdev->sb_page = NULL; 824 rdev->sb_start = 0; 825 rdev->sectors = 0; 826 } 827 if (rdev->bb_page) { 828 put_page(rdev->bb_page); 829 rdev->bb_page = NULL; 830 } 831 badblocks_exit(&rdev->badblocks); 832 } 833 EXPORT_SYMBOL_GPL(md_rdev_clear); 834 835 static void super_written(struct bio *bio) 836 { 837 struct md_rdev *rdev = bio->bi_private; 838 struct mddev *mddev = rdev->mddev; 839 840 if (bio->bi_status) { 841 pr_err("md: super_written gets error=%d\n", bio->bi_status); 842 md_error(mddev, rdev); 843 if (!test_bit(Faulty, &rdev->flags) 844 && (bio->bi_opf & MD_FAILFAST)) { 845 set_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags); 846 set_bit(LastDev, &rdev->flags); 847 } 848 } else 849 clear_bit(LastDev, &rdev->flags); 850 851 if (atomic_dec_and_test(&mddev->pending_writes)) 852 wake_up(&mddev->sb_wait); 853 rdev_dec_pending(rdev, mddev); 854 bio_put(bio); 855 } 856 857 void md_super_write(struct mddev *mddev, struct md_rdev *rdev, 858 sector_t sector, int size, struct page *page) 859 { 860 /* write first size bytes of page to sector of rdev 861 * Increment mddev->pending_writes before returning 862 * and decrement it on completion, waking up sb_wait 863 * if zero is reached. 864 * If an error occurred, call md_error 865 */ 866 struct bio *bio; 867 int ff = 0; 868 869 if (!page) 870 return; 871 872 if (test_bit(Faulty, &rdev->flags)) 873 return; 874 875 bio = md_bio_alloc_sync(mddev); 876 877 atomic_inc(&rdev->nr_pending); 878 879 bio_set_dev(bio, rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev); 880 bio->bi_iter.bi_sector = sector; 881 bio_add_page(bio, page, size, 0); 882 bio->bi_private = rdev; 883 bio->bi_end_io = super_written; 884 885 if (test_bit(MD_FAILFAST_SUPPORTED, &mddev->flags) && 886 test_bit(FailFast, &rdev->flags) && 887 !test_bit(LastDev, &rdev->flags)) 888 ff = MD_FAILFAST; 889 bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH | REQ_FUA | ff; 890 891 atomic_inc(&mddev->pending_writes); 892 submit_bio(bio); 893 } 894 895 int md_super_wait(struct mddev *mddev) 896 { 897 /* wait for all superblock writes that were scheduled to complete */ 898 wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0); 899 if (test_and_clear_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags)) 900 return -EAGAIN; 901 return 0; 902 } 903 904 int sync_page_io(struct md_rdev *rdev, sector_t sector, int size, 905 struct page *page, int op, int op_flags, bool metadata_op) 906 { 907 struct bio *bio = md_bio_alloc_sync(rdev->mddev); 908 int ret; 909 910 if (metadata_op && rdev->meta_bdev) 911 bio_set_dev(bio, rdev->meta_bdev); 912 else 913 bio_set_dev(bio, rdev->bdev); 914 bio_set_op_attrs(bio, op, op_flags); 915 if (metadata_op) 916 bio->bi_iter.bi_sector = sector + rdev->sb_start; 917 else if (rdev->mddev->reshape_position != MaxSector && 918 (rdev->mddev->reshape_backwards == 919 (sector >= rdev->mddev->reshape_position))) 920 bio->bi_iter.bi_sector = sector + rdev->new_data_offset; 921 else 922 bio->bi_iter.bi_sector = sector + rdev->data_offset; 923 bio_add_page(bio, page, size, 0); 924 925 submit_bio_wait(bio); 926 927 ret = !bio->bi_status; 928 bio_put(bio); 929 return ret; 930 } 931 EXPORT_SYMBOL_GPL(sync_page_io); 932 933 static int read_disk_sb(struct md_rdev *rdev, int size) 934 { 935 char b[BDEVNAME_SIZE]; 936 937 if (rdev->sb_loaded) 938 return 0; 939 940 if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, 0, true)) 941 goto fail; 942 rdev->sb_loaded = 1; 943 return 0; 944 945 fail: 946 pr_err("md: disabled device %s, could not read superblock.\n", 947 bdevname(rdev->bdev,b)); 948 return -EINVAL; 949 } 950 951 static int md_uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2) 952 { 953 return sb1->set_uuid0 == sb2->set_uuid0 && 954 sb1->set_uuid1 == sb2->set_uuid1 && 955 sb1->set_uuid2 == sb2->set_uuid2 && 956 sb1->set_uuid3 == sb2->set_uuid3; 957 } 958 959 static int md_sb_equal(mdp_super_t *sb1, mdp_super_t *sb2) 960 { 961 int ret; 962 mdp_super_t *tmp1, *tmp2; 963 964 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL); 965 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL); 966 967 if (!tmp1 || !tmp2) { 968 ret = 0; 969 goto abort; 970 } 971 972 *tmp1 = *sb1; 973 *tmp2 = *sb2; 974 975 /* 976 * nr_disks is not constant 977 */ 978 tmp1->nr_disks = 0; 979 tmp2->nr_disks = 0; 980 981 ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0); 982 abort: 983 kfree(tmp1); 984 kfree(tmp2); 985 return ret; 986 } 987 988 static u32 md_csum_fold(u32 csum) 989 { 990 csum = (csum & 0xffff) + (csum >> 16); 991 return (csum & 0xffff) + (csum >> 16); 992 } 993 994 static unsigned int calc_sb_csum(mdp_super_t *sb) 995 { 996 u64 newcsum = 0; 997 u32 *sb32 = (u32*)sb; 998 int i; 999 unsigned int disk_csum, csum; 1000 1001 disk_csum = sb->sb_csum; 1002 sb->sb_csum = 0; 1003 1004 for (i = 0; i < MD_SB_BYTES/4 ; i++) 1005 newcsum += sb32[i]; 1006 csum = (newcsum & 0xffffffff) + (newcsum>>32); 1007 1008 #ifdef CONFIG_ALPHA 1009 /* This used to use csum_partial, which was wrong for several 1010 * reasons including that different results are returned on 1011 * different architectures. It isn't critical that we get exactly 1012 * the same return value as before (we always csum_fold before 1013 * testing, and that removes any differences). However as we 1014 * know that csum_partial always returned a 16bit value on 1015 * alphas, do a fold to maximise conformity to previous behaviour. 1016 */ 1017 sb->sb_csum = md_csum_fold(disk_csum); 1018 #else 1019 sb->sb_csum = disk_csum; 1020 #endif 1021 return csum; 1022 } 1023 1024 /* 1025 * Handle superblock details. 1026 * We want to be able to handle multiple superblock formats 1027 * so we have a common interface to them all, and an array of 1028 * different handlers. 1029 * We rely on user-space to write the initial superblock, and support 1030 * reading and updating of superblocks. 1031 * Interface methods are: 1032 * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version) 1033 * loads and validates a superblock on dev. 1034 * if refdev != NULL, compare superblocks on both devices 1035 * Return: 1036 * 0 - dev has a superblock that is compatible with refdev 1037 * 1 - dev has a superblock that is compatible and newer than refdev 1038 * so dev should be used as the refdev in future 1039 * -EINVAL superblock incompatible or invalid 1040 * -othererror e.g. -EIO 1041 * 1042 * int validate_super(struct mddev *mddev, struct md_rdev *dev) 1043 * Verify that dev is acceptable into mddev. 1044 * The first time, mddev->raid_disks will be 0, and data from 1045 * dev should be merged in. Subsequent calls check that dev 1046 * is new enough. Return 0 or -EINVAL 1047 * 1048 * void sync_super(struct mddev *mddev, struct md_rdev *dev) 1049 * Update the superblock for rdev with data in mddev 1050 * This does not write to disc. 1051 * 1052 */ 1053 1054 struct super_type { 1055 char *name; 1056 struct module *owner; 1057 int (*load_super)(struct md_rdev *rdev, 1058 struct md_rdev *refdev, 1059 int minor_version); 1060 int (*validate_super)(struct mddev *mddev, 1061 struct md_rdev *rdev); 1062 void (*sync_super)(struct mddev *mddev, 1063 struct md_rdev *rdev); 1064 unsigned long long (*rdev_size_change)(struct md_rdev *rdev, 1065 sector_t num_sectors); 1066 int (*allow_new_offset)(struct md_rdev *rdev, 1067 unsigned long long new_offset); 1068 }; 1069 1070 /* 1071 * Check that the given mddev has no bitmap. 1072 * 1073 * This function is called from the run method of all personalities that do not 1074 * support bitmaps. It prints an error message and returns non-zero if mddev 1075 * has a bitmap. Otherwise, it returns 0. 1076 * 1077 */ 1078 int md_check_no_bitmap(struct mddev *mddev) 1079 { 1080 if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset) 1081 return 0; 1082 pr_warn("%s: bitmaps are not supported for %s\n", 1083 mdname(mddev), mddev->pers->name); 1084 return 1; 1085 } 1086 EXPORT_SYMBOL(md_check_no_bitmap); 1087 1088 /* 1089 * load_super for 0.90.0 1090 */ 1091 static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version) 1092 { 1093 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 1094 mdp_super_t *sb; 1095 int ret; 1096 1097 /* 1098 * Calculate the position of the superblock (512byte sectors), 1099 * it's at the end of the disk. 1100 * 1101 * It also happens to be a multiple of 4Kb. 1102 */ 1103 rdev->sb_start = calc_dev_sboffset(rdev); 1104 1105 ret = read_disk_sb(rdev, MD_SB_BYTES); 1106 if (ret) 1107 return ret; 1108 1109 ret = -EINVAL; 1110 1111 bdevname(rdev->bdev, b); 1112 sb = page_address(rdev->sb_page); 1113 1114 if (sb->md_magic != MD_SB_MAGIC) { 1115 pr_warn("md: invalid raid superblock magic on %s\n", b); 1116 goto abort; 1117 } 1118 1119 if (sb->major_version != 0 || 1120 sb->minor_version < 90 || 1121 sb->minor_version > 91) { 1122 pr_warn("Bad version number %d.%d on %s\n", 1123 sb->major_version, sb->minor_version, b); 1124 goto abort; 1125 } 1126 1127 if (sb->raid_disks <= 0) 1128 goto abort; 1129 1130 if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) { 1131 pr_warn("md: invalid superblock checksum on %s\n", b); 1132 goto abort; 1133 } 1134 1135 rdev->preferred_minor = sb->md_minor; 1136 rdev->data_offset = 0; 1137 rdev->new_data_offset = 0; 1138 rdev->sb_size = MD_SB_BYTES; 1139 rdev->badblocks.shift = -1; 1140 1141 if (sb->level == LEVEL_MULTIPATH) 1142 rdev->desc_nr = -1; 1143 else 1144 rdev->desc_nr = sb->this_disk.number; 1145 1146 if (!refdev) { 1147 ret = 1; 1148 } else { 1149 __u64 ev1, ev2; 1150 mdp_super_t *refsb = page_address(refdev->sb_page); 1151 if (!md_uuid_equal(refsb, sb)) { 1152 pr_warn("md: %s has different UUID to %s\n", 1153 b, bdevname(refdev->bdev,b2)); 1154 goto abort; 1155 } 1156 if (!md_sb_equal(refsb, sb)) { 1157 pr_warn("md: %s has same UUID but different superblock to %s\n", 1158 b, bdevname(refdev->bdev, b2)); 1159 goto abort; 1160 } 1161 ev1 = md_event(sb); 1162 ev2 = md_event(refsb); 1163 if (ev1 > ev2) 1164 ret = 1; 1165 else 1166 ret = 0; 1167 } 1168 rdev->sectors = rdev->sb_start; 1169 /* Limit to 4TB as metadata cannot record more than that. 1170 * (not needed for Linear and RAID0 as metadata doesn't 1171 * record this size) 1172 */ 1173 if ((u64)rdev->sectors >= (2ULL << 32) && sb->level >= 1) 1174 rdev->sectors = (sector_t)(2ULL << 32) - 2; 1175 1176 if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1) 1177 /* "this cannot possibly happen" ... */ 1178 ret = -EINVAL; 1179 1180 abort: 1181 return ret; 1182 } 1183 1184 /* 1185 * validate_super for 0.90.0 1186 */ 1187 static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev) 1188 { 1189 mdp_disk_t *desc; 1190 mdp_super_t *sb = page_address(rdev->sb_page); 1191 __u64 ev1 = md_event(sb); 1192 1193 rdev->raid_disk = -1; 1194 clear_bit(Faulty, &rdev->flags); 1195 clear_bit(In_sync, &rdev->flags); 1196 clear_bit(Bitmap_sync, &rdev->flags); 1197 clear_bit(WriteMostly, &rdev->flags); 1198 1199 if (mddev->raid_disks == 0) { 1200 mddev->major_version = 0; 1201 mddev->minor_version = sb->minor_version; 1202 mddev->patch_version = sb->patch_version; 1203 mddev->external = 0; 1204 mddev->chunk_sectors = sb->chunk_size >> 9; 1205 mddev->ctime = sb->ctime; 1206 mddev->utime = sb->utime; 1207 mddev->level = sb->level; 1208 mddev->clevel[0] = 0; 1209 mddev->layout = sb->layout; 1210 mddev->raid_disks = sb->raid_disks; 1211 mddev->dev_sectors = ((sector_t)sb->size) * 2; 1212 mddev->events = ev1; 1213 mddev->bitmap_info.offset = 0; 1214 mddev->bitmap_info.space = 0; 1215 /* bitmap can use 60 K after the 4K superblocks */ 1216 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9; 1217 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9); 1218 mddev->reshape_backwards = 0; 1219 1220 if (mddev->minor_version >= 91) { 1221 mddev->reshape_position = sb->reshape_position; 1222 mddev->delta_disks = sb->delta_disks; 1223 mddev->new_level = sb->new_level; 1224 mddev->new_layout = sb->new_layout; 1225 mddev->new_chunk_sectors = sb->new_chunk >> 9; 1226 if (mddev->delta_disks < 0) 1227 mddev->reshape_backwards = 1; 1228 } else { 1229 mddev->reshape_position = MaxSector; 1230 mddev->delta_disks = 0; 1231 mddev->new_level = mddev->level; 1232 mddev->new_layout = mddev->layout; 1233 mddev->new_chunk_sectors = mddev->chunk_sectors; 1234 } 1235 1236 if (sb->state & (1<<MD_SB_CLEAN)) 1237 mddev->recovery_cp = MaxSector; 1238 else { 1239 if (sb->events_hi == sb->cp_events_hi && 1240 sb->events_lo == sb->cp_events_lo) { 1241 mddev->recovery_cp = sb->recovery_cp; 1242 } else 1243 mddev->recovery_cp = 0; 1244 } 1245 1246 memcpy(mddev->uuid+0, &sb->set_uuid0, 4); 1247 memcpy(mddev->uuid+4, &sb->set_uuid1, 4); 1248 memcpy(mddev->uuid+8, &sb->set_uuid2, 4); 1249 memcpy(mddev->uuid+12,&sb->set_uuid3, 4); 1250 1251 mddev->max_disks = MD_SB_DISKS; 1252 1253 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) && 1254 mddev->bitmap_info.file == NULL) { 1255 mddev->bitmap_info.offset = 1256 mddev->bitmap_info.default_offset; 1257 mddev->bitmap_info.space = 1258 mddev->bitmap_info.default_space; 1259 } 1260 1261 } else if (mddev->pers == NULL) { 1262 /* Insist on good event counter while assembling, except 1263 * for spares (which don't need an event count) */ 1264 ++ev1; 1265 if (sb->disks[rdev->desc_nr].state & ( 1266 (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE))) 1267 if (ev1 < mddev->events) 1268 return -EINVAL; 1269 } else if (mddev->bitmap) { 1270 /* if adding to array with a bitmap, then we can accept an 1271 * older device ... but not too old. 1272 */ 1273 if (ev1 < mddev->bitmap->events_cleared) 1274 return 0; 1275 if (ev1 < mddev->events) 1276 set_bit(Bitmap_sync, &rdev->flags); 1277 } else { 1278 if (ev1 < mddev->events) 1279 /* just a hot-add of a new device, leave raid_disk at -1 */ 1280 return 0; 1281 } 1282 1283 if (mddev->level != LEVEL_MULTIPATH) { 1284 desc = sb->disks + rdev->desc_nr; 1285 1286 if (desc->state & (1<<MD_DISK_FAULTY)) 1287 set_bit(Faulty, &rdev->flags); 1288 else if (desc->state & (1<<MD_DISK_SYNC) /* && 1289 desc->raid_disk < mddev->raid_disks */) { 1290 set_bit(In_sync, &rdev->flags); 1291 rdev->raid_disk = desc->raid_disk; 1292 rdev->saved_raid_disk = desc->raid_disk; 1293 } else if (desc->state & (1<<MD_DISK_ACTIVE)) { 1294 /* active but not in sync implies recovery up to 1295 * reshape position. We don't know exactly where 1296 * that is, so set to zero for now */ 1297 if (mddev->minor_version >= 91) { 1298 rdev->recovery_offset = 0; 1299 rdev->raid_disk = desc->raid_disk; 1300 } 1301 } 1302 if (desc->state & (1<<MD_DISK_WRITEMOSTLY)) 1303 set_bit(WriteMostly, &rdev->flags); 1304 if (desc->state & (1<<MD_DISK_FAILFAST)) 1305 set_bit(FailFast, &rdev->flags); 1306 } else /* MULTIPATH are always insync */ 1307 set_bit(In_sync, &rdev->flags); 1308 return 0; 1309 } 1310 1311 /* 1312 * sync_super for 0.90.0 1313 */ 1314 static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev) 1315 { 1316 mdp_super_t *sb; 1317 struct md_rdev *rdev2; 1318 int next_spare = mddev->raid_disks; 1319 1320 /* make rdev->sb match mddev data.. 1321 * 1322 * 1/ zero out disks 1323 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare); 1324 * 3/ any empty disks < next_spare become removed 1325 * 1326 * disks[0] gets initialised to REMOVED because 1327 * we cannot be sure from other fields if it has 1328 * been initialised or not. 1329 */ 1330 int i; 1331 int active=0, working=0,failed=0,spare=0,nr_disks=0; 1332 1333 rdev->sb_size = MD_SB_BYTES; 1334 1335 sb = page_address(rdev->sb_page); 1336 1337 memset(sb, 0, sizeof(*sb)); 1338 1339 sb->md_magic = MD_SB_MAGIC; 1340 sb->major_version = mddev->major_version; 1341 sb->patch_version = mddev->patch_version; 1342 sb->gvalid_words = 0; /* ignored */ 1343 memcpy(&sb->set_uuid0, mddev->uuid+0, 4); 1344 memcpy(&sb->set_uuid1, mddev->uuid+4, 4); 1345 memcpy(&sb->set_uuid2, mddev->uuid+8, 4); 1346 memcpy(&sb->set_uuid3, mddev->uuid+12,4); 1347 1348 sb->ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX); 1349 sb->level = mddev->level; 1350 sb->size = mddev->dev_sectors / 2; 1351 sb->raid_disks = mddev->raid_disks; 1352 sb->md_minor = mddev->md_minor; 1353 sb->not_persistent = 0; 1354 sb->utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX); 1355 sb->state = 0; 1356 sb->events_hi = (mddev->events>>32); 1357 sb->events_lo = (u32)mddev->events; 1358 1359 if (mddev->reshape_position == MaxSector) 1360 sb->minor_version = 90; 1361 else { 1362 sb->minor_version = 91; 1363 sb->reshape_position = mddev->reshape_position; 1364 sb->new_level = mddev->new_level; 1365 sb->delta_disks = mddev->delta_disks; 1366 sb->new_layout = mddev->new_layout; 1367 sb->new_chunk = mddev->new_chunk_sectors << 9; 1368 } 1369 mddev->minor_version = sb->minor_version; 1370 if (mddev->in_sync) 1371 { 1372 sb->recovery_cp = mddev->recovery_cp; 1373 sb->cp_events_hi = (mddev->events>>32); 1374 sb->cp_events_lo = (u32)mddev->events; 1375 if (mddev->recovery_cp == MaxSector) 1376 sb->state = (1<< MD_SB_CLEAN); 1377 } else 1378 sb->recovery_cp = 0; 1379 1380 sb->layout = mddev->layout; 1381 sb->chunk_size = mddev->chunk_sectors << 9; 1382 1383 if (mddev->bitmap && mddev->bitmap_info.file == NULL) 1384 sb->state |= (1<<MD_SB_BITMAP_PRESENT); 1385 1386 sb->disks[0].state = (1<<MD_DISK_REMOVED); 1387 rdev_for_each(rdev2, mddev) { 1388 mdp_disk_t *d; 1389 int desc_nr; 1390 int is_active = test_bit(In_sync, &rdev2->flags); 1391 1392 if (rdev2->raid_disk >= 0 && 1393 sb->minor_version >= 91) 1394 /* we have nowhere to store the recovery_offset, 1395 * but if it is not below the reshape_position, 1396 * we can piggy-back on that. 1397 */ 1398 is_active = 1; 1399 if (rdev2->raid_disk < 0 || 1400 test_bit(Faulty, &rdev2->flags)) 1401 is_active = 0; 1402 if (is_active) 1403 desc_nr = rdev2->raid_disk; 1404 else 1405 desc_nr = next_spare++; 1406 rdev2->desc_nr = desc_nr; 1407 d = &sb->disks[rdev2->desc_nr]; 1408 nr_disks++; 1409 d->number = rdev2->desc_nr; 1410 d->major = MAJOR(rdev2->bdev->bd_dev); 1411 d->minor = MINOR(rdev2->bdev->bd_dev); 1412 if (is_active) 1413 d->raid_disk = rdev2->raid_disk; 1414 else 1415 d->raid_disk = rdev2->desc_nr; /* compatibility */ 1416 if (test_bit(Faulty, &rdev2->flags)) 1417 d->state = (1<<MD_DISK_FAULTY); 1418 else if (is_active) { 1419 d->state = (1<<MD_DISK_ACTIVE); 1420 if (test_bit(In_sync, &rdev2->flags)) 1421 d->state |= (1<<MD_DISK_SYNC); 1422 active++; 1423 working++; 1424 } else { 1425 d->state = 0; 1426 spare++; 1427 working++; 1428 } 1429 if (test_bit(WriteMostly, &rdev2->flags)) 1430 d->state |= (1<<MD_DISK_WRITEMOSTLY); 1431 if (test_bit(FailFast, &rdev2->flags)) 1432 d->state |= (1<<MD_DISK_FAILFAST); 1433 } 1434 /* now set the "removed" and "faulty" bits on any missing devices */ 1435 for (i=0 ; i < mddev->raid_disks ; i++) { 1436 mdp_disk_t *d = &sb->disks[i]; 1437 if (d->state == 0 && d->number == 0) { 1438 d->number = i; 1439 d->raid_disk = i; 1440 d->state = (1<<MD_DISK_REMOVED); 1441 d->state |= (1<<MD_DISK_FAULTY); 1442 failed++; 1443 } 1444 } 1445 sb->nr_disks = nr_disks; 1446 sb->active_disks = active; 1447 sb->working_disks = working; 1448 sb->failed_disks = failed; 1449 sb->spare_disks = spare; 1450 1451 sb->this_disk = sb->disks[rdev->desc_nr]; 1452 sb->sb_csum = calc_sb_csum(sb); 1453 } 1454 1455 /* 1456 * rdev_size_change for 0.90.0 1457 */ 1458 static unsigned long long 1459 super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors) 1460 { 1461 if (num_sectors && num_sectors < rdev->mddev->dev_sectors) 1462 return 0; /* component must fit device */ 1463 if (rdev->mddev->bitmap_info.offset) 1464 return 0; /* can't move bitmap */ 1465 rdev->sb_start = calc_dev_sboffset(rdev); 1466 if (!num_sectors || num_sectors > rdev->sb_start) 1467 num_sectors = rdev->sb_start; 1468 /* Limit to 4TB as metadata cannot record more than that. 1469 * 4TB == 2^32 KB, or 2*2^32 sectors. 1470 */ 1471 if ((u64)num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1) 1472 num_sectors = (sector_t)(2ULL << 32) - 2; 1473 do { 1474 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size, 1475 rdev->sb_page); 1476 } while (md_super_wait(rdev->mddev) < 0); 1477 return num_sectors; 1478 } 1479 1480 static int 1481 super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset) 1482 { 1483 /* non-zero offset changes not possible with v0.90 */ 1484 return new_offset == 0; 1485 } 1486 1487 /* 1488 * version 1 superblock 1489 */ 1490 1491 static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb) 1492 { 1493 __le32 disk_csum; 1494 u32 csum; 1495 unsigned long long newcsum; 1496 int size = 256 + le32_to_cpu(sb->max_dev)*2; 1497 __le32 *isuper = (__le32*)sb; 1498 1499 disk_csum = sb->sb_csum; 1500 sb->sb_csum = 0; 1501 newcsum = 0; 1502 for (; size >= 4; size -= 4) 1503 newcsum += le32_to_cpu(*isuper++); 1504 1505 if (size == 2) 1506 newcsum += le16_to_cpu(*(__le16*) isuper); 1507 1508 csum = (newcsum & 0xffffffff) + (newcsum >> 32); 1509 sb->sb_csum = disk_csum; 1510 return cpu_to_le32(csum); 1511 } 1512 1513 static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version) 1514 { 1515 struct mdp_superblock_1 *sb; 1516 int ret; 1517 sector_t sb_start; 1518 sector_t sectors; 1519 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 1520 int bmask; 1521 1522 /* 1523 * Calculate the position of the superblock in 512byte sectors. 1524 * It is always aligned to a 4K boundary and 1525 * depeding on minor_version, it can be: 1526 * 0: At least 8K, but less than 12K, from end of device 1527 * 1: At start of device 1528 * 2: 4K from start of device. 1529 */ 1530 switch(minor_version) { 1531 case 0: 1532 sb_start = i_size_read(rdev->bdev->bd_inode) >> 9; 1533 sb_start -= 8*2; 1534 sb_start &= ~(sector_t)(4*2-1); 1535 break; 1536 case 1: 1537 sb_start = 0; 1538 break; 1539 case 2: 1540 sb_start = 8; 1541 break; 1542 default: 1543 return -EINVAL; 1544 } 1545 rdev->sb_start = sb_start; 1546 1547 /* superblock is rarely larger than 1K, but it can be larger, 1548 * and it is safe to read 4k, so we do that 1549 */ 1550 ret = read_disk_sb(rdev, 4096); 1551 if (ret) return ret; 1552 1553 sb = page_address(rdev->sb_page); 1554 1555 if (sb->magic != cpu_to_le32(MD_SB_MAGIC) || 1556 sb->major_version != cpu_to_le32(1) || 1557 le32_to_cpu(sb->max_dev) > (4096-256)/2 || 1558 le64_to_cpu(sb->super_offset) != rdev->sb_start || 1559 (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0) 1560 return -EINVAL; 1561 1562 if (calc_sb_1_csum(sb) != sb->sb_csum) { 1563 pr_warn("md: invalid superblock checksum on %s\n", 1564 bdevname(rdev->bdev,b)); 1565 return -EINVAL; 1566 } 1567 if (le64_to_cpu(sb->data_size) < 10) { 1568 pr_warn("md: data_size too small on %s\n", 1569 bdevname(rdev->bdev,b)); 1570 return -EINVAL; 1571 } 1572 if (sb->pad0 || 1573 sb->pad3[0] || 1574 memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1]))) 1575 /* Some padding is non-zero, might be a new feature */ 1576 return -EINVAL; 1577 1578 rdev->preferred_minor = 0xffff; 1579 rdev->data_offset = le64_to_cpu(sb->data_offset); 1580 rdev->new_data_offset = rdev->data_offset; 1581 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) && 1582 (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET)) 1583 rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset); 1584 atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read)); 1585 1586 rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256; 1587 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1; 1588 if (rdev->sb_size & bmask) 1589 rdev->sb_size = (rdev->sb_size | bmask) + 1; 1590 1591 if (minor_version 1592 && rdev->data_offset < sb_start + (rdev->sb_size/512)) 1593 return -EINVAL; 1594 if (minor_version 1595 && rdev->new_data_offset < sb_start + (rdev->sb_size/512)) 1596 return -EINVAL; 1597 1598 if (sb->level == cpu_to_le32(LEVEL_MULTIPATH)) 1599 rdev->desc_nr = -1; 1600 else 1601 rdev->desc_nr = le32_to_cpu(sb->dev_number); 1602 1603 if (!rdev->bb_page) { 1604 rdev->bb_page = alloc_page(GFP_KERNEL); 1605 if (!rdev->bb_page) 1606 return -ENOMEM; 1607 } 1608 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) && 1609 rdev->badblocks.count == 0) { 1610 /* need to load the bad block list. 1611 * Currently we limit it to one page. 1612 */ 1613 s32 offset; 1614 sector_t bb_sector; 1615 __le64 *bbp; 1616 int i; 1617 int sectors = le16_to_cpu(sb->bblog_size); 1618 if (sectors > (PAGE_SIZE / 512)) 1619 return -EINVAL; 1620 offset = le32_to_cpu(sb->bblog_offset); 1621 if (offset == 0) 1622 return -EINVAL; 1623 bb_sector = (long long)offset; 1624 if (!sync_page_io(rdev, bb_sector, sectors << 9, 1625 rdev->bb_page, REQ_OP_READ, 0, true)) 1626 return -EIO; 1627 bbp = (__le64 *)page_address(rdev->bb_page); 1628 rdev->badblocks.shift = sb->bblog_shift; 1629 for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) { 1630 u64 bb = le64_to_cpu(*bbp); 1631 int count = bb & (0x3ff); 1632 u64 sector = bb >> 10; 1633 sector <<= sb->bblog_shift; 1634 count <<= sb->bblog_shift; 1635 if (bb + 1 == 0) 1636 break; 1637 if (badblocks_set(&rdev->badblocks, sector, count, 1)) 1638 return -EINVAL; 1639 } 1640 } else if (sb->bblog_offset != 0) 1641 rdev->badblocks.shift = 0; 1642 1643 if ((le32_to_cpu(sb->feature_map) & 1644 (MD_FEATURE_PPL | MD_FEATURE_MULTIPLE_PPLS))) { 1645 rdev->ppl.offset = (__s16)le16_to_cpu(sb->ppl.offset); 1646 rdev->ppl.size = le16_to_cpu(sb->ppl.size); 1647 rdev->ppl.sector = rdev->sb_start + rdev->ppl.offset; 1648 } 1649 1650 if (!refdev) { 1651 ret = 1; 1652 } else { 1653 __u64 ev1, ev2; 1654 struct mdp_superblock_1 *refsb = page_address(refdev->sb_page); 1655 1656 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 || 1657 sb->level != refsb->level || 1658 sb->layout != refsb->layout || 1659 sb->chunksize != refsb->chunksize) { 1660 pr_warn("md: %s has strangely different superblock to %s\n", 1661 bdevname(rdev->bdev,b), 1662 bdevname(refdev->bdev,b2)); 1663 return -EINVAL; 1664 } 1665 ev1 = le64_to_cpu(sb->events); 1666 ev2 = le64_to_cpu(refsb->events); 1667 1668 if (ev1 > ev2) 1669 ret = 1; 1670 else 1671 ret = 0; 1672 } 1673 if (minor_version) { 1674 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9); 1675 sectors -= rdev->data_offset; 1676 } else 1677 sectors = rdev->sb_start; 1678 if (sectors < le64_to_cpu(sb->data_size)) 1679 return -EINVAL; 1680 rdev->sectors = le64_to_cpu(sb->data_size); 1681 return ret; 1682 } 1683 1684 static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev) 1685 { 1686 struct mdp_superblock_1 *sb = page_address(rdev->sb_page); 1687 __u64 ev1 = le64_to_cpu(sb->events); 1688 1689 rdev->raid_disk = -1; 1690 clear_bit(Faulty, &rdev->flags); 1691 clear_bit(In_sync, &rdev->flags); 1692 clear_bit(Bitmap_sync, &rdev->flags); 1693 clear_bit(WriteMostly, &rdev->flags); 1694 1695 if (mddev->raid_disks == 0) { 1696 mddev->major_version = 1; 1697 mddev->patch_version = 0; 1698 mddev->external = 0; 1699 mddev->chunk_sectors = le32_to_cpu(sb->chunksize); 1700 mddev->ctime = le64_to_cpu(sb->ctime); 1701 mddev->utime = le64_to_cpu(sb->utime); 1702 mddev->level = le32_to_cpu(sb->level); 1703 mddev->clevel[0] = 0; 1704 mddev->layout = le32_to_cpu(sb->layout); 1705 mddev->raid_disks = le32_to_cpu(sb->raid_disks); 1706 mddev->dev_sectors = le64_to_cpu(sb->size); 1707 mddev->events = ev1; 1708 mddev->bitmap_info.offset = 0; 1709 mddev->bitmap_info.space = 0; 1710 /* Default location for bitmap is 1K after superblock 1711 * using 3K - total of 4K 1712 */ 1713 mddev->bitmap_info.default_offset = 1024 >> 9; 1714 mddev->bitmap_info.default_space = (4096-1024) >> 9; 1715 mddev->reshape_backwards = 0; 1716 1717 mddev->recovery_cp = le64_to_cpu(sb->resync_offset); 1718 memcpy(mddev->uuid, sb->set_uuid, 16); 1719 1720 mddev->max_disks = (4096-256)/2; 1721 1722 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) && 1723 mddev->bitmap_info.file == NULL) { 1724 mddev->bitmap_info.offset = 1725 (__s32)le32_to_cpu(sb->bitmap_offset); 1726 /* Metadata doesn't record how much space is available. 1727 * For 1.0, we assume we can use up to the superblock 1728 * if before, else to 4K beyond superblock. 1729 * For others, assume no change is possible. 1730 */ 1731 if (mddev->minor_version > 0) 1732 mddev->bitmap_info.space = 0; 1733 else if (mddev->bitmap_info.offset > 0) 1734 mddev->bitmap_info.space = 1735 8 - mddev->bitmap_info.offset; 1736 else 1737 mddev->bitmap_info.space = 1738 -mddev->bitmap_info.offset; 1739 } 1740 1741 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) { 1742 mddev->reshape_position = le64_to_cpu(sb->reshape_position); 1743 mddev->delta_disks = le32_to_cpu(sb->delta_disks); 1744 mddev->new_level = le32_to_cpu(sb->new_level); 1745 mddev->new_layout = le32_to_cpu(sb->new_layout); 1746 mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk); 1747 if (mddev->delta_disks < 0 || 1748 (mddev->delta_disks == 0 && 1749 (le32_to_cpu(sb->feature_map) 1750 & MD_FEATURE_RESHAPE_BACKWARDS))) 1751 mddev->reshape_backwards = 1; 1752 } else { 1753 mddev->reshape_position = MaxSector; 1754 mddev->delta_disks = 0; 1755 mddev->new_level = mddev->level; 1756 mddev->new_layout = mddev->layout; 1757 mddev->new_chunk_sectors = mddev->chunk_sectors; 1758 } 1759 1760 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL) 1761 set_bit(MD_HAS_JOURNAL, &mddev->flags); 1762 1763 if (le32_to_cpu(sb->feature_map) & 1764 (MD_FEATURE_PPL | MD_FEATURE_MULTIPLE_PPLS)) { 1765 if (le32_to_cpu(sb->feature_map) & 1766 (MD_FEATURE_BITMAP_OFFSET | MD_FEATURE_JOURNAL)) 1767 return -EINVAL; 1768 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_PPL) && 1769 (le32_to_cpu(sb->feature_map) & 1770 MD_FEATURE_MULTIPLE_PPLS)) 1771 return -EINVAL; 1772 set_bit(MD_HAS_PPL, &mddev->flags); 1773 } 1774 } else if (mddev->pers == NULL) { 1775 /* Insist of good event counter while assembling, except for 1776 * spares (which don't need an event count) */ 1777 ++ev1; 1778 if (rdev->desc_nr >= 0 && 1779 rdev->desc_nr < le32_to_cpu(sb->max_dev) && 1780 (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX || 1781 le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL)) 1782 if (ev1 < mddev->events) 1783 return -EINVAL; 1784 } else if (mddev->bitmap) { 1785 /* If adding to array with a bitmap, then we can accept an 1786 * older device, but not too old. 1787 */ 1788 if (ev1 < mddev->bitmap->events_cleared) 1789 return 0; 1790 if (ev1 < mddev->events) 1791 set_bit(Bitmap_sync, &rdev->flags); 1792 } else { 1793 if (ev1 < mddev->events) 1794 /* just a hot-add of a new device, leave raid_disk at -1 */ 1795 return 0; 1796 } 1797 if (mddev->level != LEVEL_MULTIPATH) { 1798 int role; 1799 if (rdev->desc_nr < 0 || 1800 rdev->desc_nr >= le32_to_cpu(sb->max_dev)) { 1801 role = MD_DISK_ROLE_SPARE; 1802 rdev->desc_nr = -1; 1803 } else 1804 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]); 1805 switch(role) { 1806 case MD_DISK_ROLE_SPARE: /* spare */ 1807 break; 1808 case MD_DISK_ROLE_FAULTY: /* faulty */ 1809 set_bit(Faulty, &rdev->flags); 1810 break; 1811 case MD_DISK_ROLE_JOURNAL: /* journal device */ 1812 if (!(le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)) { 1813 /* journal device without journal feature */ 1814 pr_warn("md: journal device provided without journal feature, ignoring the device\n"); 1815 return -EINVAL; 1816 } 1817 set_bit(Journal, &rdev->flags); 1818 rdev->journal_tail = le64_to_cpu(sb->journal_tail); 1819 rdev->raid_disk = 0; 1820 break; 1821 default: 1822 rdev->saved_raid_disk = role; 1823 if ((le32_to_cpu(sb->feature_map) & 1824 MD_FEATURE_RECOVERY_OFFSET)) { 1825 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset); 1826 if (!(le32_to_cpu(sb->feature_map) & 1827 MD_FEATURE_RECOVERY_BITMAP)) 1828 rdev->saved_raid_disk = -1; 1829 } else 1830 set_bit(In_sync, &rdev->flags); 1831 rdev->raid_disk = role; 1832 break; 1833 } 1834 if (sb->devflags & WriteMostly1) 1835 set_bit(WriteMostly, &rdev->flags); 1836 if (sb->devflags & FailFast1) 1837 set_bit(FailFast, &rdev->flags); 1838 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT) 1839 set_bit(Replacement, &rdev->flags); 1840 } else /* MULTIPATH are always insync */ 1841 set_bit(In_sync, &rdev->flags); 1842 1843 return 0; 1844 } 1845 1846 static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev) 1847 { 1848 struct mdp_superblock_1 *sb; 1849 struct md_rdev *rdev2; 1850 int max_dev, i; 1851 /* make rdev->sb match mddev and rdev data. */ 1852 1853 sb = page_address(rdev->sb_page); 1854 1855 sb->feature_map = 0; 1856 sb->pad0 = 0; 1857 sb->recovery_offset = cpu_to_le64(0); 1858 memset(sb->pad3, 0, sizeof(sb->pad3)); 1859 1860 sb->utime = cpu_to_le64((__u64)mddev->utime); 1861 sb->events = cpu_to_le64(mddev->events); 1862 if (mddev->in_sync) 1863 sb->resync_offset = cpu_to_le64(mddev->recovery_cp); 1864 else if (test_bit(MD_JOURNAL_CLEAN, &mddev->flags)) 1865 sb->resync_offset = cpu_to_le64(MaxSector); 1866 else 1867 sb->resync_offset = cpu_to_le64(0); 1868 1869 sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors)); 1870 1871 sb->raid_disks = cpu_to_le32(mddev->raid_disks); 1872 sb->size = cpu_to_le64(mddev->dev_sectors); 1873 sb->chunksize = cpu_to_le32(mddev->chunk_sectors); 1874 sb->level = cpu_to_le32(mddev->level); 1875 sb->layout = cpu_to_le32(mddev->layout); 1876 if (test_bit(FailFast, &rdev->flags)) 1877 sb->devflags |= FailFast1; 1878 else 1879 sb->devflags &= ~FailFast1; 1880 1881 if (test_bit(WriteMostly, &rdev->flags)) 1882 sb->devflags |= WriteMostly1; 1883 else 1884 sb->devflags &= ~WriteMostly1; 1885 sb->data_offset = cpu_to_le64(rdev->data_offset); 1886 sb->data_size = cpu_to_le64(rdev->sectors); 1887 1888 if (mddev->bitmap && mddev->bitmap_info.file == NULL) { 1889 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset); 1890 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET); 1891 } 1892 1893 if (rdev->raid_disk >= 0 && !test_bit(Journal, &rdev->flags) && 1894 !test_bit(In_sync, &rdev->flags)) { 1895 sb->feature_map |= 1896 cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET); 1897 sb->recovery_offset = 1898 cpu_to_le64(rdev->recovery_offset); 1899 if (rdev->saved_raid_disk >= 0 && mddev->bitmap) 1900 sb->feature_map |= 1901 cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP); 1902 } 1903 /* Note: recovery_offset and journal_tail share space */ 1904 if (test_bit(Journal, &rdev->flags)) 1905 sb->journal_tail = cpu_to_le64(rdev->journal_tail); 1906 if (test_bit(Replacement, &rdev->flags)) 1907 sb->feature_map |= 1908 cpu_to_le32(MD_FEATURE_REPLACEMENT); 1909 1910 if (mddev->reshape_position != MaxSector) { 1911 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE); 1912 sb->reshape_position = cpu_to_le64(mddev->reshape_position); 1913 sb->new_layout = cpu_to_le32(mddev->new_layout); 1914 sb->delta_disks = cpu_to_le32(mddev->delta_disks); 1915 sb->new_level = cpu_to_le32(mddev->new_level); 1916 sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors); 1917 if (mddev->delta_disks == 0 && 1918 mddev->reshape_backwards) 1919 sb->feature_map 1920 |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS); 1921 if (rdev->new_data_offset != rdev->data_offset) { 1922 sb->feature_map 1923 |= cpu_to_le32(MD_FEATURE_NEW_OFFSET); 1924 sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset 1925 - rdev->data_offset)); 1926 } 1927 } 1928 1929 if (mddev_is_clustered(mddev)) 1930 sb->feature_map |= cpu_to_le32(MD_FEATURE_CLUSTERED); 1931 1932 if (rdev->badblocks.count == 0) 1933 /* Nothing to do for bad blocks*/ ; 1934 else if (sb->bblog_offset == 0) 1935 /* Cannot record bad blocks on this device */ 1936 md_error(mddev, rdev); 1937 else { 1938 struct badblocks *bb = &rdev->badblocks; 1939 __le64 *bbp = (__le64 *)page_address(rdev->bb_page); 1940 u64 *p = bb->page; 1941 sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS); 1942 if (bb->changed) { 1943 unsigned seq; 1944 1945 retry: 1946 seq = read_seqbegin(&bb->lock); 1947 1948 memset(bbp, 0xff, PAGE_SIZE); 1949 1950 for (i = 0 ; i < bb->count ; i++) { 1951 u64 internal_bb = p[i]; 1952 u64 store_bb = ((BB_OFFSET(internal_bb) << 10) 1953 | BB_LEN(internal_bb)); 1954 bbp[i] = cpu_to_le64(store_bb); 1955 } 1956 bb->changed = 0; 1957 if (read_seqretry(&bb->lock, seq)) 1958 goto retry; 1959 1960 bb->sector = (rdev->sb_start + 1961 (int)le32_to_cpu(sb->bblog_offset)); 1962 bb->size = le16_to_cpu(sb->bblog_size); 1963 } 1964 } 1965 1966 max_dev = 0; 1967 rdev_for_each(rdev2, mddev) 1968 if (rdev2->desc_nr+1 > max_dev) 1969 max_dev = rdev2->desc_nr+1; 1970 1971 if (max_dev > le32_to_cpu(sb->max_dev)) { 1972 int bmask; 1973 sb->max_dev = cpu_to_le32(max_dev); 1974 rdev->sb_size = max_dev * 2 + 256; 1975 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1; 1976 if (rdev->sb_size & bmask) 1977 rdev->sb_size = (rdev->sb_size | bmask) + 1; 1978 } else 1979 max_dev = le32_to_cpu(sb->max_dev); 1980 1981 for (i=0; i<max_dev;i++) 1982 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE); 1983 1984 if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) 1985 sb->feature_map |= cpu_to_le32(MD_FEATURE_JOURNAL); 1986 1987 if (test_bit(MD_HAS_PPL, &mddev->flags)) { 1988 if (test_bit(MD_HAS_MULTIPLE_PPLS, &mddev->flags)) 1989 sb->feature_map |= 1990 cpu_to_le32(MD_FEATURE_MULTIPLE_PPLS); 1991 else 1992 sb->feature_map |= cpu_to_le32(MD_FEATURE_PPL); 1993 sb->ppl.offset = cpu_to_le16(rdev->ppl.offset); 1994 sb->ppl.size = cpu_to_le16(rdev->ppl.size); 1995 } 1996 1997 rdev_for_each(rdev2, mddev) { 1998 i = rdev2->desc_nr; 1999 if (test_bit(Faulty, &rdev2->flags)) 2000 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY); 2001 else if (test_bit(In_sync, &rdev2->flags)) 2002 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk); 2003 else if (test_bit(Journal, &rdev2->flags)) 2004 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_JOURNAL); 2005 else if (rdev2->raid_disk >= 0) 2006 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk); 2007 else 2008 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE); 2009 } 2010 2011 sb->sb_csum = calc_sb_1_csum(sb); 2012 } 2013 2014 static unsigned long long 2015 super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors) 2016 { 2017 struct mdp_superblock_1 *sb; 2018 sector_t max_sectors; 2019 if (num_sectors && num_sectors < rdev->mddev->dev_sectors) 2020 return 0; /* component must fit device */ 2021 if (rdev->data_offset != rdev->new_data_offset) 2022 return 0; /* too confusing */ 2023 if (rdev->sb_start < rdev->data_offset) { 2024 /* minor versions 1 and 2; superblock before data */ 2025 max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9; 2026 max_sectors -= rdev->data_offset; 2027 if (!num_sectors || num_sectors > max_sectors) 2028 num_sectors = max_sectors; 2029 } else if (rdev->mddev->bitmap_info.offset) { 2030 /* minor version 0 with bitmap we can't move */ 2031 return 0; 2032 } else { 2033 /* minor version 0; superblock after data */ 2034 sector_t sb_start; 2035 sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2; 2036 sb_start &= ~(sector_t)(4*2 - 1); 2037 max_sectors = rdev->sectors + sb_start - rdev->sb_start; 2038 if (!num_sectors || num_sectors > max_sectors) 2039 num_sectors = max_sectors; 2040 rdev->sb_start = sb_start; 2041 } 2042 sb = page_address(rdev->sb_page); 2043 sb->data_size = cpu_to_le64(num_sectors); 2044 sb->super_offset = cpu_to_le64(rdev->sb_start); 2045 sb->sb_csum = calc_sb_1_csum(sb); 2046 do { 2047 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size, 2048 rdev->sb_page); 2049 } while (md_super_wait(rdev->mddev) < 0); 2050 return num_sectors; 2051 2052 } 2053 2054 static int 2055 super_1_allow_new_offset(struct md_rdev *rdev, 2056 unsigned long long new_offset) 2057 { 2058 /* All necessary checks on new >= old have been done */ 2059 struct bitmap *bitmap; 2060 if (new_offset >= rdev->data_offset) 2061 return 1; 2062 2063 /* with 1.0 metadata, there is no metadata to tread on 2064 * so we can always move back */ 2065 if (rdev->mddev->minor_version == 0) 2066 return 1; 2067 2068 /* otherwise we must be sure not to step on 2069 * any metadata, so stay: 2070 * 36K beyond start of superblock 2071 * beyond end of badblocks 2072 * beyond write-intent bitmap 2073 */ 2074 if (rdev->sb_start + (32+4)*2 > new_offset) 2075 return 0; 2076 bitmap = rdev->mddev->bitmap; 2077 if (bitmap && !rdev->mddev->bitmap_info.file && 2078 rdev->sb_start + rdev->mddev->bitmap_info.offset + 2079 bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset) 2080 return 0; 2081 if (rdev->badblocks.sector + rdev->badblocks.size > new_offset) 2082 return 0; 2083 2084 return 1; 2085 } 2086 2087 static struct super_type super_types[] = { 2088 [0] = { 2089 .name = "0.90.0", 2090 .owner = THIS_MODULE, 2091 .load_super = super_90_load, 2092 .validate_super = super_90_validate, 2093 .sync_super = super_90_sync, 2094 .rdev_size_change = super_90_rdev_size_change, 2095 .allow_new_offset = super_90_allow_new_offset, 2096 }, 2097 [1] = { 2098 .name = "md-1", 2099 .owner = THIS_MODULE, 2100 .load_super = super_1_load, 2101 .validate_super = super_1_validate, 2102 .sync_super = super_1_sync, 2103 .rdev_size_change = super_1_rdev_size_change, 2104 .allow_new_offset = super_1_allow_new_offset, 2105 }, 2106 }; 2107 2108 static void sync_super(struct mddev *mddev, struct md_rdev *rdev) 2109 { 2110 if (mddev->sync_super) { 2111 mddev->sync_super(mddev, rdev); 2112 return; 2113 } 2114 2115 BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types)); 2116 2117 super_types[mddev->major_version].sync_super(mddev, rdev); 2118 } 2119 2120 static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2) 2121 { 2122 struct md_rdev *rdev, *rdev2; 2123 2124 rcu_read_lock(); 2125 rdev_for_each_rcu(rdev, mddev1) { 2126 if (test_bit(Faulty, &rdev->flags) || 2127 test_bit(Journal, &rdev->flags) || 2128 rdev->raid_disk == -1) 2129 continue; 2130 rdev_for_each_rcu(rdev2, mddev2) { 2131 if (test_bit(Faulty, &rdev2->flags) || 2132 test_bit(Journal, &rdev2->flags) || 2133 rdev2->raid_disk == -1) 2134 continue; 2135 if (rdev->bdev->bd_contains == 2136 rdev2->bdev->bd_contains) { 2137 rcu_read_unlock(); 2138 return 1; 2139 } 2140 } 2141 } 2142 rcu_read_unlock(); 2143 return 0; 2144 } 2145 2146 static LIST_HEAD(pending_raid_disks); 2147 2148 /* 2149 * Try to register data integrity profile for an mddev 2150 * 2151 * This is called when an array is started and after a disk has been kicked 2152 * from the array. It only succeeds if all working and active component devices 2153 * are integrity capable with matching profiles. 2154 */ 2155 int md_integrity_register(struct mddev *mddev) 2156 { 2157 struct md_rdev *rdev, *reference = NULL; 2158 2159 if (list_empty(&mddev->disks)) 2160 return 0; /* nothing to do */ 2161 if (!mddev->gendisk || blk_get_integrity(mddev->gendisk)) 2162 return 0; /* shouldn't register, or already is */ 2163 rdev_for_each(rdev, mddev) { 2164 /* skip spares and non-functional disks */ 2165 if (test_bit(Faulty, &rdev->flags)) 2166 continue; 2167 if (rdev->raid_disk < 0) 2168 continue; 2169 if (!reference) { 2170 /* Use the first rdev as the reference */ 2171 reference = rdev; 2172 continue; 2173 } 2174 /* does this rdev's profile match the reference profile? */ 2175 if (blk_integrity_compare(reference->bdev->bd_disk, 2176 rdev->bdev->bd_disk) < 0) 2177 return -EINVAL; 2178 } 2179 if (!reference || !bdev_get_integrity(reference->bdev)) 2180 return 0; 2181 /* 2182 * All component devices are integrity capable and have matching 2183 * profiles, register the common profile for the md device. 2184 */ 2185 blk_integrity_register(mddev->gendisk, 2186 bdev_get_integrity(reference->bdev)); 2187 2188 pr_debug("md: data integrity enabled on %s\n", mdname(mddev)); 2189 if (bioset_integrity_create(&mddev->bio_set, BIO_POOL_SIZE)) { 2190 pr_err("md: failed to create integrity pool for %s\n", 2191 mdname(mddev)); 2192 return -EINVAL; 2193 } 2194 return 0; 2195 } 2196 EXPORT_SYMBOL(md_integrity_register); 2197 2198 /* 2199 * Attempt to add an rdev, but only if it is consistent with the current 2200 * integrity profile 2201 */ 2202 int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev) 2203 { 2204 struct blk_integrity *bi_mddev; 2205 char name[BDEVNAME_SIZE]; 2206 2207 if (!mddev->gendisk) 2208 return 0; 2209 2210 bi_mddev = blk_get_integrity(mddev->gendisk); 2211 2212 if (!bi_mddev) /* nothing to do */ 2213 return 0; 2214 2215 if (blk_integrity_compare(mddev->gendisk, rdev->bdev->bd_disk) != 0) { 2216 pr_err("%s: incompatible integrity profile for %s\n", 2217 mdname(mddev), bdevname(rdev->bdev, name)); 2218 return -ENXIO; 2219 } 2220 2221 return 0; 2222 } 2223 EXPORT_SYMBOL(md_integrity_add_rdev); 2224 2225 static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev) 2226 { 2227 char b[BDEVNAME_SIZE]; 2228 struct kobject *ko; 2229 int err; 2230 2231 /* prevent duplicates */ 2232 if (find_rdev(mddev, rdev->bdev->bd_dev)) 2233 return -EEXIST; 2234 2235 if ((bdev_read_only(rdev->bdev) || bdev_read_only(rdev->meta_bdev)) && 2236 mddev->pers) 2237 return -EROFS; 2238 2239 /* make sure rdev->sectors exceeds mddev->dev_sectors */ 2240 if (!test_bit(Journal, &rdev->flags) && 2241 rdev->sectors && 2242 (mddev->dev_sectors == 0 || rdev->sectors < mddev->dev_sectors)) { 2243 if (mddev->pers) { 2244 /* Cannot change size, so fail 2245 * If mddev->level <= 0, then we don't care 2246 * about aligning sizes (e.g. linear) 2247 */ 2248 if (mddev->level > 0) 2249 return -ENOSPC; 2250 } else 2251 mddev->dev_sectors = rdev->sectors; 2252 } 2253 2254 /* Verify rdev->desc_nr is unique. 2255 * If it is -1, assign a free number, else 2256 * check number is not in use 2257 */ 2258 rcu_read_lock(); 2259 if (rdev->desc_nr < 0) { 2260 int choice = 0; 2261 if (mddev->pers) 2262 choice = mddev->raid_disks; 2263 while (md_find_rdev_nr_rcu(mddev, choice)) 2264 choice++; 2265 rdev->desc_nr = choice; 2266 } else { 2267 if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) { 2268 rcu_read_unlock(); 2269 return -EBUSY; 2270 } 2271 } 2272 rcu_read_unlock(); 2273 if (!test_bit(Journal, &rdev->flags) && 2274 mddev->max_disks && rdev->desc_nr >= mddev->max_disks) { 2275 pr_warn("md: %s: array is limited to %d devices\n", 2276 mdname(mddev), mddev->max_disks); 2277 return -EBUSY; 2278 } 2279 bdevname(rdev->bdev,b); 2280 strreplace(b, '/', '!'); 2281 2282 rdev->mddev = mddev; 2283 pr_debug("md: bind<%s>\n", b); 2284 2285 if (mddev->raid_disks) 2286 mddev_create_wb_pool(mddev, rdev, false); 2287 2288 if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b))) 2289 goto fail; 2290 2291 ko = &part_to_dev(rdev->bdev->bd_part)->kobj; 2292 if (sysfs_create_link(&rdev->kobj, ko, "block")) 2293 /* failure here is OK */; 2294 rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state"); 2295 2296 list_add_rcu(&rdev->same_set, &mddev->disks); 2297 bd_link_disk_holder(rdev->bdev, mddev->gendisk); 2298 2299 /* May as well allow recovery to be retried once */ 2300 mddev->recovery_disabled++; 2301 2302 return 0; 2303 2304 fail: 2305 pr_warn("md: failed to register dev-%s for %s\n", 2306 b, mdname(mddev)); 2307 return err; 2308 } 2309 2310 static void md_delayed_delete(struct work_struct *ws) 2311 { 2312 struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work); 2313 kobject_del(&rdev->kobj); 2314 kobject_put(&rdev->kobj); 2315 } 2316 2317 static void unbind_rdev_from_array(struct md_rdev *rdev) 2318 { 2319 char b[BDEVNAME_SIZE]; 2320 2321 bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk); 2322 list_del_rcu(&rdev->same_set); 2323 pr_debug("md: unbind<%s>\n", bdevname(rdev->bdev,b)); 2324 mddev_destroy_wb_pool(rdev->mddev, rdev); 2325 rdev->mddev = NULL; 2326 sysfs_remove_link(&rdev->kobj, "block"); 2327 sysfs_put(rdev->sysfs_state); 2328 rdev->sysfs_state = NULL; 2329 rdev->badblocks.count = 0; 2330 /* We need to delay this, otherwise we can deadlock when 2331 * writing to 'remove' to "dev/state". We also need 2332 * to delay it due to rcu usage. 2333 */ 2334 synchronize_rcu(); 2335 INIT_WORK(&rdev->del_work, md_delayed_delete); 2336 kobject_get(&rdev->kobj); 2337 queue_work(md_misc_wq, &rdev->del_work); 2338 } 2339 2340 /* 2341 * prevent the device from being mounted, repartitioned or 2342 * otherwise reused by a RAID array (or any other kernel 2343 * subsystem), by bd_claiming the device. 2344 */ 2345 static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared) 2346 { 2347 int err = 0; 2348 struct block_device *bdev; 2349 char b[BDEVNAME_SIZE]; 2350 2351 bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, 2352 shared ? (struct md_rdev *)lock_rdev : rdev); 2353 if (IS_ERR(bdev)) { 2354 pr_warn("md: could not open %s.\n", __bdevname(dev, b)); 2355 return PTR_ERR(bdev); 2356 } 2357 rdev->bdev = bdev; 2358 return err; 2359 } 2360 2361 static void unlock_rdev(struct md_rdev *rdev) 2362 { 2363 struct block_device *bdev = rdev->bdev; 2364 rdev->bdev = NULL; 2365 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL); 2366 } 2367 2368 void md_autodetect_dev(dev_t dev); 2369 2370 static void export_rdev(struct md_rdev *rdev) 2371 { 2372 char b[BDEVNAME_SIZE]; 2373 2374 pr_debug("md: export_rdev(%s)\n", bdevname(rdev->bdev,b)); 2375 md_rdev_clear(rdev); 2376 #ifndef MODULE 2377 if (test_bit(AutoDetected, &rdev->flags)) 2378 md_autodetect_dev(rdev->bdev->bd_dev); 2379 #endif 2380 unlock_rdev(rdev); 2381 kobject_put(&rdev->kobj); 2382 } 2383 2384 void md_kick_rdev_from_array(struct md_rdev *rdev) 2385 { 2386 unbind_rdev_from_array(rdev); 2387 export_rdev(rdev); 2388 } 2389 EXPORT_SYMBOL_GPL(md_kick_rdev_from_array); 2390 2391 static void export_array(struct mddev *mddev) 2392 { 2393 struct md_rdev *rdev; 2394 2395 while (!list_empty(&mddev->disks)) { 2396 rdev = list_first_entry(&mddev->disks, struct md_rdev, 2397 same_set); 2398 md_kick_rdev_from_array(rdev); 2399 } 2400 mddev->raid_disks = 0; 2401 mddev->major_version = 0; 2402 } 2403 2404 static bool set_in_sync(struct mddev *mddev) 2405 { 2406 lockdep_assert_held(&mddev->lock); 2407 if (!mddev->in_sync) { 2408 mddev->sync_checkers++; 2409 spin_unlock(&mddev->lock); 2410 percpu_ref_switch_to_atomic_sync(&mddev->writes_pending); 2411 spin_lock(&mddev->lock); 2412 if (!mddev->in_sync && 2413 percpu_ref_is_zero(&mddev->writes_pending)) { 2414 mddev->in_sync = 1; 2415 /* 2416 * Ensure ->in_sync is visible before we clear 2417 * ->sync_checkers. 2418 */ 2419 smp_mb(); 2420 set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags); 2421 sysfs_notify_dirent_safe(mddev->sysfs_state); 2422 } 2423 if (--mddev->sync_checkers == 0) 2424 percpu_ref_switch_to_percpu(&mddev->writes_pending); 2425 } 2426 if (mddev->safemode == 1) 2427 mddev->safemode = 0; 2428 return mddev->in_sync; 2429 } 2430 2431 static void sync_sbs(struct mddev *mddev, int nospares) 2432 { 2433 /* Update each superblock (in-memory image), but 2434 * if we are allowed to, skip spares which already 2435 * have the right event counter, or have one earlier 2436 * (which would mean they aren't being marked as dirty 2437 * with the rest of the array) 2438 */ 2439 struct md_rdev *rdev; 2440 rdev_for_each(rdev, mddev) { 2441 if (rdev->sb_events == mddev->events || 2442 (nospares && 2443 rdev->raid_disk < 0 && 2444 rdev->sb_events+1 == mddev->events)) { 2445 /* Don't update this superblock */ 2446 rdev->sb_loaded = 2; 2447 } else { 2448 sync_super(mddev, rdev); 2449 rdev->sb_loaded = 1; 2450 } 2451 } 2452 } 2453 2454 static bool does_sb_need_changing(struct mddev *mddev) 2455 { 2456 struct md_rdev *rdev; 2457 struct mdp_superblock_1 *sb; 2458 int role; 2459 2460 /* Find a good rdev */ 2461 rdev_for_each(rdev, mddev) 2462 if ((rdev->raid_disk >= 0) && !test_bit(Faulty, &rdev->flags)) 2463 break; 2464 2465 /* No good device found. */ 2466 if (!rdev) 2467 return false; 2468 2469 sb = page_address(rdev->sb_page); 2470 /* Check if a device has become faulty or a spare become active */ 2471 rdev_for_each(rdev, mddev) { 2472 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]); 2473 /* Device activated? */ 2474 if (role == 0xffff && rdev->raid_disk >=0 && 2475 !test_bit(Faulty, &rdev->flags)) 2476 return true; 2477 /* Device turned faulty? */ 2478 if (test_bit(Faulty, &rdev->flags) && (role < 0xfffd)) 2479 return true; 2480 } 2481 2482 /* Check if any mddev parameters have changed */ 2483 if ((mddev->dev_sectors != le64_to_cpu(sb->size)) || 2484 (mddev->reshape_position != le64_to_cpu(sb->reshape_position)) || 2485 (mddev->layout != le32_to_cpu(sb->layout)) || 2486 (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) || 2487 (mddev->chunk_sectors != le32_to_cpu(sb->chunksize))) 2488 return true; 2489 2490 return false; 2491 } 2492 2493 void md_update_sb(struct mddev *mddev, int force_change) 2494 { 2495 struct md_rdev *rdev; 2496 int sync_req; 2497 int nospares = 0; 2498 int any_badblocks_changed = 0; 2499 int ret = -1; 2500 2501 if (mddev->ro) { 2502 if (force_change) 2503 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 2504 return; 2505 } 2506 2507 repeat: 2508 if (mddev_is_clustered(mddev)) { 2509 if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)) 2510 force_change = 1; 2511 if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags)) 2512 nospares = 1; 2513 ret = md_cluster_ops->metadata_update_start(mddev); 2514 /* Has someone else has updated the sb */ 2515 if (!does_sb_need_changing(mddev)) { 2516 if (ret == 0) 2517 md_cluster_ops->metadata_update_cancel(mddev); 2518 bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING), 2519 BIT(MD_SB_CHANGE_DEVS) | 2520 BIT(MD_SB_CHANGE_CLEAN)); 2521 return; 2522 } 2523 } 2524 2525 /* 2526 * First make sure individual recovery_offsets are correct 2527 * curr_resync_completed can only be used during recovery. 2528 * During reshape/resync it might use array-addresses rather 2529 * that device addresses. 2530 */ 2531 rdev_for_each(rdev, mddev) { 2532 if (rdev->raid_disk >= 0 && 2533 mddev->delta_disks >= 0 && 2534 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) && 2535 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery) && 2536 !test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 2537 !test_bit(Journal, &rdev->flags) && 2538 !test_bit(In_sync, &rdev->flags) && 2539 mddev->curr_resync_completed > rdev->recovery_offset) 2540 rdev->recovery_offset = mddev->curr_resync_completed; 2541 2542 } 2543 if (!mddev->persistent) { 2544 clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags); 2545 clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 2546 if (!mddev->external) { 2547 clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags); 2548 rdev_for_each(rdev, mddev) { 2549 if (rdev->badblocks.changed) { 2550 rdev->badblocks.changed = 0; 2551 ack_all_badblocks(&rdev->badblocks); 2552 md_error(mddev, rdev); 2553 } 2554 clear_bit(Blocked, &rdev->flags); 2555 clear_bit(BlockedBadBlocks, &rdev->flags); 2556 wake_up(&rdev->blocked_wait); 2557 } 2558 } 2559 wake_up(&mddev->sb_wait); 2560 return; 2561 } 2562 2563 spin_lock(&mddev->lock); 2564 2565 mddev->utime = ktime_get_real_seconds(); 2566 2567 if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)) 2568 force_change = 1; 2569 if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags)) 2570 /* just a clean<-> dirty transition, possibly leave spares alone, 2571 * though if events isn't the right even/odd, we will have to do 2572 * spares after all 2573 */ 2574 nospares = 1; 2575 if (force_change) 2576 nospares = 0; 2577 if (mddev->degraded) 2578 /* If the array is degraded, then skipping spares is both 2579 * dangerous and fairly pointless. 2580 * Dangerous because a device that was removed from the array 2581 * might have a event_count that still looks up-to-date, 2582 * so it can be re-added without a resync. 2583 * Pointless because if there are any spares to skip, 2584 * then a recovery will happen and soon that array won't 2585 * be degraded any more and the spare can go back to sleep then. 2586 */ 2587 nospares = 0; 2588 2589 sync_req = mddev->in_sync; 2590 2591 /* If this is just a dirty<->clean transition, and the array is clean 2592 * and 'events' is odd, we can roll back to the previous clean state */ 2593 if (nospares 2594 && (mddev->in_sync && mddev->recovery_cp == MaxSector) 2595 && mddev->can_decrease_events 2596 && mddev->events != 1) { 2597 mddev->events--; 2598 mddev->can_decrease_events = 0; 2599 } else { 2600 /* otherwise we have to go forward and ... */ 2601 mddev->events ++; 2602 mddev->can_decrease_events = nospares; 2603 } 2604 2605 /* 2606 * This 64-bit counter should never wrap. 2607 * Either we are in around ~1 trillion A.C., assuming 2608 * 1 reboot per second, or we have a bug... 2609 */ 2610 WARN_ON(mddev->events == 0); 2611 2612 rdev_for_each(rdev, mddev) { 2613 if (rdev->badblocks.changed) 2614 any_badblocks_changed++; 2615 if (test_bit(Faulty, &rdev->flags)) 2616 set_bit(FaultRecorded, &rdev->flags); 2617 } 2618 2619 sync_sbs(mddev, nospares); 2620 spin_unlock(&mddev->lock); 2621 2622 pr_debug("md: updating %s RAID superblock on device (in sync %d)\n", 2623 mdname(mddev), mddev->in_sync); 2624 2625 if (mddev->queue) 2626 blk_add_trace_msg(mddev->queue, "md md_update_sb"); 2627 rewrite: 2628 md_bitmap_update_sb(mddev->bitmap); 2629 rdev_for_each(rdev, mddev) { 2630 char b[BDEVNAME_SIZE]; 2631 2632 if (rdev->sb_loaded != 1) 2633 continue; /* no noise on spare devices */ 2634 2635 if (!test_bit(Faulty, &rdev->flags)) { 2636 md_super_write(mddev,rdev, 2637 rdev->sb_start, rdev->sb_size, 2638 rdev->sb_page); 2639 pr_debug("md: (write) %s's sb offset: %llu\n", 2640 bdevname(rdev->bdev, b), 2641 (unsigned long long)rdev->sb_start); 2642 rdev->sb_events = mddev->events; 2643 if (rdev->badblocks.size) { 2644 md_super_write(mddev, rdev, 2645 rdev->badblocks.sector, 2646 rdev->badblocks.size << 9, 2647 rdev->bb_page); 2648 rdev->badblocks.size = 0; 2649 } 2650 2651 } else 2652 pr_debug("md: %s (skipping faulty)\n", 2653 bdevname(rdev->bdev, b)); 2654 2655 if (mddev->level == LEVEL_MULTIPATH) 2656 /* only need to write one superblock... */ 2657 break; 2658 } 2659 if (md_super_wait(mddev) < 0) 2660 goto rewrite; 2661 /* if there was a failure, MD_SB_CHANGE_DEVS was set, and we re-write super */ 2662 2663 if (mddev_is_clustered(mddev) && ret == 0) 2664 md_cluster_ops->metadata_update_finish(mddev); 2665 2666 if (mddev->in_sync != sync_req || 2667 !bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING), 2668 BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_CLEAN))) 2669 /* have to write it out again */ 2670 goto repeat; 2671 wake_up(&mddev->sb_wait); 2672 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 2673 sysfs_notify(&mddev->kobj, NULL, "sync_completed"); 2674 2675 rdev_for_each(rdev, mddev) { 2676 if (test_and_clear_bit(FaultRecorded, &rdev->flags)) 2677 clear_bit(Blocked, &rdev->flags); 2678 2679 if (any_badblocks_changed) 2680 ack_all_badblocks(&rdev->badblocks); 2681 clear_bit(BlockedBadBlocks, &rdev->flags); 2682 wake_up(&rdev->blocked_wait); 2683 } 2684 } 2685 EXPORT_SYMBOL(md_update_sb); 2686 2687 static int add_bound_rdev(struct md_rdev *rdev) 2688 { 2689 struct mddev *mddev = rdev->mddev; 2690 int err = 0; 2691 bool add_journal = test_bit(Journal, &rdev->flags); 2692 2693 if (!mddev->pers->hot_remove_disk || add_journal) { 2694 /* If there is hot_add_disk but no hot_remove_disk 2695 * then added disks for geometry changes, 2696 * and should be added immediately. 2697 */ 2698 super_types[mddev->major_version]. 2699 validate_super(mddev, rdev); 2700 if (add_journal) 2701 mddev_suspend(mddev); 2702 err = mddev->pers->hot_add_disk(mddev, rdev); 2703 if (add_journal) 2704 mddev_resume(mddev); 2705 if (err) { 2706 md_kick_rdev_from_array(rdev); 2707 return err; 2708 } 2709 } 2710 sysfs_notify_dirent_safe(rdev->sysfs_state); 2711 2712 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 2713 if (mddev->degraded) 2714 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 2715 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 2716 md_new_event(mddev); 2717 md_wakeup_thread(mddev->thread); 2718 return 0; 2719 } 2720 2721 /* words written to sysfs files may, or may not, be \n terminated. 2722 * We want to accept with case. For this we use cmd_match. 2723 */ 2724 static int cmd_match(const char *cmd, const char *str) 2725 { 2726 /* See if cmd, written into a sysfs file, matches 2727 * str. They must either be the same, or cmd can 2728 * have a trailing newline 2729 */ 2730 while (*cmd && *str && *cmd == *str) { 2731 cmd++; 2732 str++; 2733 } 2734 if (*cmd == '\n') 2735 cmd++; 2736 if (*str || *cmd) 2737 return 0; 2738 return 1; 2739 } 2740 2741 struct rdev_sysfs_entry { 2742 struct attribute attr; 2743 ssize_t (*show)(struct md_rdev *, char *); 2744 ssize_t (*store)(struct md_rdev *, const char *, size_t); 2745 }; 2746 2747 static ssize_t 2748 state_show(struct md_rdev *rdev, char *page) 2749 { 2750 char *sep = ","; 2751 size_t len = 0; 2752 unsigned long flags = READ_ONCE(rdev->flags); 2753 2754 if (test_bit(Faulty, &flags) || 2755 (!test_bit(ExternalBbl, &flags) && 2756 rdev->badblocks.unacked_exist)) 2757 len += sprintf(page+len, "faulty%s", sep); 2758 if (test_bit(In_sync, &flags)) 2759 len += sprintf(page+len, "in_sync%s", sep); 2760 if (test_bit(Journal, &flags)) 2761 len += sprintf(page+len, "journal%s", sep); 2762 if (test_bit(WriteMostly, &flags)) 2763 len += sprintf(page+len, "write_mostly%s", sep); 2764 if (test_bit(Blocked, &flags) || 2765 (rdev->badblocks.unacked_exist 2766 && !test_bit(Faulty, &flags))) 2767 len += sprintf(page+len, "blocked%s", sep); 2768 if (!test_bit(Faulty, &flags) && 2769 !test_bit(Journal, &flags) && 2770 !test_bit(In_sync, &flags)) 2771 len += sprintf(page+len, "spare%s", sep); 2772 if (test_bit(WriteErrorSeen, &flags)) 2773 len += sprintf(page+len, "write_error%s", sep); 2774 if (test_bit(WantReplacement, &flags)) 2775 len += sprintf(page+len, "want_replacement%s", sep); 2776 if (test_bit(Replacement, &flags)) 2777 len += sprintf(page+len, "replacement%s", sep); 2778 if (test_bit(ExternalBbl, &flags)) 2779 len += sprintf(page+len, "external_bbl%s", sep); 2780 if (test_bit(FailFast, &flags)) 2781 len += sprintf(page+len, "failfast%s", sep); 2782 2783 if (len) 2784 len -= strlen(sep); 2785 2786 return len+sprintf(page+len, "\n"); 2787 } 2788 2789 static ssize_t 2790 state_store(struct md_rdev *rdev, const char *buf, size_t len) 2791 { 2792 /* can write 2793 * faulty - simulates an error 2794 * remove - disconnects the device 2795 * writemostly - sets write_mostly 2796 * -writemostly - clears write_mostly 2797 * blocked - sets the Blocked flags 2798 * -blocked - clears the Blocked and possibly simulates an error 2799 * insync - sets Insync providing device isn't active 2800 * -insync - clear Insync for a device with a slot assigned, 2801 * so that it gets rebuilt based on bitmap 2802 * write_error - sets WriteErrorSeen 2803 * -write_error - clears WriteErrorSeen 2804 * {,-}failfast - set/clear FailFast 2805 */ 2806 int err = -EINVAL; 2807 if (cmd_match(buf, "faulty") && rdev->mddev->pers) { 2808 md_error(rdev->mddev, rdev); 2809 if (test_bit(Faulty, &rdev->flags)) 2810 err = 0; 2811 else 2812 err = -EBUSY; 2813 } else if (cmd_match(buf, "remove")) { 2814 if (rdev->mddev->pers) { 2815 clear_bit(Blocked, &rdev->flags); 2816 remove_and_add_spares(rdev->mddev, rdev); 2817 } 2818 if (rdev->raid_disk >= 0) 2819 err = -EBUSY; 2820 else { 2821 struct mddev *mddev = rdev->mddev; 2822 err = 0; 2823 if (mddev_is_clustered(mddev)) 2824 err = md_cluster_ops->remove_disk(mddev, rdev); 2825 2826 if (err == 0) { 2827 md_kick_rdev_from_array(rdev); 2828 if (mddev->pers) { 2829 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 2830 md_wakeup_thread(mddev->thread); 2831 } 2832 md_new_event(mddev); 2833 } 2834 } 2835 } else if (cmd_match(buf, "writemostly")) { 2836 set_bit(WriteMostly, &rdev->flags); 2837 mddev_create_wb_pool(rdev->mddev, rdev, false); 2838 err = 0; 2839 } else if (cmd_match(buf, "-writemostly")) { 2840 mddev_destroy_wb_pool(rdev->mddev, rdev); 2841 clear_bit(WriteMostly, &rdev->flags); 2842 err = 0; 2843 } else if (cmd_match(buf, "blocked")) { 2844 set_bit(Blocked, &rdev->flags); 2845 err = 0; 2846 } else if (cmd_match(buf, "-blocked")) { 2847 if (!test_bit(Faulty, &rdev->flags) && 2848 !test_bit(ExternalBbl, &rdev->flags) && 2849 rdev->badblocks.unacked_exist) { 2850 /* metadata handler doesn't understand badblocks, 2851 * so we need to fail the device 2852 */ 2853 md_error(rdev->mddev, rdev); 2854 } 2855 clear_bit(Blocked, &rdev->flags); 2856 clear_bit(BlockedBadBlocks, &rdev->flags); 2857 wake_up(&rdev->blocked_wait); 2858 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery); 2859 md_wakeup_thread(rdev->mddev->thread); 2860 2861 err = 0; 2862 } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) { 2863 set_bit(In_sync, &rdev->flags); 2864 err = 0; 2865 } else if (cmd_match(buf, "failfast")) { 2866 set_bit(FailFast, &rdev->flags); 2867 err = 0; 2868 } else if (cmd_match(buf, "-failfast")) { 2869 clear_bit(FailFast, &rdev->flags); 2870 err = 0; 2871 } else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0 && 2872 !test_bit(Journal, &rdev->flags)) { 2873 if (rdev->mddev->pers == NULL) { 2874 clear_bit(In_sync, &rdev->flags); 2875 rdev->saved_raid_disk = rdev->raid_disk; 2876 rdev->raid_disk = -1; 2877 err = 0; 2878 } 2879 } else if (cmd_match(buf, "write_error")) { 2880 set_bit(WriteErrorSeen, &rdev->flags); 2881 err = 0; 2882 } else if (cmd_match(buf, "-write_error")) { 2883 clear_bit(WriteErrorSeen, &rdev->flags); 2884 err = 0; 2885 } else if (cmd_match(buf, "want_replacement")) { 2886 /* Any non-spare device that is not a replacement can 2887 * become want_replacement at any time, but we then need to 2888 * check if recovery is needed. 2889 */ 2890 if (rdev->raid_disk >= 0 && 2891 !test_bit(Journal, &rdev->flags) && 2892 !test_bit(Replacement, &rdev->flags)) 2893 set_bit(WantReplacement, &rdev->flags); 2894 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery); 2895 md_wakeup_thread(rdev->mddev->thread); 2896 err = 0; 2897 } else if (cmd_match(buf, "-want_replacement")) { 2898 /* Clearing 'want_replacement' is always allowed. 2899 * Once replacements starts it is too late though. 2900 */ 2901 err = 0; 2902 clear_bit(WantReplacement, &rdev->flags); 2903 } else if (cmd_match(buf, "replacement")) { 2904 /* Can only set a device as a replacement when array has not 2905 * yet been started. Once running, replacement is automatic 2906 * from spares, or by assigning 'slot'. 2907 */ 2908 if (rdev->mddev->pers) 2909 err = -EBUSY; 2910 else { 2911 set_bit(Replacement, &rdev->flags); 2912 err = 0; 2913 } 2914 } else if (cmd_match(buf, "-replacement")) { 2915 /* Similarly, can only clear Replacement before start */ 2916 if (rdev->mddev->pers) 2917 err = -EBUSY; 2918 else { 2919 clear_bit(Replacement, &rdev->flags); 2920 err = 0; 2921 } 2922 } else if (cmd_match(buf, "re-add")) { 2923 if (!rdev->mddev->pers) 2924 err = -EINVAL; 2925 else if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1) && 2926 rdev->saved_raid_disk >= 0) { 2927 /* clear_bit is performed _after_ all the devices 2928 * have their local Faulty bit cleared. If any writes 2929 * happen in the meantime in the local node, they 2930 * will land in the local bitmap, which will be synced 2931 * by this node eventually 2932 */ 2933 if (!mddev_is_clustered(rdev->mddev) || 2934 (err = md_cluster_ops->gather_bitmaps(rdev)) == 0) { 2935 clear_bit(Faulty, &rdev->flags); 2936 err = add_bound_rdev(rdev); 2937 } 2938 } else 2939 err = -EBUSY; 2940 } else if (cmd_match(buf, "external_bbl") && (rdev->mddev->external)) { 2941 set_bit(ExternalBbl, &rdev->flags); 2942 rdev->badblocks.shift = 0; 2943 err = 0; 2944 } else if (cmd_match(buf, "-external_bbl") && (rdev->mddev->external)) { 2945 clear_bit(ExternalBbl, &rdev->flags); 2946 err = 0; 2947 } 2948 if (!err) 2949 sysfs_notify_dirent_safe(rdev->sysfs_state); 2950 return err ? err : len; 2951 } 2952 static struct rdev_sysfs_entry rdev_state = 2953 __ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store); 2954 2955 static ssize_t 2956 errors_show(struct md_rdev *rdev, char *page) 2957 { 2958 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors)); 2959 } 2960 2961 static ssize_t 2962 errors_store(struct md_rdev *rdev, const char *buf, size_t len) 2963 { 2964 unsigned int n; 2965 int rv; 2966 2967 rv = kstrtouint(buf, 10, &n); 2968 if (rv < 0) 2969 return rv; 2970 atomic_set(&rdev->corrected_errors, n); 2971 return len; 2972 } 2973 static struct rdev_sysfs_entry rdev_errors = 2974 __ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store); 2975 2976 static ssize_t 2977 slot_show(struct md_rdev *rdev, char *page) 2978 { 2979 if (test_bit(Journal, &rdev->flags)) 2980 return sprintf(page, "journal\n"); 2981 else if (rdev->raid_disk < 0) 2982 return sprintf(page, "none\n"); 2983 else 2984 return sprintf(page, "%d\n", rdev->raid_disk); 2985 } 2986 2987 static ssize_t 2988 slot_store(struct md_rdev *rdev, const char *buf, size_t len) 2989 { 2990 int slot; 2991 int err; 2992 2993 if (test_bit(Journal, &rdev->flags)) 2994 return -EBUSY; 2995 if (strncmp(buf, "none", 4)==0) 2996 slot = -1; 2997 else { 2998 err = kstrtouint(buf, 10, (unsigned int *)&slot); 2999 if (err < 0) 3000 return err; 3001 } 3002 if (rdev->mddev->pers && slot == -1) { 3003 /* Setting 'slot' on an active array requires also 3004 * updating the 'rd%d' link, and communicating 3005 * with the personality with ->hot_*_disk. 3006 * For now we only support removing 3007 * failed/spare devices. This normally happens automatically, 3008 * but not when the metadata is externally managed. 3009 */ 3010 if (rdev->raid_disk == -1) 3011 return -EEXIST; 3012 /* personality does all needed checks */ 3013 if (rdev->mddev->pers->hot_remove_disk == NULL) 3014 return -EINVAL; 3015 clear_bit(Blocked, &rdev->flags); 3016 remove_and_add_spares(rdev->mddev, rdev); 3017 if (rdev->raid_disk >= 0) 3018 return -EBUSY; 3019 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery); 3020 md_wakeup_thread(rdev->mddev->thread); 3021 } else if (rdev->mddev->pers) { 3022 /* Activating a spare .. or possibly reactivating 3023 * if we ever get bitmaps working here. 3024 */ 3025 int err; 3026 3027 if (rdev->raid_disk != -1) 3028 return -EBUSY; 3029 3030 if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery)) 3031 return -EBUSY; 3032 3033 if (rdev->mddev->pers->hot_add_disk == NULL) 3034 return -EINVAL; 3035 3036 if (slot >= rdev->mddev->raid_disks && 3037 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks) 3038 return -ENOSPC; 3039 3040 rdev->raid_disk = slot; 3041 if (test_bit(In_sync, &rdev->flags)) 3042 rdev->saved_raid_disk = slot; 3043 else 3044 rdev->saved_raid_disk = -1; 3045 clear_bit(In_sync, &rdev->flags); 3046 clear_bit(Bitmap_sync, &rdev->flags); 3047 err = rdev->mddev->pers-> 3048 hot_add_disk(rdev->mddev, rdev); 3049 if (err) { 3050 rdev->raid_disk = -1; 3051 return err; 3052 } else 3053 sysfs_notify_dirent_safe(rdev->sysfs_state); 3054 if (sysfs_link_rdev(rdev->mddev, rdev)) 3055 /* failure here is OK */; 3056 /* don't wakeup anyone, leave that to userspace. */ 3057 } else { 3058 if (slot >= rdev->mddev->raid_disks && 3059 slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks) 3060 return -ENOSPC; 3061 rdev->raid_disk = slot; 3062 /* assume it is working */ 3063 clear_bit(Faulty, &rdev->flags); 3064 clear_bit(WriteMostly, &rdev->flags); 3065 set_bit(In_sync, &rdev->flags); 3066 sysfs_notify_dirent_safe(rdev->sysfs_state); 3067 } 3068 return len; 3069 } 3070 3071 static struct rdev_sysfs_entry rdev_slot = 3072 __ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store); 3073 3074 static ssize_t 3075 offset_show(struct md_rdev *rdev, char *page) 3076 { 3077 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset); 3078 } 3079 3080 static ssize_t 3081 offset_store(struct md_rdev *rdev, const char *buf, size_t len) 3082 { 3083 unsigned long long offset; 3084 if (kstrtoull(buf, 10, &offset) < 0) 3085 return -EINVAL; 3086 if (rdev->mddev->pers && rdev->raid_disk >= 0) 3087 return -EBUSY; 3088 if (rdev->sectors && rdev->mddev->external) 3089 /* Must set offset before size, so overlap checks 3090 * can be sane */ 3091 return -EBUSY; 3092 rdev->data_offset = offset; 3093 rdev->new_data_offset = offset; 3094 return len; 3095 } 3096 3097 static struct rdev_sysfs_entry rdev_offset = 3098 __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store); 3099 3100 static ssize_t new_offset_show(struct md_rdev *rdev, char *page) 3101 { 3102 return sprintf(page, "%llu\n", 3103 (unsigned long long)rdev->new_data_offset); 3104 } 3105 3106 static ssize_t new_offset_store(struct md_rdev *rdev, 3107 const char *buf, size_t len) 3108 { 3109 unsigned long long new_offset; 3110 struct mddev *mddev = rdev->mddev; 3111 3112 if (kstrtoull(buf, 10, &new_offset) < 0) 3113 return -EINVAL; 3114 3115 if (mddev->sync_thread || 3116 test_bit(MD_RECOVERY_RUNNING,&mddev->recovery)) 3117 return -EBUSY; 3118 if (new_offset == rdev->data_offset) 3119 /* reset is always permitted */ 3120 ; 3121 else if (new_offset > rdev->data_offset) { 3122 /* must not push array size beyond rdev_sectors */ 3123 if (new_offset - rdev->data_offset 3124 + mddev->dev_sectors > rdev->sectors) 3125 return -E2BIG; 3126 } 3127 /* Metadata worries about other space details. */ 3128 3129 /* decreasing the offset is inconsistent with a backwards 3130 * reshape. 3131 */ 3132 if (new_offset < rdev->data_offset && 3133 mddev->reshape_backwards) 3134 return -EINVAL; 3135 /* Increasing offset is inconsistent with forwards 3136 * reshape. reshape_direction should be set to 3137 * 'backwards' first. 3138 */ 3139 if (new_offset > rdev->data_offset && 3140 !mddev->reshape_backwards) 3141 return -EINVAL; 3142 3143 if (mddev->pers && mddev->persistent && 3144 !super_types[mddev->major_version] 3145 .allow_new_offset(rdev, new_offset)) 3146 return -E2BIG; 3147 rdev->new_data_offset = new_offset; 3148 if (new_offset > rdev->data_offset) 3149 mddev->reshape_backwards = 1; 3150 else if (new_offset < rdev->data_offset) 3151 mddev->reshape_backwards = 0; 3152 3153 return len; 3154 } 3155 static struct rdev_sysfs_entry rdev_new_offset = 3156 __ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store); 3157 3158 static ssize_t 3159 rdev_size_show(struct md_rdev *rdev, char *page) 3160 { 3161 return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2); 3162 } 3163 3164 static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2) 3165 { 3166 /* check if two start/length pairs overlap */ 3167 if (s1+l1 <= s2) 3168 return 0; 3169 if (s2+l2 <= s1) 3170 return 0; 3171 return 1; 3172 } 3173 3174 static int strict_blocks_to_sectors(const char *buf, sector_t *sectors) 3175 { 3176 unsigned long long blocks; 3177 sector_t new; 3178 3179 if (kstrtoull(buf, 10, &blocks) < 0) 3180 return -EINVAL; 3181 3182 if (blocks & 1ULL << (8 * sizeof(blocks) - 1)) 3183 return -EINVAL; /* sector conversion overflow */ 3184 3185 new = blocks * 2; 3186 if (new != blocks * 2) 3187 return -EINVAL; /* unsigned long long to sector_t overflow */ 3188 3189 *sectors = new; 3190 return 0; 3191 } 3192 3193 static ssize_t 3194 rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len) 3195 { 3196 struct mddev *my_mddev = rdev->mddev; 3197 sector_t oldsectors = rdev->sectors; 3198 sector_t sectors; 3199 3200 if (test_bit(Journal, &rdev->flags)) 3201 return -EBUSY; 3202 if (strict_blocks_to_sectors(buf, §ors) < 0) 3203 return -EINVAL; 3204 if (rdev->data_offset != rdev->new_data_offset) 3205 return -EINVAL; /* too confusing */ 3206 if (my_mddev->pers && rdev->raid_disk >= 0) { 3207 if (my_mddev->persistent) { 3208 sectors = super_types[my_mddev->major_version]. 3209 rdev_size_change(rdev, sectors); 3210 if (!sectors) 3211 return -EBUSY; 3212 } else if (!sectors) 3213 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) - 3214 rdev->data_offset; 3215 if (!my_mddev->pers->resize) 3216 /* Cannot change size for RAID0 or Linear etc */ 3217 return -EINVAL; 3218 } 3219 if (sectors < my_mddev->dev_sectors) 3220 return -EINVAL; /* component must fit device */ 3221 3222 rdev->sectors = sectors; 3223 if (sectors > oldsectors && my_mddev->external) { 3224 /* Need to check that all other rdevs with the same 3225 * ->bdev do not overlap. 'rcu' is sufficient to walk 3226 * the rdev lists safely. 3227 * This check does not provide a hard guarantee, it 3228 * just helps avoid dangerous mistakes. 3229 */ 3230 struct mddev *mddev; 3231 int overlap = 0; 3232 struct list_head *tmp; 3233 3234 rcu_read_lock(); 3235 for_each_mddev(mddev, tmp) { 3236 struct md_rdev *rdev2; 3237 3238 rdev_for_each(rdev2, mddev) 3239 if (rdev->bdev == rdev2->bdev && 3240 rdev != rdev2 && 3241 overlaps(rdev->data_offset, rdev->sectors, 3242 rdev2->data_offset, 3243 rdev2->sectors)) { 3244 overlap = 1; 3245 break; 3246 } 3247 if (overlap) { 3248 mddev_put(mddev); 3249 break; 3250 } 3251 } 3252 rcu_read_unlock(); 3253 if (overlap) { 3254 /* Someone else could have slipped in a size 3255 * change here, but doing so is just silly. 3256 * We put oldsectors back because we *know* it is 3257 * safe, and trust userspace not to race with 3258 * itself 3259 */ 3260 rdev->sectors = oldsectors; 3261 return -EBUSY; 3262 } 3263 } 3264 return len; 3265 } 3266 3267 static struct rdev_sysfs_entry rdev_size = 3268 __ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store); 3269 3270 static ssize_t recovery_start_show(struct md_rdev *rdev, char *page) 3271 { 3272 unsigned long long recovery_start = rdev->recovery_offset; 3273 3274 if (test_bit(In_sync, &rdev->flags) || 3275 recovery_start == MaxSector) 3276 return sprintf(page, "none\n"); 3277 3278 return sprintf(page, "%llu\n", recovery_start); 3279 } 3280 3281 static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len) 3282 { 3283 unsigned long long recovery_start; 3284 3285 if (cmd_match(buf, "none")) 3286 recovery_start = MaxSector; 3287 else if (kstrtoull(buf, 10, &recovery_start)) 3288 return -EINVAL; 3289 3290 if (rdev->mddev->pers && 3291 rdev->raid_disk >= 0) 3292 return -EBUSY; 3293 3294 rdev->recovery_offset = recovery_start; 3295 if (recovery_start == MaxSector) 3296 set_bit(In_sync, &rdev->flags); 3297 else 3298 clear_bit(In_sync, &rdev->flags); 3299 return len; 3300 } 3301 3302 static struct rdev_sysfs_entry rdev_recovery_start = 3303 __ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store); 3304 3305 /* sysfs access to bad-blocks list. 3306 * We present two files. 3307 * 'bad-blocks' lists sector numbers and lengths of ranges that 3308 * are recorded as bad. The list is truncated to fit within 3309 * the one-page limit of sysfs. 3310 * Writing "sector length" to this file adds an acknowledged 3311 * bad block list. 3312 * 'unacknowledged-bad-blocks' lists bad blocks that have not yet 3313 * been acknowledged. Writing to this file adds bad blocks 3314 * without acknowledging them. This is largely for testing. 3315 */ 3316 static ssize_t bb_show(struct md_rdev *rdev, char *page) 3317 { 3318 return badblocks_show(&rdev->badblocks, page, 0); 3319 } 3320 static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len) 3321 { 3322 int rv = badblocks_store(&rdev->badblocks, page, len, 0); 3323 /* Maybe that ack was all we needed */ 3324 if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags)) 3325 wake_up(&rdev->blocked_wait); 3326 return rv; 3327 } 3328 static struct rdev_sysfs_entry rdev_bad_blocks = 3329 __ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store); 3330 3331 static ssize_t ubb_show(struct md_rdev *rdev, char *page) 3332 { 3333 return badblocks_show(&rdev->badblocks, page, 1); 3334 } 3335 static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len) 3336 { 3337 return badblocks_store(&rdev->badblocks, page, len, 1); 3338 } 3339 static struct rdev_sysfs_entry rdev_unack_bad_blocks = 3340 __ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store); 3341 3342 static ssize_t 3343 ppl_sector_show(struct md_rdev *rdev, char *page) 3344 { 3345 return sprintf(page, "%llu\n", (unsigned long long)rdev->ppl.sector); 3346 } 3347 3348 static ssize_t 3349 ppl_sector_store(struct md_rdev *rdev, const char *buf, size_t len) 3350 { 3351 unsigned long long sector; 3352 3353 if (kstrtoull(buf, 10, §or) < 0) 3354 return -EINVAL; 3355 if (sector != (sector_t)sector) 3356 return -EINVAL; 3357 3358 if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) && 3359 rdev->raid_disk >= 0) 3360 return -EBUSY; 3361 3362 if (rdev->mddev->persistent) { 3363 if (rdev->mddev->major_version == 0) 3364 return -EINVAL; 3365 if ((sector > rdev->sb_start && 3366 sector - rdev->sb_start > S16_MAX) || 3367 (sector < rdev->sb_start && 3368 rdev->sb_start - sector > -S16_MIN)) 3369 return -EINVAL; 3370 rdev->ppl.offset = sector - rdev->sb_start; 3371 } else if (!rdev->mddev->external) { 3372 return -EBUSY; 3373 } 3374 rdev->ppl.sector = sector; 3375 return len; 3376 } 3377 3378 static struct rdev_sysfs_entry rdev_ppl_sector = 3379 __ATTR(ppl_sector, S_IRUGO|S_IWUSR, ppl_sector_show, ppl_sector_store); 3380 3381 static ssize_t 3382 ppl_size_show(struct md_rdev *rdev, char *page) 3383 { 3384 return sprintf(page, "%u\n", rdev->ppl.size); 3385 } 3386 3387 static ssize_t 3388 ppl_size_store(struct md_rdev *rdev, const char *buf, size_t len) 3389 { 3390 unsigned int size; 3391 3392 if (kstrtouint(buf, 10, &size) < 0) 3393 return -EINVAL; 3394 3395 if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) && 3396 rdev->raid_disk >= 0) 3397 return -EBUSY; 3398 3399 if (rdev->mddev->persistent) { 3400 if (rdev->mddev->major_version == 0) 3401 return -EINVAL; 3402 if (size > U16_MAX) 3403 return -EINVAL; 3404 } else if (!rdev->mddev->external) { 3405 return -EBUSY; 3406 } 3407 rdev->ppl.size = size; 3408 return len; 3409 } 3410 3411 static struct rdev_sysfs_entry rdev_ppl_size = 3412 __ATTR(ppl_size, S_IRUGO|S_IWUSR, ppl_size_show, ppl_size_store); 3413 3414 static struct attribute *rdev_default_attrs[] = { 3415 &rdev_state.attr, 3416 &rdev_errors.attr, 3417 &rdev_slot.attr, 3418 &rdev_offset.attr, 3419 &rdev_new_offset.attr, 3420 &rdev_size.attr, 3421 &rdev_recovery_start.attr, 3422 &rdev_bad_blocks.attr, 3423 &rdev_unack_bad_blocks.attr, 3424 &rdev_ppl_sector.attr, 3425 &rdev_ppl_size.attr, 3426 NULL, 3427 }; 3428 static ssize_t 3429 rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page) 3430 { 3431 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr); 3432 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj); 3433 3434 if (!entry->show) 3435 return -EIO; 3436 if (!rdev->mddev) 3437 return -ENODEV; 3438 return entry->show(rdev, page); 3439 } 3440 3441 static ssize_t 3442 rdev_attr_store(struct kobject *kobj, struct attribute *attr, 3443 const char *page, size_t length) 3444 { 3445 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr); 3446 struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj); 3447 ssize_t rv; 3448 struct mddev *mddev = rdev->mddev; 3449 3450 if (!entry->store) 3451 return -EIO; 3452 if (!capable(CAP_SYS_ADMIN)) 3453 return -EACCES; 3454 rv = mddev ? mddev_lock(mddev) : -ENODEV; 3455 if (!rv) { 3456 if (rdev->mddev == NULL) 3457 rv = -ENODEV; 3458 else 3459 rv = entry->store(rdev, page, length); 3460 mddev_unlock(mddev); 3461 } 3462 return rv; 3463 } 3464 3465 static void rdev_free(struct kobject *ko) 3466 { 3467 struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj); 3468 kfree(rdev); 3469 } 3470 static const struct sysfs_ops rdev_sysfs_ops = { 3471 .show = rdev_attr_show, 3472 .store = rdev_attr_store, 3473 }; 3474 static struct kobj_type rdev_ktype = { 3475 .release = rdev_free, 3476 .sysfs_ops = &rdev_sysfs_ops, 3477 .default_attrs = rdev_default_attrs, 3478 }; 3479 3480 int md_rdev_init(struct md_rdev *rdev) 3481 { 3482 rdev->desc_nr = -1; 3483 rdev->saved_raid_disk = -1; 3484 rdev->raid_disk = -1; 3485 rdev->flags = 0; 3486 rdev->data_offset = 0; 3487 rdev->new_data_offset = 0; 3488 rdev->sb_events = 0; 3489 rdev->last_read_error = 0; 3490 rdev->sb_loaded = 0; 3491 rdev->bb_page = NULL; 3492 atomic_set(&rdev->nr_pending, 0); 3493 atomic_set(&rdev->read_errors, 0); 3494 atomic_set(&rdev->corrected_errors, 0); 3495 3496 INIT_LIST_HEAD(&rdev->same_set); 3497 init_waitqueue_head(&rdev->blocked_wait); 3498 3499 /* Add space to store bad block list. 3500 * This reserves the space even on arrays where it cannot 3501 * be used - I wonder if that matters 3502 */ 3503 return badblocks_init(&rdev->badblocks, 0); 3504 } 3505 EXPORT_SYMBOL_GPL(md_rdev_init); 3506 /* 3507 * Import a device. If 'super_format' >= 0, then sanity check the superblock 3508 * 3509 * mark the device faulty if: 3510 * 3511 * - the device is nonexistent (zero size) 3512 * - the device has no valid superblock 3513 * 3514 * a faulty rdev _never_ has rdev->sb set. 3515 */ 3516 static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor) 3517 { 3518 char b[BDEVNAME_SIZE]; 3519 int err; 3520 struct md_rdev *rdev; 3521 sector_t size; 3522 3523 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL); 3524 if (!rdev) 3525 return ERR_PTR(-ENOMEM); 3526 3527 err = md_rdev_init(rdev); 3528 if (err) 3529 goto abort_free; 3530 err = alloc_disk_sb(rdev); 3531 if (err) 3532 goto abort_free; 3533 3534 err = lock_rdev(rdev, newdev, super_format == -2); 3535 if (err) 3536 goto abort_free; 3537 3538 kobject_init(&rdev->kobj, &rdev_ktype); 3539 3540 size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS; 3541 if (!size) { 3542 pr_warn("md: %s has zero or unknown size, marking faulty!\n", 3543 bdevname(rdev->bdev,b)); 3544 err = -EINVAL; 3545 goto abort_free; 3546 } 3547 3548 if (super_format >= 0) { 3549 err = super_types[super_format]. 3550 load_super(rdev, NULL, super_minor); 3551 if (err == -EINVAL) { 3552 pr_warn("md: %s does not have a valid v%d.%d superblock, not importing!\n", 3553 bdevname(rdev->bdev,b), 3554 super_format, super_minor); 3555 goto abort_free; 3556 } 3557 if (err < 0) { 3558 pr_warn("md: could not read %s's sb, not importing!\n", 3559 bdevname(rdev->bdev,b)); 3560 goto abort_free; 3561 } 3562 } 3563 3564 return rdev; 3565 3566 abort_free: 3567 if (rdev->bdev) 3568 unlock_rdev(rdev); 3569 md_rdev_clear(rdev); 3570 kfree(rdev); 3571 return ERR_PTR(err); 3572 } 3573 3574 /* 3575 * Check a full RAID array for plausibility 3576 */ 3577 3578 static void analyze_sbs(struct mddev *mddev) 3579 { 3580 int i; 3581 struct md_rdev *rdev, *freshest, *tmp; 3582 char b[BDEVNAME_SIZE]; 3583 3584 freshest = NULL; 3585 rdev_for_each_safe(rdev, tmp, mddev) 3586 switch (super_types[mddev->major_version]. 3587 load_super(rdev, freshest, mddev->minor_version)) { 3588 case 1: 3589 freshest = rdev; 3590 break; 3591 case 0: 3592 break; 3593 default: 3594 pr_warn("md: fatal superblock inconsistency in %s -- removing from array\n", 3595 bdevname(rdev->bdev,b)); 3596 md_kick_rdev_from_array(rdev); 3597 } 3598 3599 super_types[mddev->major_version]. 3600 validate_super(mddev, freshest); 3601 3602 i = 0; 3603 rdev_for_each_safe(rdev, tmp, mddev) { 3604 if (mddev->max_disks && 3605 (rdev->desc_nr >= mddev->max_disks || 3606 i > mddev->max_disks)) { 3607 pr_warn("md: %s: %s: only %d devices permitted\n", 3608 mdname(mddev), bdevname(rdev->bdev, b), 3609 mddev->max_disks); 3610 md_kick_rdev_from_array(rdev); 3611 continue; 3612 } 3613 if (rdev != freshest) { 3614 if (super_types[mddev->major_version]. 3615 validate_super(mddev, rdev)) { 3616 pr_warn("md: kicking non-fresh %s from array!\n", 3617 bdevname(rdev->bdev,b)); 3618 md_kick_rdev_from_array(rdev); 3619 continue; 3620 } 3621 } 3622 if (mddev->level == LEVEL_MULTIPATH) { 3623 rdev->desc_nr = i++; 3624 rdev->raid_disk = rdev->desc_nr; 3625 set_bit(In_sync, &rdev->flags); 3626 } else if (rdev->raid_disk >= 3627 (mddev->raid_disks - min(0, mddev->delta_disks)) && 3628 !test_bit(Journal, &rdev->flags)) { 3629 rdev->raid_disk = -1; 3630 clear_bit(In_sync, &rdev->flags); 3631 } 3632 } 3633 } 3634 3635 /* Read a fixed-point number. 3636 * Numbers in sysfs attributes should be in "standard" units where 3637 * possible, so time should be in seconds. 3638 * However we internally use a a much smaller unit such as 3639 * milliseconds or jiffies. 3640 * This function takes a decimal number with a possible fractional 3641 * component, and produces an integer which is the result of 3642 * multiplying that number by 10^'scale'. 3643 * all without any floating-point arithmetic. 3644 */ 3645 int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale) 3646 { 3647 unsigned long result = 0; 3648 long decimals = -1; 3649 while (isdigit(*cp) || (*cp == '.' && decimals < 0)) { 3650 if (*cp == '.') 3651 decimals = 0; 3652 else if (decimals < scale) { 3653 unsigned int value; 3654 value = *cp - '0'; 3655 result = result * 10 + value; 3656 if (decimals >= 0) 3657 decimals++; 3658 } 3659 cp++; 3660 } 3661 if (*cp == '\n') 3662 cp++; 3663 if (*cp) 3664 return -EINVAL; 3665 if (decimals < 0) 3666 decimals = 0; 3667 while (decimals < scale) { 3668 result *= 10; 3669 decimals ++; 3670 } 3671 *res = result; 3672 return 0; 3673 } 3674 3675 static ssize_t 3676 safe_delay_show(struct mddev *mddev, char *page) 3677 { 3678 int msec = (mddev->safemode_delay*1000)/HZ; 3679 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000); 3680 } 3681 static ssize_t 3682 safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len) 3683 { 3684 unsigned long msec; 3685 3686 if (mddev_is_clustered(mddev)) { 3687 pr_warn("md: Safemode is disabled for clustered mode\n"); 3688 return -EINVAL; 3689 } 3690 3691 if (strict_strtoul_scaled(cbuf, &msec, 3) < 0) 3692 return -EINVAL; 3693 if (msec == 0) 3694 mddev->safemode_delay = 0; 3695 else { 3696 unsigned long old_delay = mddev->safemode_delay; 3697 unsigned long new_delay = (msec*HZ)/1000; 3698 3699 if (new_delay == 0) 3700 new_delay = 1; 3701 mddev->safemode_delay = new_delay; 3702 if (new_delay < old_delay || old_delay == 0) 3703 mod_timer(&mddev->safemode_timer, jiffies+1); 3704 } 3705 return len; 3706 } 3707 static struct md_sysfs_entry md_safe_delay = 3708 __ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store); 3709 3710 static ssize_t 3711 level_show(struct mddev *mddev, char *page) 3712 { 3713 struct md_personality *p; 3714 int ret; 3715 spin_lock(&mddev->lock); 3716 p = mddev->pers; 3717 if (p) 3718 ret = sprintf(page, "%s\n", p->name); 3719 else if (mddev->clevel[0]) 3720 ret = sprintf(page, "%s\n", mddev->clevel); 3721 else if (mddev->level != LEVEL_NONE) 3722 ret = sprintf(page, "%d\n", mddev->level); 3723 else 3724 ret = 0; 3725 spin_unlock(&mddev->lock); 3726 return ret; 3727 } 3728 3729 static ssize_t 3730 level_store(struct mddev *mddev, const char *buf, size_t len) 3731 { 3732 char clevel[16]; 3733 ssize_t rv; 3734 size_t slen = len; 3735 struct md_personality *pers, *oldpers; 3736 long level; 3737 void *priv, *oldpriv; 3738 struct md_rdev *rdev; 3739 3740 if (slen == 0 || slen >= sizeof(clevel)) 3741 return -EINVAL; 3742 3743 rv = mddev_lock(mddev); 3744 if (rv) 3745 return rv; 3746 3747 if (mddev->pers == NULL) { 3748 strncpy(mddev->clevel, buf, slen); 3749 if (mddev->clevel[slen-1] == '\n') 3750 slen--; 3751 mddev->clevel[slen] = 0; 3752 mddev->level = LEVEL_NONE; 3753 rv = len; 3754 goto out_unlock; 3755 } 3756 rv = -EROFS; 3757 if (mddev->ro) 3758 goto out_unlock; 3759 3760 /* request to change the personality. Need to ensure: 3761 * - array is not engaged in resync/recovery/reshape 3762 * - old personality can be suspended 3763 * - new personality will access other array. 3764 */ 3765 3766 rv = -EBUSY; 3767 if (mddev->sync_thread || 3768 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) || 3769 mddev->reshape_position != MaxSector || 3770 mddev->sysfs_active) 3771 goto out_unlock; 3772 3773 rv = -EINVAL; 3774 if (!mddev->pers->quiesce) { 3775 pr_warn("md: %s: %s does not support online personality change\n", 3776 mdname(mddev), mddev->pers->name); 3777 goto out_unlock; 3778 } 3779 3780 /* Now find the new personality */ 3781 strncpy(clevel, buf, slen); 3782 if (clevel[slen-1] == '\n') 3783 slen--; 3784 clevel[slen] = 0; 3785 if (kstrtol(clevel, 10, &level)) 3786 level = LEVEL_NONE; 3787 3788 if (request_module("md-%s", clevel) != 0) 3789 request_module("md-level-%s", clevel); 3790 spin_lock(&pers_lock); 3791 pers = find_pers(level, clevel); 3792 if (!pers || !try_module_get(pers->owner)) { 3793 spin_unlock(&pers_lock); 3794 pr_warn("md: personality %s not loaded\n", clevel); 3795 rv = -EINVAL; 3796 goto out_unlock; 3797 } 3798 spin_unlock(&pers_lock); 3799 3800 if (pers == mddev->pers) { 3801 /* Nothing to do! */ 3802 module_put(pers->owner); 3803 rv = len; 3804 goto out_unlock; 3805 } 3806 if (!pers->takeover) { 3807 module_put(pers->owner); 3808 pr_warn("md: %s: %s does not support personality takeover\n", 3809 mdname(mddev), clevel); 3810 rv = -EINVAL; 3811 goto out_unlock; 3812 } 3813 3814 rdev_for_each(rdev, mddev) 3815 rdev->new_raid_disk = rdev->raid_disk; 3816 3817 /* ->takeover must set new_* and/or delta_disks 3818 * if it succeeds, and may set them when it fails. 3819 */ 3820 priv = pers->takeover(mddev); 3821 if (IS_ERR(priv)) { 3822 mddev->new_level = mddev->level; 3823 mddev->new_layout = mddev->layout; 3824 mddev->new_chunk_sectors = mddev->chunk_sectors; 3825 mddev->raid_disks -= mddev->delta_disks; 3826 mddev->delta_disks = 0; 3827 mddev->reshape_backwards = 0; 3828 module_put(pers->owner); 3829 pr_warn("md: %s: %s would not accept array\n", 3830 mdname(mddev), clevel); 3831 rv = PTR_ERR(priv); 3832 goto out_unlock; 3833 } 3834 3835 /* Looks like we have a winner */ 3836 mddev_suspend(mddev); 3837 mddev_detach(mddev); 3838 3839 spin_lock(&mddev->lock); 3840 oldpers = mddev->pers; 3841 oldpriv = mddev->private; 3842 mddev->pers = pers; 3843 mddev->private = priv; 3844 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel)); 3845 mddev->level = mddev->new_level; 3846 mddev->layout = mddev->new_layout; 3847 mddev->chunk_sectors = mddev->new_chunk_sectors; 3848 mddev->delta_disks = 0; 3849 mddev->reshape_backwards = 0; 3850 mddev->degraded = 0; 3851 spin_unlock(&mddev->lock); 3852 3853 if (oldpers->sync_request == NULL && 3854 mddev->external) { 3855 /* We are converting from a no-redundancy array 3856 * to a redundancy array and metadata is managed 3857 * externally so we need to be sure that writes 3858 * won't block due to a need to transition 3859 * clean->dirty 3860 * until external management is started. 3861 */ 3862 mddev->in_sync = 0; 3863 mddev->safemode_delay = 0; 3864 mddev->safemode = 0; 3865 } 3866 3867 oldpers->free(mddev, oldpriv); 3868 3869 if (oldpers->sync_request == NULL && 3870 pers->sync_request != NULL) { 3871 /* need to add the md_redundancy_group */ 3872 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group)) 3873 pr_warn("md: cannot register extra attributes for %s\n", 3874 mdname(mddev)); 3875 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action"); 3876 } 3877 if (oldpers->sync_request != NULL && 3878 pers->sync_request == NULL) { 3879 /* need to remove the md_redundancy_group */ 3880 if (mddev->to_remove == NULL) 3881 mddev->to_remove = &md_redundancy_group; 3882 } 3883 3884 module_put(oldpers->owner); 3885 3886 rdev_for_each(rdev, mddev) { 3887 if (rdev->raid_disk < 0) 3888 continue; 3889 if (rdev->new_raid_disk >= mddev->raid_disks) 3890 rdev->new_raid_disk = -1; 3891 if (rdev->new_raid_disk == rdev->raid_disk) 3892 continue; 3893 sysfs_unlink_rdev(mddev, rdev); 3894 } 3895 rdev_for_each(rdev, mddev) { 3896 if (rdev->raid_disk < 0) 3897 continue; 3898 if (rdev->new_raid_disk == rdev->raid_disk) 3899 continue; 3900 rdev->raid_disk = rdev->new_raid_disk; 3901 if (rdev->raid_disk < 0) 3902 clear_bit(In_sync, &rdev->flags); 3903 else { 3904 if (sysfs_link_rdev(mddev, rdev)) 3905 pr_warn("md: cannot register rd%d for %s after level change\n", 3906 rdev->raid_disk, mdname(mddev)); 3907 } 3908 } 3909 3910 if (pers->sync_request == NULL) { 3911 /* this is now an array without redundancy, so 3912 * it must always be in_sync 3913 */ 3914 mddev->in_sync = 1; 3915 del_timer_sync(&mddev->safemode_timer); 3916 } 3917 blk_set_stacking_limits(&mddev->queue->limits); 3918 pers->run(mddev); 3919 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 3920 mddev_resume(mddev); 3921 if (!mddev->thread) 3922 md_update_sb(mddev, 1); 3923 sysfs_notify(&mddev->kobj, NULL, "level"); 3924 md_new_event(mddev); 3925 rv = len; 3926 out_unlock: 3927 mddev_unlock(mddev); 3928 return rv; 3929 } 3930 3931 static struct md_sysfs_entry md_level = 3932 __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store); 3933 3934 static ssize_t 3935 layout_show(struct mddev *mddev, char *page) 3936 { 3937 /* just a number, not meaningful for all levels */ 3938 if (mddev->reshape_position != MaxSector && 3939 mddev->layout != mddev->new_layout) 3940 return sprintf(page, "%d (%d)\n", 3941 mddev->new_layout, mddev->layout); 3942 return sprintf(page, "%d\n", mddev->layout); 3943 } 3944 3945 static ssize_t 3946 layout_store(struct mddev *mddev, const char *buf, size_t len) 3947 { 3948 unsigned int n; 3949 int err; 3950 3951 err = kstrtouint(buf, 10, &n); 3952 if (err < 0) 3953 return err; 3954 err = mddev_lock(mddev); 3955 if (err) 3956 return err; 3957 3958 if (mddev->pers) { 3959 if (mddev->pers->check_reshape == NULL) 3960 err = -EBUSY; 3961 else if (mddev->ro) 3962 err = -EROFS; 3963 else { 3964 mddev->new_layout = n; 3965 err = mddev->pers->check_reshape(mddev); 3966 if (err) 3967 mddev->new_layout = mddev->layout; 3968 } 3969 } else { 3970 mddev->new_layout = n; 3971 if (mddev->reshape_position == MaxSector) 3972 mddev->layout = n; 3973 } 3974 mddev_unlock(mddev); 3975 return err ?: len; 3976 } 3977 static struct md_sysfs_entry md_layout = 3978 __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store); 3979 3980 static ssize_t 3981 raid_disks_show(struct mddev *mddev, char *page) 3982 { 3983 if (mddev->raid_disks == 0) 3984 return 0; 3985 if (mddev->reshape_position != MaxSector && 3986 mddev->delta_disks != 0) 3987 return sprintf(page, "%d (%d)\n", mddev->raid_disks, 3988 mddev->raid_disks - mddev->delta_disks); 3989 return sprintf(page, "%d\n", mddev->raid_disks); 3990 } 3991 3992 static int update_raid_disks(struct mddev *mddev, int raid_disks); 3993 3994 static ssize_t 3995 raid_disks_store(struct mddev *mddev, const char *buf, size_t len) 3996 { 3997 unsigned int n; 3998 int err; 3999 4000 err = kstrtouint(buf, 10, &n); 4001 if (err < 0) 4002 return err; 4003 4004 err = mddev_lock(mddev); 4005 if (err) 4006 return err; 4007 if (mddev->pers) 4008 err = update_raid_disks(mddev, n); 4009 else if (mddev->reshape_position != MaxSector) { 4010 struct md_rdev *rdev; 4011 int olddisks = mddev->raid_disks - mddev->delta_disks; 4012 4013 err = -EINVAL; 4014 rdev_for_each(rdev, mddev) { 4015 if (olddisks < n && 4016 rdev->data_offset < rdev->new_data_offset) 4017 goto out_unlock; 4018 if (olddisks > n && 4019 rdev->data_offset > rdev->new_data_offset) 4020 goto out_unlock; 4021 } 4022 err = 0; 4023 mddev->delta_disks = n - olddisks; 4024 mddev->raid_disks = n; 4025 mddev->reshape_backwards = (mddev->delta_disks < 0); 4026 } else 4027 mddev->raid_disks = n; 4028 out_unlock: 4029 mddev_unlock(mddev); 4030 return err ? err : len; 4031 } 4032 static struct md_sysfs_entry md_raid_disks = 4033 __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store); 4034 4035 static ssize_t 4036 chunk_size_show(struct mddev *mddev, char *page) 4037 { 4038 if (mddev->reshape_position != MaxSector && 4039 mddev->chunk_sectors != mddev->new_chunk_sectors) 4040 return sprintf(page, "%d (%d)\n", 4041 mddev->new_chunk_sectors << 9, 4042 mddev->chunk_sectors << 9); 4043 return sprintf(page, "%d\n", mddev->chunk_sectors << 9); 4044 } 4045 4046 static ssize_t 4047 chunk_size_store(struct mddev *mddev, const char *buf, size_t len) 4048 { 4049 unsigned long n; 4050 int err; 4051 4052 err = kstrtoul(buf, 10, &n); 4053 if (err < 0) 4054 return err; 4055 4056 err = mddev_lock(mddev); 4057 if (err) 4058 return err; 4059 if (mddev->pers) { 4060 if (mddev->pers->check_reshape == NULL) 4061 err = -EBUSY; 4062 else if (mddev->ro) 4063 err = -EROFS; 4064 else { 4065 mddev->new_chunk_sectors = n >> 9; 4066 err = mddev->pers->check_reshape(mddev); 4067 if (err) 4068 mddev->new_chunk_sectors = mddev->chunk_sectors; 4069 } 4070 } else { 4071 mddev->new_chunk_sectors = n >> 9; 4072 if (mddev->reshape_position == MaxSector) 4073 mddev->chunk_sectors = n >> 9; 4074 } 4075 mddev_unlock(mddev); 4076 return err ?: len; 4077 } 4078 static struct md_sysfs_entry md_chunk_size = 4079 __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store); 4080 4081 static ssize_t 4082 resync_start_show(struct mddev *mddev, char *page) 4083 { 4084 if (mddev->recovery_cp == MaxSector) 4085 return sprintf(page, "none\n"); 4086 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp); 4087 } 4088 4089 static ssize_t 4090 resync_start_store(struct mddev *mddev, const char *buf, size_t len) 4091 { 4092 unsigned long long n; 4093 int err; 4094 4095 if (cmd_match(buf, "none")) 4096 n = MaxSector; 4097 else { 4098 err = kstrtoull(buf, 10, &n); 4099 if (err < 0) 4100 return err; 4101 if (n != (sector_t)n) 4102 return -EINVAL; 4103 } 4104 4105 err = mddev_lock(mddev); 4106 if (err) 4107 return err; 4108 if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) 4109 err = -EBUSY; 4110 4111 if (!err) { 4112 mddev->recovery_cp = n; 4113 if (mddev->pers) 4114 set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags); 4115 } 4116 mddev_unlock(mddev); 4117 return err ?: len; 4118 } 4119 static struct md_sysfs_entry md_resync_start = 4120 __ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR, 4121 resync_start_show, resync_start_store); 4122 4123 /* 4124 * The array state can be: 4125 * 4126 * clear 4127 * No devices, no size, no level 4128 * Equivalent to STOP_ARRAY ioctl 4129 * inactive 4130 * May have some settings, but array is not active 4131 * all IO results in error 4132 * When written, doesn't tear down array, but just stops it 4133 * suspended (not supported yet) 4134 * All IO requests will block. The array can be reconfigured. 4135 * Writing this, if accepted, will block until array is quiescent 4136 * readonly 4137 * no resync can happen. no superblocks get written. 4138 * write requests fail 4139 * read-auto 4140 * like readonly, but behaves like 'clean' on a write request. 4141 * 4142 * clean - no pending writes, but otherwise active. 4143 * When written to inactive array, starts without resync 4144 * If a write request arrives then 4145 * if metadata is known, mark 'dirty' and switch to 'active'. 4146 * if not known, block and switch to write-pending 4147 * If written to an active array that has pending writes, then fails. 4148 * active 4149 * fully active: IO and resync can be happening. 4150 * When written to inactive array, starts with resync 4151 * 4152 * write-pending 4153 * clean, but writes are blocked waiting for 'active' to be written. 4154 * 4155 * active-idle 4156 * like active, but no writes have been seen for a while (100msec). 4157 * 4158 */ 4159 enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active, 4160 write_pending, active_idle, bad_word}; 4161 static char *array_states[] = { 4162 "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active", 4163 "write-pending", "active-idle", NULL }; 4164 4165 static int match_word(const char *word, char **list) 4166 { 4167 int n; 4168 for (n=0; list[n]; n++) 4169 if (cmd_match(word, list[n])) 4170 break; 4171 return n; 4172 } 4173 4174 static ssize_t 4175 array_state_show(struct mddev *mddev, char *page) 4176 { 4177 enum array_state st = inactive; 4178 4179 if (mddev->pers) 4180 switch(mddev->ro) { 4181 case 1: 4182 st = readonly; 4183 break; 4184 case 2: 4185 st = read_auto; 4186 break; 4187 case 0: 4188 spin_lock(&mddev->lock); 4189 if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) 4190 st = write_pending; 4191 else if (mddev->in_sync) 4192 st = clean; 4193 else if (mddev->safemode) 4194 st = active_idle; 4195 else 4196 st = active; 4197 spin_unlock(&mddev->lock); 4198 } 4199 else { 4200 if (list_empty(&mddev->disks) && 4201 mddev->raid_disks == 0 && 4202 mddev->dev_sectors == 0) 4203 st = clear; 4204 else 4205 st = inactive; 4206 } 4207 return sprintf(page, "%s\n", array_states[st]); 4208 } 4209 4210 static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev); 4211 static int md_set_readonly(struct mddev *mddev, struct block_device *bdev); 4212 static int do_md_run(struct mddev *mddev); 4213 static int restart_array(struct mddev *mddev); 4214 4215 static ssize_t 4216 array_state_store(struct mddev *mddev, const char *buf, size_t len) 4217 { 4218 int err = 0; 4219 enum array_state st = match_word(buf, array_states); 4220 4221 if (mddev->pers && (st == active || st == clean) && mddev->ro != 1) { 4222 /* don't take reconfig_mutex when toggling between 4223 * clean and active 4224 */ 4225 spin_lock(&mddev->lock); 4226 if (st == active) { 4227 restart_array(mddev); 4228 clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags); 4229 md_wakeup_thread(mddev->thread); 4230 wake_up(&mddev->sb_wait); 4231 } else /* st == clean */ { 4232 restart_array(mddev); 4233 if (!set_in_sync(mddev)) 4234 err = -EBUSY; 4235 } 4236 if (!err) 4237 sysfs_notify_dirent_safe(mddev->sysfs_state); 4238 spin_unlock(&mddev->lock); 4239 return err ?: len; 4240 } 4241 err = mddev_lock(mddev); 4242 if (err) 4243 return err; 4244 err = -EINVAL; 4245 switch(st) { 4246 case bad_word: 4247 break; 4248 case clear: 4249 /* stopping an active array */ 4250 err = do_md_stop(mddev, 0, NULL); 4251 break; 4252 case inactive: 4253 /* stopping an active array */ 4254 if (mddev->pers) 4255 err = do_md_stop(mddev, 2, NULL); 4256 else 4257 err = 0; /* already inactive */ 4258 break; 4259 case suspended: 4260 break; /* not supported yet */ 4261 case readonly: 4262 if (mddev->pers) 4263 err = md_set_readonly(mddev, NULL); 4264 else { 4265 mddev->ro = 1; 4266 set_disk_ro(mddev->gendisk, 1); 4267 err = do_md_run(mddev); 4268 } 4269 break; 4270 case read_auto: 4271 if (mddev->pers) { 4272 if (mddev->ro == 0) 4273 err = md_set_readonly(mddev, NULL); 4274 else if (mddev->ro == 1) 4275 err = restart_array(mddev); 4276 if (err == 0) { 4277 mddev->ro = 2; 4278 set_disk_ro(mddev->gendisk, 0); 4279 } 4280 } else { 4281 mddev->ro = 2; 4282 err = do_md_run(mddev); 4283 } 4284 break; 4285 case clean: 4286 if (mddev->pers) { 4287 err = restart_array(mddev); 4288 if (err) 4289 break; 4290 spin_lock(&mddev->lock); 4291 if (!set_in_sync(mddev)) 4292 err = -EBUSY; 4293 spin_unlock(&mddev->lock); 4294 } else 4295 err = -EINVAL; 4296 break; 4297 case active: 4298 if (mddev->pers) { 4299 err = restart_array(mddev); 4300 if (err) 4301 break; 4302 clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags); 4303 wake_up(&mddev->sb_wait); 4304 err = 0; 4305 } else { 4306 mddev->ro = 0; 4307 set_disk_ro(mddev->gendisk, 0); 4308 err = do_md_run(mddev); 4309 } 4310 break; 4311 case write_pending: 4312 case active_idle: 4313 /* these cannot be set */ 4314 break; 4315 } 4316 4317 if (!err) { 4318 if (mddev->hold_active == UNTIL_IOCTL) 4319 mddev->hold_active = 0; 4320 sysfs_notify_dirent_safe(mddev->sysfs_state); 4321 } 4322 mddev_unlock(mddev); 4323 return err ?: len; 4324 } 4325 static struct md_sysfs_entry md_array_state = 4326 __ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store); 4327 4328 static ssize_t 4329 max_corrected_read_errors_show(struct mddev *mddev, char *page) { 4330 return sprintf(page, "%d\n", 4331 atomic_read(&mddev->max_corr_read_errors)); 4332 } 4333 4334 static ssize_t 4335 max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len) 4336 { 4337 unsigned int n; 4338 int rv; 4339 4340 rv = kstrtouint(buf, 10, &n); 4341 if (rv < 0) 4342 return rv; 4343 atomic_set(&mddev->max_corr_read_errors, n); 4344 return len; 4345 } 4346 4347 static struct md_sysfs_entry max_corr_read_errors = 4348 __ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show, 4349 max_corrected_read_errors_store); 4350 4351 static ssize_t 4352 null_show(struct mddev *mddev, char *page) 4353 { 4354 return -EINVAL; 4355 } 4356 4357 static ssize_t 4358 new_dev_store(struct mddev *mddev, const char *buf, size_t len) 4359 { 4360 /* buf must be %d:%d\n? giving major and minor numbers */ 4361 /* The new device is added to the array. 4362 * If the array has a persistent superblock, we read the 4363 * superblock to initialise info and check validity. 4364 * Otherwise, only checking done is that in bind_rdev_to_array, 4365 * which mainly checks size. 4366 */ 4367 char *e; 4368 int major = simple_strtoul(buf, &e, 10); 4369 int minor; 4370 dev_t dev; 4371 struct md_rdev *rdev; 4372 int err; 4373 4374 if (!*buf || *e != ':' || !e[1] || e[1] == '\n') 4375 return -EINVAL; 4376 minor = simple_strtoul(e+1, &e, 10); 4377 if (*e && *e != '\n') 4378 return -EINVAL; 4379 dev = MKDEV(major, minor); 4380 if (major != MAJOR(dev) || 4381 minor != MINOR(dev)) 4382 return -EOVERFLOW; 4383 4384 flush_workqueue(md_misc_wq); 4385 4386 err = mddev_lock(mddev); 4387 if (err) 4388 return err; 4389 if (mddev->persistent) { 4390 rdev = md_import_device(dev, mddev->major_version, 4391 mddev->minor_version); 4392 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) { 4393 struct md_rdev *rdev0 4394 = list_entry(mddev->disks.next, 4395 struct md_rdev, same_set); 4396 err = super_types[mddev->major_version] 4397 .load_super(rdev, rdev0, mddev->minor_version); 4398 if (err < 0) 4399 goto out; 4400 } 4401 } else if (mddev->external) 4402 rdev = md_import_device(dev, -2, -1); 4403 else 4404 rdev = md_import_device(dev, -1, -1); 4405 4406 if (IS_ERR(rdev)) { 4407 mddev_unlock(mddev); 4408 return PTR_ERR(rdev); 4409 } 4410 err = bind_rdev_to_array(rdev, mddev); 4411 out: 4412 if (err) 4413 export_rdev(rdev); 4414 mddev_unlock(mddev); 4415 if (!err) 4416 md_new_event(mddev); 4417 return err ? err : len; 4418 } 4419 4420 static struct md_sysfs_entry md_new_device = 4421 __ATTR(new_dev, S_IWUSR, null_show, new_dev_store); 4422 4423 static ssize_t 4424 bitmap_store(struct mddev *mddev, const char *buf, size_t len) 4425 { 4426 char *end; 4427 unsigned long chunk, end_chunk; 4428 int err; 4429 4430 err = mddev_lock(mddev); 4431 if (err) 4432 return err; 4433 if (!mddev->bitmap) 4434 goto out; 4435 /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */ 4436 while (*buf) { 4437 chunk = end_chunk = simple_strtoul(buf, &end, 0); 4438 if (buf == end) break; 4439 if (*end == '-') { /* range */ 4440 buf = end + 1; 4441 end_chunk = simple_strtoul(buf, &end, 0); 4442 if (buf == end) break; 4443 } 4444 if (*end && !isspace(*end)) break; 4445 md_bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk); 4446 buf = skip_spaces(end); 4447 } 4448 md_bitmap_unplug(mddev->bitmap); /* flush the bits to disk */ 4449 out: 4450 mddev_unlock(mddev); 4451 return len; 4452 } 4453 4454 static struct md_sysfs_entry md_bitmap = 4455 __ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store); 4456 4457 static ssize_t 4458 size_show(struct mddev *mddev, char *page) 4459 { 4460 return sprintf(page, "%llu\n", 4461 (unsigned long long)mddev->dev_sectors / 2); 4462 } 4463 4464 static int update_size(struct mddev *mddev, sector_t num_sectors); 4465 4466 static ssize_t 4467 size_store(struct mddev *mddev, const char *buf, size_t len) 4468 { 4469 /* If array is inactive, we can reduce the component size, but 4470 * not increase it (except from 0). 4471 * If array is active, we can try an on-line resize 4472 */ 4473 sector_t sectors; 4474 int err = strict_blocks_to_sectors(buf, §ors); 4475 4476 if (err < 0) 4477 return err; 4478 err = mddev_lock(mddev); 4479 if (err) 4480 return err; 4481 if (mddev->pers) { 4482 err = update_size(mddev, sectors); 4483 if (err == 0) 4484 md_update_sb(mddev, 1); 4485 } else { 4486 if (mddev->dev_sectors == 0 || 4487 mddev->dev_sectors > sectors) 4488 mddev->dev_sectors = sectors; 4489 else 4490 err = -ENOSPC; 4491 } 4492 mddev_unlock(mddev); 4493 return err ? err : len; 4494 } 4495 4496 static struct md_sysfs_entry md_size = 4497 __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store); 4498 4499 /* Metadata version. 4500 * This is one of 4501 * 'none' for arrays with no metadata (good luck...) 4502 * 'external' for arrays with externally managed metadata, 4503 * or N.M for internally known formats 4504 */ 4505 static ssize_t 4506 metadata_show(struct mddev *mddev, char *page) 4507 { 4508 if (mddev->persistent) 4509 return sprintf(page, "%d.%d\n", 4510 mddev->major_version, mddev->minor_version); 4511 else if (mddev->external) 4512 return sprintf(page, "external:%s\n", mddev->metadata_type); 4513 else 4514 return sprintf(page, "none\n"); 4515 } 4516 4517 static ssize_t 4518 metadata_store(struct mddev *mddev, const char *buf, size_t len) 4519 { 4520 int major, minor; 4521 char *e; 4522 int err; 4523 /* Changing the details of 'external' metadata is 4524 * always permitted. Otherwise there must be 4525 * no devices attached to the array. 4526 */ 4527 4528 err = mddev_lock(mddev); 4529 if (err) 4530 return err; 4531 err = -EBUSY; 4532 if (mddev->external && strncmp(buf, "external:", 9) == 0) 4533 ; 4534 else if (!list_empty(&mddev->disks)) 4535 goto out_unlock; 4536 4537 err = 0; 4538 if (cmd_match(buf, "none")) { 4539 mddev->persistent = 0; 4540 mddev->external = 0; 4541 mddev->major_version = 0; 4542 mddev->minor_version = 90; 4543 goto out_unlock; 4544 } 4545 if (strncmp(buf, "external:", 9) == 0) { 4546 size_t namelen = len-9; 4547 if (namelen >= sizeof(mddev->metadata_type)) 4548 namelen = sizeof(mddev->metadata_type)-1; 4549 strncpy(mddev->metadata_type, buf+9, namelen); 4550 mddev->metadata_type[namelen] = 0; 4551 if (namelen && mddev->metadata_type[namelen-1] == '\n') 4552 mddev->metadata_type[--namelen] = 0; 4553 mddev->persistent = 0; 4554 mddev->external = 1; 4555 mddev->major_version = 0; 4556 mddev->minor_version = 90; 4557 goto out_unlock; 4558 } 4559 major = simple_strtoul(buf, &e, 10); 4560 err = -EINVAL; 4561 if (e==buf || *e != '.') 4562 goto out_unlock; 4563 buf = e+1; 4564 minor = simple_strtoul(buf, &e, 10); 4565 if (e==buf || (*e && *e != '\n') ) 4566 goto out_unlock; 4567 err = -ENOENT; 4568 if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL) 4569 goto out_unlock; 4570 mddev->major_version = major; 4571 mddev->minor_version = minor; 4572 mddev->persistent = 1; 4573 mddev->external = 0; 4574 err = 0; 4575 out_unlock: 4576 mddev_unlock(mddev); 4577 return err ?: len; 4578 } 4579 4580 static struct md_sysfs_entry md_metadata = 4581 __ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store); 4582 4583 static ssize_t 4584 action_show(struct mddev *mddev, char *page) 4585 { 4586 char *type = "idle"; 4587 unsigned long recovery = mddev->recovery; 4588 if (test_bit(MD_RECOVERY_FROZEN, &recovery)) 4589 type = "frozen"; 4590 else if (test_bit(MD_RECOVERY_RUNNING, &recovery) || 4591 (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery))) { 4592 if (test_bit(MD_RECOVERY_RESHAPE, &recovery)) 4593 type = "reshape"; 4594 else if (test_bit(MD_RECOVERY_SYNC, &recovery)) { 4595 if (!test_bit(MD_RECOVERY_REQUESTED, &recovery)) 4596 type = "resync"; 4597 else if (test_bit(MD_RECOVERY_CHECK, &recovery)) 4598 type = "check"; 4599 else 4600 type = "repair"; 4601 } else if (test_bit(MD_RECOVERY_RECOVER, &recovery)) 4602 type = "recover"; 4603 else if (mddev->reshape_position != MaxSector) 4604 type = "reshape"; 4605 } 4606 return sprintf(page, "%s\n", type); 4607 } 4608 4609 static ssize_t 4610 action_store(struct mddev *mddev, const char *page, size_t len) 4611 { 4612 if (!mddev->pers || !mddev->pers->sync_request) 4613 return -EINVAL; 4614 4615 4616 if (cmd_match(page, "idle") || cmd_match(page, "frozen")) { 4617 if (cmd_match(page, "frozen")) 4618 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 4619 else 4620 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 4621 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) && 4622 mddev_lock(mddev) == 0) { 4623 flush_workqueue(md_misc_wq); 4624 if (mddev->sync_thread) { 4625 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 4626 md_reap_sync_thread(mddev); 4627 } 4628 mddev_unlock(mddev); 4629 } 4630 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 4631 return -EBUSY; 4632 else if (cmd_match(page, "resync")) 4633 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 4634 else if (cmd_match(page, "recover")) { 4635 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 4636 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 4637 } else if (cmd_match(page, "reshape")) { 4638 int err; 4639 if (mddev->pers->start_reshape == NULL) 4640 return -EINVAL; 4641 err = mddev_lock(mddev); 4642 if (!err) { 4643 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 4644 err = -EBUSY; 4645 else { 4646 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 4647 err = mddev->pers->start_reshape(mddev); 4648 } 4649 mddev_unlock(mddev); 4650 } 4651 if (err) 4652 return err; 4653 sysfs_notify(&mddev->kobj, NULL, "degraded"); 4654 } else { 4655 if (cmd_match(page, "check")) 4656 set_bit(MD_RECOVERY_CHECK, &mddev->recovery); 4657 else if (!cmd_match(page, "repair")) 4658 return -EINVAL; 4659 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 4660 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); 4661 set_bit(MD_RECOVERY_SYNC, &mddev->recovery); 4662 } 4663 if (mddev->ro == 2) { 4664 /* A write to sync_action is enough to justify 4665 * canceling read-auto mode 4666 */ 4667 mddev->ro = 0; 4668 md_wakeup_thread(mddev->sync_thread); 4669 } 4670 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 4671 md_wakeup_thread(mddev->thread); 4672 sysfs_notify_dirent_safe(mddev->sysfs_action); 4673 return len; 4674 } 4675 4676 static struct md_sysfs_entry md_scan_mode = 4677 __ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store); 4678 4679 static ssize_t 4680 last_sync_action_show(struct mddev *mddev, char *page) 4681 { 4682 return sprintf(page, "%s\n", mddev->last_sync_action); 4683 } 4684 4685 static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action); 4686 4687 static ssize_t 4688 mismatch_cnt_show(struct mddev *mddev, char *page) 4689 { 4690 return sprintf(page, "%llu\n", 4691 (unsigned long long) 4692 atomic64_read(&mddev->resync_mismatches)); 4693 } 4694 4695 static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt); 4696 4697 static ssize_t 4698 sync_min_show(struct mddev *mddev, char *page) 4699 { 4700 return sprintf(page, "%d (%s)\n", speed_min(mddev), 4701 mddev->sync_speed_min ? "local": "system"); 4702 } 4703 4704 static ssize_t 4705 sync_min_store(struct mddev *mddev, const char *buf, size_t len) 4706 { 4707 unsigned int min; 4708 int rv; 4709 4710 if (strncmp(buf, "system", 6)==0) { 4711 min = 0; 4712 } else { 4713 rv = kstrtouint(buf, 10, &min); 4714 if (rv < 0) 4715 return rv; 4716 if (min == 0) 4717 return -EINVAL; 4718 } 4719 mddev->sync_speed_min = min; 4720 return len; 4721 } 4722 4723 static struct md_sysfs_entry md_sync_min = 4724 __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store); 4725 4726 static ssize_t 4727 sync_max_show(struct mddev *mddev, char *page) 4728 { 4729 return sprintf(page, "%d (%s)\n", speed_max(mddev), 4730 mddev->sync_speed_max ? "local": "system"); 4731 } 4732 4733 static ssize_t 4734 sync_max_store(struct mddev *mddev, const char *buf, size_t len) 4735 { 4736 unsigned int max; 4737 int rv; 4738 4739 if (strncmp(buf, "system", 6)==0) { 4740 max = 0; 4741 } else { 4742 rv = kstrtouint(buf, 10, &max); 4743 if (rv < 0) 4744 return rv; 4745 if (max == 0) 4746 return -EINVAL; 4747 } 4748 mddev->sync_speed_max = max; 4749 return len; 4750 } 4751 4752 static struct md_sysfs_entry md_sync_max = 4753 __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store); 4754 4755 static ssize_t 4756 degraded_show(struct mddev *mddev, char *page) 4757 { 4758 return sprintf(page, "%d\n", mddev->degraded); 4759 } 4760 static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded); 4761 4762 static ssize_t 4763 sync_force_parallel_show(struct mddev *mddev, char *page) 4764 { 4765 return sprintf(page, "%d\n", mddev->parallel_resync); 4766 } 4767 4768 static ssize_t 4769 sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len) 4770 { 4771 long n; 4772 4773 if (kstrtol(buf, 10, &n)) 4774 return -EINVAL; 4775 4776 if (n != 0 && n != 1) 4777 return -EINVAL; 4778 4779 mddev->parallel_resync = n; 4780 4781 if (mddev->sync_thread) 4782 wake_up(&resync_wait); 4783 4784 return len; 4785 } 4786 4787 /* force parallel resync, even with shared block devices */ 4788 static struct md_sysfs_entry md_sync_force_parallel = 4789 __ATTR(sync_force_parallel, S_IRUGO|S_IWUSR, 4790 sync_force_parallel_show, sync_force_parallel_store); 4791 4792 static ssize_t 4793 sync_speed_show(struct mddev *mddev, char *page) 4794 { 4795 unsigned long resync, dt, db; 4796 if (mddev->curr_resync == 0) 4797 return sprintf(page, "none\n"); 4798 resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active); 4799 dt = (jiffies - mddev->resync_mark) / HZ; 4800 if (!dt) dt++; 4801 db = resync - mddev->resync_mark_cnt; 4802 return sprintf(page, "%lu\n", db/dt/2); /* K/sec */ 4803 } 4804 4805 static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed); 4806 4807 static ssize_t 4808 sync_completed_show(struct mddev *mddev, char *page) 4809 { 4810 unsigned long long max_sectors, resync; 4811 4812 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 4813 return sprintf(page, "none\n"); 4814 4815 if (mddev->curr_resync == 1 || 4816 mddev->curr_resync == 2) 4817 return sprintf(page, "delayed\n"); 4818 4819 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) || 4820 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) 4821 max_sectors = mddev->resync_max_sectors; 4822 else 4823 max_sectors = mddev->dev_sectors; 4824 4825 resync = mddev->curr_resync_completed; 4826 return sprintf(page, "%llu / %llu\n", resync, max_sectors); 4827 } 4828 4829 static struct md_sysfs_entry md_sync_completed = 4830 __ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL); 4831 4832 static ssize_t 4833 min_sync_show(struct mddev *mddev, char *page) 4834 { 4835 return sprintf(page, "%llu\n", 4836 (unsigned long long)mddev->resync_min); 4837 } 4838 static ssize_t 4839 min_sync_store(struct mddev *mddev, const char *buf, size_t len) 4840 { 4841 unsigned long long min; 4842 int err; 4843 4844 if (kstrtoull(buf, 10, &min)) 4845 return -EINVAL; 4846 4847 spin_lock(&mddev->lock); 4848 err = -EINVAL; 4849 if (min > mddev->resync_max) 4850 goto out_unlock; 4851 4852 err = -EBUSY; 4853 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 4854 goto out_unlock; 4855 4856 /* Round down to multiple of 4K for safety */ 4857 mddev->resync_min = round_down(min, 8); 4858 err = 0; 4859 4860 out_unlock: 4861 spin_unlock(&mddev->lock); 4862 return err ?: len; 4863 } 4864 4865 static struct md_sysfs_entry md_min_sync = 4866 __ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store); 4867 4868 static ssize_t 4869 max_sync_show(struct mddev *mddev, char *page) 4870 { 4871 if (mddev->resync_max == MaxSector) 4872 return sprintf(page, "max\n"); 4873 else 4874 return sprintf(page, "%llu\n", 4875 (unsigned long long)mddev->resync_max); 4876 } 4877 static ssize_t 4878 max_sync_store(struct mddev *mddev, const char *buf, size_t len) 4879 { 4880 int err; 4881 spin_lock(&mddev->lock); 4882 if (strncmp(buf, "max", 3) == 0) 4883 mddev->resync_max = MaxSector; 4884 else { 4885 unsigned long long max; 4886 int chunk; 4887 4888 err = -EINVAL; 4889 if (kstrtoull(buf, 10, &max)) 4890 goto out_unlock; 4891 if (max < mddev->resync_min) 4892 goto out_unlock; 4893 4894 err = -EBUSY; 4895 if (max < mddev->resync_max && 4896 mddev->ro == 0 && 4897 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 4898 goto out_unlock; 4899 4900 /* Must be a multiple of chunk_size */ 4901 chunk = mddev->chunk_sectors; 4902 if (chunk) { 4903 sector_t temp = max; 4904 4905 err = -EINVAL; 4906 if (sector_div(temp, chunk)) 4907 goto out_unlock; 4908 } 4909 mddev->resync_max = max; 4910 } 4911 wake_up(&mddev->recovery_wait); 4912 err = 0; 4913 out_unlock: 4914 spin_unlock(&mddev->lock); 4915 return err ?: len; 4916 } 4917 4918 static struct md_sysfs_entry md_max_sync = 4919 __ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store); 4920 4921 static ssize_t 4922 suspend_lo_show(struct mddev *mddev, char *page) 4923 { 4924 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo); 4925 } 4926 4927 static ssize_t 4928 suspend_lo_store(struct mddev *mddev, const char *buf, size_t len) 4929 { 4930 unsigned long long new; 4931 int err; 4932 4933 err = kstrtoull(buf, 10, &new); 4934 if (err < 0) 4935 return err; 4936 if (new != (sector_t)new) 4937 return -EINVAL; 4938 4939 err = mddev_lock(mddev); 4940 if (err) 4941 return err; 4942 err = -EINVAL; 4943 if (mddev->pers == NULL || 4944 mddev->pers->quiesce == NULL) 4945 goto unlock; 4946 mddev_suspend(mddev); 4947 mddev->suspend_lo = new; 4948 mddev_resume(mddev); 4949 4950 err = 0; 4951 unlock: 4952 mddev_unlock(mddev); 4953 return err ?: len; 4954 } 4955 static struct md_sysfs_entry md_suspend_lo = 4956 __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store); 4957 4958 static ssize_t 4959 suspend_hi_show(struct mddev *mddev, char *page) 4960 { 4961 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi); 4962 } 4963 4964 static ssize_t 4965 suspend_hi_store(struct mddev *mddev, const char *buf, size_t len) 4966 { 4967 unsigned long long new; 4968 int err; 4969 4970 err = kstrtoull(buf, 10, &new); 4971 if (err < 0) 4972 return err; 4973 if (new != (sector_t)new) 4974 return -EINVAL; 4975 4976 err = mddev_lock(mddev); 4977 if (err) 4978 return err; 4979 err = -EINVAL; 4980 if (mddev->pers == NULL) 4981 goto unlock; 4982 4983 mddev_suspend(mddev); 4984 mddev->suspend_hi = new; 4985 mddev_resume(mddev); 4986 4987 err = 0; 4988 unlock: 4989 mddev_unlock(mddev); 4990 return err ?: len; 4991 } 4992 static struct md_sysfs_entry md_suspend_hi = 4993 __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store); 4994 4995 static ssize_t 4996 reshape_position_show(struct mddev *mddev, char *page) 4997 { 4998 if (mddev->reshape_position != MaxSector) 4999 return sprintf(page, "%llu\n", 5000 (unsigned long long)mddev->reshape_position); 5001 strcpy(page, "none\n"); 5002 return 5; 5003 } 5004 5005 static ssize_t 5006 reshape_position_store(struct mddev *mddev, const char *buf, size_t len) 5007 { 5008 struct md_rdev *rdev; 5009 unsigned long long new; 5010 int err; 5011 5012 err = kstrtoull(buf, 10, &new); 5013 if (err < 0) 5014 return err; 5015 if (new != (sector_t)new) 5016 return -EINVAL; 5017 err = mddev_lock(mddev); 5018 if (err) 5019 return err; 5020 err = -EBUSY; 5021 if (mddev->pers) 5022 goto unlock; 5023 mddev->reshape_position = new; 5024 mddev->delta_disks = 0; 5025 mddev->reshape_backwards = 0; 5026 mddev->new_level = mddev->level; 5027 mddev->new_layout = mddev->layout; 5028 mddev->new_chunk_sectors = mddev->chunk_sectors; 5029 rdev_for_each(rdev, mddev) 5030 rdev->new_data_offset = rdev->data_offset; 5031 err = 0; 5032 unlock: 5033 mddev_unlock(mddev); 5034 return err ?: len; 5035 } 5036 5037 static struct md_sysfs_entry md_reshape_position = 5038 __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show, 5039 reshape_position_store); 5040 5041 static ssize_t 5042 reshape_direction_show(struct mddev *mddev, char *page) 5043 { 5044 return sprintf(page, "%s\n", 5045 mddev->reshape_backwards ? "backwards" : "forwards"); 5046 } 5047 5048 static ssize_t 5049 reshape_direction_store(struct mddev *mddev, const char *buf, size_t len) 5050 { 5051 int backwards = 0; 5052 int err; 5053 5054 if (cmd_match(buf, "forwards")) 5055 backwards = 0; 5056 else if (cmd_match(buf, "backwards")) 5057 backwards = 1; 5058 else 5059 return -EINVAL; 5060 if (mddev->reshape_backwards == backwards) 5061 return len; 5062 5063 err = mddev_lock(mddev); 5064 if (err) 5065 return err; 5066 /* check if we are allowed to change */ 5067 if (mddev->delta_disks) 5068 err = -EBUSY; 5069 else if (mddev->persistent && 5070 mddev->major_version == 0) 5071 err = -EINVAL; 5072 else 5073 mddev->reshape_backwards = backwards; 5074 mddev_unlock(mddev); 5075 return err ?: len; 5076 } 5077 5078 static struct md_sysfs_entry md_reshape_direction = 5079 __ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show, 5080 reshape_direction_store); 5081 5082 static ssize_t 5083 array_size_show(struct mddev *mddev, char *page) 5084 { 5085 if (mddev->external_size) 5086 return sprintf(page, "%llu\n", 5087 (unsigned long long)mddev->array_sectors/2); 5088 else 5089 return sprintf(page, "default\n"); 5090 } 5091 5092 static ssize_t 5093 array_size_store(struct mddev *mddev, const char *buf, size_t len) 5094 { 5095 sector_t sectors; 5096 int err; 5097 5098 err = mddev_lock(mddev); 5099 if (err) 5100 return err; 5101 5102 /* cluster raid doesn't support change array_sectors */ 5103 if (mddev_is_clustered(mddev)) { 5104 mddev_unlock(mddev); 5105 return -EINVAL; 5106 } 5107 5108 if (strncmp(buf, "default", 7) == 0) { 5109 if (mddev->pers) 5110 sectors = mddev->pers->size(mddev, 0, 0); 5111 else 5112 sectors = mddev->array_sectors; 5113 5114 mddev->external_size = 0; 5115 } else { 5116 if (strict_blocks_to_sectors(buf, §ors) < 0) 5117 err = -EINVAL; 5118 else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors) 5119 err = -E2BIG; 5120 else 5121 mddev->external_size = 1; 5122 } 5123 5124 if (!err) { 5125 mddev->array_sectors = sectors; 5126 if (mddev->pers) { 5127 set_capacity(mddev->gendisk, mddev->array_sectors); 5128 revalidate_disk(mddev->gendisk); 5129 } 5130 } 5131 mddev_unlock(mddev); 5132 return err ?: len; 5133 } 5134 5135 static struct md_sysfs_entry md_array_size = 5136 __ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show, 5137 array_size_store); 5138 5139 static ssize_t 5140 consistency_policy_show(struct mddev *mddev, char *page) 5141 { 5142 int ret; 5143 5144 if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) { 5145 ret = sprintf(page, "journal\n"); 5146 } else if (test_bit(MD_HAS_PPL, &mddev->flags)) { 5147 ret = sprintf(page, "ppl\n"); 5148 } else if (mddev->bitmap) { 5149 ret = sprintf(page, "bitmap\n"); 5150 } else if (mddev->pers) { 5151 if (mddev->pers->sync_request) 5152 ret = sprintf(page, "resync\n"); 5153 else 5154 ret = sprintf(page, "none\n"); 5155 } else { 5156 ret = sprintf(page, "unknown\n"); 5157 } 5158 5159 return ret; 5160 } 5161 5162 static ssize_t 5163 consistency_policy_store(struct mddev *mddev, const char *buf, size_t len) 5164 { 5165 int err = 0; 5166 5167 if (mddev->pers) { 5168 if (mddev->pers->change_consistency_policy) 5169 err = mddev->pers->change_consistency_policy(mddev, buf); 5170 else 5171 err = -EBUSY; 5172 } else if (mddev->external && strncmp(buf, "ppl", 3) == 0) { 5173 set_bit(MD_HAS_PPL, &mddev->flags); 5174 } else { 5175 err = -EINVAL; 5176 } 5177 5178 return err ? err : len; 5179 } 5180 5181 static struct md_sysfs_entry md_consistency_policy = 5182 __ATTR(consistency_policy, S_IRUGO | S_IWUSR, consistency_policy_show, 5183 consistency_policy_store); 5184 5185 static struct attribute *md_default_attrs[] = { 5186 &md_level.attr, 5187 &md_layout.attr, 5188 &md_raid_disks.attr, 5189 &md_chunk_size.attr, 5190 &md_size.attr, 5191 &md_resync_start.attr, 5192 &md_metadata.attr, 5193 &md_new_device.attr, 5194 &md_safe_delay.attr, 5195 &md_array_state.attr, 5196 &md_reshape_position.attr, 5197 &md_reshape_direction.attr, 5198 &md_array_size.attr, 5199 &max_corr_read_errors.attr, 5200 &md_consistency_policy.attr, 5201 NULL, 5202 }; 5203 5204 static struct attribute *md_redundancy_attrs[] = { 5205 &md_scan_mode.attr, 5206 &md_last_scan_mode.attr, 5207 &md_mismatches.attr, 5208 &md_sync_min.attr, 5209 &md_sync_max.attr, 5210 &md_sync_speed.attr, 5211 &md_sync_force_parallel.attr, 5212 &md_sync_completed.attr, 5213 &md_min_sync.attr, 5214 &md_max_sync.attr, 5215 &md_suspend_lo.attr, 5216 &md_suspend_hi.attr, 5217 &md_bitmap.attr, 5218 &md_degraded.attr, 5219 NULL, 5220 }; 5221 static struct attribute_group md_redundancy_group = { 5222 .name = NULL, 5223 .attrs = md_redundancy_attrs, 5224 }; 5225 5226 static ssize_t 5227 md_attr_show(struct kobject *kobj, struct attribute *attr, char *page) 5228 { 5229 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr); 5230 struct mddev *mddev = container_of(kobj, struct mddev, kobj); 5231 ssize_t rv; 5232 5233 if (!entry->show) 5234 return -EIO; 5235 spin_lock(&all_mddevs_lock); 5236 if (list_empty(&mddev->all_mddevs)) { 5237 spin_unlock(&all_mddevs_lock); 5238 return -EBUSY; 5239 } 5240 mddev_get(mddev); 5241 spin_unlock(&all_mddevs_lock); 5242 5243 rv = entry->show(mddev, page); 5244 mddev_put(mddev); 5245 return rv; 5246 } 5247 5248 static ssize_t 5249 md_attr_store(struct kobject *kobj, struct attribute *attr, 5250 const char *page, size_t length) 5251 { 5252 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr); 5253 struct mddev *mddev = container_of(kobj, struct mddev, kobj); 5254 ssize_t rv; 5255 5256 if (!entry->store) 5257 return -EIO; 5258 if (!capable(CAP_SYS_ADMIN)) 5259 return -EACCES; 5260 spin_lock(&all_mddevs_lock); 5261 if (list_empty(&mddev->all_mddevs)) { 5262 spin_unlock(&all_mddevs_lock); 5263 return -EBUSY; 5264 } 5265 mddev_get(mddev); 5266 spin_unlock(&all_mddevs_lock); 5267 rv = entry->store(mddev, page, length); 5268 mddev_put(mddev); 5269 return rv; 5270 } 5271 5272 static void md_free(struct kobject *ko) 5273 { 5274 struct mddev *mddev = container_of(ko, struct mddev, kobj); 5275 5276 if (mddev->sysfs_state) 5277 sysfs_put(mddev->sysfs_state); 5278 5279 if (mddev->gendisk) 5280 del_gendisk(mddev->gendisk); 5281 if (mddev->queue) 5282 blk_cleanup_queue(mddev->queue); 5283 if (mddev->gendisk) 5284 put_disk(mddev->gendisk); 5285 percpu_ref_exit(&mddev->writes_pending); 5286 5287 bioset_exit(&mddev->bio_set); 5288 bioset_exit(&mddev->sync_set); 5289 kfree(mddev); 5290 } 5291 5292 static const struct sysfs_ops md_sysfs_ops = { 5293 .show = md_attr_show, 5294 .store = md_attr_store, 5295 }; 5296 static struct kobj_type md_ktype = { 5297 .release = md_free, 5298 .sysfs_ops = &md_sysfs_ops, 5299 .default_attrs = md_default_attrs, 5300 }; 5301 5302 int mdp_major = 0; 5303 5304 static void mddev_delayed_delete(struct work_struct *ws) 5305 { 5306 struct mddev *mddev = container_of(ws, struct mddev, del_work); 5307 5308 sysfs_remove_group(&mddev->kobj, &md_bitmap_group); 5309 kobject_del(&mddev->kobj); 5310 kobject_put(&mddev->kobj); 5311 } 5312 5313 static void no_op(struct percpu_ref *r) {} 5314 5315 int mddev_init_writes_pending(struct mddev *mddev) 5316 { 5317 if (mddev->writes_pending.percpu_count_ptr) 5318 return 0; 5319 if (percpu_ref_init(&mddev->writes_pending, no_op, 0, GFP_KERNEL) < 0) 5320 return -ENOMEM; 5321 /* We want to start with the refcount at zero */ 5322 percpu_ref_put(&mddev->writes_pending); 5323 return 0; 5324 } 5325 EXPORT_SYMBOL_GPL(mddev_init_writes_pending); 5326 5327 static int md_alloc(dev_t dev, char *name) 5328 { 5329 /* 5330 * If dev is zero, name is the name of a device to allocate with 5331 * an arbitrary minor number. It will be "md_???" 5332 * If dev is non-zero it must be a device number with a MAJOR of 5333 * MD_MAJOR or mdp_major. In this case, if "name" is NULL, then 5334 * the device is being created by opening a node in /dev. 5335 * If "name" is not NULL, the device is being created by 5336 * writing to /sys/module/md_mod/parameters/new_array. 5337 */ 5338 static DEFINE_MUTEX(disks_mutex); 5339 struct mddev *mddev = mddev_find(dev); 5340 struct gendisk *disk; 5341 int partitioned; 5342 int shift; 5343 int unit; 5344 int error; 5345 5346 if (!mddev) 5347 return -ENODEV; 5348 5349 partitioned = (MAJOR(mddev->unit) != MD_MAJOR); 5350 shift = partitioned ? MdpMinorShift : 0; 5351 unit = MINOR(mddev->unit) >> shift; 5352 5353 /* wait for any previous instance of this device to be 5354 * completely removed (mddev_delayed_delete). 5355 */ 5356 flush_workqueue(md_misc_wq); 5357 5358 mutex_lock(&disks_mutex); 5359 error = -EEXIST; 5360 if (mddev->gendisk) 5361 goto abort; 5362 5363 if (name && !dev) { 5364 /* Need to ensure that 'name' is not a duplicate. 5365 */ 5366 struct mddev *mddev2; 5367 spin_lock(&all_mddevs_lock); 5368 5369 list_for_each_entry(mddev2, &all_mddevs, all_mddevs) 5370 if (mddev2->gendisk && 5371 strcmp(mddev2->gendisk->disk_name, name) == 0) { 5372 spin_unlock(&all_mddevs_lock); 5373 goto abort; 5374 } 5375 spin_unlock(&all_mddevs_lock); 5376 } 5377 if (name && dev) 5378 /* 5379 * Creating /dev/mdNNN via "newarray", so adjust hold_active. 5380 */ 5381 mddev->hold_active = UNTIL_STOP; 5382 5383 error = -ENOMEM; 5384 mddev->queue = blk_alloc_queue(GFP_KERNEL); 5385 if (!mddev->queue) 5386 goto abort; 5387 mddev->queue->queuedata = mddev; 5388 5389 blk_queue_make_request(mddev->queue, md_make_request); 5390 blk_set_stacking_limits(&mddev->queue->limits); 5391 5392 disk = alloc_disk(1 << shift); 5393 if (!disk) { 5394 blk_cleanup_queue(mddev->queue); 5395 mddev->queue = NULL; 5396 goto abort; 5397 } 5398 disk->major = MAJOR(mddev->unit); 5399 disk->first_minor = unit << shift; 5400 if (name) 5401 strcpy(disk->disk_name, name); 5402 else if (partitioned) 5403 sprintf(disk->disk_name, "md_d%d", unit); 5404 else 5405 sprintf(disk->disk_name, "md%d", unit); 5406 disk->fops = &md_fops; 5407 disk->private_data = mddev; 5408 disk->queue = mddev->queue; 5409 blk_queue_write_cache(mddev->queue, true, true); 5410 /* Allow extended partitions. This makes the 5411 * 'mdp' device redundant, but we can't really 5412 * remove it now. 5413 */ 5414 disk->flags |= GENHD_FL_EXT_DEVT; 5415 mddev->gendisk = disk; 5416 /* As soon as we call add_disk(), another thread could get 5417 * through to md_open, so make sure it doesn't get too far 5418 */ 5419 mutex_lock(&mddev->open_mutex); 5420 add_disk(disk); 5421 5422 error = kobject_add(&mddev->kobj, &disk_to_dev(disk)->kobj, "%s", "md"); 5423 if (error) { 5424 /* This isn't possible, but as kobject_init_and_add is marked 5425 * __must_check, we must do something with the result 5426 */ 5427 pr_debug("md: cannot register %s/md - name in use\n", 5428 disk->disk_name); 5429 error = 0; 5430 } 5431 if (mddev->kobj.sd && 5432 sysfs_create_group(&mddev->kobj, &md_bitmap_group)) 5433 pr_debug("pointless warning\n"); 5434 mutex_unlock(&mddev->open_mutex); 5435 abort: 5436 mutex_unlock(&disks_mutex); 5437 if (!error && mddev->kobj.sd) { 5438 kobject_uevent(&mddev->kobj, KOBJ_ADD); 5439 mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state"); 5440 } 5441 mddev_put(mddev); 5442 return error; 5443 } 5444 5445 static struct kobject *md_probe(dev_t dev, int *part, void *data) 5446 { 5447 if (create_on_open) 5448 md_alloc(dev, NULL); 5449 return NULL; 5450 } 5451 5452 static int add_named_array(const char *val, const struct kernel_param *kp) 5453 { 5454 /* 5455 * val must be "md_*" or "mdNNN". 5456 * For "md_*" we allocate an array with a large free minor number, and 5457 * set the name to val. val must not already be an active name. 5458 * For "mdNNN" we allocate an array with the minor number NNN 5459 * which must not already be in use. 5460 */ 5461 int len = strlen(val); 5462 char buf[DISK_NAME_LEN]; 5463 unsigned long devnum; 5464 5465 while (len && val[len-1] == '\n') 5466 len--; 5467 if (len >= DISK_NAME_LEN) 5468 return -E2BIG; 5469 strlcpy(buf, val, len+1); 5470 if (strncmp(buf, "md_", 3) == 0) 5471 return md_alloc(0, buf); 5472 if (strncmp(buf, "md", 2) == 0 && 5473 isdigit(buf[2]) && 5474 kstrtoul(buf+2, 10, &devnum) == 0 && 5475 devnum <= MINORMASK) 5476 return md_alloc(MKDEV(MD_MAJOR, devnum), NULL); 5477 5478 return -EINVAL; 5479 } 5480 5481 static void md_safemode_timeout(struct timer_list *t) 5482 { 5483 struct mddev *mddev = from_timer(mddev, t, safemode_timer); 5484 5485 mddev->safemode = 1; 5486 if (mddev->external) 5487 sysfs_notify_dirent_safe(mddev->sysfs_state); 5488 5489 md_wakeup_thread(mddev->thread); 5490 } 5491 5492 static int start_dirty_degraded; 5493 5494 int md_run(struct mddev *mddev) 5495 { 5496 int err; 5497 struct md_rdev *rdev; 5498 struct md_personality *pers; 5499 5500 if (list_empty(&mddev->disks)) 5501 /* cannot run an array with no devices.. */ 5502 return -EINVAL; 5503 5504 if (mddev->pers) 5505 return -EBUSY; 5506 /* Cannot run until previous stop completes properly */ 5507 if (mddev->sysfs_active) 5508 return -EBUSY; 5509 5510 /* 5511 * Analyze all RAID superblock(s) 5512 */ 5513 if (!mddev->raid_disks) { 5514 if (!mddev->persistent) 5515 return -EINVAL; 5516 analyze_sbs(mddev); 5517 } 5518 5519 if (mddev->level != LEVEL_NONE) 5520 request_module("md-level-%d", mddev->level); 5521 else if (mddev->clevel[0]) 5522 request_module("md-%s", mddev->clevel); 5523 5524 /* 5525 * Drop all container device buffers, from now on 5526 * the only valid external interface is through the md 5527 * device. 5528 */ 5529 mddev->has_superblocks = false; 5530 rdev_for_each(rdev, mddev) { 5531 if (test_bit(Faulty, &rdev->flags)) 5532 continue; 5533 sync_blockdev(rdev->bdev); 5534 invalidate_bdev(rdev->bdev); 5535 if (mddev->ro != 1 && 5536 (bdev_read_only(rdev->bdev) || 5537 bdev_read_only(rdev->meta_bdev))) { 5538 mddev->ro = 1; 5539 if (mddev->gendisk) 5540 set_disk_ro(mddev->gendisk, 1); 5541 } 5542 5543 if (rdev->sb_page) 5544 mddev->has_superblocks = true; 5545 5546 /* perform some consistency tests on the device. 5547 * We don't want the data to overlap the metadata, 5548 * Internal Bitmap issues have been handled elsewhere. 5549 */ 5550 if (rdev->meta_bdev) { 5551 /* Nothing to check */; 5552 } else if (rdev->data_offset < rdev->sb_start) { 5553 if (mddev->dev_sectors && 5554 rdev->data_offset + mddev->dev_sectors 5555 > rdev->sb_start) { 5556 pr_warn("md: %s: data overlaps metadata\n", 5557 mdname(mddev)); 5558 return -EINVAL; 5559 } 5560 } else { 5561 if (rdev->sb_start + rdev->sb_size/512 5562 > rdev->data_offset) { 5563 pr_warn("md: %s: metadata overlaps data\n", 5564 mdname(mddev)); 5565 return -EINVAL; 5566 } 5567 } 5568 sysfs_notify_dirent_safe(rdev->sysfs_state); 5569 } 5570 5571 if (!bioset_initialized(&mddev->bio_set)) { 5572 err = bioset_init(&mddev->bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS); 5573 if (err) 5574 return err; 5575 } 5576 if (!bioset_initialized(&mddev->sync_set)) { 5577 err = bioset_init(&mddev->sync_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS); 5578 if (err) 5579 return err; 5580 } 5581 5582 spin_lock(&pers_lock); 5583 pers = find_pers(mddev->level, mddev->clevel); 5584 if (!pers || !try_module_get(pers->owner)) { 5585 spin_unlock(&pers_lock); 5586 if (mddev->level != LEVEL_NONE) 5587 pr_warn("md: personality for level %d is not loaded!\n", 5588 mddev->level); 5589 else 5590 pr_warn("md: personality for level %s is not loaded!\n", 5591 mddev->clevel); 5592 err = -EINVAL; 5593 goto abort; 5594 } 5595 spin_unlock(&pers_lock); 5596 if (mddev->level != pers->level) { 5597 mddev->level = pers->level; 5598 mddev->new_level = pers->level; 5599 } 5600 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel)); 5601 5602 if (mddev->reshape_position != MaxSector && 5603 pers->start_reshape == NULL) { 5604 /* This personality cannot handle reshaping... */ 5605 module_put(pers->owner); 5606 err = -EINVAL; 5607 goto abort; 5608 } 5609 5610 if (pers->sync_request) { 5611 /* Warn if this is a potentially silly 5612 * configuration. 5613 */ 5614 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 5615 struct md_rdev *rdev2; 5616 int warned = 0; 5617 5618 rdev_for_each(rdev, mddev) 5619 rdev_for_each(rdev2, mddev) { 5620 if (rdev < rdev2 && 5621 rdev->bdev->bd_contains == 5622 rdev2->bdev->bd_contains) { 5623 pr_warn("%s: WARNING: %s appears to be on the same physical disk as %s.\n", 5624 mdname(mddev), 5625 bdevname(rdev->bdev,b), 5626 bdevname(rdev2->bdev,b2)); 5627 warned = 1; 5628 } 5629 } 5630 5631 if (warned) 5632 pr_warn("True protection against single-disk failure might be compromised.\n"); 5633 } 5634 5635 mddev->recovery = 0; 5636 /* may be over-ridden by personality */ 5637 mddev->resync_max_sectors = mddev->dev_sectors; 5638 5639 mddev->ok_start_degraded = start_dirty_degraded; 5640 5641 if (start_readonly && mddev->ro == 0) 5642 mddev->ro = 2; /* read-only, but switch on first write */ 5643 5644 err = pers->run(mddev); 5645 if (err) 5646 pr_warn("md: pers->run() failed ...\n"); 5647 else if (pers->size(mddev, 0, 0) < mddev->array_sectors) { 5648 WARN_ONCE(!mddev->external_size, 5649 "%s: default size too small, but 'external_size' not in effect?\n", 5650 __func__); 5651 pr_warn("md: invalid array_size %llu > default size %llu\n", 5652 (unsigned long long)mddev->array_sectors / 2, 5653 (unsigned long long)pers->size(mddev, 0, 0) / 2); 5654 err = -EINVAL; 5655 } 5656 if (err == 0 && pers->sync_request && 5657 (mddev->bitmap_info.file || mddev->bitmap_info.offset)) { 5658 struct bitmap *bitmap; 5659 5660 bitmap = md_bitmap_create(mddev, -1); 5661 if (IS_ERR(bitmap)) { 5662 err = PTR_ERR(bitmap); 5663 pr_warn("%s: failed to create bitmap (%d)\n", 5664 mdname(mddev), err); 5665 } else 5666 mddev->bitmap = bitmap; 5667 5668 } 5669 if (err) { 5670 mddev_detach(mddev); 5671 if (mddev->private) 5672 pers->free(mddev, mddev->private); 5673 mddev->private = NULL; 5674 module_put(pers->owner); 5675 md_bitmap_destroy(mddev); 5676 goto abort; 5677 } 5678 5679 if (mddev->bitmap_info.max_write_behind > 0) { 5680 bool creat_pool = false; 5681 5682 rdev_for_each(rdev, mddev) { 5683 if (test_bit(WriteMostly, &rdev->flags) && 5684 rdev_init_wb(rdev)) 5685 creat_pool = true; 5686 } 5687 if (creat_pool && mddev->wb_info_pool == NULL) { 5688 mddev->wb_info_pool = 5689 mempool_create_kmalloc_pool(NR_WB_INFOS, 5690 sizeof(struct wb_info)); 5691 if (!mddev->wb_info_pool) { 5692 err = -ENOMEM; 5693 mddev_detach(mddev); 5694 if (mddev->private) 5695 pers->free(mddev, mddev->private); 5696 mddev->private = NULL; 5697 module_put(pers->owner); 5698 md_bitmap_destroy(mddev); 5699 goto abort; 5700 } 5701 } 5702 } 5703 5704 if (mddev->queue) { 5705 bool nonrot = true; 5706 5707 rdev_for_each(rdev, mddev) { 5708 if (rdev->raid_disk >= 0 && 5709 !blk_queue_nonrot(bdev_get_queue(rdev->bdev))) { 5710 nonrot = false; 5711 break; 5712 } 5713 } 5714 if (mddev->degraded) 5715 nonrot = false; 5716 if (nonrot) 5717 blk_queue_flag_set(QUEUE_FLAG_NONROT, mddev->queue); 5718 else 5719 blk_queue_flag_clear(QUEUE_FLAG_NONROT, mddev->queue); 5720 mddev->queue->backing_dev_info->congested_data = mddev; 5721 mddev->queue->backing_dev_info->congested_fn = md_congested; 5722 } 5723 if (pers->sync_request) { 5724 if (mddev->kobj.sd && 5725 sysfs_create_group(&mddev->kobj, &md_redundancy_group)) 5726 pr_warn("md: cannot register extra attributes for %s\n", 5727 mdname(mddev)); 5728 mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action"); 5729 } else if (mddev->ro == 2) /* auto-readonly not meaningful */ 5730 mddev->ro = 0; 5731 5732 atomic_set(&mddev->max_corr_read_errors, 5733 MD_DEFAULT_MAX_CORRECTED_READ_ERRORS); 5734 mddev->safemode = 0; 5735 if (mddev_is_clustered(mddev)) 5736 mddev->safemode_delay = 0; 5737 else 5738 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */ 5739 mddev->in_sync = 1; 5740 smp_wmb(); 5741 spin_lock(&mddev->lock); 5742 mddev->pers = pers; 5743 spin_unlock(&mddev->lock); 5744 rdev_for_each(rdev, mddev) 5745 if (rdev->raid_disk >= 0) 5746 sysfs_link_rdev(mddev, rdev); /* failure here is OK */ 5747 5748 if (mddev->degraded && !mddev->ro) 5749 /* This ensures that recovering status is reported immediately 5750 * via sysfs - until a lack of spares is confirmed. 5751 */ 5752 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 5753 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 5754 5755 if (mddev->sb_flags) 5756 md_update_sb(mddev, 0); 5757 5758 md_new_event(mddev); 5759 sysfs_notify_dirent_safe(mddev->sysfs_state); 5760 sysfs_notify_dirent_safe(mddev->sysfs_action); 5761 sysfs_notify(&mddev->kobj, NULL, "degraded"); 5762 return 0; 5763 5764 abort: 5765 bioset_exit(&mddev->bio_set); 5766 bioset_exit(&mddev->sync_set); 5767 return err; 5768 } 5769 EXPORT_SYMBOL_GPL(md_run); 5770 5771 static int do_md_run(struct mddev *mddev) 5772 { 5773 int err; 5774 5775 err = md_run(mddev); 5776 if (err) 5777 goto out; 5778 err = md_bitmap_load(mddev); 5779 if (err) { 5780 md_bitmap_destroy(mddev); 5781 goto out; 5782 } 5783 5784 if (mddev_is_clustered(mddev)) 5785 md_allow_write(mddev); 5786 5787 /* run start up tasks that require md_thread */ 5788 md_start(mddev); 5789 5790 md_wakeup_thread(mddev->thread); 5791 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */ 5792 5793 set_capacity(mddev->gendisk, mddev->array_sectors); 5794 revalidate_disk(mddev->gendisk); 5795 mddev->changed = 1; 5796 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE); 5797 out: 5798 return err; 5799 } 5800 5801 int md_start(struct mddev *mddev) 5802 { 5803 int ret = 0; 5804 5805 if (mddev->pers->start) { 5806 set_bit(MD_RECOVERY_WAIT, &mddev->recovery); 5807 md_wakeup_thread(mddev->thread); 5808 ret = mddev->pers->start(mddev); 5809 clear_bit(MD_RECOVERY_WAIT, &mddev->recovery); 5810 md_wakeup_thread(mddev->sync_thread); 5811 } 5812 return ret; 5813 } 5814 EXPORT_SYMBOL_GPL(md_start); 5815 5816 static int restart_array(struct mddev *mddev) 5817 { 5818 struct gendisk *disk = mddev->gendisk; 5819 struct md_rdev *rdev; 5820 bool has_journal = false; 5821 bool has_readonly = false; 5822 5823 /* Complain if it has no devices */ 5824 if (list_empty(&mddev->disks)) 5825 return -ENXIO; 5826 if (!mddev->pers) 5827 return -EINVAL; 5828 if (!mddev->ro) 5829 return -EBUSY; 5830 5831 rcu_read_lock(); 5832 rdev_for_each_rcu(rdev, mddev) { 5833 if (test_bit(Journal, &rdev->flags) && 5834 !test_bit(Faulty, &rdev->flags)) 5835 has_journal = true; 5836 if (bdev_read_only(rdev->bdev)) 5837 has_readonly = true; 5838 } 5839 rcu_read_unlock(); 5840 if (test_bit(MD_HAS_JOURNAL, &mddev->flags) && !has_journal) 5841 /* Don't restart rw with journal missing/faulty */ 5842 return -EINVAL; 5843 if (has_readonly) 5844 return -EROFS; 5845 5846 mddev->safemode = 0; 5847 mddev->ro = 0; 5848 set_disk_ro(disk, 0); 5849 pr_debug("md: %s switched to read-write mode.\n", mdname(mddev)); 5850 /* Kick recovery or resync if necessary */ 5851 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 5852 md_wakeup_thread(mddev->thread); 5853 md_wakeup_thread(mddev->sync_thread); 5854 sysfs_notify_dirent_safe(mddev->sysfs_state); 5855 return 0; 5856 } 5857 5858 static void md_clean(struct mddev *mddev) 5859 { 5860 mddev->array_sectors = 0; 5861 mddev->external_size = 0; 5862 mddev->dev_sectors = 0; 5863 mddev->raid_disks = 0; 5864 mddev->recovery_cp = 0; 5865 mddev->resync_min = 0; 5866 mddev->resync_max = MaxSector; 5867 mddev->reshape_position = MaxSector; 5868 mddev->external = 0; 5869 mddev->persistent = 0; 5870 mddev->level = LEVEL_NONE; 5871 mddev->clevel[0] = 0; 5872 mddev->flags = 0; 5873 mddev->sb_flags = 0; 5874 mddev->ro = 0; 5875 mddev->metadata_type[0] = 0; 5876 mddev->chunk_sectors = 0; 5877 mddev->ctime = mddev->utime = 0; 5878 mddev->layout = 0; 5879 mddev->max_disks = 0; 5880 mddev->events = 0; 5881 mddev->can_decrease_events = 0; 5882 mddev->delta_disks = 0; 5883 mddev->reshape_backwards = 0; 5884 mddev->new_level = LEVEL_NONE; 5885 mddev->new_layout = 0; 5886 mddev->new_chunk_sectors = 0; 5887 mddev->curr_resync = 0; 5888 atomic64_set(&mddev->resync_mismatches, 0); 5889 mddev->suspend_lo = mddev->suspend_hi = 0; 5890 mddev->sync_speed_min = mddev->sync_speed_max = 0; 5891 mddev->recovery = 0; 5892 mddev->in_sync = 0; 5893 mddev->changed = 0; 5894 mddev->degraded = 0; 5895 mddev->safemode = 0; 5896 mddev->private = NULL; 5897 mddev->cluster_info = NULL; 5898 mddev->bitmap_info.offset = 0; 5899 mddev->bitmap_info.default_offset = 0; 5900 mddev->bitmap_info.default_space = 0; 5901 mddev->bitmap_info.chunksize = 0; 5902 mddev->bitmap_info.daemon_sleep = 0; 5903 mddev->bitmap_info.max_write_behind = 0; 5904 mddev->bitmap_info.nodes = 0; 5905 } 5906 5907 static void __md_stop_writes(struct mddev *mddev) 5908 { 5909 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 5910 flush_workqueue(md_misc_wq); 5911 if (mddev->sync_thread) { 5912 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 5913 md_reap_sync_thread(mddev); 5914 } 5915 5916 del_timer_sync(&mddev->safemode_timer); 5917 5918 if (mddev->pers && mddev->pers->quiesce) { 5919 mddev->pers->quiesce(mddev, 1); 5920 mddev->pers->quiesce(mddev, 0); 5921 } 5922 md_bitmap_flush(mddev); 5923 5924 if (mddev->ro == 0 && 5925 ((!mddev->in_sync && !mddev_is_clustered(mddev)) || 5926 mddev->sb_flags)) { 5927 /* mark array as shutdown cleanly */ 5928 if (!mddev_is_clustered(mddev)) 5929 mddev->in_sync = 1; 5930 md_update_sb(mddev, 1); 5931 } 5932 mempool_destroy(mddev->wb_info_pool); 5933 mddev->wb_info_pool = NULL; 5934 } 5935 5936 void md_stop_writes(struct mddev *mddev) 5937 { 5938 mddev_lock_nointr(mddev); 5939 __md_stop_writes(mddev); 5940 mddev_unlock(mddev); 5941 } 5942 EXPORT_SYMBOL_GPL(md_stop_writes); 5943 5944 static void mddev_detach(struct mddev *mddev) 5945 { 5946 md_bitmap_wait_behind_writes(mddev); 5947 if (mddev->pers && mddev->pers->quiesce) { 5948 mddev->pers->quiesce(mddev, 1); 5949 mddev->pers->quiesce(mddev, 0); 5950 } 5951 md_unregister_thread(&mddev->thread); 5952 if (mddev->queue) 5953 blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/ 5954 } 5955 5956 static void __md_stop(struct mddev *mddev) 5957 { 5958 struct md_personality *pers = mddev->pers; 5959 md_bitmap_destroy(mddev); 5960 mddev_detach(mddev); 5961 /* Ensure ->event_work is done */ 5962 flush_workqueue(md_misc_wq); 5963 spin_lock(&mddev->lock); 5964 mddev->pers = NULL; 5965 spin_unlock(&mddev->lock); 5966 pers->free(mddev, mddev->private); 5967 mddev->private = NULL; 5968 if (pers->sync_request && mddev->to_remove == NULL) 5969 mddev->to_remove = &md_redundancy_group; 5970 module_put(pers->owner); 5971 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 5972 } 5973 5974 void md_stop(struct mddev *mddev) 5975 { 5976 /* stop the array and free an attached data structures. 5977 * This is called from dm-raid 5978 */ 5979 __md_stop(mddev); 5980 bioset_exit(&mddev->bio_set); 5981 bioset_exit(&mddev->sync_set); 5982 } 5983 5984 EXPORT_SYMBOL_GPL(md_stop); 5985 5986 static int md_set_readonly(struct mddev *mddev, struct block_device *bdev) 5987 { 5988 int err = 0; 5989 int did_freeze = 0; 5990 5991 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) { 5992 did_freeze = 1; 5993 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 5994 md_wakeup_thread(mddev->thread); 5995 } 5996 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 5997 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 5998 if (mddev->sync_thread) 5999 /* Thread might be blocked waiting for metadata update 6000 * which will now never happen */ 6001 wake_up_process(mddev->sync_thread->tsk); 6002 6003 if (mddev->external && test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) 6004 return -EBUSY; 6005 mddev_unlock(mddev); 6006 wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING, 6007 &mddev->recovery)); 6008 wait_event(mddev->sb_wait, 6009 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)); 6010 mddev_lock_nointr(mddev); 6011 6012 mutex_lock(&mddev->open_mutex); 6013 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) || 6014 mddev->sync_thread || 6015 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) { 6016 pr_warn("md: %s still in use.\n",mdname(mddev)); 6017 if (did_freeze) { 6018 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 6019 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 6020 md_wakeup_thread(mddev->thread); 6021 } 6022 err = -EBUSY; 6023 goto out; 6024 } 6025 if (mddev->pers) { 6026 __md_stop_writes(mddev); 6027 6028 err = -ENXIO; 6029 if (mddev->ro==1) 6030 goto out; 6031 mddev->ro = 1; 6032 set_disk_ro(mddev->gendisk, 1); 6033 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 6034 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 6035 md_wakeup_thread(mddev->thread); 6036 sysfs_notify_dirent_safe(mddev->sysfs_state); 6037 err = 0; 6038 } 6039 out: 6040 mutex_unlock(&mddev->open_mutex); 6041 return err; 6042 } 6043 6044 /* mode: 6045 * 0 - completely stop and dis-assemble array 6046 * 2 - stop but do not disassemble array 6047 */ 6048 static int do_md_stop(struct mddev *mddev, int mode, 6049 struct block_device *bdev) 6050 { 6051 struct gendisk *disk = mddev->gendisk; 6052 struct md_rdev *rdev; 6053 int did_freeze = 0; 6054 6055 if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) { 6056 did_freeze = 1; 6057 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 6058 md_wakeup_thread(mddev->thread); 6059 } 6060 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 6061 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 6062 if (mddev->sync_thread) 6063 /* Thread might be blocked waiting for metadata update 6064 * which will now never happen */ 6065 wake_up_process(mddev->sync_thread->tsk); 6066 6067 mddev_unlock(mddev); 6068 wait_event(resync_wait, (mddev->sync_thread == NULL && 6069 !test_bit(MD_RECOVERY_RUNNING, 6070 &mddev->recovery))); 6071 mddev_lock_nointr(mddev); 6072 6073 mutex_lock(&mddev->open_mutex); 6074 if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) || 6075 mddev->sysfs_active || 6076 mddev->sync_thread || 6077 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) { 6078 pr_warn("md: %s still in use.\n",mdname(mddev)); 6079 mutex_unlock(&mddev->open_mutex); 6080 if (did_freeze) { 6081 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 6082 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 6083 md_wakeup_thread(mddev->thread); 6084 } 6085 return -EBUSY; 6086 } 6087 if (mddev->pers) { 6088 if (mddev->ro) 6089 set_disk_ro(disk, 0); 6090 6091 __md_stop_writes(mddev); 6092 __md_stop(mddev); 6093 mddev->queue->backing_dev_info->congested_fn = NULL; 6094 6095 /* tell userspace to handle 'inactive' */ 6096 sysfs_notify_dirent_safe(mddev->sysfs_state); 6097 6098 rdev_for_each(rdev, mddev) 6099 if (rdev->raid_disk >= 0) 6100 sysfs_unlink_rdev(mddev, rdev); 6101 6102 set_capacity(disk, 0); 6103 mutex_unlock(&mddev->open_mutex); 6104 mddev->changed = 1; 6105 revalidate_disk(disk); 6106 6107 if (mddev->ro) 6108 mddev->ro = 0; 6109 } else 6110 mutex_unlock(&mddev->open_mutex); 6111 /* 6112 * Free resources if final stop 6113 */ 6114 if (mode == 0) { 6115 pr_info("md: %s stopped.\n", mdname(mddev)); 6116 6117 if (mddev->bitmap_info.file) { 6118 struct file *f = mddev->bitmap_info.file; 6119 spin_lock(&mddev->lock); 6120 mddev->bitmap_info.file = NULL; 6121 spin_unlock(&mddev->lock); 6122 fput(f); 6123 } 6124 mddev->bitmap_info.offset = 0; 6125 6126 export_array(mddev); 6127 6128 md_clean(mddev); 6129 if (mddev->hold_active == UNTIL_STOP) 6130 mddev->hold_active = 0; 6131 } 6132 md_new_event(mddev); 6133 sysfs_notify_dirent_safe(mddev->sysfs_state); 6134 return 0; 6135 } 6136 6137 #ifndef MODULE 6138 static void autorun_array(struct mddev *mddev) 6139 { 6140 struct md_rdev *rdev; 6141 int err; 6142 6143 if (list_empty(&mddev->disks)) 6144 return; 6145 6146 pr_info("md: running: "); 6147 6148 rdev_for_each(rdev, mddev) { 6149 char b[BDEVNAME_SIZE]; 6150 pr_cont("<%s>", bdevname(rdev->bdev,b)); 6151 } 6152 pr_cont("\n"); 6153 6154 err = do_md_run(mddev); 6155 if (err) { 6156 pr_warn("md: do_md_run() returned %d\n", err); 6157 do_md_stop(mddev, 0, NULL); 6158 } 6159 } 6160 6161 /* 6162 * lets try to run arrays based on all disks that have arrived 6163 * until now. (those are in pending_raid_disks) 6164 * 6165 * the method: pick the first pending disk, collect all disks with 6166 * the same UUID, remove all from the pending list and put them into 6167 * the 'same_array' list. Then order this list based on superblock 6168 * update time (freshest comes first), kick out 'old' disks and 6169 * compare superblocks. If everything's fine then run it. 6170 * 6171 * If "unit" is allocated, then bump its reference count 6172 */ 6173 static void autorun_devices(int part) 6174 { 6175 struct md_rdev *rdev0, *rdev, *tmp; 6176 struct mddev *mddev; 6177 char b[BDEVNAME_SIZE]; 6178 6179 pr_info("md: autorun ...\n"); 6180 while (!list_empty(&pending_raid_disks)) { 6181 int unit; 6182 dev_t dev; 6183 LIST_HEAD(candidates); 6184 rdev0 = list_entry(pending_raid_disks.next, 6185 struct md_rdev, same_set); 6186 6187 pr_debug("md: considering %s ...\n", bdevname(rdev0->bdev,b)); 6188 INIT_LIST_HEAD(&candidates); 6189 rdev_for_each_list(rdev, tmp, &pending_raid_disks) 6190 if (super_90_load(rdev, rdev0, 0) >= 0) { 6191 pr_debug("md: adding %s ...\n", 6192 bdevname(rdev->bdev,b)); 6193 list_move(&rdev->same_set, &candidates); 6194 } 6195 /* 6196 * now we have a set of devices, with all of them having 6197 * mostly sane superblocks. It's time to allocate the 6198 * mddev. 6199 */ 6200 if (part) { 6201 dev = MKDEV(mdp_major, 6202 rdev0->preferred_minor << MdpMinorShift); 6203 unit = MINOR(dev) >> MdpMinorShift; 6204 } else { 6205 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor); 6206 unit = MINOR(dev); 6207 } 6208 if (rdev0->preferred_minor != unit) { 6209 pr_warn("md: unit number in %s is bad: %d\n", 6210 bdevname(rdev0->bdev, b), rdev0->preferred_minor); 6211 break; 6212 } 6213 6214 md_probe(dev, NULL, NULL); 6215 mddev = mddev_find(dev); 6216 if (!mddev || !mddev->gendisk) { 6217 if (mddev) 6218 mddev_put(mddev); 6219 break; 6220 } 6221 if (mddev_lock(mddev)) 6222 pr_warn("md: %s locked, cannot run\n", mdname(mddev)); 6223 else if (mddev->raid_disks || mddev->major_version 6224 || !list_empty(&mddev->disks)) { 6225 pr_warn("md: %s already running, cannot run %s\n", 6226 mdname(mddev), bdevname(rdev0->bdev,b)); 6227 mddev_unlock(mddev); 6228 } else { 6229 pr_debug("md: created %s\n", mdname(mddev)); 6230 mddev->persistent = 1; 6231 rdev_for_each_list(rdev, tmp, &candidates) { 6232 list_del_init(&rdev->same_set); 6233 if (bind_rdev_to_array(rdev, mddev)) 6234 export_rdev(rdev); 6235 } 6236 autorun_array(mddev); 6237 mddev_unlock(mddev); 6238 } 6239 /* on success, candidates will be empty, on error 6240 * it won't... 6241 */ 6242 rdev_for_each_list(rdev, tmp, &candidates) { 6243 list_del_init(&rdev->same_set); 6244 export_rdev(rdev); 6245 } 6246 mddev_put(mddev); 6247 } 6248 pr_info("md: ... autorun DONE.\n"); 6249 } 6250 #endif /* !MODULE */ 6251 6252 static int get_version(void __user *arg) 6253 { 6254 mdu_version_t ver; 6255 6256 ver.major = MD_MAJOR_VERSION; 6257 ver.minor = MD_MINOR_VERSION; 6258 ver.patchlevel = MD_PATCHLEVEL_VERSION; 6259 6260 if (copy_to_user(arg, &ver, sizeof(ver))) 6261 return -EFAULT; 6262 6263 return 0; 6264 } 6265 6266 static int get_array_info(struct mddev *mddev, void __user *arg) 6267 { 6268 mdu_array_info_t info; 6269 int nr,working,insync,failed,spare; 6270 struct md_rdev *rdev; 6271 6272 nr = working = insync = failed = spare = 0; 6273 rcu_read_lock(); 6274 rdev_for_each_rcu(rdev, mddev) { 6275 nr++; 6276 if (test_bit(Faulty, &rdev->flags)) 6277 failed++; 6278 else { 6279 working++; 6280 if (test_bit(In_sync, &rdev->flags)) 6281 insync++; 6282 else if (test_bit(Journal, &rdev->flags)) 6283 /* TODO: add journal count to md_u.h */ 6284 ; 6285 else 6286 spare++; 6287 } 6288 } 6289 rcu_read_unlock(); 6290 6291 info.major_version = mddev->major_version; 6292 info.minor_version = mddev->minor_version; 6293 info.patch_version = MD_PATCHLEVEL_VERSION; 6294 info.ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX); 6295 info.level = mddev->level; 6296 info.size = mddev->dev_sectors / 2; 6297 if (info.size != mddev->dev_sectors / 2) /* overflow */ 6298 info.size = -1; 6299 info.nr_disks = nr; 6300 info.raid_disks = mddev->raid_disks; 6301 info.md_minor = mddev->md_minor; 6302 info.not_persistent= !mddev->persistent; 6303 6304 info.utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX); 6305 info.state = 0; 6306 if (mddev->in_sync) 6307 info.state = (1<<MD_SB_CLEAN); 6308 if (mddev->bitmap && mddev->bitmap_info.offset) 6309 info.state |= (1<<MD_SB_BITMAP_PRESENT); 6310 if (mddev_is_clustered(mddev)) 6311 info.state |= (1<<MD_SB_CLUSTERED); 6312 info.active_disks = insync; 6313 info.working_disks = working; 6314 info.failed_disks = failed; 6315 info.spare_disks = spare; 6316 6317 info.layout = mddev->layout; 6318 info.chunk_size = mddev->chunk_sectors << 9; 6319 6320 if (copy_to_user(arg, &info, sizeof(info))) 6321 return -EFAULT; 6322 6323 return 0; 6324 } 6325 6326 static int get_bitmap_file(struct mddev *mddev, void __user * arg) 6327 { 6328 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */ 6329 char *ptr; 6330 int err; 6331 6332 file = kzalloc(sizeof(*file), GFP_NOIO); 6333 if (!file) 6334 return -ENOMEM; 6335 6336 err = 0; 6337 spin_lock(&mddev->lock); 6338 /* bitmap enabled */ 6339 if (mddev->bitmap_info.file) { 6340 ptr = file_path(mddev->bitmap_info.file, file->pathname, 6341 sizeof(file->pathname)); 6342 if (IS_ERR(ptr)) 6343 err = PTR_ERR(ptr); 6344 else 6345 memmove(file->pathname, ptr, 6346 sizeof(file->pathname)-(ptr-file->pathname)); 6347 } 6348 spin_unlock(&mddev->lock); 6349 6350 if (err == 0 && 6351 copy_to_user(arg, file, sizeof(*file))) 6352 err = -EFAULT; 6353 6354 kfree(file); 6355 return err; 6356 } 6357 6358 static int get_disk_info(struct mddev *mddev, void __user * arg) 6359 { 6360 mdu_disk_info_t info; 6361 struct md_rdev *rdev; 6362 6363 if (copy_from_user(&info, arg, sizeof(info))) 6364 return -EFAULT; 6365 6366 rcu_read_lock(); 6367 rdev = md_find_rdev_nr_rcu(mddev, info.number); 6368 if (rdev) { 6369 info.major = MAJOR(rdev->bdev->bd_dev); 6370 info.minor = MINOR(rdev->bdev->bd_dev); 6371 info.raid_disk = rdev->raid_disk; 6372 info.state = 0; 6373 if (test_bit(Faulty, &rdev->flags)) 6374 info.state |= (1<<MD_DISK_FAULTY); 6375 else if (test_bit(In_sync, &rdev->flags)) { 6376 info.state |= (1<<MD_DISK_ACTIVE); 6377 info.state |= (1<<MD_DISK_SYNC); 6378 } 6379 if (test_bit(Journal, &rdev->flags)) 6380 info.state |= (1<<MD_DISK_JOURNAL); 6381 if (test_bit(WriteMostly, &rdev->flags)) 6382 info.state |= (1<<MD_DISK_WRITEMOSTLY); 6383 if (test_bit(FailFast, &rdev->flags)) 6384 info.state |= (1<<MD_DISK_FAILFAST); 6385 } else { 6386 info.major = info.minor = 0; 6387 info.raid_disk = -1; 6388 info.state = (1<<MD_DISK_REMOVED); 6389 } 6390 rcu_read_unlock(); 6391 6392 if (copy_to_user(arg, &info, sizeof(info))) 6393 return -EFAULT; 6394 6395 return 0; 6396 } 6397 6398 static int add_new_disk(struct mddev *mddev, mdu_disk_info_t *info) 6399 { 6400 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 6401 struct md_rdev *rdev; 6402 dev_t dev = MKDEV(info->major,info->minor); 6403 6404 if (mddev_is_clustered(mddev) && 6405 !(info->state & ((1 << MD_DISK_CLUSTER_ADD) | (1 << MD_DISK_CANDIDATE)))) { 6406 pr_warn("%s: Cannot add to clustered mddev.\n", 6407 mdname(mddev)); 6408 return -EINVAL; 6409 } 6410 6411 if (info->major != MAJOR(dev) || info->minor != MINOR(dev)) 6412 return -EOVERFLOW; 6413 6414 if (!mddev->raid_disks) { 6415 int err; 6416 /* expecting a device which has a superblock */ 6417 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version); 6418 if (IS_ERR(rdev)) { 6419 pr_warn("md: md_import_device returned %ld\n", 6420 PTR_ERR(rdev)); 6421 return PTR_ERR(rdev); 6422 } 6423 if (!list_empty(&mddev->disks)) { 6424 struct md_rdev *rdev0 6425 = list_entry(mddev->disks.next, 6426 struct md_rdev, same_set); 6427 err = super_types[mddev->major_version] 6428 .load_super(rdev, rdev0, mddev->minor_version); 6429 if (err < 0) { 6430 pr_warn("md: %s has different UUID to %s\n", 6431 bdevname(rdev->bdev,b), 6432 bdevname(rdev0->bdev,b2)); 6433 export_rdev(rdev); 6434 return -EINVAL; 6435 } 6436 } 6437 err = bind_rdev_to_array(rdev, mddev); 6438 if (err) 6439 export_rdev(rdev); 6440 return err; 6441 } 6442 6443 /* 6444 * add_new_disk can be used once the array is assembled 6445 * to add "hot spares". They must already have a superblock 6446 * written 6447 */ 6448 if (mddev->pers) { 6449 int err; 6450 if (!mddev->pers->hot_add_disk) { 6451 pr_warn("%s: personality does not support diskops!\n", 6452 mdname(mddev)); 6453 return -EINVAL; 6454 } 6455 if (mddev->persistent) 6456 rdev = md_import_device(dev, mddev->major_version, 6457 mddev->minor_version); 6458 else 6459 rdev = md_import_device(dev, -1, -1); 6460 if (IS_ERR(rdev)) { 6461 pr_warn("md: md_import_device returned %ld\n", 6462 PTR_ERR(rdev)); 6463 return PTR_ERR(rdev); 6464 } 6465 /* set saved_raid_disk if appropriate */ 6466 if (!mddev->persistent) { 6467 if (info->state & (1<<MD_DISK_SYNC) && 6468 info->raid_disk < mddev->raid_disks) { 6469 rdev->raid_disk = info->raid_disk; 6470 set_bit(In_sync, &rdev->flags); 6471 clear_bit(Bitmap_sync, &rdev->flags); 6472 } else 6473 rdev->raid_disk = -1; 6474 rdev->saved_raid_disk = rdev->raid_disk; 6475 } else 6476 super_types[mddev->major_version]. 6477 validate_super(mddev, rdev); 6478 if ((info->state & (1<<MD_DISK_SYNC)) && 6479 rdev->raid_disk != info->raid_disk) { 6480 /* This was a hot-add request, but events doesn't 6481 * match, so reject it. 6482 */ 6483 export_rdev(rdev); 6484 return -EINVAL; 6485 } 6486 6487 clear_bit(In_sync, &rdev->flags); /* just to be sure */ 6488 if (info->state & (1<<MD_DISK_WRITEMOSTLY)) 6489 set_bit(WriteMostly, &rdev->flags); 6490 else 6491 clear_bit(WriteMostly, &rdev->flags); 6492 if (info->state & (1<<MD_DISK_FAILFAST)) 6493 set_bit(FailFast, &rdev->flags); 6494 else 6495 clear_bit(FailFast, &rdev->flags); 6496 6497 if (info->state & (1<<MD_DISK_JOURNAL)) { 6498 struct md_rdev *rdev2; 6499 bool has_journal = false; 6500 6501 /* make sure no existing journal disk */ 6502 rdev_for_each(rdev2, mddev) { 6503 if (test_bit(Journal, &rdev2->flags)) { 6504 has_journal = true; 6505 break; 6506 } 6507 } 6508 if (has_journal || mddev->bitmap) { 6509 export_rdev(rdev); 6510 return -EBUSY; 6511 } 6512 set_bit(Journal, &rdev->flags); 6513 } 6514 /* 6515 * check whether the device shows up in other nodes 6516 */ 6517 if (mddev_is_clustered(mddev)) { 6518 if (info->state & (1 << MD_DISK_CANDIDATE)) 6519 set_bit(Candidate, &rdev->flags); 6520 else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) { 6521 /* --add initiated by this node */ 6522 err = md_cluster_ops->add_new_disk(mddev, rdev); 6523 if (err) { 6524 export_rdev(rdev); 6525 return err; 6526 } 6527 } 6528 } 6529 6530 rdev->raid_disk = -1; 6531 err = bind_rdev_to_array(rdev, mddev); 6532 6533 if (err) 6534 export_rdev(rdev); 6535 6536 if (mddev_is_clustered(mddev)) { 6537 if (info->state & (1 << MD_DISK_CANDIDATE)) { 6538 if (!err) { 6539 err = md_cluster_ops->new_disk_ack(mddev, 6540 err == 0); 6541 if (err) 6542 md_kick_rdev_from_array(rdev); 6543 } 6544 } else { 6545 if (err) 6546 md_cluster_ops->add_new_disk_cancel(mddev); 6547 else 6548 err = add_bound_rdev(rdev); 6549 } 6550 6551 } else if (!err) 6552 err = add_bound_rdev(rdev); 6553 6554 return err; 6555 } 6556 6557 /* otherwise, add_new_disk is only allowed 6558 * for major_version==0 superblocks 6559 */ 6560 if (mddev->major_version != 0) { 6561 pr_warn("%s: ADD_NEW_DISK not supported\n", mdname(mddev)); 6562 return -EINVAL; 6563 } 6564 6565 if (!(info->state & (1<<MD_DISK_FAULTY))) { 6566 int err; 6567 rdev = md_import_device(dev, -1, 0); 6568 if (IS_ERR(rdev)) { 6569 pr_warn("md: error, md_import_device() returned %ld\n", 6570 PTR_ERR(rdev)); 6571 return PTR_ERR(rdev); 6572 } 6573 rdev->desc_nr = info->number; 6574 if (info->raid_disk < mddev->raid_disks) 6575 rdev->raid_disk = info->raid_disk; 6576 else 6577 rdev->raid_disk = -1; 6578 6579 if (rdev->raid_disk < mddev->raid_disks) 6580 if (info->state & (1<<MD_DISK_SYNC)) 6581 set_bit(In_sync, &rdev->flags); 6582 6583 if (info->state & (1<<MD_DISK_WRITEMOSTLY)) 6584 set_bit(WriteMostly, &rdev->flags); 6585 if (info->state & (1<<MD_DISK_FAILFAST)) 6586 set_bit(FailFast, &rdev->flags); 6587 6588 if (!mddev->persistent) { 6589 pr_debug("md: nonpersistent superblock ...\n"); 6590 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512; 6591 } else 6592 rdev->sb_start = calc_dev_sboffset(rdev); 6593 rdev->sectors = rdev->sb_start; 6594 6595 err = bind_rdev_to_array(rdev, mddev); 6596 if (err) { 6597 export_rdev(rdev); 6598 return err; 6599 } 6600 } 6601 6602 return 0; 6603 } 6604 6605 static int hot_remove_disk(struct mddev *mddev, dev_t dev) 6606 { 6607 char b[BDEVNAME_SIZE]; 6608 struct md_rdev *rdev; 6609 6610 if (!mddev->pers) 6611 return -ENODEV; 6612 6613 rdev = find_rdev(mddev, dev); 6614 if (!rdev) 6615 return -ENXIO; 6616 6617 if (rdev->raid_disk < 0) 6618 goto kick_rdev; 6619 6620 clear_bit(Blocked, &rdev->flags); 6621 remove_and_add_spares(mddev, rdev); 6622 6623 if (rdev->raid_disk >= 0) 6624 goto busy; 6625 6626 kick_rdev: 6627 if (mddev_is_clustered(mddev)) 6628 md_cluster_ops->remove_disk(mddev, rdev); 6629 6630 md_kick_rdev_from_array(rdev); 6631 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 6632 if (mddev->thread) 6633 md_wakeup_thread(mddev->thread); 6634 else 6635 md_update_sb(mddev, 1); 6636 md_new_event(mddev); 6637 6638 return 0; 6639 busy: 6640 pr_debug("md: cannot remove active disk %s from %s ...\n", 6641 bdevname(rdev->bdev,b), mdname(mddev)); 6642 return -EBUSY; 6643 } 6644 6645 static int hot_add_disk(struct mddev *mddev, dev_t dev) 6646 { 6647 char b[BDEVNAME_SIZE]; 6648 int err; 6649 struct md_rdev *rdev; 6650 6651 if (!mddev->pers) 6652 return -ENODEV; 6653 6654 if (mddev->major_version != 0) { 6655 pr_warn("%s: HOT_ADD may only be used with version-0 superblocks.\n", 6656 mdname(mddev)); 6657 return -EINVAL; 6658 } 6659 if (!mddev->pers->hot_add_disk) { 6660 pr_warn("%s: personality does not support diskops!\n", 6661 mdname(mddev)); 6662 return -EINVAL; 6663 } 6664 6665 rdev = md_import_device(dev, -1, 0); 6666 if (IS_ERR(rdev)) { 6667 pr_warn("md: error, md_import_device() returned %ld\n", 6668 PTR_ERR(rdev)); 6669 return -EINVAL; 6670 } 6671 6672 if (mddev->persistent) 6673 rdev->sb_start = calc_dev_sboffset(rdev); 6674 else 6675 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512; 6676 6677 rdev->sectors = rdev->sb_start; 6678 6679 if (test_bit(Faulty, &rdev->flags)) { 6680 pr_warn("md: can not hot-add faulty %s disk to %s!\n", 6681 bdevname(rdev->bdev,b), mdname(mddev)); 6682 err = -EINVAL; 6683 goto abort_export; 6684 } 6685 6686 clear_bit(In_sync, &rdev->flags); 6687 rdev->desc_nr = -1; 6688 rdev->saved_raid_disk = -1; 6689 err = bind_rdev_to_array(rdev, mddev); 6690 if (err) 6691 goto abort_export; 6692 6693 /* 6694 * The rest should better be atomic, we can have disk failures 6695 * noticed in interrupt contexts ... 6696 */ 6697 6698 rdev->raid_disk = -1; 6699 6700 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 6701 if (!mddev->thread) 6702 md_update_sb(mddev, 1); 6703 /* 6704 * Kick recovery, maybe this spare has to be added to the 6705 * array immediately. 6706 */ 6707 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 6708 md_wakeup_thread(mddev->thread); 6709 md_new_event(mddev); 6710 return 0; 6711 6712 abort_export: 6713 export_rdev(rdev); 6714 return err; 6715 } 6716 6717 static int set_bitmap_file(struct mddev *mddev, int fd) 6718 { 6719 int err = 0; 6720 6721 if (mddev->pers) { 6722 if (!mddev->pers->quiesce || !mddev->thread) 6723 return -EBUSY; 6724 if (mddev->recovery || mddev->sync_thread) 6725 return -EBUSY; 6726 /* we should be able to change the bitmap.. */ 6727 } 6728 6729 if (fd >= 0) { 6730 struct inode *inode; 6731 struct file *f; 6732 6733 if (mddev->bitmap || mddev->bitmap_info.file) 6734 return -EEXIST; /* cannot add when bitmap is present */ 6735 f = fget(fd); 6736 6737 if (f == NULL) { 6738 pr_warn("%s: error: failed to get bitmap file\n", 6739 mdname(mddev)); 6740 return -EBADF; 6741 } 6742 6743 inode = f->f_mapping->host; 6744 if (!S_ISREG(inode->i_mode)) { 6745 pr_warn("%s: error: bitmap file must be a regular file\n", 6746 mdname(mddev)); 6747 err = -EBADF; 6748 } else if (!(f->f_mode & FMODE_WRITE)) { 6749 pr_warn("%s: error: bitmap file must open for write\n", 6750 mdname(mddev)); 6751 err = -EBADF; 6752 } else if (atomic_read(&inode->i_writecount) != 1) { 6753 pr_warn("%s: error: bitmap file is already in use\n", 6754 mdname(mddev)); 6755 err = -EBUSY; 6756 } 6757 if (err) { 6758 fput(f); 6759 return err; 6760 } 6761 mddev->bitmap_info.file = f; 6762 mddev->bitmap_info.offset = 0; /* file overrides offset */ 6763 } else if (mddev->bitmap == NULL) 6764 return -ENOENT; /* cannot remove what isn't there */ 6765 err = 0; 6766 if (mddev->pers) { 6767 if (fd >= 0) { 6768 struct bitmap *bitmap; 6769 6770 bitmap = md_bitmap_create(mddev, -1); 6771 mddev_suspend(mddev); 6772 if (!IS_ERR(bitmap)) { 6773 mddev->bitmap = bitmap; 6774 err = md_bitmap_load(mddev); 6775 } else 6776 err = PTR_ERR(bitmap); 6777 if (err) { 6778 md_bitmap_destroy(mddev); 6779 fd = -1; 6780 } 6781 mddev_resume(mddev); 6782 } else if (fd < 0) { 6783 mddev_suspend(mddev); 6784 md_bitmap_destroy(mddev); 6785 mddev_resume(mddev); 6786 } 6787 } 6788 if (fd < 0) { 6789 struct file *f = mddev->bitmap_info.file; 6790 if (f) { 6791 spin_lock(&mddev->lock); 6792 mddev->bitmap_info.file = NULL; 6793 spin_unlock(&mddev->lock); 6794 fput(f); 6795 } 6796 } 6797 6798 return err; 6799 } 6800 6801 /* 6802 * set_array_info is used two different ways 6803 * The original usage is when creating a new array. 6804 * In this usage, raid_disks is > 0 and it together with 6805 * level, size, not_persistent,layout,chunksize determine the 6806 * shape of the array. 6807 * This will always create an array with a type-0.90.0 superblock. 6808 * The newer usage is when assembling an array. 6809 * In this case raid_disks will be 0, and the major_version field is 6810 * use to determine which style super-blocks are to be found on the devices. 6811 * The minor and patch _version numbers are also kept incase the 6812 * super_block handler wishes to interpret them. 6813 */ 6814 static int set_array_info(struct mddev *mddev, mdu_array_info_t *info) 6815 { 6816 6817 if (info->raid_disks == 0) { 6818 /* just setting version number for superblock loading */ 6819 if (info->major_version < 0 || 6820 info->major_version >= ARRAY_SIZE(super_types) || 6821 super_types[info->major_version].name == NULL) { 6822 /* maybe try to auto-load a module? */ 6823 pr_warn("md: superblock version %d not known\n", 6824 info->major_version); 6825 return -EINVAL; 6826 } 6827 mddev->major_version = info->major_version; 6828 mddev->minor_version = info->minor_version; 6829 mddev->patch_version = info->patch_version; 6830 mddev->persistent = !info->not_persistent; 6831 /* ensure mddev_put doesn't delete this now that there 6832 * is some minimal configuration. 6833 */ 6834 mddev->ctime = ktime_get_real_seconds(); 6835 return 0; 6836 } 6837 mddev->major_version = MD_MAJOR_VERSION; 6838 mddev->minor_version = MD_MINOR_VERSION; 6839 mddev->patch_version = MD_PATCHLEVEL_VERSION; 6840 mddev->ctime = ktime_get_real_seconds(); 6841 6842 mddev->level = info->level; 6843 mddev->clevel[0] = 0; 6844 mddev->dev_sectors = 2 * (sector_t)info->size; 6845 mddev->raid_disks = info->raid_disks; 6846 /* don't set md_minor, it is determined by which /dev/md* was 6847 * openned 6848 */ 6849 if (info->state & (1<<MD_SB_CLEAN)) 6850 mddev->recovery_cp = MaxSector; 6851 else 6852 mddev->recovery_cp = 0; 6853 mddev->persistent = ! info->not_persistent; 6854 mddev->external = 0; 6855 6856 mddev->layout = info->layout; 6857 mddev->chunk_sectors = info->chunk_size >> 9; 6858 6859 if (mddev->persistent) { 6860 mddev->max_disks = MD_SB_DISKS; 6861 mddev->flags = 0; 6862 mddev->sb_flags = 0; 6863 } 6864 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 6865 6866 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9; 6867 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9); 6868 mddev->bitmap_info.offset = 0; 6869 6870 mddev->reshape_position = MaxSector; 6871 6872 /* 6873 * Generate a 128 bit UUID 6874 */ 6875 get_random_bytes(mddev->uuid, 16); 6876 6877 mddev->new_level = mddev->level; 6878 mddev->new_chunk_sectors = mddev->chunk_sectors; 6879 mddev->new_layout = mddev->layout; 6880 mddev->delta_disks = 0; 6881 mddev->reshape_backwards = 0; 6882 6883 return 0; 6884 } 6885 6886 void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors) 6887 { 6888 lockdep_assert_held(&mddev->reconfig_mutex); 6889 6890 if (mddev->external_size) 6891 return; 6892 6893 mddev->array_sectors = array_sectors; 6894 } 6895 EXPORT_SYMBOL(md_set_array_sectors); 6896 6897 static int update_size(struct mddev *mddev, sector_t num_sectors) 6898 { 6899 struct md_rdev *rdev; 6900 int rv; 6901 int fit = (num_sectors == 0); 6902 sector_t old_dev_sectors = mddev->dev_sectors; 6903 6904 if (mddev->pers->resize == NULL) 6905 return -EINVAL; 6906 /* The "num_sectors" is the number of sectors of each device that 6907 * is used. This can only make sense for arrays with redundancy. 6908 * linear and raid0 always use whatever space is available. We can only 6909 * consider changing this number if no resync or reconstruction is 6910 * happening, and if the new size is acceptable. It must fit before the 6911 * sb_start or, if that is <data_offset, it must fit before the size 6912 * of each device. If num_sectors is zero, we find the largest size 6913 * that fits. 6914 */ 6915 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) || 6916 mddev->sync_thread) 6917 return -EBUSY; 6918 if (mddev->ro) 6919 return -EROFS; 6920 6921 rdev_for_each(rdev, mddev) { 6922 sector_t avail = rdev->sectors; 6923 6924 if (fit && (num_sectors == 0 || num_sectors > avail)) 6925 num_sectors = avail; 6926 if (avail < num_sectors) 6927 return -ENOSPC; 6928 } 6929 rv = mddev->pers->resize(mddev, num_sectors); 6930 if (!rv) { 6931 if (mddev_is_clustered(mddev)) 6932 md_cluster_ops->update_size(mddev, old_dev_sectors); 6933 else if (mddev->queue) { 6934 set_capacity(mddev->gendisk, mddev->array_sectors); 6935 revalidate_disk(mddev->gendisk); 6936 } 6937 } 6938 return rv; 6939 } 6940 6941 static int update_raid_disks(struct mddev *mddev, int raid_disks) 6942 { 6943 int rv; 6944 struct md_rdev *rdev; 6945 /* change the number of raid disks */ 6946 if (mddev->pers->check_reshape == NULL) 6947 return -EINVAL; 6948 if (mddev->ro) 6949 return -EROFS; 6950 if (raid_disks <= 0 || 6951 (mddev->max_disks && raid_disks >= mddev->max_disks)) 6952 return -EINVAL; 6953 if (mddev->sync_thread || 6954 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) || 6955 mddev->reshape_position != MaxSector) 6956 return -EBUSY; 6957 6958 rdev_for_each(rdev, mddev) { 6959 if (mddev->raid_disks < raid_disks && 6960 rdev->data_offset < rdev->new_data_offset) 6961 return -EINVAL; 6962 if (mddev->raid_disks > raid_disks && 6963 rdev->data_offset > rdev->new_data_offset) 6964 return -EINVAL; 6965 } 6966 6967 mddev->delta_disks = raid_disks - mddev->raid_disks; 6968 if (mddev->delta_disks < 0) 6969 mddev->reshape_backwards = 1; 6970 else if (mddev->delta_disks > 0) 6971 mddev->reshape_backwards = 0; 6972 6973 rv = mddev->pers->check_reshape(mddev); 6974 if (rv < 0) { 6975 mddev->delta_disks = 0; 6976 mddev->reshape_backwards = 0; 6977 } 6978 return rv; 6979 } 6980 6981 /* 6982 * update_array_info is used to change the configuration of an 6983 * on-line array. 6984 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size 6985 * fields in the info are checked against the array. 6986 * Any differences that cannot be handled will cause an error. 6987 * Normally, only one change can be managed at a time. 6988 */ 6989 static int update_array_info(struct mddev *mddev, mdu_array_info_t *info) 6990 { 6991 int rv = 0; 6992 int cnt = 0; 6993 int state = 0; 6994 6995 /* calculate expected state,ignoring low bits */ 6996 if (mddev->bitmap && mddev->bitmap_info.offset) 6997 state |= (1 << MD_SB_BITMAP_PRESENT); 6998 6999 if (mddev->major_version != info->major_version || 7000 mddev->minor_version != info->minor_version || 7001 /* mddev->patch_version != info->patch_version || */ 7002 mddev->ctime != info->ctime || 7003 mddev->level != info->level || 7004 /* mddev->layout != info->layout || */ 7005 mddev->persistent != !info->not_persistent || 7006 mddev->chunk_sectors != info->chunk_size >> 9 || 7007 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */ 7008 ((state^info->state) & 0xfffffe00) 7009 ) 7010 return -EINVAL; 7011 /* Check there is only one change */ 7012 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size) 7013 cnt++; 7014 if (mddev->raid_disks != info->raid_disks) 7015 cnt++; 7016 if (mddev->layout != info->layout) 7017 cnt++; 7018 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) 7019 cnt++; 7020 if (cnt == 0) 7021 return 0; 7022 if (cnt > 1) 7023 return -EINVAL; 7024 7025 if (mddev->layout != info->layout) { 7026 /* Change layout 7027 * we don't need to do anything at the md level, the 7028 * personality will take care of it all. 7029 */ 7030 if (mddev->pers->check_reshape == NULL) 7031 return -EINVAL; 7032 else { 7033 mddev->new_layout = info->layout; 7034 rv = mddev->pers->check_reshape(mddev); 7035 if (rv) 7036 mddev->new_layout = mddev->layout; 7037 return rv; 7038 } 7039 } 7040 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size) 7041 rv = update_size(mddev, (sector_t)info->size * 2); 7042 7043 if (mddev->raid_disks != info->raid_disks) 7044 rv = update_raid_disks(mddev, info->raid_disks); 7045 7046 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) { 7047 if (mddev->pers->quiesce == NULL || mddev->thread == NULL) { 7048 rv = -EINVAL; 7049 goto err; 7050 } 7051 if (mddev->recovery || mddev->sync_thread) { 7052 rv = -EBUSY; 7053 goto err; 7054 } 7055 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) { 7056 struct bitmap *bitmap; 7057 /* add the bitmap */ 7058 if (mddev->bitmap) { 7059 rv = -EEXIST; 7060 goto err; 7061 } 7062 if (mddev->bitmap_info.default_offset == 0) { 7063 rv = -EINVAL; 7064 goto err; 7065 } 7066 mddev->bitmap_info.offset = 7067 mddev->bitmap_info.default_offset; 7068 mddev->bitmap_info.space = 7069 mddev->bitmap_info.default_space; 7070 bitmap = md_bitmap_create(mddev, -1); 7071 mddev_suspend(mddev); 7072 if (!IS_ERR(bitmap)) { 7073 mddev->bitmap = bitmap; 7074 rv = md_bitmap_load(mddev); 7075 } else 7076 rv = PTR_ERR(bitmap); 7077 if (rv) 7078 md_bitmap_destroy(mddev); 7079 mddev_resume(mddev); 7080 } else { 7081 /* remove the bitmap */ 7082 if (!mddev->bitmap) { 7083 rv = -ENOENT; 7084 goto err; 7085 } 7086 if (mddev->bitmap->storage.file) { 7087 rv = -EINVAL; 7088 goto err; 7089 } 7090 if (mddev->bitmap_info.nodes) { 7091 /* hold PW on all the bitmap lock */ 7092 if (md_cluster_ops->lock_all_bitmaps(mddev) <= 0) { 7093 pr_warn("md: can't change bitmap to none since the array is in use by more than one node\n"); 7094 rv = -EPERM; 7095 md_cluster_ops->unlock_all_bitmaps(mddev); 7096 goto err; 7097 } 7098 7099 mddev->bitmap_info.nodes = 0; 7100 md_cluster_ops->leave(mddev); 7101 } 7102 mddev_suspend(mddev); 7103 md_bitmap_destroy(mddev); 7104 mddev_resume(mddev); 7105 mddev->bitmap_info.offset = 0; 7106 } 7107 } 7108 md_update_sb(mddev, 1); 7109 return rv; 7110 err: 7111 return rv; 7112 } 7113 7114 static int set_disk_faulty(struct mddev *mddev, dev_t dev) 7115 { 7116 struct md_rdev *rdev; 7117 int err = 0; 7118 7119 if (mddev->pers == NULL) 7120 return -ENODEV; 7121 7122 rcu_read_lock(); 7123 rdev = md_find_rdev_rcu(mddev, dev); 7124 if (!rdev) 7125 err = -ENODEV; 7126 else { 7127 md_error(mddev, rdev); 7128 if (!test_bit(Faulty, &rdev->flags)) 7129 err = -EBUSY; 7130 } 7131 rcu_read_unlock(); 7132 return err; 7133 } 7134 7135 /* 7136 * We have a problem here : there is no easy way to give a CHS 7137 * virtual geometry. We currently pretend that we have a 2 heads 7138 * 4 sectors (with a BIG number of cylinders...). This drives 7139 * dosfs just mad... ;-) 7140 */ 7141 static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo) 7142 { 7143 struct mddev *mddev = bdev->bd_disk->private_data; 7144 7145 geo->heads = 2; 7146 geo->sectors = 4; 7147 geo->cylinders = mddev->array_sectors / 8; 7148 return 0; 7149 } 7150 7151 static inline bool md_ioctl_valid(unsigned int cmd) 7152 { 7153 switch (cmd) { 7154 case ADD_NEW_DISK: 7155 case BLKROSET: 7156 case GET_ARRAY_INFO: 7157 case GET_BITMAP_FILE: 7158 case GET_DISK_INFO: 7159 case HOT_ADD_DISK: 7160 case HOT_REMOVE_DISK: 7161 case RAID_AUTORUN: 7162 case RAID_VERSION: 7163 case RESTART_ARRAY_RW: 7164 case RUN_ARRAY: 7165 case SET_ARRAY_INFO: 7166 case SET_BITMAP_FILE: 7167 case SET_DISK_FAULTY: 7168 case STOP_ARRAY: 7169 case STOP_ARRAY_RO: 7170 case CLUSTERED_DISK_NACK: 7171 return true; 7172 default: 7173 return false; 7174 } 7175 } 7176 7177 static int md_ioctl(struct block_device *bdev, fmode_t mode, 7178 unsigned int cmd, unsigned long arg) 7179 { 7180 int err = 0; 7181 void __user *argp = (void __user *)arg; 7182 struct mddev *mddev = NULL; 7183 int ro; 7184 bool did_set_md_closing = false; 7185 7186 if (!md_ioctl_valid(cmd)) 7187 return -ENOTTY; 7188 7189 switch (cmd) { 7190 case RAID_VERSION: 7191 case GET_ARRAY_INFO: 7192 case GET_DISK_INFO: 7193 break; 7194 default: 7195 if (!capable(CAP_SYS_ADMIN)) 7196 return -EACCES; 7197 } 7198 7199 /* 7200 * Commands dealing with the RAID driver but not any 7201 * particular array: 7202 */ 7203 switch (cmd) { 7204 case RAID_VERSION: 7205 err = get_version(argp); 7206 goto out; 7207 7208 #ifndef MODULE 7209 case RAID_AUTORUN: 7210 err = 0; 7211 autostart_arrays(arg); 7212 goto out; 7213 #endif 7214 default:; 7215 } 7216 7217 /* 7218 * Commands creating/starting a new array: 7219 */ 7220 7221 mddev = bdev->bd_disk->private_data; 7222 7223 if (!mddev) { 7224 BUG(); 7225 goto out; 7226 } 7227 7228 /* Some actions do not requires the mutex */ 7229 switch (cmd) { 7230 case GET_ARRAY_INFO: 7231 if (!mddev->raid_disks && !mddev->external) 7232 err = -ENODEV; 7233 else 7234 err = get_array_info(mddev, argp); 7235 goto out; 7236 7237 case GET_DISK_INFO: 7238 if (!mddev->raid_disks && !mddev->external) 7239 err = -ENODEV; 7240 else 7241 err = get_disk_info(mddev, argp); 7242 goto out; 7243 7244 case SET_DISK_FAULTY: 7245 err = set_disk_faulty(mddev, new_decode_dev(arg)); 7246 goto out; 7247 7248 case GET_BITMAP_FILE: 7249 err = get_bitmap_file(mddev, argp); 7250 goto out; 7251 7252 } 7253 7254 if (cmd == ADD_NEW_DISK) 7255 /* need to ensure md_delayed_delete() has completed */ 7256 flush_workqueue(md_misc_wq); 7257 7258 if (cmd == HOT_REMOVE_DISK) 7259 /* need to ensure recovery thread has run */ 7260 wait_event_interruptible_timeout(mddev->sb_wait, 7261 !test_bit(MD_RECOVERY_NEEDED, 7262 &mddev->recovery), 7263 msecs_to_jiffies(5000)); 7264 if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) { 7265 /* Need to flush page cache, and ensure no-one else opens 7266 * and writes 7267 */ 7268 mutex_lock(&mddev->open_mutex); 7269 if (mddev->pers && atomic_read(&mddev->openers) > 1) { 7270 mutex_unlock(&mddev->open_mutex); 7271 err = -EBUSY; 7272 goto out; 7273 } 7274 WARN_ON_ONCE(test_bit(MD_CLOSING, &mddev->flags)); 7275 set_bit(MD_CLOSING, &mddev->flags); 7276 did_set_md_closing = true; 7277 mutex_unlock(&mddev->open_mutex); 7278 sync_blockdev(bdev); 7279 } 7280 err = mddev_lock(mddev); 7281 if (err) { 7282 pr_debug("md: ioctl lock interrupted, reason %d, cmd %d\n", 7283 err, cmd); 7284 goto out; 7285 } 7286 7287 if (cmd == SET_ARRAY_INFO) { 7288 mdu_array_info_t info; 7289 if (!arg) 7290 memset(&info, 0, sizeof(info)); 7291 else if (copy_from_user(&info, argp, sizeof(info))) { 7292 err = -EFAULT; 7293 goto unlock; 7294 } 7295 if (mddev->pers) { 7296 err = update_array_info(mddev, &info); 7297 if (err) { 7298 pr_warn("md: couldn't update array info. %d\n", err); 7299 goto unlock; 7300 } 7301 goto unlock; 7302 } 7303 if (!list_empty(&mddev->disks)) { 7304 pr_warn("md: array %s already has disks!\n", mdname(mddev)); 7305 err = -EBUSY; 7306 goto unlock; 7307 } 7308 if (mddev->raid_disks) { 7309 pr_warn("md: array %s already initialised!\n", mdname(mddev)); 7310 err = -EBUSY; 7311 goto unlock; 7312 } 7313 err = set_array_info(mddev, &info); 7314 if (err) { 7315 pr_warn("md: couldn't set array info. %d\n", err); 7316 goto unlock; 7317 } 7318 goto unlock; 7319 } 7320 7321 /* 7322 * Commands querying/configuring an existing array: 7323 */ 7324 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY, 7325 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */ 7326 if ((!mddev->raid_disks && !mddev->external) 7327 && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY 7328 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE 7329 && cmd != GET_BITMAP_FILE) { 7330 err = -ENODEV; 7331 goto unlock; 7332 } 7333 7334 /* 7335 * Commands even a read-only array can execute: 7336 */ 7337 switch (cmd) { 7338 case RESTART_ARRAY_RW: 7339 err = restart_array(mddev); 7340 goto unlock; 7341 7342 case STOP_ARRAY: 7343 err = do_md_stop(mddev, 0, bdev); 7344 goto unlock; 7345 7346 case STOP_ARRAY_RO: 7347 err = md_set_readonly(mddev, bdev); 7348 goto unlock; 7349 7350 case HOT_REMOVE_DISK: 7351 err = hot_remove_disk(mddev, new_decode_dev(arg)); 7352 goto unlock; 7353 7354 case ADD_NEW_DISK: 7355 /* We can support ADD_NEW_DISK on read-only arrays 7356 * only if we are re-adding a preexisting device. 7357 * So require mddev->pers and MD_DISK_SYNC. 7358 */ 7359 if (mddev->pers) { 7360 mdu_disk_info_t info; 7361 if (copy_from_user(&info, argp, sizeof(info))) 7362 err = -EFAULT; 7363 else if (!(info.state & (1<<MD_DISK_SYNC))) 7364 /* Need to clear read-only for this */ 7365 break; 7366 else 7367 err = add_new_disk(mddev, &info); 7368 goto unlock; 7369 } 7370 break; 7371 7372 case BLKROSET: 7373 if (get_user(ro, (int __user *)(arg))) { 7374 err = -EFAULT; 7375 goto unlock; 7376 } 7377 err = -EINVAL; 7378 7379 /* if the bdev is going readonly the value of mddev->ro 7380 * does not matter, no writes are coming 7381 */ 7382 if (ro) 7383 goto unlock; 7384 7385 /* are we are already prepared for writes? */ 7386 if (mddev->ro != 1) 7387 goto unlock; 7388 7389 /* transitioning to readauto need only happen for 7390 * arrays that call md_write_start 7391 */ 7392 if (mddev->pers) { 7393 err = restart_array(mddev); 7394 if (err == 0) { 7395 mddev->ro = 2; 7396 set_disk_ro(mddev->gendisk, 0); 7397 } 7398 } 7399 goto unlock; 7400 } 7401 7402 /* 7403 * The remaining ioctls are changing the state of the 7404 * superblock, so we do not allow them on read-only arrays. 7405 */ 7406 if (mddev->ro && mddev->pers) { 7407 if (mddev->ro == 2) { 7408 mddev->ro = 0; 7409 sysfs_notify_dirent_safe(mddev->sysfs_state); 7410 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 7411 /* mddev_unlock will wake thread */ 7412 /* If a device failed while we were read-only, we 7413 * need to make sure the metadata is updated now. 7414 */ 7415 if (test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)) { 7416 mddev_unlock(mddev); 7417 wait_event(mddev->sb_wait, 7418 !test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags) && 7419 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)); 7420 mddev_lock_nointr(mddev); 7421 } 7422 } else { 7423 err = -EROFS; 7424 goto unlock; 7425 } 7426 } 7427 7428 switch (cmd) { 7429 case ADD_NEW_DISK: 7430 { 7431 mdu_disk_info_t info; 7432 if (copy_from_user(&info, argp, sizeof(info))) 7433 err = -EFAULT; 7434 else 7435 err = add_new_disk(mddev, &info); 7436 goto unlock; 7437 } 7438 7439 case CLUSTERED_DISK_NACK: 7440 if (mddev_is_clustered(mddev)) 7441 md_cluster_ops->new_disk_ack(mddev, false); 7442 else 7443 err = -EINVAL; 7444 goto unlock; 7445 7446 case HOT_ADD_DISK: 7447 err = hot_add_disk(mddev, new_decode_dev(arg)); 7448 goto unlock; 7449 7450 case RUN_ARRAY: 7451 err = do_md_run(mddev); 7452 goto unlock; 7453 7454 case SET_BITMAP_FILE: 7455 err = set_bitmap_file(mddev, (int)arg); 7456 goto unlock; 7457 7458 default: 7459 err = -EINVAL; 7460 goto unlock; 7461 } 7462 7463 unlock: 7464 if (mddev->hold_active == UNTIL_IOCTL && 7465 err != -EINVAL) 7466 mddev->hold_active = 0; 7467 mddev_unlock(mddev); 7468 out: 7469 if(did_set_md_closing) 7470 clear_bit(MD_CLOSING, &mddev->flags); 7471 return err; 7472 } 7473 #ifdef CONFIG_COMPAT 7474 static int md_compat_ioctl(struct block_device *bdev, fmode_t mode, 7475 unsigned int cmd, unsigned long arg) 7476 { 7477 switch (cmd) { 7478 case HOT_REMOVE_DISK: 7479 case HOT_ADD_DISK: 7480 case SET_DISK_FAULTY: 7481 case SET_BITMAP_FILE: 7482 /* These take in integer arg, do not convert */ 7483 break; 7484 default: 7485 arg = (unsigned long)compat_ptr(arg); 7486 break; 7487 } 7488 7489 return md_ioctl(bdev, mode, cmd, arg); 7490 } 7491 #endif /* CONFIG_COMPAT */ 7492 7493 static int md_open(struct block_device *bdev, fmode_t mode) 7494 { 7495 /* 7496 * Succeed if we can lock the mddev, which confirms that 7497 * it isn't being stopped right now. 7498 */ 7499 struct mddev *mddev = mddev_find(bdev->bd_dev); 7500 int err; 7501 7502 if (!mddev) 7503 return -ENODEV; 7504 7505 if (mddev->gendisk != bdev->bd_disk) { 7506 /* we are racing with mddev_put which is discarding this 7507 * bd_disk. 7508 */ 7509 mddev_put(mddev); 7510 /* Wait until bdev->bd_disk is definitely gone */ 7511 flush_workqueue(md_misc_wq); 7512 /* Then retry the open from the top */ 7513 return -ERESTARTSYS; 7514 } 7515 BUG_ON(mddev != bdev->bd_disk->private_data); 7516 7517 if ((err = mutex_lock_interruptible(&mddev->open_mutex))) 7518 goto out; 7519 7520 if (test_bit(MD_CLOSING, &mddev->flags)) { 7521 mutex_unlock(&mddev->open_mutex); 7522 err = -ENODEV; 7523 goto out; 7524 } 7525 7526 err = 0; 7527 atomic_inc(&mddev->openers); 7528 mutex_unlock(&mddev->open_mutex); 7529 7530 check_disk_change(bdev); 7531 out: 7532 if (err) 7533 mddev_put(mddev); 7534 return err; 7535 } 7536 7537 static void md_release(struct gendisk *disk, fmode_t mode) 7538 { 7539 struct mddev *mddev = disk->private_data; 7540 7541 BUG_ON(!mddev); 7542 atomic_dec(&mddev->openers); 7543 mddev_put(mddev); 7544 } 7545 7546 static int md_media_changed(struct gendisk *disk) 7547 { 7548 struct mddev *mddev = disk->private_data; 7549 7550 return mddev->changed; 7551 } 7552 7553 static int md_revalidate(struct gendisk *disk) 7554 { 7555 struct mddev *mddev = disk->private_data; 7556 7557 mddev->changed = 0; 7558 return 0; 7559 } 7560 static const struct block_device_operations md_fops = 7561 { 7562 .owner = THIS_MODULE, 7563 .open = md_open, 7564 .release = md_release, 7565 .ioctl = md_ioctl, 7566 #ifdef CONFIG_COMPAT 7567 .compat_ioctl = md_compat_ioctl, 7568 #endif 7569 .getgeo = md_getgeo, 7570 .media_changed = md_media_changed, 7571 .revalidate_disk= md_revalidate, 7572 }; 7573 7574 static int md_thread(void *arg) 7575 { 7576 struct md_thread *thread = arg; 7577 7578 /* 7579 * md_thread is a 'system-thread', it's priority should be very 7580 * high. We avoid resource deadlocks individually in each 7581 * raid personality. (RAID5 does preallocation) We also use RR and 7582 * the very same RT priority as kswapd, thus we will never get 7583 * into a priority inversion deadlock. 7584 * 7585 * we definitely have to have equal or higher priority than 7586 * bdflush, otherwise bdflush will deadlock if there are too 7587 * many dirty RAID5 blocks. 7588 */ 7589 7590 allow_signal(SIGKILL); 7591 while (!kthread_should_stop()) { 7592 7593 /* We need to wait INTERRUPTIBLE so that 7594 * we don't add to the load-average. 7595 * That means we need to be sure no signals are 7596 * pending 7597 */ 7598 if (signal_pending(current)) 7599 flush_signals(current); 7600 7601 wait_event_interruptible_timeout 7602 (thread->wqueue, 7603 test_bit(THREAD_WAKEUP, &thread->flags) 7604 || kthread_should_stop() || kthread_should_park(), 7605 thread->timeout); 7606 7607 clear_bit(THREAD_WAKEUP, &thread->flags); 7608 if (kthread_should_park()) 7609 kthread_parkme(); 7610 if (!kthread_should_stop()) 7611 thread->run(thread); 7612 } 7613 7614 return 0; 7615 } 7616 7617 void md_wakeup_thread(struct md_thread *thread) 7618 { 7619 if (thread) { 7620 pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm); 7621 set_bit(THREAD_WAKEUP, &thread->flags); 7622 wake_up(&thread->wqueue); 7623 } 7624 } 7625 EXPORT_SYMBOL(md_wakeup_thread); 7626 7627 struct md_thread *md_register_thread(void (*run) (struct md_thread *), 7628 struct mddev *mddev, const char *name) 7629 { 7630 struct md_thread *thread; 7631 7632 thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL); 7633 if (!thread) 7634 return NULL; 7635 7636 init_waitqueue_head(&thread->wqueue); 7637 7638 thread->run = run; 7639 thread->mddev = mddev; 7640 thread->timeout = MAX_SCHEDULE_TIMEOUT; 7641 thread->tsk = kthread_run(md_thread, thread, 7642 "%s_%s", 7643 mdname(thread->mddev), 7644 name); 7645 if (IS_ERR(thread->tsk)) { 7646 kfree(thread); 7647 return NULL; 7648 } 7649 return thread; 7650 } 7651 EXPORT_SYMBOL(md_register_thread); 7652 7653 void md_unregister_thread(struct md_thread **threadp) 7654 { 7655 struct md_thread *thread = *threadp; 7656 if (!thread) 7657 return; 7658 pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk)); 7659 /* Locking ensures that mddev_unlock does not wake_up a 7660 * non-existent thread 7661 */ 7662 spin_lock(&pers_lock); 7663 *threadp = NULL; 7664 spin_unlock(&pers_lock); 7665 7666 kthread_stop(thread->tsk); 7667 kfree(thread); 7668 } 7669 EXPORT_SYMBOL(md_unregister_thread); 7670 7671 void md_error(struct mddev *mddev, struct md_rdev *rdev) 7672 { 7673 if (!rdev || test_bit(Faulty, &rdev->flags)) 7674 return; 7675 7676 if (!mddev->pers || !mddev->pers->error_handler) 7677 return; 7678 mddev->pers->error_handler(mddev,rdev); 7679 if (mddev->degraded) 7680 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 7681 sysfs_notify_dirent_safe(rdev->sysfs_state); 7682 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 7683 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 7684 md_wakeup_thread(mddev->thread); 7685 if (mddev->event_work.func) 7686 queue_work(md_misc_wq, &mddev->event_work); 7687 md_new_event(mddev); 7688 } 7689 EXPORT_SYMBOL(md_error); 7690 7691 /* seq_file implementation /proc/mdstat */ 7692 7693 static void status_unused(struct seq_file *seq) 7694 { 7695 int i = 0; 7696 struct md_rdev *rdev; 7697 7698 seq_printf(seq, "unused devices: "); 7699 7700 list_for_each_entry(rdev, &pending_raid_disks, same_set) { 7701 char b[BDEVNAME_SIZE]; 7702 i++; 7703 seq_printf(seq, "%s ", 7704 bdevname(rdev->bdev,b)); 7705 } 7706 if (!i) 7707 seq_printf(seq, "<none>"); 7708 7709 seq_printf(seq, "\n"); 7710 } 7711 7712 static int status_resync(struct seq_file *seq, struct mddev *mddev) 7713 { 7714 sector_t max_sectors, resync, res; 7715 unsigned long dt, db; 7716 sector_t rt; 7717 int scale; 7718 unsigned int per_milli; 7719 7720 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) || 7721 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) 7722 max_sectors = mddev->resync_max_sectors; 7723 else 7724 max_sectors = mddev->dev_sectors; 7725 7726 resync = mddev->curr_resync; 7727 if (resync <= 3) { 7728 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery)) 7729 /* Still cleaning up */ 7730 resync = max_sectors; 7731 } else if (resync > max_sectors) 7732 resync = max_sectors; 7733 else 7734 resync -= atomic_read(&mddev->recovery_active); 7735 7736 if (resync == 0) { 7737 if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery)) { 7738 struct md_rdev *rdev; 7739 7740 rdev_for_each(rdev, mddev) 7741 if (rdev->raid_disk >= 0 && 7742 !test_bit(Faulty, &rdev->flags) && 7743 rdev->recovery_offset != MaxSector && 7744 rdev->recovery_offset) { 7745 seq_printf(seq, "\trecover=REMOTE"); 7746 return 1; 7747 } 7748 if (mddev->reshape_position != MaxSector) 7749 seq_printf(seq, "\treshape=REMOTE"); 7750 else 7751 seq_printf(seq, "\tresync=REMOTE"); 7752 return 1; 7753 } 7754 if (mddev->recovery_cp < MaxSector) { 7755 seq_printf(seq, "\tresync=PENDING"); 7756 return 1; 7757 } 7758 return 0; 7759 } 7760 if (resync < 3) { 7761 seq_printf(seq, "\tresync=DELAYED"); 7762 return 1; 7763 } 7764 7765 WARN_ON(max_sectors == 0); 7766 /* Pick 'scale' such that (resync>>scale)*1000 will fit 7767 * in a sector_t, and (max_sectors>>scale) will fit in a 7768 * u32, as those are the requirements for sector_div. 7769 * Thus 'scale' must be at least 10 7770 */ 7771 scale = 10; 7772 if (sizeof(sector_t) > sizeof(unsigned long)) { 7773 while ( max_sectors/2 > (1ULL<<(scale+32))) 7774 scale++; 7775 } 7776 res = (resync>>scale)*1000; 7777 sector_div(res, (u32)((max_sectors>>scale)+1)); 7778 7779 per_milli = res; 7780 { 7781 int i, x = per_milli/50, y = 20-x; 7782 seq_printf(seq, "["); 7783 for (i = 0; i < x; i++) 7784 seq_printf(seq, "="); 7785 seq_printf(seq, ">"); 7786 for (i = 0; i < y; i++) 7787 seq_printf(seq, "."); 7788 seq_printf(seq, "] "); 7789 } 7790 seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)", 7791 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)? 7792 "reshape" : 7793 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)? 7794 "check" : 7795 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ? 7796 "resync" : "recovery"))), 7797 per_milli/10, per_milli % 10, 7798 (unsigned long long) resync/2, 7799 (unsigned long long) max_sectors/2); 7800 7801 /* 7802 * dt: time from mark until now 7803 * db: blocks written from mark until now 7804 * rt: remaining time 7805 * 7806 * rt is a sector_t, so could be 32bit or 64bit. 7807 * So we divide before multiply in case it is 32bit and close 7808 * to the limit. 7809 * We scale the divisor (db) by 32 to avoid losing precision 7810 * near the end of resync when the number of remaining sectors 7811 * is close to 'db'. 7812 * We then divide rt by 32 after multiplying by db to compensate. 7813 * The '+1' avoids division by zero if db is very small. 7814 */ 7815 dt = ((jiffies - mddev->resync_mark) / HZ); 7816 if (!dt) dt++; 7817 db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active)) 7818 - mddev->resync_mark_cnt; 7819 7820 rt = max_sectors - resync; /* number of remaining sectors */ 7821 sector_div(rt, db/32+1); 7822 rt *= dt; 7823 rt >>= 5; 7824 7825 seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60, 7826 ((unsigned long)rt % 60)/6); 7827 7828 seq_printf(seq, " speed=%ldK/sec", db/2/dt); 7829 return 1; 7830 } 7831 7832 static void *md_seq_start(struct seq_file *seq, loff_t *pos) 7833 { 7834 struct list_head *tmp; 7835 loff_t l = *pos; 7836 struct mddev *mddev; 7837 7838 if (l >= 0x10000) 7839 return NULL; 7840 if (!l--) 7841 /* header */ 7842 return (void*)1; 7843 7844 spin_lock(&all_mddevs_lock); 7845 list_for_each(tmp,&all_mddevs) 7846 if (!l--) { 7847 mddev = list_entry(tmp, struct mddev, all_mddevs); 7848 mddev_get(mddev); 7849 spin_unlock(&all_mddevs_lock); 7850 return mddev; 7851 } 7852 spin_unlock(&all_mddevs_lock); 7853 if (!l--) 7854 return (void*)2;/* tail */ 7855 return NULL; 7856 } 7857 7858 static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos) 7859 { 7860 struct list_head *tmp; 7861 struct mddev *next_mddev, *mddev = v; 7862 7863 ++*pos; 7864 if (v == (void*)2) 7865 return NULL; 7866 7867 spin_lock(&all_mddevs_lock); 7868 if (v == (void*)1) 7869 tmp = all_mddevs.next; 7870 else 7871 tmp = mddev->all_mddevs.next; 7872 if (tmp != &all_mddevs) 7873 next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs)); 7874 else { 7875 next_mddev = (void*)2; 7876 *pos = 0x10000; 7877 } 7878 spin_unlock(&all_mddevs_lock); 7879 7880 if (v != (void*)1) 7881 mddev_put(mddev); 7882 return next_mddev; 7883 7884 } 7885 7886 static void md_seq_stop(struct seq_file *seq, void *v) 7887 { 7888 struct mddev *mddev = v; 7889 7890 if (mddev && v != (void*)1 && v != (void*)2) 7891 mddev_put(mddev); 7892 } 7893 7894 static int md_seq_show(struct seq_file *seq, void *v) 7895 { 7896 struct mddev *mddev = v; 7897 sector_t sectors; 7898 struct md_rdev *rdev; 7899 7900 if (v == (void*)1) { 7901 struct md_personality *pers; 7902 seq_printf(seq, "Personalities : "); 7903 spin_lock(&pers_lock); 7904 list_for_each_entry(pers, &pers_list, list) 7905 seq_printf(seq, "[%s] ", pers->name); 7906 7907 spin_unlock(&pers_lock); 7908 seq_printf(seq, "\n"); 7909 seq->poll_event = atomic_read(&md_event_count); 7910 return 0; 7911 } 7912 if (v == (void*)2) { 7913 status_unused(seq); 7914 return 0; 7915 } 7916 7917 spin_lock(&mddev->lock); 7918 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) { 7919 seq_printf(seq, "%s : %sactive", mdname(mddev), 7920 mddev->pers ? "" : "in"); 7921 if (mddev->pers) { 7922 if (mddev->ro==1) 7923 seq_printf(seq, " (read-only)"); 7924 if (mddev->ro==2) 7925 seq_printf(seq, " (auto-read-only)"); 7926 seq_printf(seq, " %s", mddev->pers->name); 7927 } 7928 7929 sectors = 0; 7930 rcu_read_lock(); 7931 rdev_for_each_rcu(rdev, mddev) { 7932 char b[BDEVNAME_SIZE]; 7933 seq_printf(seq, " %s[%d]", 7934 bdevname(rdev->bdev,b), rdev->desc_nr); 7935 if (test_bit(WriteMostly, &rdev->flags)) 7936 seq_printf(seq, "(W)"); 7937 if (test_bit(Journal, &rdev->flags)) 7938 seq_printf(seq, "(J)"); 7939 if (test_bit(Faulty, &rdev->flags)) { 7940 seq_printf(seq, "(F)"); 7941 continue; 7942 } 7943 if (rdev->raid_disk < 0) 7944 seq_printf(seq, "(S)"); /* spare */ 7945 if (test_bit(Replacement, &rdev->flags)) 7946 seq_printf(seq, "(R)"); 7947 sectors += rdev->sectors; 7948 } 7949 rcu_read_unlock(); 7950 7951 if (!list_empty(&mddev->disks)) { 7952 if (mddev->pers) 7953 seq_printf(seq, "\n %llu blocks", 7954 (unsigned long long) 7955 mddev->array_sectors / 2); 7956 else 7957 seq_printf(seq, "\n %llu blocks", 7958 (unsigned long long)sectors / 2); 7959 } 7960 if (mddev->persistent) { 7961 if (mddev->major_version != 0 || 7962 mddev->minor_version != 90) { 7963 seq_printf(seq," super %d.%d", 7964 mddev->major_version, 7965 mddev->minor_version); 7966 } 7967 } else if (mddev->external) 7968 seq_printf(seq, " super external:%s", 7969 mddev->metadata_type); 7970 else 7971 seq_printf(seq, " super non-persistent"); 7972 7973 if (mddev->pers) { 7974 mddev->pers->status(seq, mddev); 7975 seq_printf(seq, "\n "); 7976 if (mddev->pers->sync_request) { 7977 if (status_resync(seq, mddev)) 7978 seq_printf(seq, "\n "); 7979 } 7980 } else 7981 seq_printf(seq, "\n "); 7982 7983 md_bitmap_status(seq, mddev->bitmap); 7984 7985 seq_printf(seq, "\n"); 7986 } 7987 spin_unlock(&mddev->lock); 7988 7989 return 0; 7990 } 7991 7992 static const struct seq_operations md_seq_ops = { 7993 .start = md_seq_start, 7994 .next = md_seq_next, 7995 .stop = md_seq_stop, 7996 .show = md_seq_show, 7997 }; 7998 7999 static int md_seq_open(struct inode *inode, struct file *file) 8000 { 8001 struct seq_file *seq; 8002 int error; 8003 8004 error = seq_open(file, &md_seq_ops); 8005 if (error) 8006 return error; 8007 8008 seq = file->private_data; 8009 seq->poll_event = atomic_read(&md_event_count); 8010 return error; 8011 } 8012 8013 static int md_unloading; 8014 static __poll_t mdstat_poll(struct file *filp, poll_table *wait) 8015 { 8016 struct seq_file *seq = filp->private_data; 8017 __poll_t mask; 8018 8019 if (md_unloading) 8020 return EPOLLIN|EPOLLRDNORM|EPOLLERR|EPOLLPRI; 8021 poll_wait(filp, &md_event_waiters, wait); 8022 8023 /* always allow read */ 8024 mask = EPOLLIN | EPOLLRDNORM; 8025 8026 if (seq->poll_event != atomic_read(&md_event_count)) 8027 mask |= EPOLLERR | EPOLLPRI; 8028 return mask; 8029 } 8030 8031 static const struct file_operations md_seq_fops = { 8032 .owner = THIS_MODULE, 8033 .open = md_seq_open, 8034 .read = seq_read, 8035 .llseek = seq_lseek, 8036 .release = seq_release, 8037 .poll = mdstat_poll, 8038 }; 8039 8040 int register_md_personality(struct md_personality *p) 8041 { 8042 pr_debug("md: %s personality registered for level %d\n", 8043 p->name, p->level); 8044 spin_lock(&pers_lock); 8045 list_add_tail(&p->list, &pers_list); 8046 spin_unlock(&pers_lock); 8047 return 0; 8048 } 8049 EXPORT_SYMBOL(register_md_personality); 8050 8051 int unregister_md_personality(struct md_personality *p) 8052 { 8053 pr_debug("md: %s personality unregistered\n", p->name); 8054 spin_lock(&pers_lock); 8055 list_del_init(&p->list); 8056 spin_unlock(&pers_lock); 8057 return 0; 8058 } 8059 EXPORT_SYMBOL(unregister_md_personality); 8060 8061 int register_md_cluster_operations(struct md_cluster_operations *ops, 8062 struct module *module) 8063 { 8064 int ret = 0; 8065 spin_lock(&pers_lock); 8066 if (md_cluster_ops != NULL) 8067 ret = -EALREADY; 8068 else { 8069 md_cluster_ops = ops; 8070 md_cluster_mod = module; 8071 } 8072 spin_unlock(&pers_lock); 8073 return ret; 8074 } 8075 EXPORT_SYMBOL(register_md_cluster_operations); 8076 8077 int unregister_md_cluster_operations(void) 8078 { 8079 spin_lock(&pers_lock); 8080 md_cluster_ops = NULL; 8081 spin_unlock(&pers_lock); 8082 return 0; 8083 } 8084 EXPORT_SYMBOL(unregister_md_cluster_operations); 8085 8086 int md_setup_cluster(struct mddev *mddev, int nodes) 8087 { 8088 if (!md_cluster_ops) 8089 request_module("md-cluster"); 8090 spin_lock(&pers_lock); 8091 /* ensure module won't be unloaded */ 8092 if (!md_cluster_ops || !try_module_get(md_cluster_mod)) { 8093 pr_warn("can't find md-cluster module or get it's reference.\n"); 8094 spin_unlock(&pers_lock); 8095 return -ENOENT; 8096 } 8097 spin_unlock(&pers_lock); 8098 8099 return md_cluster_ops->join(mddev, nodes); 8100 } 8101 8102 void md_cluster_stop(struct mddev *mddev) 8103 { 8104 if (!md_cluster_ops) 8105 return; 8106 md_cluster_ops->leave(mddev); 8107 module_put(md_cluster_mod); 8108 } 8109 8110 static int is_mddev_idle(struct mddev *mddev, int init) 8111 { 8112 struct md_rdev *rdev; 8113 int idle; 8114 int curr_events; 8115 8116 idle = 1; 8117 rcu_read_lock(); 8118 rdev_for_each_rcu(rdev, mddev) { 8119 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk; 8120 curr_events = (int)part_stat_read_accum(&disk->part0, sectors) - 8121 atomic_read(&disk->sync_io); 8122 /* sync IO will cause sync_io to increase before the disk_stats 8123 * as sync_io is counted when a request starts, and 8124 * disk_stats is counted when it completes. 8125 * So resync activity will cause curr_events to be smaller than 8126 * when there was no such activity. 8127 * non-sync IO will cause disk_stat to increase without 8128 * increasing sync_io so curr_events will (eventually) 8129 * be larger than it was before. Once it becomes 8130 * substantially larger, the test below will cause 8131 * the array to appear non-idle, and resync will slow 8132 * down. 8133 * If there is a lot of outstanding resync activity when 8134 * we set last_event to curr_events, then all that activity 8135 * completing might cause the array to appear non-idle 8136 * and resync will be slowed down even though there might 8137 * not have been non-resync activity. This will only 8138 * happen once though. 'last_events' will soon reflect 8139 * the state where there is little or no outstanding 8140 * resync requests, and further resync activity will 8141 * always make curr_events less than last_events. 8142 * 8143 */ 8144 if (init || curr_events - rdev->last_events > 64) { 8145 rdev->last_events = curr_events; 8146 idle = 0; 8147 } 8148 } 8149 rcu_read_unlock(); 8150 return idle; 8151 } 8152 8153 void md_done_sync(struct mddev *mddev, int blocks, int ok) 8154 { 8155 /* another "blocks" (512byte) blocks have been synced */ 8156 atomic_sub(blocks, &mddev->recovery_active); 8157 wake_up(&mddev->recovery_wait); 8158 if (!ok) { 8159 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 8160 set_bit(MD_RECOVERY_ERROR, &mddev->recovery); 8161 md_wakeup_thread(mddev->thread); 8162 // stop recovery, signal do_sync .... 8163 } 8164 } 8165 EXPORT_SYMBOL(md_done_sync); 8166 8167 /* md_write_start(mddev, bi) 8168 * If we need to update some array metadata (e.g. 'active' flag 8169 * in superblock) before writing, schedule a superblock update 8170 * and wait for it to complete. 8171 * A return value of 'false' means that the write wasn't recorded 8172 * and cannot proceed as the array is being suspend. 8173 */ 8174 bool md_write_start(struct mddev *mddev, struct bio *bi) 8175 { 8176 int did_change = 0; 8177 8178 if (bio_data_dir(bi) != WRITE) 8179 return true; 8180 8181 BUG_ON(mddev->ro == 1); 8182 if (mddev->ro == 2) { 8183 /* need to switch to read/write */ 8184 mddev->ro = 0; 8185 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 8186 md_wakeup_thread(mddev->thread); 8187 md_wakeup_thread(mddev->sync_thread); 8188 did_change = 1; 8189 } 8190 rcu_read_lock(); 8191 percpu_ref_get(&mddev->writes_pending); 8192 smp_mb(); /* Match smp_mb in set_in_sync() */ 8193 if (mddev->safemode == 1) 8194 mddev->safemode = 0; 8195 /* sync_checkers is always 0 when writes_pending is in per-cpu mode */ 8196 if (mddev->in_sync || mddev->sync_checkers) { 8197 spin_lock(&mddev->lock); 8198 if (mddev->in_sync) { 8199 mddev->in_sync = 0; 8200 set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags); 8201 set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags); 8202 md_wakeup_thread(mddev->thread); 8203 did_change = 1; 8204 } 8205 spin_unlock(&mddev->lock); 8206 } 8207 rcu_read_unlock(); 8208 if (did_change) 8209 sysfs_notify_dirent_safe(mddev->sysfs_state); 8210 if (!mddev->has_superblocks) 8211 return true; 8212 wait_event(mddev->sb_wait, 8213 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags) || 8214 mddev->suspended); 8215 if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) { 8216 percpu_ref_put(&mddev->writes_pending); 8217 return false; 8218 } 8219 return true; 8220 } 8221 EXPORT_SYMBOL(md_write_start); 8222 8223 /* md_write_inc can only be called when md_write_start() has 8224 * already been called at least once of the current request. 8225 * It increments the counter and is useful when a single request 8226 * is split into several parts. Each part causes an increment and 8227 * so needs a matching md_write_end(). 8228 * Unlike md_write_start(), it is safe to call md_write_inc() inside 8229 * a spinlocked region. 8230 */ 8231 void md_write_inc(struct mddev *mddev, struct bio *bi) 8232 { 8233 if (bio_data_dir(bi) != WRITE) 8234 return; 8235 WARN_ON_ONCE(mddev->in_sync || mddev->ro); 8236 percpu_ref_get(&mddev->writes_pending); 8237 } 8238 EXPORT_SYMBOL(md_write_inc); 8239 8240 void md_write_end(struct mddev *mddev) 8241 { 8242 percpu_ref_put(&mddev->writes_pending); 8243 8244 if (mddev->safemode == 2) 8245 md_wakeup_thread(mddev->thread); 8246 else if (mddev->safemode_delay) 8247 /* The roundup() ensures this only performs locking once 8248 * every ->safemode_delay jiffies 8249 */ 8250 mod_timer(&mddev->safemode_timer, 8251 roundup(jiffies, mddev->safemode_delay) + 8252 mddev->safemode_delay); 8253 } 8254 8255 EXPORT_SYMBOL(md_write_end); 8256 8257 /* md_allow_write(mddev) 8258 * Calling this ensures that the array is marked 'active' so that writes 8259 * may proceed without blocking. It is important to call this before 8260 * attempting a GFP_KERNEL allocation while holding the mddev lock. 8261 * Must be called with mddev_lock held. 8262 */ 8263 void md_allow_write(struct mddev *mddev) 8264 { 8265 if (!mddev->pers) 8266 return; 8267 if (mddev->ro) 8268 return; 8269 if (!mddev->pers->sync_request) 8270 return; 8271 8272 spin_lock(&mddev->lock); 8273 if (mddev->in_sync) { 8274 mddev->in_sync = 0; 8275 set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags); 8276 set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags); 8277 if (mddev->safemode_delay && 8278 mddev->safemode == 0) 8279 mddev->safemode = 1; 8280 spin_unlock(&mddev->lock); 8281 md_update_sb(mddev, 0); 8282 sysfs_notify_dirent_safe(mddev->sysfs_state); 8283 /* wait for the dirty state to be recorded in the metadata */ 8284 wait_event(mddev->sb_wait, 8285 !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)); 8286 } else 8287 spin_unlock(&mddev->lock); 8288 } 8289 EXPORT_SYMBOL_GPL(md_allow_write); 8290 8291 #define SYNC_MARKS 10 8292 #define SYNC_MARK_STEP (3*HZ) 8293 #define UPDATE_FREQUENCY (5*60*HZ) 8294 void md_do_sync(struct md_thread *thread) 8295 { 8296 struct mddev *mddev = thread->mddev; 8297 struct mddev *mddev2; 8298 unsigned int currspeed = 0, window; 8299 sector_t max_sectors,j, io_sectors, recovery_done; 8300 unsigned long mark[SYNC_MARKS]; 8301 unsigned long update_time; 8302 sector_t mark_cnt[SYNC_MARKS]; 8303 int last_mark,m; 8304 struct list_head *tmp; 8305 sector_t last_check; 8306 int skipped = 0; 8307 struct md_rdev *rdev; 8308 char *desc, *action = NULL; 8309 struct blk_plug plug; 8310 int ret; 8311 8312 /* just incase thread restarts... */ 8313 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery) || 8314 test_bit(MD_RECOVERY_WAIT, &mddev->recovery)) 8315 return; 8316 if (mddev->ro) {/* never try to sync a read-only array */ 8317 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 8318 return; 8319 } 8320 8321 if (mddev_is_clustered(mddev)) { 8322 ret = md_cluster_ops->resync_start(mddev); 8323 if (ret) 8324 goto skip; 8325 8326 set_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags); 8327 if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) || 8328 test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) || 8329 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery)) 8330 && ((unsigned long long)mddev->curr_resync_completed 8331 < (unsigned long long)mddev->resync_max_sectors)) 8332 goto skip; 8333 } 8334 8335 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) { 8336 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) { 8337 desc = "data-check"; 8338 action = "check"; 8339 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) { 8340 desc = "requested-resync"; 8341 action = "repair"; 8342 } else 8343 desc = "resync"; 8344 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) 8345 desc = "reshape"; 8346 else 8347 desc = "recovery"; 8348 8349 mddev->last_sync_action = action ?: desc; 8350 8351 /* we overload curr_resync somewhat here. 8352 * 0 == not engaged in resync at all 8353 * 2 == checking that there is no conflict with another sync 8354 * 1 == like 2, but have yielded to allow conflicting resync to 8355 * commence 8356 * other == active in resync - this many blocks 8357 * 8358 * Before starting a resync we must have set curr_resync to 8359 * 2, and then checked that every "conflicting" array has curr_resync 8360 * less than ours. When we find one that is the same or higher 8361 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync 8362 * to 1 if we choose to yield (based arbitrarily on address of mddev structure). 8363 * This will mean we have to start checking from the beginning again. 8364 * 8365 */ 8366 8367 do { 8368 int mddev2_minor = -1; 8369 mddev->curr_resync = 2; 8370 8371 try_again: 8372 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) 8373 goto skip; 8374 for_each_mddev(mddev2, tmp) { 8375 if (mddev2 == mddev) 8376 continue; 8377 if (!mddev->parallel_resync 8378 && mddev2->curr_resync 8379 && match_mddev_units(mddev, mddev2)) { 8380 DEFINE_WAIT(wq); 8381 if (mddev < mddev2 && mddev->curr_resync == 2) { 8382 /* arbitrarily yield */ 8383 mddev->curr_resync = 1; 8384 wake_up(&resync_wait); 8385 } 8386 if (mddev > mddev2 && mddev->curr_resync == 1) 8387 /* no need to wait here, we can wait the next 8388 * time 'round when curr_resync == 2 8389 */ 8390 continue; 8391 /* We need to wait 'interruptible' so as not to 8392 * contribute to the load average, and not to 8393 * be caught by 'softlockup' 8394 */ 8395 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE); 8396 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) && 8397 mddev2->curr_resync >= mddev->curr_resync) { 8398 if (mddev2_minor != mddev2->md_minor) { 8399 mddev2_minor = mddev2->md_minor; 8400 pr_info("md: delaying %s of %s until %s has finished (they share one or more physical units)\n", 8401 desc, mdname(mddev), 8402 mdname(mddev2)); 8403 } 8404 mddev_put(mddev2); 8405 if (signal_pending(current)) 8406 flush_signals(current); 8407 schedule(); 8408 finish_wait(&resync_wait, &wq); 8409 goto try_again; 8410 } 8411 finish_wait(&resync_wait, &wq); 8412 } 8413 } 8414 } while (mddev->curr_resync < 2); 8415 8416 j = 0; 8417 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) { 8418 /* resync follows the size requested by the personality, 8419 * which defaults to physical size, but can be virtual size 8420 */ 8421 max_sectors = mddev->resync_max_sectors; 8422 atomic64_set(&mddev->resync_mismatches, 0); 8423 /* we don't use the checkpoint if there's a bitmap */ 8424 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) 8425 j = mddev->resync_min; 8426 else if (!mddev->bitmap) 8427 j = mddev->recovery_cp; 8428 8429 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) { 8430 max_sectors = mddev->resync_max_sectors; 8431 /* 8432 * If the original node aborts reshaping then we continue the 8433 * reshaping, so set j again to avoid restart reshape from the 8434 * first beginning 8435 */ 8436 if (mddev_is_clustered(mddev) && 8437 mddev->reshape_position != MaxSector) 8438 j = mddev->reshape_position; 8439 } else { 8440 /* recovery follows the physical size of devices */ 8441 max_sectors = mddev->dev_sectors; 8442 j = MaxSector; 8443 rcu_read_lock(); 8444 rdev_for_each_rcu(rdev, mddev) 8445 if (rdev->raid_disk >= 0 && 8446 !test_bit(Journal, &rdev->flags) && 8447 !test_bit(Faulty, &rdev->flags) && 8448 !test_bit(In_sync, &rdev->flags) && 8449 rdev->recovery_offset < j) 8450 j = rdev->recovery_offset; 8451 rcu_read_unlock(); 8452 8453 /* If there is a bitmap, we need to make sure all 8454 * writes that started before we added a spare 8455 * complete before we start doing a recovery. 8456 * Otherwise the write might complete and (via 8457 * bitmap_endwrite) set a bit in the bitmap after the 8458 * recovery has checked that bit and skipped that 8459 * region. 8460 */ 8461 if (mddev->bitmap) { 8462 mddev->pers->quiesce(mddev, 1); 8463 mddev->pers->quiesce(mddev, 0); 8464 } 8465 } 8466 8467 pr_info("md: %s of RAID array %s\n", desc, mdname(mddev)); 8468 pr_debug("md: minimum _guaranteed_ speed: %d KB/sec/disk.\n", speed_min(mddev)); 8469 pr_debug("md: using maximum available idle IO bandwidth (but not more than %d KB/sec) for %s.\n", 8470 speed_max(mddev), desc); 8471 8472 is_mddev_idle(mddev, 1); /* this initializes IO event counters */ 8473 8474 io_sectors = 0; 8475 for (m = 0; m < SYNC_MARKS; m++) { 8476 mark[m] = jiffies; 8477 mark_cnt[m] = io_sectors; 8478 } 8479 last_mark = 0; 8480 mddev->resync_mark = mark[last_mark]; 8481 mddev->resync_mark_cnt = mark_cnt[last_mark]; 8482 8483 /* 8484 * Tune reconstruction: 8485 */ 8486 window = 32 * (PAGE_SIZE / 512); 8487 pr_debug("md: using %dk window, over a total of %lluk.\n", 8488 window/2, (unsigned long long)max_sectors/2); 8489 8490 atomic_set(&mddev->recovery_active, 0); 8491 last_check = 0; 8492 8493 if (j>2) { 8494 pr_debug("md: resuming %s of %s from checkpoint.\n", 8495 desc, mdname(mddev)); 8496 mddev->curr_resync = j; 8497 } else 8498 mddev->curr_resync = 3; /* no longer delayed */ 8499 mddev->curr_resync_completed = j; 8500 sysfs_notify(&mddev->kobj, NULL, "sync_completed"); 8501 md_new_event(mddev); 8502 update_time = jiffies; 8503 8504 blk_start_plug(&plug); 8505 while (j < max_sectors) { 8506 sector_t sectors; 8507 8508 skipped = 0; 8509 8510 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 8511 ((mddev->curr_resync > mddev->curr_resync_completed && 8512 (mddev->curr_resync - mddev->curr_resync_completed) 8513 > (max_sectors >> 4)) || 8514 time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) || 8515 (j - mddev->curr_resync_completed)*2 8516 >= mddev->resync_max - mddev->curr_resync_completed || 8517 mddev->curr_resync_completed > mddev->resync_max 8518 )) { 8519 /* time to update curr_resync_completed */ 8520 wait_event(mddev->recovery_wait, 8521 atomic_read(&mddev->recovery_active) == 0); 8522 mddev->curr_resync_completed = j; 8523 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) && 8524 j > mddev->recovery_cp) 8525 mddev->recovery_cp = j; 8526 update_time = jiffies; 8527 set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags); 8528 sysfs_notify(&mddev->kobj, NULL, "sync_completed"); 8529 } 8530 8531 while (j >= mddev->resync_max && 8532 !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) { 8533 /* As this condition is controlled by user-space, 8534 * we can block indefinitely, so use '_interruptible' 8535 * to avoid triggering warnings. 8536 */ 8537 flush_signals(current); /* just in case */ 8538 wait_event_interruptible(mddev->recovery_wait, 8539 mddev->resync_max > j 8540 || test_bit(MD_RECOVERY_INTR, 8541 &mddev->recovery)); 8542 } 8543 8544 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) 8545 break; 8546 8547 sectors = mddev->pers->sync_request(mddev, j, &skipped); 8548 if (sectors == 0) { 8549 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 8550 break; 8551 } 8552 8553 if (!skipped) { /* actual IO requested */ 8554 io_sectors += sectors; 8555 atomic_add(sectors, &mddev->recovery_active); 8556 } 8557 8558 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) 8559 break; 8560 8561 j += sectors; 8562 if (j > max_sectors) 8563 /* when skipping, extra large numbers can be returned. */ 8564 j = max_sectors; 8565 if (j > 2) 8566 mddev->curr_resync = j; 8567 mddev->curr_mark_cnt = io_sectors; 8568 if (last_check == 0) 8569 /* this is the earliest that rebuild will be 8570 * visible in /proc/mdstat 8571 */ 8572 md_new_event(mddev); 8573 8574 if (last_check + window > io_sectors || j == max_sectors) 8575 continue; 8576 8577 last_check = io_sectors; 8578 repeat: 8579 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) { 8580 /* step marks */ 8581 int next = (last_mark+1) % SYNC_MARKS; 8582 8583 mddev->resync_mark = mark[next]; 8584 mddev->resync_mark_cnt = mark_cnt[next]; 8585 mark[next] = jiffies; 8586 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active); 8587 last_mark = next; 8588 } 8589 8590 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) 8591 break; 8592 8593 /* 8594 * this loop exits only if either when we are slower than 8595 * the 'hard' speed limit, or the system was IO-idle for 8596 * a jiffy. 8597 * the system might be non-idle CPU-wise, but we only care 8598 * about not overloading the IO subsystem. (things like an 8599 * e2fsck being done on the RAID array should execute fast) 8600 */ 8601 cond_resched(); 8602 8603 recovery_done = io_sectors - atomic_read(&mddev->recovery_active); 8604 currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2 8605 /((jiffies-mddev->resync_mark)/HZ +1) +1; 8606 8607 if (currspeed > speed_min(mddev)) { 8608 if (currspeed > speed_max(mddev)) { 8609 msleep(500); 8610 goto repeat; 8611 } 8612 if (!is_mddev_idle(mddev, 0)) { 8613 /* 8614 * Give other IO more of a chance. 8615 * The faster the devices, the less we wait. 8616 */ 8617 wait_event(mddev->recovery_wait, 8618 !atomic_read(&mddev->recovery_active)); 8619 } 8620 } 8621 } 8622 pr_info("md: %s: %s %s.\n",mdname(mddev), desc, 8623 test_bit(MD_RECOVERY_INTR, &mddev->recovery) 8624 ? "interrupted" : "done"); 8625 /* 8626 * this also signals 'finished resyncing' to md_stop 8627 */ 8628 blk_finish_plug(&plug); 8629 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active)); 8630 8631 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 8632 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) && 8633 mddev->curr_resync > 3) { 8634 mddev->curr_resync_completed = mddev->curr_resync; 8635 sysfs_notify(&mddev->kobj, NULL, "sync_completed"); 8636 } 8637 mddev->pers->sync_request(mddev, max_sectors, &skipped); 8638 8639 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) && 8640 mddev->curr_resync > 3) { 8641 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) { 8642 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) { 8643 if (mddev->curr_resync >= mddev->recovery_cp) { 8644 pr_debug("md: checkpointing %s of %s.\n", 8645 desc, mdname(mddev)); 8646 if (test_bit(MD_RECOVERY_ERROR, 8647 &mddev->recovery)) 8648 mddev->recovery_cp = 8649 mddev->curr_resync_completed; 8650 else 8651 mddev->recovery_cp = 8652 mddev->curr_resync; 8653 } 8654 } else 8655 mddev->recovery_cp = MaxSector; 8656 } else { 8657 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) 8658 mddev->curr_resync = MaxSector; 8659 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 8660 test_bit(MD_RECOVERY_RECOVER, &mddev->recovery)) { 8661 rcu_read_lock(); 8662 rdev_for_each_rcu(rdev, mddev) 8663 if (rdev->raid_disk >= 0 && 8664 mddev->delta_disks >= 0 && 8665 !test_bit(Journal, &rdev->flags) && 8666 !test_bit(Faulty, &rdev->flags) && 8667 !test_bit(In_sync, &rdev->flags) && 8668 rdev->recovery_offset < mddev->curr_resync) 8669 rdev->recovery_offset = mddev->curr_resync; 8670 rcu_read_unlock(); 8671 } 8672 } 8673 } 8674 skip: 8675 /* set CHANGE_PENDING here since maybe another update is needed, 8676 * so other nodes are informed. It should be harmless for normal 8677 * raid */ 8678 set_mask_bits(&mddev->sb_flags, 0, 8679 BIT(MD_SB_CHANGE_PENDING) | BIT(MD_SB_CHANGE_DEVS)); 8680 8681 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 8682 !test_bit(MD_RECOVERY_INTR, &mddev->recovery) && 8683 mddev->delta_disks > 0 && 8684 mddev->pers->finish_reshape && 8685 mddev->pers->size && 8686 mddev->queue) { 8687 mddev_lock_nointr(mddev); 8688 md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0)); 8689 mddev_unlock(mddev); 8690 if (!mddev_is_clustered(mddev)) { 8691 set_capacity(mddev->gendisk, mddev->array_sectors); 8692 revalidate_disk(mddev->gendisk); 8693 } 8694 } 8695 8696 spin_lock(&mddev->lock); 8697 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) { 8698 /* We completed so min/max setting can be forgotten if used. */ 8699 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) 8700 mddev->resync_min = 0; 8701 mddev->resync_max = MaxSector; 8702 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) 8703 mddev->resync_min = mddev->curr_resync_completed; 8704 set_bit(MD_RECOVERY_DONE, &mddev->recovery); 8705 mddev->curr_resync = 0; 8706 spin_unlock(&mddev->lock); 8707 8708 wake_up(&resync_wait); 8709 md_wakeup_thread(mddev->thread); 8710 return; 8711 } 8712 EXPORT_SYMBOL_GPL(md_do_sync); 8713 8714 static int remove_and_add_spares(struct mddev *mddev, 8715 struct md_rdev *this) 8716 { 8717 struct md_rdev *rdev; 8718 int spares = 0; 8719 int removed = 0; 8720 bool remove_some = false; 8721 8722 if (this && test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 8723 /* Mustn't remove devices when resync thread is running */ 8724 return 0; 8725 8726 rdev_for_each(rdev, mddev) { 8727 if ((this == NULL || rdev == this) && 8728 rdev->raid_disk >= 0 && 8729 !test_bit(Blocked, &rdev->flags) && 8730 test_bit(Faulty, &rdev->flags) && 8731 atomic_read(&rdev->nr_pending)==0) { 8732 /* Faulty non-Blocked devices with nr_pending == 0 8733 * never get nr_pending incremented, 8734 * never get Faulty cleared, and never get Blocked set. 8735 * So we can synchronize_rcu now rather than once per device 8736 */ 8737 remove_some = true; 8738 set_bit(RemoveSynchronized, &rdev->flags); 8739 } 8740 } 8741 8742 if (remove_some) 8743 synchronize_rcu(); 8744 rdev_for_each(rdev, mddev) { 8745 if ((this == NULL || rdev == this) && 8746 rdev->raid_disk >= 0 && 8747 !test_bit(Blocked, &rdev->flags) && 8748 ((test_bit(RemoveSynchronized, &rdev->flags) || 8749 (!test_bit(In_sync, &rdev->flags) && 8750 !test_bit(Journal, &rdev->flags))) && 8751 atomic_read(&rdev->nr_pending)==0)) { 8752 if (mddev->pers->hot_remove_disk( 8753 mddev, rdev) == 0) { 8754 sysfs_unlink_rdev(mddev, rdev); 8755 rdev->saved_raid_disk = rdev->raid_disk; 8756 rdev->raid_disk = -1; 8757 removed++; 8758 } 8759 } 8760 if (remove_some && test_bit(RemoveSynchronized, &rdev->flags)) 8761 clear_bit(RemoveSynchronized, &rdev->flags); 8762 } 8763 8764 if (removed && mddev->kobj.sd) 8765 sysfs_notify(&mddev->kobj, NULL, "degraded"); 8766 8767 if (this && removed) 8768 goto no_add; 8769 8770 rdev_for_each(rdev, mddev) { 8771 if (this && this != rdev) 8772 continue; 8773 if (test_bit(Candidate, &rdev->flags)) 8774 continue; 8775 if (rdev->raid_disk >= 0 && 8776 !test_bit(In_sync, &rdev->flags) && 8777 !test_bit(Journal, &rdev->flags) && 8778 !test_bit(Faulty, &rdev->flags)) 8779 spares++; 8780 if (rdev->raid_disk >= 0) 8781 continue; 8782 if (test_bit(Faulty, &rdev->flags)) 8783 continue; 8784 if (!test_bit(Journal, &rdev->flags)) { 8785 if (mddev->ro && 8786 ! (rdev->saved_raid_disk >= 0 && 8787 !test_bit(Bitmap_sync, &rdev->flags))) 8788 continue; 8789 8790 rdev->recovery_offset = 0; 8791 } 8792 if (mddev->pers-> 8793 hot_add_disk(mddev, rdev) == 0) { 8794 if (sysfs_link_rdev(mddev, rdev)) 8795 /* failure here is OK */; 8796 if (!test_bit(Journal, &rdev->flags)) 8797 spares++; 8798 md_new_event(mddev); 8799 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 8800 } 8801 } 8802 no_add: 8803 if (removed) 8804 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 8805 return spares; 8806 } 8807 8808 static void md_start_sync(struct work_struct *ws) 8809 { 8810 struct mddev *mddev = container_of(ws, struct mddev, del_work); 8811 8812 mddev->sync_thread = md_register_thread(md_do_sync, 8813 mddev, 8814 "resync"); 8815 if (!mddev->sync_thread) { 8816 pr_warn("%s: could not start resync thread...\n", 8817 mdname(mddev)); 8818 /* leave the spares where they are, it shouldn't hurt */ 8819 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery); 8820 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery); 8821 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); 8822 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery); 8823 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery); 8824 wake_up(&resync_wait); 8825 if (test_and_clear_bit(MD_RECOVERY_RECOVER, 8826 &mddev->recovery)) 8827 if (mddev->sysfs_action) 8828 sysfs_notify_dirent_safe(mddev->sysfs_action); 8829 } else 8830 md_wakeup_thread(mddev->sync_thread); 8831 sysfs_notify_dirent_safe(mddev->sysfs_action); 8832 md_new_event(mddev); 8833 } 8834 8835 /* 8836 * This routine is regularly called by all per-raid-array threads to 8837 * deal with generic issues like resync and super-block update. 8838 * Raid personalities that don't have a thread (linear/raid0) do not 8839 * need this as they never do any recovery or update the superblock. 8840 * 8841 * It does not do any resync itself, but rather "forks" off other threads 8842 * to do that as needed. 8843 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in 8844 * "->recovery" and create a thread at ->sync_thread. 8845 * When the thread finishes it sets MD_RECOVERY_DONE 8846 * and wakeups up this thread which will reap the thread and finish up. 8847 * This thread also removes any faulty devices (with nr_pending == 0). 8848 * 8849 * The overall approach is: 8850 * 1/ if the superblock needs updating, update it. 8851 * 2/ If a recovery thread is running, don't do anything else. 8852 * 3/ If recovery has finished, clean up, possibly marking spares active. 8853 * 4/ If there are any faulty devices, remove them. 8854 * 5/ If array is degraded, try to add spares devices 8855 * 6/ If array has spares or is not in-sync, start a resync thread. 8856 */ 8857 void md_check_recovery(struct mddev *mddev) 8858 { 8859 if (test_bit(MD_ALLOW_SB_UPDATE, &mddev->flags) && mddev->sb_flags) { 8860 /* Write superblock - thread that called mddev_suspend() 8861 * holds reconfig_mutex for us. 8862 */ 8863 set_bit(MD_UPDATING_SB, &mddev->flags); 8864 smp_mb__after_atomic(); 8865 if (test_bit(MD_ALLOW_SB_UPDATE, &mddev->flags)) 8866 md_update_sb(mddev, 0); 8867 clear_bit_unlock(MD_UPDATING_SB, &mddev->flags); 8868 wake_up(&mddev->sb_wait); 8869 } 8870 8871 if (mddev->suspended) 8872 return; 8873 8874 if (mddev->bitmap) 8875 md_bitmap_daemon_work(mddev); 8876 8877 if (signal_pending(current)) { 8878 if (mddev->pers->sync_request && !mddev->external) { 8879 pr_debug("md: %s in immediate safe mode\n", 8880 mdname(mddev)); 8881 mddev->safemode = 2; 8882 } 8883 flush_signals(current); 8884 } 8885 8886 if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) 8887 return; 8888 if ( ! ( 8889 (mddev->sb_flags & ~ (1<<MD_SB_CHANGE_PENDING)) || 8890 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) || 8891 test_bit(MD_RECOVERY_DONE, &mddev->recovery) || 8892 (mddev->external == 0 && mddev->safemode == 1) || 8893 (mddev->safemode == 2 8894 && !mddev->in_sync && mddev->recovery_cp == MaxSector) 8895 )) 8896 return; 8897 8898 if (mddev_trylock(mddev)) { 8899 int spares = 0; 8900 8901 if (!mddev->external && mddev->safemode == 1) 8902 mddev->safemode = 0; 8903 8904 if (mddev->ro) { 8905 struct md_rdev *rdev; 8906 if (!mddev->external && mddev->in_sync) 8907 /* 'Blocked' flag not needed as failed devices 8908 * will be recorded if array switched to read/write. 8909 * Leaving it set will prevent the device 8910 * from being removed. 8911 */ 8912 rdev_for_each(rdev, mddev) 8913 clear_bit(Blocked, &rdev->flags); 8914 /* On a read-only array we can: 8915 * - remove failed devices 8916 * - add already-in_sync devices if the array itself 8917 * is in-sync. 8918 * As we only add devices that are already in-sync, 8919 * we can activate the spares immediately. 8920 */ 8921 remove_and_add_spares(mddev, NULL); 8922 /* There is no thread, but we need to call 8923 * ->spare_active and clear saved_raid_disk 8924 */ 8925 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 8926 md_reap_sync_thread(mddev); 8927 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 8928 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 8929 clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags); 8930 goto unlock; 8931 } 8932 8933 if (mddev_is_clustered(mddev)) { 8934 struct md_rdev *rdev; 8935 /* kick the device if another node issued a 8936 * remove disk. 8937 */ 8938 rdev_for_each(rdev, mddev) { 8939 if (test_and_clear_bit(ClusterRemove, &rdev->flags) && 8940 rdev->raid_disk < 0) 8941 md_kick_rdev_from_array(rdev); 8942 } 8943 } 8944 8945 if (!mddev->external && !mddev->in_sync) { 8946 spin_lock(&mddev->lock); 8947 set_in_sync(mddev); 8948 spin_unlock(&mddev->lock); 8949 } 8950 8951 if (mddev->sb_flags) 8952 md_update_sb(mddev, 0); 8953 8954 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) && 8955 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) { 8956 /* resync/recovery still happening */ 8957 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 8958 goto unlock; 8959 } 8960 if (mddev->sync_thread) { 8961 md_reap_sync_thread(mddev); 8962 goto unlock; 8963 } 8964 /* Set RUNNING before clearing NEEDED to avoid 8965 * any transients in the value of "sync_action". 8966 */ 8967 mddev->curr_resync_completed = 0; 8968 spin_lock(&mddev->lock); 8969 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery); 8970 spin_unlock(&mddev->lock); 8971 /* Clear some bits that don't mean anything, but 8972 * might be left set 8973 */ 8974 clear_bit(MD_RECOVERY_INTR, &mddev->recovery); 8975 clear_bit(MD_RECOVERY_DONE, &mddev->recovery); 8976 8977 if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) || 8978 test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) 8979 goto not_running; 8980 /* no recovery is running. 8981 * remove any failed drives, then 8982 * add spares if possible. 8983 * Spares are also removed and re-added, to allow 8984 * the personality to fail the re-add. 8985 */ 8986 8987 if (mddev->reshape_position != MaxSector) { 8988 if (mddev->pers->check_reshape == NULL || 8989 mddev->pers->check_reshape(mddev) != 0) 8990 /* Cannot proceed */ 8991 goto not_running; 8992 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery); 8993 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 8994 } else if ((spares = remove_and_add_spares(mddev, NULL))) { 8995 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery); 8996 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery); 8997 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); 8998 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 8999 } else if (mddev->recovery_cp < MaxSector) { 9000 set_bit(MD_RECOVERY_SYNC, &mddev->recovery); 9001 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 9002 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) 9003 /* nothing to be done ... */ 9004 goto not_running; 9005 9006 if (mddev->pers->sync_request) { 9007 if (spares) { 9008 /* We are adding a device or devices to an array 9009 * which has the bitmap stored on all devices. 9010 * So make sure all bitmap pages get written 9011 */ 9012 md_bitmap_write_all(mddev->bitmap); 9013 } 9014 INIT_WORK(&mddev->del_work, md_start_sync); 9015 queue_work(md_misc_wq, &mddev->del_work); 9016 goto unlock; 9017 } 9018 not_running: 9019 if (!mddev->sync_thread) { 9020 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery); 9021 wake_up(&resync_wait); 9022 if (test_and_clear_bit(MD_RECOVERY_RECOVER, 9023 &mddev->recovery)) 9024 if (mddev->sysfs_action) 9025 sysfs_notify_dirent_safe(mddev->sysfs_action); 9026 } 9027 unlock: 9028 wake_up(&mddev->sb_wait); 9029 mddev_unlock(mddev); 9030 } 9031 } 9032 EXPORT_SYMBOL(md_check_recovery); 9033 9034 void md_reap_sync_thread(struct mddev *mddev) 9035 { 9036 struct md_rdev *rdev; 9037 sector_t old_dev_sectors = mddev->dev_sectors; 9038 bool is_reshaped = false; 9039 9040 /* resync has finished, collect result */ 9041 md_unregister_thread(&mddev->sync_thread); 9042 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) && 9043 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) { 9044 /* success...*/ 9045 /* activate any spares */ 9046 if (mddev->pers->spare_active(mddev)) { 9047 sysfs_notify(&mddev->kobj, NULL, 9048 "degraded"); 9049 set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 9050 } 9051 } 9052 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 9053 mddev->pers->finish_reshape) { 9054 mddev->pers->finish_reshape(mddev); 9055 if (mddev_is_clustered(mddev)) 9056 is_reshaped = true; 9057 } 9058 9059 /* If array is no-longer degraded, then any saved_raid_disk 9060 * information must be scrapped. 9061 */ 9062 if (!mddev->degraded) 9063 rdev_for_each(rdev, mddev) 9064 rdev->saved_raid_disk = -1; 9065 9066 md_update_sb(mddev, 1); 9067 /* MD_SB_CHANGE_PENDING should be cleared by md_update_sb, so we can 9068 * call resync_finish here if MD_CLUSTER_RESYNC_LOCKED is set by 9069 * clustered raid */ 9070 if (test_and_clear_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags)) 9071 md_cluster_ops->resync_finish(mddev); 9072 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery); 9073 clear_bit(MD_RECOVERY_DONE, &mddev->recovery); 9074 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery); 9075 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery); 9076 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); 9077 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery); 9078 /* 9079 * We call md_cluster_ops->update_size here because sync_size could 9080 * be changed by md_update_sb, and MD_RECOVERY_RESHAPE is cleared, 9081 * so it is time to update size across cluster. 9082 */ 9083 if (mddev_is_clustered(mddev) && is_reshaped 9084 && !test_bit(MD_CLOSING, &mddev->flags)) 9085 md_cluster_ops->update_size(mddev, old_dev_sectors); 9086 wake_up(&resync_wait); 9087 /* flag recovery needed just to double check */ 9088 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 9089 sysfs_notify_dirent_safe(mddev->sysfs_action); 9090 md_new_event(mddev); 9091 if (mddev->event_work.func) 9092 queue_work(md_misc_wq, &mddev->event_work); 9093 } 9094 EXPORT_SYMBOL(md_reap_sync_thread); 9095 9096 void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev) 9097 { 9098 sysfs_notify_dirent_safe(rdev->sysfs_state); 9099 wait_event_timeout(rdev->blocked_wait, 9100 !test_bit(Blocked, &rdev->flags) && 9101 !test_bit(BlockedBadBlocks, &rdev->flags), 9102 msecs_to_jiffies(5000)); 9103 rdev_dec_pending(rdev, mddev); 9104 } 9105 EXPORT_SYMBOL(md_wait_for_blocked_rdev); 9106 9107 void md_finish_reshape(struct mddev *mddev) 9108 { 9109 /* called be personality module when reshape completes. */ 9110 struct md_rdev *rdev; 9111 9112 rdev_for_each(rdev, mddev) { 9113 if (rdev->data_offset > rdev->new_data_offset) 9114 rdev->sectors += rdev->data_offset - rdev->new_data_offset; 9115 else 9116 rdev->sectors -= rdev->new_data_offset - rdev->data_offset; 9117 rdev->data_offset = rdev->new_data_offset; 9118 } 9119 } 9120 EXPORT_SYMBOL(md_finish_reshape); 9121 9122 /* Bad block management */ 9123 9124 /* Returns 1 on success, 0 on failure */ 9125 int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors, 9126 int is_new) 9127 { 9128 struct mddev *mddev = rdev->mddev; 9129 int rv; 9130 if (is_new) 9131 s += rdev->new_data_offset; 9132 else 9133 s += rdev->data_offset; 9134 rv = badblocks_set(&rdev->badblocks, s, sectors, 0); 9135 if (rv == 0) { 9136 /* Make sure they get written out promptly */ 9137 if (test_bit(ExternalBbl, &rdev->flags)) 9138 sysfs_notify(&rdev->kobj, NULL, 9139 "unacknowledged_bad_blocks"); 9140 sysfs_notify_dirent_safe(rdev->sysfs_state); 9141 set_mask_bits(&mddev->sb_flags, 0, 9142 BIT(MD_SB_CHANGE_CLEAN) | BIT(MD_SB_CHANGE_PENDING)); 9143 md_wakeup_thread(rdev->mddev->thread); 9144 return 1; 9145 } else 9146 return 0; 9147 } 9148 EXPORT_SYMBOL_GPL(rdev_set_badblocks); 9149 9150 int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors, 9151 int is_new) 9152 { 9153 int rv; 9154 if (is_new) 9155 s += rdev->new_data_offset; 9156 else 9157 s += rdev->data_offset; 9158 rv = badblocks_clear(&rdev->badblocks, s, sectors); 9159 if ((rv == 0) && test_bit(ExternalBbl, &rdev->flags)) 9160 sysfs_notify(&rdev->kobj, NULL, "bad_blocks"); 9161 return rv; 9162 } 9163 EXPORT_SYMBOL_GPL(rdev_clear_badblocks); 9164 9165 static int md_notify_reboot(struct notifier_block *this, 9166 unsigned long code, void *x) 9167 { 9168 struct list_head *tmp; 9169 struct mddev *mddev; 9170 int need_delay = 0; 9171 9172 for_each_mddev(mddev, tmp) { 9173 if (mddev_trylock(mddev)) { 9174 if (mddev->pers) 9175 __md_stop_writes(mddev); 9176 if (mddev->persistent) 9177 mddev->safemode = 2; 9178 mddev_unlock(mddev); 9179 } 9180 need_delay = 1; 9181 } 9182 /* 9183 * certain more exotic SCSI devices are known to be 9184 * volatile wrt too early system reboots. While the 9185 * right place to handle this issue is the given 9186 * driver, we do want to have a safe RAID driver ... 9187 */ 9188 if (need_delay) 9189 mdelay(1000*1); 9190 9191 return NOTIFY_DONE; 9192 } 9193 9194 static struct notifier_block md_notifier = { 9195 .notifier_call = md_notify_reboot, 9196 .next = NULL, 9197 .priority = INT_MAX, /* before any real devices */ 9198 }; 9199 9200 static void md_geninit(void) 9201 { 9202 pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t)); 9203 9204 proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops); 9205 } 9206 9207 static int __init md_init(void) 9208 { 9209 int ret = -ENOMEM; 9210 9211 md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0); 9212 if (!md_wq) 9213 goto err_wq; 9214 9215 md_misc_wq = alloc_workqueue("md_misc", 0, 0); 9216 if (!md_misc_wq) 9217 goto err_misc_wq; 9218 9219 if ((ret = register_blkdev(MD_MAJOR, "md")) < 0) 9220 goto err_md; 9221 9222 if ((ret = register_blkdev(0, "mdp")) < 0) 9223 goto err_mdp; 9224 mdp_major = ret; 9225 9226 blk_register_region(MKDEV(MD_MAJOR, 0), 512, THIS_MODULE, 9227 md_probe, NULL, NULL); 9228 blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE, 9229 md_probe, NULL, NULL); 9230 9231 register_reboot_notifier(&md_notifier); 9232 raid_table_header = register_sysctl_table(raid_root_table); 9233 9234 md_geninit(); 9235 return 0; 9236 9237 err_mdp: 9238 unregister_blkdev(MD_MAJOR, "md"); 9239 err_md: 9240 destroy_workqueue(md_misc_wq); 9241 err_misc_wq: 9242 destroy_workqueue(md_wq); 9243 err_wq: 9244 return ret; 9245 } 9246 9247 static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev) 9248 { 9249 struct mdp_superblock_1 *sb = page_address(rdev->sb_page); 9250 struct md_rdev *rdev2; 9251 int role, ret; 9252 char b[BDEVNAME_SIZE]; 9253 9254 /* 9255 * If size is changed in another node then we need to 9256 * do resize as well. 9257 */ 9258 if (mddev->dev_sectors != le64_to_cpu(sb->size)) { 9259 ret = mddev->pers->resize(mddev, le64_to_cpu(sb->size)); 9260 if (ret) 9261 pr_info("md-cluster: resize failed\n"); 9262 else 9263 md_bitmap_update_sb(mddev->bitmap); 9264 } 9265 9266 /* Check for change of roles in the active devices */ 9267 rdev_for_each(rdev2, mddev) { 9268 if (test_bit(Faulty, &rdev2->flags)) 9269 continue; 9270 9271 /* Check if the roles changed */ 9272 role = le16_to_cpu(sb->dev_roles[rdev2->desc_nr]); 9273 9274 if (test_bit(Candidate, &rdev2->flags)) { 9275 if (role == 0xfffe) { 9276 pr_info("md: Removing Candidate device %s because add failed\n", bdevname(rdev2->bdev,b)); 9277 md_kick_rdev_from_array(rdev2); 9278 continue; 9279 } 9280 else 9281 clear_bit(Candidate, &rdev2->flags); 9282 } 9283 9284 if (role != rdev2->raid_disk) { 9285 /* 9286 * got activated except reshape is happening. 9287 */ 9288 if (rdev2->raid_disk == -1 && role != 0xffff && 9289 !(le32_to_cpu(sb->feature_map) & 9290 MD_FEATURE_RESHAPE_ACTIVE)) { 9291 rdev2->saved_raid_disk = role; 9292 ret = remove_and_add_spares(mddev, rdev2); 9293 pr_info("Activated spare: %s\n", 9294 bdevname(rdev2->bdev,b)); 9295 /* wakeup mddev->thread here, so array could 9296 * perform resync with the new activated disk */ 9297 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 9298 md_wakeup_thread(mddev->thread); 9299 } 9300 /* device faulty 9301 * We just want to do the minimum to mark the disk 9302 * as faulty. The recovery is performed by the 9303 * one who initiated the error. 9304 */ 9305 if ((role == 0xfffe) || (role == 0xfffd)) { 9306 md_error(mddev, rdev2); 9307 clear_bit(Blocked, &rdev2->flags); 9308 } 9309 } 9310 } 9311 9312 if (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) 9313 update_raid_disks(mddev, le32_to_cpu(sb->raid_disks)); 9314 9315 /* 9316 * Since mddev->delta_disks has already updated in update_raid_disks, 9317 * so it is time to check reshape. 9318 */ 9319 if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) && 9320 (le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) { 9321 /* 9322 * reshape is happening in the remote node, we need to 9323 * update reshape_position and call start_reshape. 9324 */ 9325 mddev->reshape_position = le64_to_cpu(sb->reshape_position); 9326 if (mddev->pers->update_reshape_pos) 9327 mddev->pers->update_reshape_pos(mddev); 9328 if (mddev->pers->start_reshape) 9329 mddev->pers->start_reshape(mddev); 9330 } else if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) && 9331 mddev->reshape_position != MaxSector && 9332 !(le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) { 9333 /* reshape is just done in another node. */ 9334 mddev->reshape_position = MaxSector; 9335 if (mddev->pers->update_reshape_pos) 9336 mddev->pers->update_reshape_pos(mddev); 9337 } 9338 9339 /* Finally set the event to be up to date */ 9340 mddev->events = le64_to_cpu(sb->events); 9341 } 9342 9343 static int read_rdev(struct mddev *mddev, struct md_rdev *rdev) 9344 { 9345 int err; 9346 struct page *swapout = rdev->sb_page; 9347 struct mdp_superblock_1 *sb; 9348 9349 /* Store the sb page of the rdev in the swapout temporary 9350 * variable in case we err in the future 9351 */ 9352 rdev->sb_page = NULL; 9353 err = alloc_disk_sb(rdev); 9354 if (err == 0) { 9355 ClearPageUptodate(rdev->sb_page); 9356 rdev->sb_loaded = 0; 9357 err = super_types[mddev->major_version]. 9358 load_super(rdev, NULL, mddev->minor_version); 9359 } 9360 if (err < 0) { 9361 pr_warn("%s: %d Could not reload rdev(%d) err: %d. Restoring old values\n", 9362 __func__, __LINE__, rdev->desc_nr, err); 9363 if (rdev->sb_page) 9364 put_page(rdev->sb_page); 9365 rdev->sb_page = swapout; 9366 rdev->sb_loaded = 1; 9367 return err; 9368 } 9369 9370 sb = page_address(rdev->sb_page); 9371 /* Read the offset unconditionally, even if MD_FEATURE_RECOVERY_OFFSET 9372 * is not set 9373 */ 9374 9375 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET)) 9376 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset); 9377 9378 /* The other node finished recovery, call spare_active to set 9379 * device In_sync and mddev->degraded 9380 */ 9381 if (rdev->recovery_offset == MaxSector && 9382 !test_bit(In_sync, &rdev->flags) && 9383 mddev->pers->spare_active(mddev)) 9384 sysfs_notify(&mddev->kobj, NULL, "degraded"); 9385 9386 put_page(swapout); 9387 return 0; 9388 } 9389 9390 void md_reload_sb(struct mddev *mddev, int nr) 9391 { 9392 struct md_rdev *rdev; 9393 int err; 9394 9395 /* Find the rdev */ 9396 rdev_for_each_rcu(rdev, mddev) { 9397 if (rdev->desc_nr == nr) 9398 break; 9399 } 9400 9401 if (!rdev || rdev->desc_nr != nr) { 9402 pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr); 9403 return; 9404 } 9405 9406 err = read_rdev(mddev, rdev); 9407 if (err < 0) 9408 return; 9409 9410 check_sb_changes(mddev, rdev); 9411 9412 /* Read all rdev's to update recovery_offset */ 9413 rdev_for_each_rcu(rdev, mddev) { 9414 if (!test_bit(Faulty, &rdev->flags)) 9415 read_rdev(mddev, rdev); 9416 } 9417 } 9418 EXPORT_SYMBOL(md_reload_sb); 9419 9420 #ifndef MODULE 9421 9422 /* 9423 * Searches all registered partitions for autorun RAID arrays 9424 * at boot time. 9425 */ 9426 9427 static DEFINE_MUTEX(detected_devices_mutex); 9428 static LIST_HEAD(all_detected_devices); 9429 struct detected_devices_node { 9430 struct list_head list; 9431 dev_t dev; 9432 }; 9433 9434 void md_autodetect_dev(dev_t dev) 9435 { 9436 struct detected_devices_node *node_detected_dev; 9437 9438 node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL); 9439 if (node_detected_dev) { 9440 node_detected_dev->dev = dev; 9441 mutex_lock(&detected_devices_mutex); 9442 list_add_tail(&node_detected_dev->list, &all_detected_devices); 9443 mutex_unlock(&detected_devices_mutex); 9444 } 9445 } 9446 9447 static void autostart_arrays(int part) 9448 { 9449 struct md_rdev *rdev; 9450 struct detected_devices_node *node_detected_dev; 9451 dev_t dev; 9452 int i_scanned, i_passed; 9453 9454 i_scanned = 0; 9455 i_passed = 0; 9456 9457 pr_info("md: Autodetecting RAID arrays.\n"); 9458 9459 mutex_lock(&detected_devices_mutex); 9460 while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) { 9461 i_scanned++; 9462 node_detected_dev = list_entry(all_detected_devices.next, 9463 struct detected_devices_node, list); 9464 list_del(&node_detected_dev->list); 9465 dev = node_detected_dev->dev; 9466 kfree(node_detected_dev); 9467 mutex_unlock(&detected_devices_mutex); 9468 rdev = md_import_device(dev,0, 90); 9469 mutex_lock(&detected_devices_mutex); 9470 if (IS_ERR(rdev)) 9471 continue; 9472 9473 if (test_bit(Faulty, &rdev->flags)) 9474 continue; 9475 9476 set_bit(AutoDetected, &rdev->flags); 9477 list_add(&rdev->same_set, &pending_raid_disks); 9478 i_passed++; 9479 } 9480 mutex_unlock(&detected_devices_mutex); 9481 9482 pr_debug("md: Scanned %d and added %d devices.\n", i_scanned, i_passed); 9483 9484 autorun_devices(part); 9485 } 9486 9487 #endif /* !MODULE */ 9488 9489 static __exit void md_exit(void) 9490 { 9491 struct mddev *mddev; 9492 struct list_head *tmp; 9493 int delay = 1; 9494 9495 blk_unregister_region(MKDEV(MD_MAJOR,0), 512); 9496 blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS); 9497 9498 unregister_blkdev(MD_MAJOR,"md"); 9499 unregister_blkdev(mdp_major, "mdp"); 9500 unregister_reboot_notifier(&md_notifier); 9501 unregister_sysctl_table(raid_table_header); 9502 9503 /* We cannot unload the modules while some process is 9504 * waiting for us in select() or poll() - wake them up 9505 */ 9506 md_unloading = 1; 9507 while (waitqueue_active(&md_event_waiters)) { 9508 /* not safe to leave yet */ 9509 wake_up(&md_event_waiters); 9510 msleep(delay); 9511 delay += delay; 9512 } 9513 remove_proc_entry("mdstat", NULL); 9514 9515 for_each_mddev(mddev, tmp) { 9516 export_array(mddev); 9517 mddev->ctime = 0; 9518 mddev->hold_active = 0; 9519 /* 9520 * for_each_mddev() will call mddev_put() at the end of each 9521 * iteration. As the mddev is now fully clear, this will 9522 * schedule the mddev for destruction by a workqueue, and the 9523 * destroy_workqueue() below will wait for that to complete. 9524 */ 9525 } 9526 destroy_workqueue(md_misc_wq); 9527 destroy_workqueue(md_wq); 9528 } 9529 9530 subsys_initcall(md_init); 9531 module_exit(md_exit) 9532 9533 static int get_ro(char *buffer, const struct kernel_param *kp) 9534 { 9535 return sprintf(buffer, "%d", start_readonly); 9536 } 9537 static int set_ro(const char *val, const struct kernel_param *kp) 9538 { 9539 return kstrtouint(val, 10, (unsigned int *)&start_readonly); 9540 } 9541 9542 module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR); 9543 module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR); 9544 module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR); 9545 module_param(create_on_open, bool, S_IRUSR|S_IWUSR); 9546 9547 MODULE_LICENSE("GPL"); 9548 MODULE_DESCRIPTION("MD RAID framework"); 9549 MODULE_ALIAS("md"); 9550 MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR); 9551