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