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/buffer_head.h> /* for invalidate_bdev */ 40 #include <linux/poll.h> 41 #include <linux/ctype.h> 42 #include <linux/hdreg.h> 43 #include <linux/proc_fs.h> 44 #include <linux/random.h> 45 #include <linux/reboot.h> 46 #include <linux/file.h> 47 #include <linux/delay.h> 48 #include <linux/raid/md_p.h> 49 #include <linux/raid/md_u.h> 50 #include "md.h" 51 #include "bitmap.h" 52 53 #define DEBUG 0 54 #define dprintk(x...) ((void)(DEBUG && printk(x))) 55 56 57 #ifndef MODULE 58 static void autostart_arrays(int part); 59 #endif 60 61 static LIST_HEAD(pers_list); 62 static DEFINE_SPINLOCK(pers_lock); 63 64 static void md_print_devices(void); 65 66 static DECLARE_WAIT_QUEUE_HEAD(resync_wait); 67 68 #define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); } 69 70 /* 71 * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit' 72 * is 1000 KB/sec, so the extra system load does not show up that much. 73 * Increase it if you want to have more _guaranteed_ speed. Note that 74 * the RAID driver will use the maximum available bandwidth if the IO 75 * subsystem is idle. There is also an 'absolute maximum' reconstruction 76 * speed limit - in case reconstruction slows down your system despite 77 * idle IO detection. 78 * 79 * you can change it via /proc/sys/dev/raid/speed_limit_min and _max. 80 * or /sys/block/mdX/md/sync_speed_{min,max} 81 */ 82 83 static int sysctl_speed_limit_min = 1000; 84 static int sysctl_speed_limit_max = 200000; 85 static inline int speed_min(mddev_t *mddev) 86 { 87 return mddev->sync_speed_min ? 88 mddev->sync_speed_min : sysctl_speed_limit_min; 89 } 90 91 static inline int speed_max(mddev_t *mddev) 92 { 93 return mddev->sync_speed_max ? 94 mddev->sync_speed_max : sysctl_speed_limit_max; 95 } 96 97 static struct ctl_table_header *raid_table_header; 98 99 static ctl_table raid_table[] = { 100 { 101 .ctl_name = DEV_RAID_SPEED_LIMIT_MIN, 102 .procname = "speed_limit_min", 103 .data = &sysctl_speed_limit_min, 104 .maxlen = sizeof(int), 105 .mode = S_IRUGO|S_IWUSR, 106 .proc_handler = &proc_dointvec, 107 }, 108 { 109 .ctl_name = DEV_RAID_SPEED_LIMIT_MAX, 110 .procname = "speed_limit_max", 111 .data = &sysctl_speed_limit_max, 112 .maxlen = sizeof(int), 113 .mode = S_IRUGO|S_IWUSR, 114 .proc_handler = &proc_dointvec, 115 }, 116 { .ctl_name = 0 } 117 }; 118 119 static ctl_table raid_dir_table[] = { 120 { 121 .ctl_name = DEV_RAID, 122 .procname = "raid", 123 .maxlen = 0, 124 .mode = S_IRUGO|S_IXUGO, 125 .child = raid_table, 126 }, 127 { .ctl_name = 0 } 128 }; 129 130 static ctl_table raid_root_table[] = { 131 { 132 .ctl_name = CTL_DEV, 133 .procname = "dev", 134 .maxlen = 0, 135 .mode = 0555, 136 .child = raid_dir_table, 137 }, 138 { .ctl_name = 0 } 139 }; 140 141 static struct block_device_operations md_fops; 142 143 static int start_readonly; 144 145 /* 146 * We have a system wide 'event count' that is incremented 147 * on any 'interesting' event, and readers of /proc/mdstat 148 * can use 'poll' or 'select' to find out when the event 149 * count increases. 150 * 151 * Events are: 152 * start array, stop array, error, add device, remove device, 153 * start build, activate spare 154 */ 155 static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters); 156 static atomic_t md_event_count; 157 void md_new_event(mddev_t *mddev) 158 { 159 atomic_inc(&md_event_count); 160 wake_up(&md_event_waiters); 161 } 162 EXPORT_SYMBOL_GPL(md_new_event); 163 164 /* Alternate version that can be called from interrupts 165 * when calling sysfs_notify isn't needed. 166 */ 167 static void md_new_event_inintr(mddev_t *mddev) 168 { 169 atomic_inc(&md_event_count); 170 wake_up(&md_event_waiters); 171 } 172 173 /* 174 * Enables to iterate over all existing md arrays 175 * all_mddevs_lock protects this list. 176 */ 177 static LIST_HEAD(all_mddevs); 178 static DEFINE_SPINLOCK(all_mddevs_lock); 179 180 181 /* 182 * iterates through all used mddevs in the system. 183 * We take care to grab the all_mddevs_lock whenever navigating 184 * the list, and to always hold a refcount when unlocked. 185 * Any code which breaks out of this loop while own 186 * a reference to the current mddev and must mddev_put it. 187 */ 188 #define for_each_mddev(mddev,tmp) \ 189 \ 190 for (({ spin_lock(&all_mddevs_lock); \ 191 tmp = all_mddevs.next; \ 192 mddev = NULL;}); \ 193 ({ if (tmp != &all_mddevs) \ 194 mddev_get(list_entry(tmp, mddev_t, all_mddevs));\ 195 spin_unlock(&all_mddevs_lock); \ 196 if (mddev) mddev_put(mddev); \ 197 mddev = list_entry(tmp, mddev_t, all_mddevs); \ 198 tmp != &all_mddevs;}); \ 199 ({ spin_lock(&all_mddevs_lock); \ 200 tmp = tmp->next;}) \ 201 ) 202 203 204 /* Rather than calling directly into the personality make_request function, 205 * IO requests come here first so that we can check if the device is 206 * being suspended pending a reconfiguration. 207 * We hold a refcount over the call to ->make_request. By the time that 208 * call has finished, the bio has been linked into some internal structure 209 * and so is visible to ->quiesce(), so we don't need the refcount any more. 210 */ 211 static int md_make_request(struct request_queue *q, struct bio *bio) 212 { 213 mddev_t *mddev = q->queuedata; 214 int rv; 215 if (mddev == NULL || mddev->pers == NULL) { 216 bio_io_error(bio); 217 return 0; 218 } 219 rcu_read_lock(); 220 if (mddev->suspended) { 221 DEFINE_WAIT(__wait); 222 for (;;) { 223 prepare_to_wait(&mddev->sb_wait, &__wait, 224 TASK_UNINTERRUPTIBLE); 225 if (!mddev->suspended) 226 break; 227 rcu_read_unlock(); 228 schedule(); 229 rcu_read_lock(); 230 } 231 finish_wait(&mddev->sb_wait, &__wait); 232 } 233 atomic_inc(&mddev->active_io); 234 rcu_read_unlock(); 235 rv = mddev->pers->make_request(q, bio); 236 if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended) 237 wake_up(&mddev->sb_wait); 238 239 return rv; 240 } 241 242 static void mddev_suspend(mddev_t *mddev) 243 { 244 BUG_ON(mddev->suspended); 245 mddev->suspended = 1; 246 synchronize_rcu(); 247 wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0); 248 mddev->pers->quiesce(mddev, 1); 249 md_unregister_thread(mddev->thread); 250 mddev->thread = NULL; 251 /* we now know that no code is executing in the personality module, 252 * except possibly the tail end of a ->bi_end_io function, but that 253 * is certain to complete before the module has a chance to get 254 * unloaded 255 */ 256 } 257 258 static void mddev_resume(mddev_t *mddev) 259 { 260 mddev->suspended = 0; 261 wake_up(&mddev->sb_wait); 262 mddev->pers->quiesce(mddev, 0); 263 } 264 265 266 static inline mddev_t *mddev_get(mddev_t *mddev) 267 { 268 atomic_inc(&mddev->active); 269 return mddev; 270 } 271 272 static void mddev_delayed_delete(struct work_struct *ws); 273 274 static void mddev_put(mddev_t *mddev) 275 { 276 if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock)) 277 return; 278 if (!mddev->raid_disks && list_empty(&mddev->disks) && 279 !mddev->hold_active) { 280 list_del(&mddev->all_mddevs); 281 if (mddev->gendisk) { 282 /* we did a probe so need to clean up. 283 * Call schedule_work inside the spinlock 284 * so that flush_scheduled_work() after 285 * mddev_find will succeed in waiting for the 286 * work to be done. 287 */ 288 INIT_WORK(&mddev->del_work, mddev_delayed_delete); 289 schedule_work(&mddev->del_work); 290 } else 291 kfree(mddev); 292 } 293 spin_unlock(&all_mddevs_lock); 294 } 295 296 static mddev_t * mddev_find(dev_t unit) 297 { 298 mddev_t *mddev, *new = NULL; 299 300 retry: 301 spin_lock(&all_mddevs_lock); 302 303 if (unit) { 304 list_for_each_entry(mddev, &all_mddevs, all_mddevs) 305 if (mddev->unit == unit) { 306 mddev_get(mddev); 307 spin_unlock(&all_mddevs_lock); 308 kfree(new); 309 return mddev; 310 } 311 312 if (new) { 313 list_add(&new->all_mddevs, &all_mddevs); 314 spin_unlock(&all_mddevs_lock); 315 new->hold_active = UNTIL_IOCTL; 316 return new; 317 } 318 } else if (new) { 319 /* find an unused unit number */ 320 static int next_minor = 512; 321 int start = next_minor; 322 int is_free = 0; 323 int dev = 0; 324 while (!is_free) { 325 dev = MKDEV(MD_MAJOR, next_minor); 326 next_minor++; 327 if (next_minor > MINORMASK) 328 next_minor = 0; 329 if (next_minor == start) { 330 /* Oh dear, all in use. */ 331 spin_unlock(&all_mddevs_lock); 332 kfree(new); 333 return NULL; 334 } 335 336 is_free = 1; 337 list_for_each_entry(mddev, &all_mddevs, all_mddevs) 338 if (mddev->unit == dev) { 339 is_free = 0; 340 break; 341 } 342 } 343 new->unit = dev; 344 new->md_minor = MINOR(dev); 345 new->hold_active = UNTIL_STOP; 346 list_add(&new->all_mddevs, &all_mddevs); 347 spin_unlock(&all_mddevs_lock); 348 return new; 349 } 350 spin_unlock(&all_mddevs_lock); 351 352 new = kzalloc(sizeof(*new), GFP_KERNEL); 353 if (!new) 354 return NULL; 355 356 new->unit = unit; 357 if (MAJOR(unit) == MD_MAJOR) 358 new->md_minor = MINOR(unit); 359 else 360 new->md_minor = MINOR(unit) >> MdpMinorShift; 361 362 mutex_init(&new->reconfig_mutex); 363 INIT_LIST_HEAD(&new->disks); 364 INIT_LIST_HEAD(&new->all_mddevs); 365 init_timer(&new->safemode_timer); 366 atomic_set(&new->active, 1); 367 atomic_set(&new->openers, 0); 368 atomic_set(&new->active_io, 0); 369 spin_lock_init(&new->write_lock); 370 init_waitqueue_head(&new->sb_wait); 371 init_waitqueue_head(&new->recovery_wait); 372 new->reshape_position = MaxSector; 373 new->resync_min = 0; 374 new->resync_max = MaxSector; 375 new->level = LEVEL_NONE; 376 377 goto retry; 378 } 379 380 static inline int mddev_lock(mddev_t * mddev) 381 { 382 return mutex_lock_interruptible(&mddev->reconfig_mutex); 383 } 384 385 static inline int mddev_is_locked(mddev_t *mddev) 386 { 387 return mutex_is_locked(&mddev->reconfig_mutex); 388 } 389 390 static inline int mddev_trylock(mddev_t * mddev) 391 { 392 return mutex_trylock(&mddev->reconfig_mutex); 393 } 394 395 static inline void mddev_unlock(mddev_t * mddev) 396 { 397 mutex_unlock(&mddev->reconfig_mutex); 398 399 md_wakeup_thread(mddev->thread); 400 } 401 402 static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr) 403 { 404 mdk_rdev_t *rdev; 405 406 list_for_each_entry(rdev, &mddev->disks, same_set) 407 if (rdev->desc_nr == nr) 408 return rdev; 409 410 return NULL; 411 } 412 413 static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev) 414 { 415 mdk_rdev_t *rdev; 416 417 list_for_each_entry(rdev, &mddev->disks, same_set) 418 if (rdev->bdev->bd_dev == dev) 419 return rdev; 420 421 return NULL; 422 } 423 424 static struct mdk_personality *find_pers(int level, char *clevel) 425 { 426 struct mdk_personality *pers; 427 list_for_each_entry(pers, &pers_list, list) { 428 if (level != LEVEL_NONE && pers->level == level) 429 return pers; 430 if (strcmp(pers->name, clevel)==0) 431 return pers; 432 } 433 return NULL; 434 } 435 436 /* return the offset of the super block in 512byte sectors */ 437 static inline sector_t calc_dev_sboffset(struct block_device *bdev) 438 { 439 sector_t num_sectors = bdev->bd_inode->i_size / 512; 440 return MD_NEW_SIZE_SECTORS(num_sectors); 441 } 442 443 static int alloc_disk_sb(mdk_rdev_t * rdev) 444 { 445 if (rdev->sb_page) 446 MD_BUG(); 447 448 rdev->sb_page = alloc_page(GFP_KERNEL); 449 if (!rdev->sb_page) { 450 printk(KERN_ALERT "md: out of memory.\n"); 451 return -ENOMEM; 452 } 453 454 return 0; 455 } 456 457 static void free_disk_sb(mdk_rdev_t * rdev) 458 { 459 if (rdev->sb_page) { 460 put_page(rdev->sb_page); 461 rdev->sb_loaded = 0; 462 rdev->sb_page = NULL; 463 rdev->sb_start = 0; 464 rdev->sectors = 0; 465 } 466 } 467 468 469 static void super_written(struct bio *bio, int error) 470 { 471 mdk_rdev_t *rdev = bio->bi_private; 472 mddev_t *mddev = rdev->mddev; 473 474 if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) { 475 printk("md: super_written gets error=%d, uptodate=%d\n", 476 error, test_bit(BIO_UPTODATE, &bio->bi_flags)); 477 WARN_ON(test_bit(BIO_UPTODATE, &bio->bi_flags)); 478 md_error(mddev, rdev); 479 } 480 481 if (atomic_dec_and_test(&mddev->pending_writes)) 482 wake_up(&mddev->sb_wait); 483 bio_put(bio); 484 } 485 486 static void super_written_barrier(struct bio *bio, int error) 487 { 488 struct bio *bio2 = bio->bi_private; 489 mdk_rdev_t *rdev = bio2->bi_private; 490 mddev_t *mddev = rdev->mddev; 491 492 if (!test_bit(BIO_UPTODATE, &bio->bi_flags) && 493 error == -EOPNOTSUPP) { 494 unsigned long flags; 495 /* barriers don't appear to be supported :-( */ 496 set_bit(BarriersNotsupp, &rdev->flags); 497 mddev->barriers_work = 0; 498 spin_lock_irqsave(&mddev->write_lock, flags); 499 bio2->bi_next = mddev->biolist; 500 mddev->biolist = bio2; 501 spin_unlock_irqrestore(&mddev->write_lock, flags); 502 wake_up(&mddev->sb_wait); 503 bio_put(bio); 504 } else { 505 bio_put(bio2); 506 bio->bi_private = rdev; 507 super_written(bio, error); 508 } 509 } 510 511 void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev, 512 sector_t sector, int size, struct page *page) 513 { 514 /* write first size bytes of page to sector of rdev 515 * Increment mddev->pending_writes before returning 516 * and decrement it on completion, waking up sb_wait 517 * if zero is reached. 518 * If an error occurred, call md_error 519 * 520 * As we might need to resubmit the request if BIO_RW_BARRIER 521 * causes ENOTSUPP, we allocate a spare bio... 522 */ 523 struct bio *bio = bio_alloc(GFP_NOIO, 1); 524 int rw = (1<<BIO_RW) | (1<<BIO_RW_SYNCIO) | (1<<BIO_RW_UNPLUG); 525 526 bio->bi_bdev = rdev->bdev; 527 bio->bi_sector = sector; 528 bio_add_page(bio, page, size, 0); 529 bio->bi_private = rdev; 530 bio->bi_end_io = super_written; 531 bio->bi_rw = rw; 532 533 atomic_inc(&mddev->pending_writes); 534 if (!test_bit(BarriersNotsupp, &rdev->flags)) { 535 struct bio *rbio; 536 rw |= (1<<BIO_RW_BARRIER); 537 rbio = bio_clone(bio, GFP_NOIO); 538 rbio->bi_private = bio; 539 rbio->bi_end_io = super_written_barrier; 540 submit_bio(rw, rbio); 541 } else 542 submit_bio(rw, bio); 543 } 544 545 void md_super_wait(mddev_t *mddev) 546 { 547 /* wait for all superblock writes that were scheduled to complete. 548 * if any had to be retried (due to BARRIER problems), retry them 549 */ 550 DEFINE_WAIT(wq); 551 for(;;) { 552 prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE); 553 if (atomic_read(&mddev->pending_writes)==0) 554 break; 555 while (mddev->biolist) { 556 struct bio *bio; 557 spin_lock_irq(&mddev->write_lock); 558 bio = mddev->biolist; 559 mddev->biolist = bio->bi_next ; 560 bio->bi_next = NULL; 561 spin_unlock_irq(&mddev->write_lock); 562 submit_bio(bio->bi_rw, bio); 563 } 564 schedule(); 565 } 566 finish_wait(&mddev->sb_wait, &wq); 567 } 568 569 static void bi_complete(struct bio *bio, int error) 570 { 571 complete((struct completion*)bio->bi_private); 572 } 573 574 int sync_page_io(struct block_device *bdev, sector_t sector, int size, 575 struct page *page, int rw) 576 { 577 struct bio *bio = bio_alloc(GFP_NOIO, 1); 578 struct completion event; 579 int ret; 580 581 rw |= (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG); 582 583 bio->bi_bdev = bdev; 584 bio->bi_sector = sector; 585 bio_add_page(bio, page, size, 0); 586 init_completion(&event); 587 bio->bi_private = &event; 588 bio->bi_end_io = bi_complete; 589 submit_bio(rw, bio); 590 wait_for_completion(&event); 591 592 ret = test_bit(BIO_UPTODATE, &bio->bi_flags); 593 bio_put(bio); 594 return ret; 595 } 596 EXPORT_SYMBOL_GPL(sync_page_io); 597 598 static int read_disk_sb(mdk_rdev_t * rdev, int size) 599 { 600 char b[BDEVNAME_SIZE]; 601 if (!rdev->sb_page) { 602 MD_BUG(); 603 return -EINVAL; 604 } 605 if (rdev->sb_loaded) 606 return 0; 607 608 609 if (!sync_page_io(rdev->bdev, rdev->sb_start, size, rdev->sb_page, READ)) 610 goto fail; 611 rdev->sb_loaded = 1; 612 return 0; 613 614 fail: 615 printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n", 616 bdevname(rdev->bdev,b)); 617 return -EINVAL; 618 } 619 620 static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2) 621 { 622 return sb1->set_uuid0 == sb2->set_uuid0 && 623 sb1->set_uuid1 == sb2->set_uuid1 && 624 sb1->set_uuid2 == sb2->set_uuid2 && 625 sb1->set_uuid3 == sb2->set_uuid3; 626 } 627 628 static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2) 629 { 630 int ret; 631 mdp_super_t *tmp1, *tmp2; 632 633 tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL); 634 tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL); 635 636 if (!tmp1 || !tmp2) { 637 ret = 0; 638 printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n"); 639 goto abort; 640 } 641 642 *tmp1 = *sb1; 643 *tmp2 = *sb2; 644 645 /* 646 * nr_disks is not constant 647 */ 648 tmp1->nr_disks = 0; 649 tmp2->nr_disks = 0; 650 651 ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0); 652 abort: 653 kfree(tmp1); 654 kfree(tmp2); 655 return ret; 656 } 657 658 659 static u32 md_csum_fold(u32 csum) 660 { 661 csum = (csum & 0xffff) + (csum >> 16); 662 return (csum & 0xffff) + (csum >> 16); 663 } 664 665 static unsigned int calc_sb_csum(mdp_super_t * sb) 666 { 667 u64 newcsum = 0; 668 u32 *sb32 = (u32*)sb; 669 int i; 670 unsigned int disk_csum, csum; 671 672 disk_csum = sb->sb_csum; 673 sb->sb_csum = 0; 674 675 for (i = 0; i < MD_SB_BYTES/4 ; i++) 676 newcsum += sb32[i]; 677 csum = (newcsum & 0xffffffff) + (newcsum>>32); 678 679 680 #ifdef CONFIG_ALPHA 681 /* This used to use csum_partial, which was wrong for several 682 * reasons including that different results are returned on 683 * different architectures. It isn't critical that we get exactly 684 * the same return value as before (we always csum_fold before 685 * testing, and that removes any differences). However as we 686 * know that csum_partial always returned a 16bit value on 687 * alphas, do a fold to maximise conformity to previous behaviour. 688 */ 689 sb->sb_csum = md_csum_fold(disk_csum); 690 #else 691 sb->sb_csum = disk_csum; 692 #endif 693 return csum; 694 } 695 696 697 /* 698 * Handle superblock details. 699 * We want to be able to handle multiple superblock formats 700 * so we have a common interface to them all, and an array of 701 * different handlers. 702 * We rely on user-space to write the initial superblock, and support 703 * reading and updating of superblocks. 704 * Interface methods are: 705 * int load_super(mdk_rdev_t *dev, mdk_rdev_t *refdev, int minor_version) 706 * loads and validates a superblock on dev. 707 * if refdev != NULL, compare superblocks on both devices 708 * Return: 709 * 0 - dev has a superblock that is compatible with refdev 710 * 1 - dev has a superblock that is compatible and newer than refdev 711 * so dev should be used as the refdev in future 712 * -EINVAL superblock incompatible or invalid 713 * -othererror e.g. -EIO 714 * 715 * int validate_super(mddev_t *mddev, mdk_rdev_t *dev) 716 * Verify that dev is acceptable into mddev. 717 * The first time, mddev->raid_disks will be 0, and data from 718 * dev should be merged in. Subsequent calls check that dev 719 * is new enough. Return 0 or -EINVAL 720 * 721 * void sync_super(mddev_t *mddev, mdk_rdev_t *dev) 722 * Update the superblock for rdev with data in mddev 723 * This does not write to disc. 724 * 725 */ 726 727 struct super_type { 728 char *name; 729 struct module *owner; 730 int (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev, 731 int minor_version); 732 int (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev); 733 void (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev); 734 unsigned long long (*rdev_size_change)(mdk_rdev_t *rdev, 735 sector_t num_sectors); 736 }; 737 738 /* 739 * Check that the given mddev has no bitmap. 740 * 741 * This function is called from the run method of all personalities that do not 742 * support bitmaps. It prints an error message and returns non-zero if mddev 743 * has a bitmap. Otherwise, it returns 0. 744 * 745 */ 746 int md_check_no_bitmap(mddev_t *mddev) 747 { 748 if (!mddev->bitmap_file && !mddev->bitmap_offset) 749 return 0; 750 printk(KERN_ERR "%s: bitmaps are not supported for %s\n", 751 mdname(mddev), mddev->pers->name); 752 return 1; 753 } 754 EXPORT_SYMBOL(md_check_no_bitmap); 755 756 /* 757 * load_super for 0.90.0 758 */ 759 static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version) 760 { 761 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 762 mdp_super_t *sb; 763 int ret; 764 765 /* 766 * Calculate the position of the superblock (512byte sectors), 767 * it's at the end of the disk. 768 * 769 * It also happens to be a multiple of 4Kb. 770 */ 771 rdev->sb_start = calc_dev_sboffset(rdev->bdev); 772 773 ret = read_disk_sb(rdev, MD_SB_BYTES); 774 if (ret) return ret; 775 776 ret = -EINVAL; 777 778 bdevname(rdev->bdev, b); 779 sb = (mdp_super_t*)page_address(rdev->sb_page); 780 781 if (sb->md_magic != MD_SB_MAGIC) { 782 printk(KERN_ERR "md: invalid raid superblock magic on %s\n", 783 b); 784 goto abort; 785 } 786 787 if (sb->major_version != 0 || 788 sb->minor_version < 90 || 789 sb->minor_version > 91) { 790 printk(KERN_WARNING "Bad version number %d.%d on %s\n", 791 sb->major_version, sb->minor_version, 792 b); 793 goto abort; 794 } 795 796 if (sb->raid_disks <= 0) 797 goto abort; 798 799 if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) { 800 printk(KERN_WARNING "md: invalid superblock checksum on %s\n", 801 b); 802 goto abort; 803 } 804 805 rdev->preferred_minor = sb->md_minor; 806 rdev->data_offset = 0; 807 rdev->sb_size = MD_SB_BYTES; 808 809 if (sb->level == LEVEL_MULTIPATH) 810 rdev->desc_nr = -1; 811 else 812 rdev->desc_nr = sb->this_disk.number; 813 814 if (!refdev) { 815 ret = 1; 816 } else { 817 __u64 ev1, ev2; 818 mdp_super_t *refsb = (mdp_super_t*)page_address(refdev->sb_page); 819 if (!uuid_equal(refsb, sb)) { 820 printk(KERN_WARNING "md: %s has different UUID to %s\n", 821 b, bdevname(refdev->bdev,b2)); 822 goto abort; 823 } 824 if (!sb_equal(refsb, sb)) { 825 printk(KERN_WARNING "md: %s has same UUID" 826 " but different superblock to %s\n", 827 b, bdevname(refdev->bdev, b2)); 828 goto abort; 829 } 830 ev1 = md_event(sb); 831 ev2 = md_event(refsb); 832 if (ev1 > ev2) 833 ret = 1; 834 else 835 ret = 0; 836 } 837 rdev->sectors = rdev->sb_start; 838 839 if (rdev->sectors < sb->size * 2 && sb->level > 1) 840 /* "this cannot possibly happen" ... */ 841 ret = -EINVAL; 842 843 abort: 844 return ret; 845 } 846 847 /* 848 * validate_super for 0.90.0 849 */ 850 static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev) 851 { 852 mdp_disk_t *desc; 853 mdp_super_t *sb = (mdp_super_t *)page_address(rdev->sb_page); 854 __u64 ev1 = md_event(sb); 855 856 rdev->raid_disk = -1; 857 clear_bit(Faulty, &rdev->flags); 858 clear_bit(In_sync, &rdev->flags); 859 clear_bit(WriteMostly, &rdev->flags); 860 clear_bit(BarriersNotsupp, &rdev->flags); 861 862 if (mddev->raid_disks == 0) { 863 mddev->major_version = 0; 864 mddev->minor_version = sb->minor_version; 865 mddev->patch_version = sb->patch_version; 866 mddev->external = 0; 867 mddev->chunk_sectors = sb->chunk_size >> 9; 868 mddev->ctime = sb->ctime; 869 mddev->utime = sb->utime; 870 mddev->level = sb->level; 871 mddev->clevel[0] = 0; 872 mddev->layout = sb->layout; 873 mddev->raid_disks = sb->raid_disks; 874 mddev->dev_sectors = sb->size * 2; 875 mddev->events = ev1; 876 mddev->bitmap_offset = 0; 877 mddev->default_bitmap_offset = MD_SB_BYTES >> 9; 878 879 if (mddev->minor_version >= 91) { 880 mddev->reshape_position = sb->reshape_position; 881 mddev->delta_disks = sb->delta_disks; 882 mddev->new_level = sb->new_level; 883 mddev->new_layout = sb->new_layout; 884 mddev->new_chunk_sectors = sb->new_chunk >> 9; 885 } else { 886 mddev->reshape_position = MaxSector; 887 mddev->delta_disks = 0; 888 mddev->new_level = mddev->level; 889 mddev->new_layout = mddev->layout; 890 mddev->new_chunk_sectors = mddev->chunk_sectors; 891 } 892 893 if (sb->state & (1<<MD_SB_CLEAN)) 894 mddev->recovery_cp = MaxSector; 895 else { 896 if (sb->events_hi == sb->cp_events_hi && 897 sb->events_lo == sb->cp_events_lo) { 898 mddev->recovery_cp = sb->recovery_cp; 899 } else 900 mddev->recovery_cp = 0; 901 } 902 903 memcpy(mddev->uuid+0, &sb->set_uuid0, 4); 904 memcpy(mddev->uuid+4, &sb->set_uuid1, 4); 905 memcpy(mddev->uuid+8, &sb->set_uuid2, 4); 906 memcpy(mddev->uuid+12,&sb->set_uuid3, 4); 907 908 mddev->max_disks = MD_SB_DISKS; 909 910 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) && 911 mddev->bitmap_file == NULL) 912 mddev->bitmap_offset = mddev->default_bitmap_offset; 913 914 } else if (mddev->pers == NULL) { 915 /* Insist on good event counter while assembling */ 916 ++ev1; 917 if (ev1 < mddev->events) 918 return -EINVAL; 919 } else if (mddev->bitmap) { 920 /* if adding to array with a bitmap, then we can accept an 921 * older device ... but not too old. 922 */ 923 if (ev1 < mddev->bitmap->events_cleared) 924 return 0; 925 } else { 926 if (ev1 < mddev->events) 927 /* just a hot-add of a new device, leave raid_disk at -1 */ 928 return 0; 929 } 930 931 if (mddev->level != LEVEL_MULTIPATH) { 932 desc = sb->disks + rdev->desc_nr; 933 934 if (desc->state & (1<<MD_DISK_FAULTY)) 935 set_bit(Faulty, &rdev->flags); 936 else if (desc->state & (1<<MD_DISK_SYNC) /* && 937 desc->raid_disk < mddev->raid_disks */) { 938 set_bit(In_sync, &rdev->flags); 939 rdev->raid_disk = desc->raid_disk; 940 } 941 if (desc->state & (1<<MD_DISK_WRITEMOSTLY)) 942 set_bit(WriteMostly, &rdev->flags); 943 } else /* MULTIPATH are always insync */ 944 set_bit(In_sync, &rdev->flags); 945 return 0; 946 } 947 948 /* 949 * sync_super for 0.90.0 950 */ 951 static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev) 952 { 953 mdp_super_t *sb; 954 mdk_rdev_t *rdev2; 955 int next_spare = mddev->raid_disks; 956 957 958 /* make rdev->sb match mddev data.. 959 * 960 * 1/ zero out disks 961 * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare); 962 * 3/ any empty disks < next_spare become removed 963 * 964 * disks[0] gets initialised to REMOVED because 965 * we cannot be sure from other fields if it has 966 * been initialised or not. 967 */ 968 int i; 969 int active=0, working=0,failed=0,spare=0,nr_disks=0; 970 971 rdev->sb_size = MD_SB_BYTES; 972 973 sb = (mdp_super_t*)page_address(rdev->sb_page); 974 975 memset(sb, 0, sizeof(*sb)); 976 977 sb->md_magic = MD_SB_MAGIC; 978 sb->major_version = mddev->major_version; 979 sb->patch_version = mddev->patch_version; 980 sb->gvalid_words = 0; /* ignored */ 981 memcpy(&sb->set_uuid0, mddev->uuid+0, 4); 982 memcpy(&sb->set_uuid1, mddev->uuid+4, 4); 983 memcpy(&sb->set_uuid2, mddev->uuid+8, 4); 984 memcpy(&sb->set_uuid3, mddev->uuid+12,4); 985 986 sb->ctime = mddev->ctime; 987 sb->level = mddev->level; 988 sb->size = mddev->dev_sectors / 2; 989 sb->raid_disks = mddev->raid_disks; 990 sb->md_minor = mddev->md_minor; 991 sb->not_persistent = 0; 992 sb->utime = mddev->utime; 993 sb->state = 0; 994 sb->events_hi = (mddev->events>>32); 995 sb->events_lo = (u32)mddev->events; 996 997 if (mddev->reshape_position == MaxSector) 998 sb->minor_version = 90; 999 else { 1000 sb->minor_version = 91; 1001 sb->reshape_position = mddev->reshape_position; 1002 sb->new_level = mddev->new_level; 1003 sb->delta_disks = mddev->delta_disks; 1004 sb->new_layout = mddev->new_layout; 1005 sb->new_chunk = mddev->new_chunk_sectors << 9; 1006 } 1007 mddev->minor_version = sb->minor_version; 1008 if (mddev->in_sync) 1009 { 1010 sb->recovery_cp = mddev->recovery_cp; 1011 sb->cp_events_hi = (mddev->events>>32); 1012 sb->cp_events_lo = (u32)mddev->events; 1013 if (mddev->recovery_cp == MaxSector) 1014 sb->state = (1<< MD_SB_CLEAN); 1015 } else 1016 sb->recovery_cp = 0; 1017 1018 sb->layout = mddev->layout; 1019 sb->chunk_size = mddev->chunk_sectors << 9; 1020 1021 if (mddev->bitmap && mddev->bitmap_file == NULL) 1022 sb->state |= (1<<MD_SB_BITMAP_PRESENT); 1023 1024 sb->disks[0].state = (1<<MD_DISK_REMOVED); 1025 list_for_each_entry(rdev2, &mddev->disks, same_set) { 1026 mdp_disk_t *d; 1027 int desc_nr; 1028 if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags) 1029 && !test_bit(Faulty, &rdev2->flags)) 1030 desc_nr = rdev2->raid_disk; 1031 else 1032 desc_nr = next_spare++; 1033 rdev2->desc_nr = desc_nr; 1034 d = &sb->disks[rdev2->desc_nr]; 1035 nr_disks++; 1036 d->number = rdev2->desc_nr; 1037 d->major = MAJOR(rdev2->bdev->bd_dev); 1038 d->minor = MINOR(rdev2->bdev->bd_dev); 1039 if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags) 1040 && !test_bit(Faulty, &rdev2->flags)) 1041 d->raid_disk = rdev2->raid_disk; 1042 else 1043 d->raid_disk = rdev2->desc_nr; /* compatibility */ 1044 if (test_bit(Faulty, &rdev2->flags)) 1045 d->state = (1<<MD_DISK_FAULTY); 1046 else if (test_bit(In_sync, &rdev2->flags)) { 1047 d->state = (1<<MD_DISK_ACTIVE); 1048 d->state |= (1<<MD_DISK_SYNC); 1049 active++; 1050 working++; 1051 } else { 1052 d->state = 0; 1053 spare++; 1054 working++; 1055 } 1056 if (test_bit(WriteMostly, &rdev2->flags)) 1057 d->state |= (1<<MD_DISK_WRITEMOSTLY); 1058 } 1059 /* now set the "removed" and "faulty" bits on any missing devices */ 1060 for (i=0 ; i < mddev->raid_disks ; i++) { 1061 mdp_disk_t *d = &sb->disks[i]; 1062 if (d->state == 0 && d->number == 0) { 1063 d->number = i; 1064 d->raid_disk = i; 1065 d->state = (1<<MD_DISK_REMOVED); 1066 d->state |= (1<<MD_DISK_FAULTY); 1067 failed++; 1068 } 1069 } 1070 sb->nr_disks = nr_disks; 1071 sb->active_disks = active; 1072 sb->working_disks = working; 1073 sb->failed_disks = failed; 1074 sb->spare_disks = spare; 1075 1076 sb->this_disk = sb->disks[rdev->desc_nr]; 1077 sb->sb_csum = calc_sb_csum(sb); 1078 } 1079 1080 /* 1081 * rdev_size_change for 0.90.0 1082 */ 1083 static unsigned long long 1084 super_90_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors) 1085 { 1086 if (num_sectors && num_sectors < rdev->mddev->dev_sectors) 1087 return 0; /* component must fit device */ 1088 if (rdev->mddev->bitmap_offset) 1089 return 0; /* can't move bitmap */ 1090 rdev->sb_start = calc_dev_sboffset(rdev->bdev); 1091 if (!num_sectors || num_sectors > rdev->sb_start) 1092 num_sectors = rdev->sb_start; 1093 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size, 1094 rdev->sb_page); 1095 md_super_wait(rdev->mddev); 1096 return num_sectors / 2; /* kB for sysfs */ 1097 } 1098 1099 1100 /* 1101 * version 1 superblock 1102 */ 1103 1104 static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb) 1105 { 1106 __le32 disk_csum; 1107 u32 csum; 1108 unsigned long long newcsum; 1109 int size = 256 + le32_to_cpu(sb->max_dev)*2; 1110 __le32 *isuper = (__le32*)sb; 1111 int i; 1112 1113 disk_csum = sb->sb_csum; 1114 sb->sb_csum = 0; 1115 newcsum = 0; 1116 for (i=0; size>=4; size -= 4 ) 1117 newcsum += le32_to_cpu(*isuper++); 1118 1119 if (size == 2) 1120 newcsum += le16_to_cpu(*(__le16*) isuper); 1121 1122 csum = (newcsum & 0xffffffff) + (newcsum >> 32); 1123 sb->sb_csum = disk_csum; 1124 return cpu_to_le32(csum); 1125 } 1126 1127 static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version) 1128 { 1129 struct mdp_superblock_1 *sb; 1130 int ret; 1131 sector_t sb_start; 1132 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 1133 int bmask; 1134 1135 /* 1136 * Calculate the position of the superblock in 512byte sectors. 1137 * It is always aligned to a 4K boundary and 1138 * depeding on minor_version, it can be: 1139 * 0: At least 8K, but less than 12K, from end of device 1140 * 1: At start of device 1141 * 2: 4K from start of device. 1142 */ 1143 switch(minor_version) { 1144 case 0: 1145 sb_start = rdev->bdev->bd_inode->i_size >> 9; 1146 sb_start -= 8*2; 1147 sb_start &= ~(sector_t)(4*2-1); 1148 break; 1149 case 1: 1150 sb_start = 0; 1151 break; 1152 case 2: 1153 sb_start = 8; 1154 break; 1155 default: 1156 return -EINVAL; 1157 } 1158 rdev->sb_start = sb_start; 1159 1160 /* superblock is rarely larger than 1K, but it can be larger, 1161 * and it is safe to read 4k, so we do that 1162 */ 1163 ret = read_disk_sb(rdev, 4096); 1164 if (ret) return ret; 1165 1166 1167 sb = (struct mdp_superblock_1*)page_address(rdev->sb_page); 1168 1169 if (sb->magic != cpu_to_le32(MD_SB_MAGIC) || 1170 sb->major_version != cpu_to_le32(1) || 1171 le32_to_cpu(sb->max_dev) > (4096-256)/2 || 1172 le64_to_cpu(sb->super_offset) != rdev->sb_start || 1173 (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0) 1174 return -EINVAL; 1175 1176 if (calc_sb_1_csum(sb) != sb->sb_csum) { 1177 printk("md: invalid superblock checksum on %s\n", 1178 bdevname(rdev->bdev,b)); 1179 return -EINVAL; 1180 } 1181 if (le64_to_cpu(sb->data_size) < 10) { 1182 printk("md: data_size too small on %s\n", 1183 bdevname(rdev->bdev,b)); 1184 return -EINVAL; 1185 } 1186 1187 rdev->preferred_minor = 0xffff; 1188 rdev->data_offset = le64_to_cpu(sb->data_offset); 1189 atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read)); 1190 1191 rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256; 1192 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1; 1193 if (rdev->sb_size & bmask) 1194 rdev->sb_size = (rdev->sb_size | bmask) + 1; 1195 1196 if (minor_version 1197 && rdev->data_offset < sb_start + (rdev->sb_size/512)) 1198 return -EINVAL; 1199 1200 if (sb->level == cpu_to_le32(LEVEL_MULTIPATH)) 1201 rdev->desc_nr = -1; 1202 else 1203 rdev->desc_nr = le32_to_cpu(sb->dev_number); 1204 1205 if (!refdev) { 1206 ret = 1; 1207 } else { 1208 __u64 ev1, ev2; 1209 struct mdp_superblock_1 *refsb = 1210 (struct mdp_superblock_1*)page_address(refdev->sb_page); 1211 1212 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 || 1213 sb->level != refsb->level || 1214 sb->layout != refsb->layout || 1215 sb->chunksize != refsb->chunksize) { 1216 printk(KERN_WARNING "md: %s has strangely different" 1217 " superblock to %s\n", 1218 bdevname(rdev->bdev,b), 1219 bdevname(refdev->bdev,b2)); 1220 return -EINVAL; 1221 } 1222 ev1 = le64_to_cpu(sb->events); 1223 ev2 = le64_to_cpu(refsb->events); 1224 1225 if (ev1 > ev2) 1226 ret = 1; 1227 else 1228 ret = 0; 1229 } 1230 if (minor_version) 1231 rdev->sectors = (rdev->bdev->bd_inode->i_size >> 9) - 1232 le64_to_cpu(sb->data_offset); 1233 else 1234 rdev->sectors = rdev->sb_start; 1235 if (rdev->sectors < le64_to_cpu(sb->data_size)) 1236 return -EINVAL; 1237 rdev->sectors = le64_to_cpu(sb->data_size); 1238 if (le64_to_cpu(sb->size) > rdev->sectors) 1239 return -EINVAL; 1240 return ret; 1241 } 1242 1243 static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev) 1244 { 1245 struct mdp_superblock_1 *sb = (struct mdp_superblock_1*)page_address(rdev->sb_page); 1246 __u64 ev1 = le64_to_cpu(sb->events); 1247 1248 rdev->raid_disk = -1; 1249 clear_bit(Faulty, &rdev->flags); 1250 clear_bit(In_sync, &rdev->flags); 1251 clear_bit(WriteMostly, &rdev->flags); 1252 clear_bit(BarriersNotsupp, &rdev->flags); 1253 1254 if (mddev->raid_disks == 0) { 1255 mddev->major_version = 1; 1256 mddev->patch_version = 0; 1257 mddev->external = 0; 1258 mddev->chunk_sectors = le32_to_cpu(sb->chunksize); 1259 mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1); 1260 mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1); 1261 mddev->level = le32_to_cpu(sb->level); 1262 mddev->clevel[0] = 0; 1263 mddev->layout = le32_to_cpu(sb->layout); 1264 mddev->raid_disks = le32_to_cpu(sb->raid_disks); 1265 mddev->dev_sectors = le64_to_cpu(sb->size); 1266 mddev->events = ev1; 1267 mddev->bitmap_offset = 0; 1268 mddev->default_bitmap_offset = 1024 >> 9; 1269 1270 mddev->recovery_cp = le64_to_cpu(sb->resync_offset); 1271 memcpy(mddev->uuid, sb->set_uuid, 16); 1272 1273 mddev->max_disks = (4096-256)/2; 1274 1275 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) && 1276 mddev->bitmap_file == NULL ) 1277 mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset); 1278 1279 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) { 1280 mddev->reshape_position = le64_to_cpu(sb->reshape_position); 1281 mddev->delta_disks = le32_to_cpu(sb->delta_disks); 1282 mddev->new_level = le32_to_cpu(sb->new_level); 1283 mddev->new_layout = le32_to_cpu(sb->new_layout); 1284 mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk); 1285 } else { 1286 mddev->reshape_position = MaxSector; 1287 mddev->delta_disks = 0; 1288 mddev->new_level = mddev->level; 1289 mddev->new_layout = mddev->layout; 1290 mddev->new_chunk_sectors = mddev->chunk_sectors; 1291 } 1292 1293 } else if (mddev->pers == NULL) { 1294 /* Insist of good event counter while assembling */ 1295 ++ev1; 1296 if (ev1 < mddev->events) 1297 return -EINVAL; 1298 } else if (mddev->bitmap) { 1299 /* If adding to array with a bitmap, then we can accept an 1300 * older device, but not too old. 1301 */ 1302 if (ev1 < mddev->bitmap->events_cleared) 1303 return 0; 1304 } else { 1305 if (ev1 < mddev->events) 1306 /* just a hot-add of a new device, leave raid_disk at -1 */ 1307 return 0; 1308 } 1309 if (mddev->level != LEVEL_MULTIPATH) { 1310 int role; 1311 if (rdev->desc_nr < 0 || 1312 rdev->desc_nr >= le32_to_cpu(sb->max_dev)) { 1313 role = 0xffff; 1314 rdev->desc_nr = -1; 1315 } else 1316 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]); 1317 switch(role) { 1318 case 0xffff: /* spare */ 1319 break; 1320 case 0xfffe: /* faulty */ 1321 set_bit(Faulty, &rdev->flags); 1322 break; 1323 default: 1324 if ((le32_to_cpu(sb->feature_map) & 1325 MD_FEATURE_RECOVERY_OFFSET)) 1326 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset); 1327 else 1328 set_bit(In_sync, &rdev->flags); 1329 rdev->raid_disk = role; 1330 break; 1331 } 1332 if (sb->devflags & WriteMostly1) 1333 set_bit(WriteMostly, &rdev->flags); 1334 } else /* MULTIPATH are always insync */ 1335 set_bit(In_sync, &rdev->flags); 1336 1337 return 0; 1338 } 1339 1340 static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev) 1341 { 1342 struct mdp_superblock_1 *sb; 1343 mdk_rdev_t *rdev2; 1344 int max_dev, i; 1345 /* make rdev->sb match mddev and rdev data. */ 1346 1347 sb = (struct mdp_superblock_1*)page_address(rdev->sb_page); 1348 1349 sb->feature_map = 0; 1350 sb->pad0 = 0; 1351 sb->recovery_offset = cpu_to_le64(0); 1352 memset(sb->pad1, 0, sizeof(sb->pad1)); 1353 memset(sb->pad2, 0, sizeof(sb->pad2)); 1354 memset(sb->pad3, 0, sizeof(sb->pad3)); 1355 1356 sb->utime = cpu_to_le64((__u64)mddev->utime); 1357 sb->events = cpu_to_le64(mddev->events); 1358 if (mddev->in_sync) 1359 sb->resync_offset = cpu_to_le64(mddev->recovery_cp); 1360 else 1361 sb->resync_offset = cpu_to_le64(0); 1362 1363 sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors)); 1364 1365 sb->raid_disks = cpu_to_le32(mddev->raid_disks); 1366 sb->size = cpu_to_le64(mddev->dev_sectors); 1367 sb->chunksize = cpu_to_le32(mddev->chunk_sectors); 1368 sb->level = cpu_to_le32(mddev->level); 1369 sb->layout = cpu_to_le32(mddev->layout); 1370 1371 if (mddev->bitmap && mddev->bitmap_file == NULL) { 1372 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset); 1373 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET); 1374 } 1375 1376 if (rdev->raid_disk >= 0 && 1377 !test_bit(In_sync, &rdev->flags)) { 1378 if (mddev->curr_resync_completed > rdev->recovery_offset) 1379 rdev->recovery_offset = mddev->curr_resync_completed; 1380 if (rdev->recovery_offset > 0) { 1381 sb->feature_map |= 1382 cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET); 1383 sb->recovery_offset = 1384 cpu_to_le64(rdev->recovery_offset); 1385 } 1386 } 1387 1388 if (mddev->reshape_position != MaxSector) { 1389 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE); 1390 sb->reshape_position = cpu_to_le64(mddev->reshape_position); 1391 sb->new_layout = cpu_to_le32(mddev->new_layout); 1392 sb->delta_disks = cpu_to_le32(mddev->delta_disks); 1393 sb->new_level = cpu_to_le32(mddev->new_level); 1394 sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors); 1395 } 1396 1397 max_dev = 0; 1398 list_for_each_entry(rdev2, &mddev->disks, same_set) 1399 if (rdev2->desc_nr+1 > max_dev) 1400 max_dev = rdev2->desc_nr+1; 1401 1402 if (max_dev > le32_to_cpu(sb->max_dev)) { 1403 int bmask; 1404 sb->max_dev = cpu_to_le32(max_dev); 1405 rdev->sb_size = max_dev * 2 + 256; 1406 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1; 1407 if (rdev->sb_size & bmask) 1408 rdev->sb_size = (rdev->sb_size | bmask) + 1; 1409 } 1410 for (i=0; i<max_dev;i++) 1411 sb->dev_roles[i] = cpu_to_le16(0xfffe); 1412 1413 list_for_each_entry(rdev2, &mddev->disks, same_set) { 1414 i = rdev2->desc_nr; 1415 if (test_bit(Faulty, &rdev2->flags)) 1416 sb->dev_roles[i] = cpu_to_le16(0xfffe); 1417 else if (test_bit(In_sync, &rdev2->flags)) 1418 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk); 1419 else if (rdev2->raid_disk >= 0 && rdev2->recovery_offset > 0) 1420 sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk); 1421 else 1422 sb->dev_roles[i] = cpu_to_le16(0xffff); 1423 } 1424 1425 sb->sb_csum = calc_sb_1_csum(sb); 1426 } 1427 1428 static unsigned long long 1429 super_1_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors) 1430 { 1431 struct mdp_superblock_1 *sb; 1432 sector_t max_sectors; 1433 if (num_sectors && num_sectors < rdev->mddev->dev_sectors) 1434 return 0; /* component must fit device */ 1435 if (rdev->sb_start < rdev->data_offset) { 1436 /* minor versions 1 and 2; superblock before data */ 1437 max_sectors = rdev->bdev->bd_inode->i_size >> 9; 1438 max_sectors -= rdev->data_offset; 1439 if (!num_sectors || num_sectors > max_sectors) 1440 num_sectors = max_sectors; 1441 } else if (rdev->mddev->bitmap_offset) { 1442 /* minor version 0 with bitmap we can't move */ 1443 return 0; 1444 } else { 1445 /* minor version 0; superblock after data */ 1446 sector_t sb_start; 1447 sb_start = (rdev->bdev->bd_inode->i_size >> 9) - 8*2; 1448 sb_start &= ~(sector_t)(4*2 - 1); 1449 max_sectors = rdev->sectors + sb_start - rdev->sb_start; 1450 if (!num_sectors || num_sectors > max_sectors) 1451 num_sectors = max_sectors; 1452 rdev->sb_start = sb_start; 1453 } 1454 sb = (struct mdp_superblock_1 *) page_address(rdev->sb_page); 1455 sb->data_size = cpu_to_le64(num_sectors); 1456 sb->super_offset = rdev->sb_start; 1457 sb->sb_csum = calc_sb_1_csum(sb); 1458 md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size, 1459 rdev->sb_page); 1460 md_super_wait(rdev->mddev); 1461 return num_sectors / 2; /* kB for sysfs */ 1462 } 1463 1464 static struct super_type super_types[] = { 1465 [0] = { 1466 .name = "0.90.0", 1467 .owner = THIS_MODULE, 1468 .load_super = super_90_load, 1469 .validate_super = super_90_validate, 1470 .sync_super = super_90_sync, 1471 .rdev_size_change = super_90_rdev_size_change, 1472 }, 1473 [1] = { 1474 .name = "md-1", 1475 .owner = THIS_MODULE, 1476 .load_super = super_1_load, 1477 .validate_super = super_1_validate, 1478 .sync_super = super_1_sync, 1479 .rdev_size_change = super_1_rdev_size_change, 1480 }, 1481 }; 1482 1483 static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2) 1484 { 1485 mdk_rdev_t *rdev, *rdev2; 1486 1487 rcu_read_lock(); 1488 rdev_for_each_rcu(rdev, mddev1) 1489 rdev_for_each_rcu(rdev2, mddev2) 1490 if (rdev->bdev->bd_contains == 1491 rdev2->bdev->bd_contains) { 1492 rcu_read_unlock(); 1493 return 1; 1494 } 1495 rcu_read_unlock(); 1496 return 0; 1497 } 1498 1499 static LIST_HEAD(pending_raid_disks); 1500 1501 /* 1502 * Try to register data integrity profile for an mddev 1503 * 1504 * This is called when an array is started and after a disk has been kicked 1505 * from the array. It only succeeds if all working and active component devices 1506 * are integrity capable with matching profiles. 1507 */ 1508 int md_integrity_register(mddev_t *mddev) 1509 { 1510 mdk_rdev_t *rdev, *reference = NULL; 1511 1512 if (list_empty(&mddev->disks)) 1513 return 0; /* nothing to do */ 1514 if (blk_get_integrity(mddev->gendisk)) 1515 return 0; /* already registered */ 1516 list_for_each_entry(rdev, &mddev->disks, same_set) { 1517 /* skip spares and non-functional disks */ 1518 if (test_bit(Faulty, &rdev->flags)) 1519 continue; 1520 if (rdev->raid_disk < 0) 1521 continue; 1522 /* 1523 * If at least one rdev is not integrity capable, we can not 1524 * enable data integrity for the md device. 1525 */ 1526 if (!bdev_get_integrity(rdev->bdev)) 1527 return -EINVAL; 1528 if (!reference) { 1529 /* Use the first rdev as the reference */ 1530 reference = rdev; 1531 continue; 1532 } 1533 /* does this rdev's profile match the reference profile? */ 1534 if (blk_integrity_compare(reference->bdev->bd_disk, 1535 rdev->bdev->bd_disk) < 0) 1536 return -EINVAL; 1537 } 1538 /* 1539 * All component devices are integrity capable and have matching 1540 * profiles, register the common profile for the md device. 1541 */ 1542 if (blk_integrity_register(mddev->gendisk, 1543 bdev_get_integrity(reference->bdev)) != 0) { 1544 printk(KERN_ERR "md: failed to register integrity for %s\n", 1545 mdname(mddev)); 1546 return -EINVAL; 1547 } 1548 printk(KERN_NOTICE "md: data integrity on %s enabled\n", 1549 mdname(mddev)); 1550 return 0; 1551 } 1552 EXPORT_SYMBOL(md_integrity_register); 1553 1554 /* Disable data integrity if non-capable/non-matching disk is being added */ 1555 void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev) 1556 { 1557 struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev); 1558 struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk); 1559 1560 if (!bi_mddev) /* nothing to do */ 1561 return; 1562 if (rdev->raid_disk < 0) /* skip spares */ 1563 return; 1564 if (bi_rdev && blk_integrity_compare(mddev->gendisk, 1565 rdev->bdev->bd_disk) >= 0) 1566 return; 1567 printk(KERN_NOTICE "disabling data integrity on %s\n", mdname(mddev)); 1568 blk_integrity_unregister(mddev->gendisk); 1569 } 1570 EXPORT_SYMBOL(md_integrity_add_rdev); 1571 1572 static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev) 1573 { 1574 char b[BDEVNAME_SIZE]; 1575 struct kobject *ko; 1576 char *s; 1577 int err; 1578 1579 if (rdev->mddev) { 1580 MD_BUG(); 1581 return -EINVAL; 1582 } 1583 1584 /* prevent duplicates */ 1585 if (find_rdev(mddev, rdev->bdev->bd_dev)) 1586 return -EEXIST; 1587 1588 /* make sure rdev->sectors exceeds mddev->dev_sectors */ 1589 if (rdev->sectors && (mddev->dev_sectors == 0 || 1590 rdev->sectors < mddev->dev_sectors)) { 1591 if (mddev->pers) { 1592 /* Cannot change size, so fail 1593 * If mddev->level <= 0, then we don't care 1594 * about aligning sizes (e.g. linear) 1595 */ 1596 if (mddev->level > 0) 1597 return -ENOSPC; 1598 } else 1599 mddev->dev_sectors = rdev->sectors; 1600 } 1601 1602 /* Verify rdev->desc_nr is unique. 1603 * If it is -1, assign a free number, else 1604 * check number is not in use 1605 */ 1606 if (rdev->desc_nr < 0) { 1607 int choice = 0; 1608 if (mddev->pers) choice = mddev->raid_disks; 1609 while (find_rdev_nr(mddev, choice)) 1610 choice++; 1611 rdev->desc_nr = choice; 1612 } else { 1613 if (find_rdev_nr(mddev, rdev->desc_nr)) 1614 return -EBUSY; 1615 } 1616 if (mddev->max_disks && rdev->desc_nr >= mddev->max_disks) { 1617 printk(KERN_WARNING "md: %s: array is limited to %d devices\n", 1618 mdname(mddev), mddev->max_disks); 1619 return -EBUSY; 1620 } 1621 bdevname(rdev->bdev,b); 1622 while ( (s=strchr(b, '/')) != NULL) 1623 *s = '!'; 1624 1625 rdev->mddev = mddev; 1626 printk(KERN_INFO "md: bind<%s>\n", b); 1627 1628 if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b))) 1629 goto fail; 1630 1631 ko = &part_to_dev(rdev->bdev->bd_part)->kobj; 1632 if ((err = sysfs_create_link(&rdev->kobj, ko, "block"))) { 1633 kobject_del(&rdev->kobj); 1634 goto fail; 1635 } 1636 rdev->sysfs_state = sysfs_get_dirent(rdev->kobj.sd, "state"); 1637 1638 list_add_rcu(&rdev->same_set, &mddev->disks); 1639 bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk); 1640 1641 /* May as well allow recovery to be retried once */ 1642 mddev->recovery_disabled = 0; 1643 1644 return 0; 1645 1646 fail: 1647 printk(KERN_WARNING "md: failed to register dev-%s for %s\n", 1648 b, mdname(mddev)); 1649 return err; 1650 } 1651 1652 static void md_delayed_delete(struct work_struct *ws) 1653 { 1654 mdk_rdev_t *rdev = container_of(ws, mdk_rdev_t, del_work); 1655 kobject_del(&rdev->kobj); 1656 kobject_put(&rdev->kobj); 1657 } 1658 1659 static void unbind_rdev_from_array(mdk_rdev_t * rdev) 1660 { 1661 char b[BDEVNAME_SIZE]; 1662 if (!rdev->mddev) { 1663 MD_BUG(); 1664 return; 1665 } 1666 bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk); 1667 list_del_rcu(&rdev->same_set); 1668 printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b)); 1669 rdev->mddev = NULL; 1670 sysfs_remove_link(&rdev->kobj, "block"); 1671 sysfs_put(rdev->sysfs_state); 1672 rdev->sysfs_state = NULL; 1673 /* We need to delay this, otherwise we can deadlock when 1674 * writing to 'remove' to "dev/state". We also need 1675 * to delay it due to rcu usage. 1676 */ 1677 synchronize_rcu(); 1678 INIT_WORK(&rdev->del_work, md_delayed_delete); 1679 kobject_get(&rdev->kobj); 1680 schedule_work(&rdev->del_work); 1681 } 1682 1683 /* 1684 * prevent the device from being mounted, repartitioned or 1685 * otherwise reused by a RAID array (or any other kernel 1686 * subsystem), by bd_claiming the device. 1687 */ 1688 static int lock_rdev(mdk_rdev_t *rdev, dev_t dev, int shared) 1689 { 1690 int err = 0; 1691 struct block_device *bdev; 1692 char b[BDEVNAME_SIZE]; 1693 1694 bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE); 1695 if (IS_ERR(bdev)) { 1696 printk(KERN_ERR "md: could not open %s.\n", 1697 __bdevname(dev, b)); 1698 return PTR_ERR(bdev); 1699 } 1700 err = bd_claim(bdev, shared ? (mdk_rdev_t *)lock_rdev : rdev); 1701 if (err) { 1702 printk(KERN_ERR "md: could not bd_claim %s.\n", 1703 bdevname(bdev, b)); 1704 blkdev_put(bdev, FMODE_READ|FMODE_WRITE); 1705 return err; 1706 } 1707 if (!shared) 1708 set_bit(AllReserved, &rdev->flags); 1709 rdev->bdev = bdev; 1710 return err; 1711 } 1712 1713 static void unlock_rdev(mdk_rdev_t *rdev) 1714 { 1715 struct block_device *bdev = rdev->bdev; 1716 rdev->bdev = NULL; 1717 if (!bdev) 1718 MD_BUG(); 1719 bd_release(bdev); 1720 blkdev_put(bdev, FMODE_READ|FMODE_WRITE); 1721 } 1722 1723 void md_autodetect_dev(dev_t dev); 1724 1725 static void export_rdev(mdk_rdev_t * rdev) 1726 { 1727 char b[BDEVNAME_SIZE]; 1728 printk(KERN_INFO "md: export_rdev(%s)\n", 1729 bdevname(rdev->bdev,b)); 1730 if (rdev->mddev) 1731 MD_BUG(); 1732 free_disk_sb(rdev); 1733 #ifndef MODULE 1734 if (test_bit(AutoDetected, &rdev->flags)) 1735 md_autodetect_dev(rdev->bdev->bd_dev); 1736 #endif 1737 unlock_rdev(rdev); 1738 kobject_put(&rdev->kobj); 1739 } 1740 1741 static void kick_rdev_from_array(mdk_rdev_t * rdev) 1742 { 1743 unbind_rdev_from_array(rdev); 1744 export_rdev(rdev); 1745 } 1746 1747 static void export_array(mddev_t *mddev) 1748 { 1749 mdk_rdev_t *rdev, *tmp; 1750 1751 rdev_for_each(rdev, tmp, mddev) { 1752 if (!rdev->mddev) { 1753 MD_BUG(); 1754 continue; 1755 } 1756 kick_rdev_from_array(rdev); 1757 } 1758 if (!list_empty(&mddev->disks)) 1759 MD_BUG(); 1760 mddev->raid_disks = 0; 1761 mddev->major_version = 0; 1762 } 1763 1764 static void print_desc(mdp_disk_t *desc) 1765 { 1766 printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number, 1767 desc->major,desc->minor,desc->raid_disk,desc->state); 1768 } 1769 1770 static void print_sb_90(mdp_super_t *sb) 1771 { 1772 int i; 1773 1774 printk(KERN_INFO 1775 "md: SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n", 1776 sb->major_version, sb->minor_version, sb->patch_version, 1777 sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3, 1778 sb->ctime); 1779 printk(KERN_INFO "md: L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n", 1780 sb->level, sb->size, sb->nr_disks, sb->raid_disks, 1781 sb->md_minor, sb->layout, sb->chunk_size); 1782 printk(KERN_INFO "md: UT:%08x ST:%d AD:%d WD:%d" 1783 " FD:%d SD:%d CSUM:%08x E:%08lx\n", 1784 sb->utime, sb->state, sb->active_disks, sb->working_disks, 1785 sb->failed_disks, sb->spare_disks, 1786 sb->sb_csum, (unsigned long)sb->events_lo); 1787 1788 printk(KERN_INFO); 1789 for (i = 0; i < MD_SB_DISKS; i++) { 1790 mdp_disk_t *desc; 1791 1792 desc = sb->disks + i; 1793 if (desc->number || desc->major || desc->minor || 1794 desc->raid_disk || (desc->state && (desc->state != 4))) { 1795 printk(" D %2d: ", i); 1796 print_desc(desc); 1797 } 1798 } 1799 printk(KERN_INFO "md: THIS: "); 1800 print_desc(&sb->this_disk); 1801 } 1802 1803 static void print_sb_1(struct mdp_superblock_1 *sb) 1804 { 1805 __u8 *uuid; 1806 1807 uuid = sb->set_uuid; 1808 printk(KERN_INFO 1809 "md: SB: (V:%u) (F:0x%08x) Array-ID:<%02x%02x%02x%02x" 1810 ":%02x%02x:%02x%02x:%02x%02x:%02x%02x%02x%02x%02x%02x>\n" 1811 "md: Name: \"%s\" CT:%llu\n", 1812 le32_to_cpu(sb->major_version), 1813 le32_to_cpu(sb->feature_map), 1814 uuid[0], uuid[1], uuid[2], uuid[3], 1815 uuid[4], uuid[5], uuid[6], uuid[7], 1816 uuid[8], uuid[9], uuid[10], uuid[11], 1817 uuid[12], uuid[13], uuid[14], uuid[15], 1818 sb->set_name, 1819 (unsigned long long)le64_to_cpu(sb->ctime) 1820 & MD_SUPERBLOCK_1_TIME_SEC_MASK); 1821 1822 uuid = sb->device_uuid; 1823 printk(KERN_INFO 1824 "md: L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu" 1825 " RO:%llu\n" 1826 "md: Dev:%08x UUID: %02x%02x%02x%02x:%02x%02x:%02x%02x:%02x%02x" 1827 ":%02x%02x%02x%02x%02x%02x\n" 1828 "md: (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n" 1829 "md: (MaxDev:%u) \n", 1830 le32_to_cpu(sb->level), 1831 (unsigned long long)le64_to_cpu(sb->size), 1832 le32_to_cpu(sb->raid_disks), 1833 le32_to_cpu(sb->layout), 1834 le32_to_cpu(sb->chunksize), 1835 (unsigned long long)le64_to_cpu(sb->data_offset), 1836 (unsigned long long)le64_to_cpu(sb->data_size), 1837 (unsigned long long)le64_to_cpu(sb->super_offset), 1838 (unsigned long long)le64_to_cpu(sb->recovery_offset), 1839 le32_to_cpu(sb->dev_number), 1840 uuid[0], uuid[1], uuid[2], uuid[3], 1841 uuid[4], uuid[5], uuid[6], uuid[7], 1842 uuid[8], uuid[9], uuid[10], uuid[11], 1843 uuid[12], uuid[13], uuid[14], uuid[15], 1844 sb->devflags, 1845 (unsigned long long)le64_to_cpu(sb->utime) & MD_SUPERBLOCK_1_TIME_SEC_MASK, 1846 (unsigned long long)le64_to_cpu(sb->events), 1847 (unsigned long long)le64_to_cpu(sb->resync_offset), 1848 le32_to_cpu(sb->sb_csum), 1849 le32_to_cpu(sb->max_dev) 1850 ); 1851 } 1852 1853 static void print_rdev(mdk_rdev_t *rdev, int major_version) 1854 { 1855 char b[BDEVNAME_SIZE]; 1856 printk(KERN_INFO "md: rdev %s, Sect:%08llu F:%d S:%d DN:%u\n", 1857 bdevname(rdev->bdev, b), (unsigned long long)rdev->sectors, 1858 test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags), 1859 rdev->desc_nr); 1860 if (rdev->sb_loaded) { 1861 printk(KERN_INFO "md: rdev superblock (MJ:%d):\n", major_version); 1862 switch (major_version) { 1863 case 0: 1864 print_sb_90((mdp_super_t*)page_address(rdev->sb_page)); 1865 break; 1866 case 1: 1867 print_sb_1((struct mdp_superblock_1 *)page_address(rdev->sb_page)); 1868 break; 1869 } 1870 } else 1871 printk(KERN_INFO "md: no rdev superblock!\n"); 1872 } 1873 1874 static void md_print_devices(void) 1875 { 1876 struct list_head *tmp; 1877 mdk_rdev_t *rdev; 1878 mddev_t *mddev; 1879 char b[BDEVNAME_SIZE]; 1880 1881 printk("\n"); 1882 printk("md: **********************************\n"); 1883 printk("md: * <COMPLETE RAID STATE PRINTOUT> *\n"); 1884 printk("md: **********************************\n"); 1885 for_each_mddev(mddev, tmp) { 1886 1887 if (mddev->bitmap) 1888 bitmap_print_sb(mddev->bitmap); 1889 else 1890 printk("%s: ", mdname(mddev)); 1891 list_for_each_entry(rdev, &mddev->disks, same_set) 1892 printk("<%s>", bdevname(rdev->bdev,b)); 1893 printk("\n"); 1894 1895 list_for_each_entry(rdev, &mddev->disks, same_set) 1896 print_rdev(rdev, mddev->major_version); 1897 } 1898 printk("md: **********************************\n"); 1899 printk("\n"); 1900 } 1901 1902 1903 static void sync_sbs(mddev_t * mddev, int nospares) 1904 { 1905 /* Update each superblock (in-memory image), but 1906 * if we are allowed to, skip spares which already 1907 * have the right event counter, or have one earlier 1908 * (which would mean they aren't being marked as dirty 1909 * with the rest of the array) 1910 */ 1911 mdk_rdev_t *rdev; 1912 1913 list_for_each_entry(rdev, &mddev->disks, same_set) { 1914 if (rdev->sb_events == mddev->events || 1915 (nospares && 1916 rdev->raid_disk < 0 && 1917 (rdev->sb_events&1)==0 && 1918 rdev->sb_events+1 == mddev->events)) { 1919 /* Don't update this superblock */ 1920 rdev->sb_loaded = 2; 1921 } else { 1922 super_types[mddev->major_version]. 1923 sync_super(mddev, rdev); 1924 rdev->sb_loaded = 1; 1925 } 1926 } 1927 } 1928 1929 static void md_update_sb(mddev_t * mddev, int force_change) 1930 { 1931 mdk_rdev_t *rdev; 1932 int sync_req; 1933 int nospares = 0; 1934 1935 mddev->utime = get_seconds(); 1936 if (mddev->external) 1937 return; 1938 repeat: 1939 spin_lock_irq(&mddev->write_lock); 1940 1941 set_bit(MD_CHANGE_PENDING, &mddev->flags); 1942 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags)) 1943 force_change = 1; 1944 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags)) 1945 /* just a clean<-> dirty transition, possibly leave spares alone, 1946 * though if events isn't the right even/odd, we will have to do 1947 * spares after all 1948 */ 1949 nospares = 1; 1950 if (force_change) 1951 nospares = 0; 1952 if (mddev->degraded) 1953 /* If the array is degraded, then skipping spares is both 1954 * dangerous and fairly pointless. 1955 * Dangerous because a device that was removed from the array 1956 * might have a event_count that still looks up-to-date, 1957 * so it can be re-added without a resync. 1958 * Pointless because if there are any spares to skip, 1959 * then a recovery will happen and soon that array won't 1960 * be degraded any more and the spare can go back to sleep then. 1961 */ 1962 nospares = 0; 1963 1964 sync_req = mddev->in_sync; 1965 1966 /* If this is just a dirty<->clean transition, and the array is clean 1967 * and 'events' is odd, we can roll back to the previous clean state */ 1968 if (nospares 1969 && (mddev->in_sync && mddev->recovery_cp == MaxSector) 1970 && (mddev->events & 1) 1971 && mddev->events != 1) 1972 mddev->events--; 1973 else { 1974 /* otherwise we have to go forward and ... */ 1975 mddev->events ++; 1976 if (!mddev->in_sync || mddev->recovery_cp != MaxSector) { /* not clean */ 1977 /* .. if the array isn't clean, insist on an odd 'events' */ 1978 if ((mddev->events&1)==0) { 1979 mddev->events++; 1980 nospares = 0; 1981 } 1982 } else { 1983 /* otherwise insist on an even 'events' (for clean states) */ 1984 if ((mddev->events&1)) { 1985 mddev->events++; 1986 nospares = 0; 1987 } 1988 } 1989 } 1990 1991 if (!mddev->events) { 1992 /* 1993 * oops, this 64-bit counter should never wrap. 1994 * Either we are in around ~1 trillion A.C., assuming 1995 * 1 reboot per second, or we have a bug: 1996 */ 1997 MD_BUG(); 1998 mddev->events --; 1999 } 2000 2001 /* 2002 * do not write anything to disk if using 2003 * nonpersistent superblocks 2004 */ 2005 if (!mddev->persistent) { 2006 if (!mddev->external) 2007 clear_bit(MD_CHANGE_PENDING, &mddev->flags); 2008 2009 spin_unlock_irq(&mddev->write_lock); 2010 wake_up(&mddev->sb_wait); 2011 return; 2012 } 2013 sync_sbs(mddev, nospares); 2014 spin_unlock_irq(&mddev->write_lock); 2015 2016 dprintk(KERN_INFO 2017 "md: updating %s RAID superblock on device (in sync %d)\n", 2018 mdname(mddev),mddev->in_sync); 2019 2020 bitmap_update_sb(mddev->bitmap); 2021 list_for_each_entry(rdev, &mddev->disks, same_set) { 2022 char b[BDEVNAME_SIZE]; 2023 dprintk(KERN_INFO "md: "); 2024 if (rdev->sb_loaded != 1) 2025 continue; /* no noise on spare devices */ 2026 if (test_bit(Faulty, &rdev->flags)) 2027 dprintk("(skipping faulty "); 2028 2029 dprintk("%s ", bdevname(rdev->bdev,b)); 2030 if (!test_bit(Faulty, &rdev->flags)) { 2031 md_super_write(mddev,rdev, 2032 rdev->sb_start, rdev->sb_size, 2033 rdev->sb_page); 2034 dprintk(KERN_INFO "(write) %s's sb offset: %llu\n", 2035 bdevname(rdev->bdev,b), 2036 (unsigned long long)rdev->sb_start); 2037 rdev->sb_events = mddev->events; 2038 2039 } else 2040 dprintk(")\n"); 2041 if (mddev->level == LEVEL_MULTIPATH) 2042 /* only need to write one superblock... */ 2043 break; 2044 } 2045 md_super_wait(mddev); 2046 /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */ 2047 2048 spin_lock_irq(&mddev->write_lock); 2049 if (mddev->in_sync != sync_req || 2050 test_bit(MD_CHANGE_DEVS, &mddev->flags)) { 2051 /* have to write it out again */ 2052 spin_unlock_irq(&mddev->write_lock); 2053 goto repeat; 2054 } 2055 clear_bit(MD_CHANGE_PENDING, &mddev->flags); 2056 spin_unlock_irq(&mddev->write_lock); 2057 wake_up(&mddev->sb_wait); 2058 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 2059 sysfs_notify(&mddev->kobj, NULL, "sync_completed"); 2060 2061 } 2062 2063 /* words written to sysfs files may, or may not, be \n terminated. 2064 * We want to accept with case. For this we use cmd_match. 2065 */ 2066 static int cmd_match(const char *cmd, const char *str) 2067 { 2068 /* See if cmd, written into a sysfs file, matches 2069 * str. They must either be the same, or cmd can 2070 * have a trailing newline 2071 */ 2072 while (*cmd && *str && *cmd == *str) { 2073 cmd++; 2074 str++; 2075 } 2076 if (*cmd == '\n') 2077 cmd++; 2078 if (*str || *cmd) 2079 return 0; 2080 return 1; 2081 } 2082 2083 struct rdev_sysfs_entry { 2084 struct attribute attr; 2085 ssize_t (*show)(mdk_rdev_t *, char *); 2086 ssize_t (*store)(mdk_rdev_t *, const char *, size_t); 2087 }; 2088 2089 static ssize_t 2090 state_show(mdk_rdev_t *rdev, char *page) 2091 { 2092 char *sep = ""; 2093 size_t len = 0; 2094 2095 if (test_bit(Faulty, &rdev->flags)) { 2096 len+= sprintf(page+len, "%sfaulty",sep); 2097 sep = ","; 2098 } 2099 if (test_bit(In_sync, &rdev->flags)) { 2100 len += sprintf(page+len, "%sin_sync",sep); 2101 sep = ","; 2102 } 2103 if (test_bit(WriteMostly, &rdev->flags)) { 2104 len += sprintf(page+len, "%swrite_mostly",sep); 2105 sep = ","; 2106 } 2107 if (test_bit(Blocked, &rdev->flags)) { 2108 len += sprintf(page+len, "%sblocked", sep); 2109 sep = ","; 2110 } 2111 if (!test_bit(Faulty, &rdev->flags) && 2112 !test_bit(In_sync, &rdev->flags)) { 2113 len += sprintf(page+len, "%sspare", sep); 2114 sep = ","; 2115 } 2116 return len+sprintf(page+len, "\n"); 2117 } 2118 2119 static ssize_t 2120 state_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2121 { 2122 /* can write 2123 * faulty - simulates and error 2124 * remove - disconnects the device 2125 * writemostly - sets write_mostly 2126 * -writemostly - clears write_mostly 2127 * blocked - sets the Blocked flag 2128 * -blocked - clears the Blocked flag 2129 * insync - sets Insync providing device isn't active 2130 */ 2131 int err = -EINVAL; 2132 if (cmd_match(buf, "faulty") && rdev->mddev->pers) { 2133 md_error(rdev->mddev, rdev); 2134 err = 0; 2135 } else if (cmd_match(buf, "remove")) { 2136 if (rdev->raid_disk >= 0) 2137 err = -EBUSY; 2138 else { 2139 mddev_t *mddev = rdev->mddev; 2140 kick_rdev_from_array(rdev); 2141 if (mddev->pers) 2142 md_update_sb(mddev, 1); 2143 md_new_event(mddev); 2144 err = 0; 2145 } 2146 } else if (cmd_match(buf, "writemostly")) { 2147 set_bit(WriteMostly, &rdev->flags); 2148 err = 0; 2149 } else if (cmd_match(buf, "-writemostly")) { 2150 clear_bit(WriteMostly, &rdev->flags); 2151 err = 0; 2152 } else if (cmd_match(buf, "blocked")) { 2153 set_bit(Blocked, &rdev->flags); 2154 err = 0; 2155 } else if (cmd_match(buf, "-blocked")) { 2156 clear_bit(Blocked, &rdev->flags); 2157 wake_up(&rdev->blocked_wait); 2158 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery); 2159 md_wakeup_thread(rdev->mddev->thread); 2160 2161 err = 0; 2162 } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) { 2163 set_bit(In_sync, &rdev->flags); 2164 err = 0; 2165 } 2166 if (!err && rdev->sysfs_state) 2167 sysfs_notify_dirent(rdev->sysfs_state); 2168 return err ? err : len; 2169 } 2170 static struct rdev_sysfs_entry rdev_state = 2171 __ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store); 2172 2173 static ssize_t 2174 errors_show(mdk_rdev_t *rdev, char *page) 2175 { 2176 return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors)); 2177 } 2178 2179 static ssize_t 2180 errors_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2181 { 2182 char *e; 2183 unsigned long n = simple_strtoul(buf, &e, 10); 2184 if (*buf && (*e == 0 || *e == '\n')) { 2185 atomic_set(&rdev->corrected_errors, n); 2186 return len; 2187 } 2188 return -EINVAL; 2189 } 2190 static struct rdev_sysfs_entry rdev_errors = 2191 __ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store); 2192 2193 static ssize_t 2194 slot_show(mdk_rdev_t *rdev, char *page) 2195 { 2196 if (rdev->raid_disk < 0) 2197 return sprintf(page, "none\n"); 2198 else 2199 return sprintf(page, "%d\n", rdev->raid_disk); 2200 } 2201 2202 static ssize_t 2203 slot_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2204 { 2205 char *e; 2206 int err; 2207 char nm[20]; 2208 int slot = simple_strtoul(buf, &e, 10); 2209 if (strncmp(buf, "none", 4)==0) 2210 slot = -1; 2211 else if (e==buf || (*e && *e!= '\n')) 2212 return -EINVAL; 2213 if (rdev->mddev->pers && slot == -1) { 2214 /* Setting 'slot' on an active array requires also 2215 * updating the 'rd%d' link, and communicating 2216 * with the personality with ->hot_*_disk. 2217 * For now we only support removing 2218 * failed/spare devices. This normally happens automatically, 2219 * but not when the metadata is externally managed. 2220 */ 2221 if (rdev->raid_disk == -1) 2222 return -EEXIST; 2223 /* personality does all needed checks */ 2224 if (rdev->mddev->pers->hot_add_disk == NULL) 2225 return -EINVAL; 2226 err = rdev->mddev->pers-> 2227 hot_remove_disk(rdev->mddev, rdev->raid_disk); 2228 if (err) 2229 return err; 2230 sprintf(nm, "rd%d", rdev->raid_disk); 2231 sysfs_remove_link(&rdev->mddev->kobj, nm); 2232 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery); 2233 md_wakeup_thread(rdev->mddev->thread); 2234 } else if (rdev->mddev->pers) { 2235 mdk_rdev_t *rdev2; 2236 /* Activating a spare .. or possibly reactivating 2237 * if we ever get bitmaps working here. 2238 */ 2239 2240 if (rdev->raid_disk != -1) 2241 return -EBUSY; 2242 2243 if (rdev->mddev->pers->hot_add_disk == NULL) 2244 return -EINVAL; 2245 2246 list_for_each_entry(rdev2, &rdev->mddev->disks, same_set) 2247 if (rdev2->raid_disk == slot) 2248 return -EEXIST; 2249 2250 rdev->raid_disk = slot; 2251 if (test_bit(In_sync, &rdev->flags)) 2252 rdev->saved_raid_disk = slot; 2253 else 2254 rdev->saved_raid_disk = -1; 2255 err = rdev->mddev->pers-> 2256 hot_add_disk(rdev->mddev, rdev); 2257 if (err) { 2258 rdev->raid_disk = -1; 2259 return err; 2260 } else 2261 sysfs_notify_dirent(rdev->sysfs_state); 2262 sprintf(nm, "rd%d", rdev->raid_disk); 2263 if (sysfs_create_link(&rdev->mddev->kobj, &rdev->kobj, nm)) 2264 printk(KERN_WARNING 2265 "md: cannot register " 2266 "%s for %s\n", 2267 nm, mdname(rdev->mddev)); 2268 2269 /* don't wakeup anyone, leave that to userspace. */ 2270 } else { 2271 if (slot >= rdev->mddev->raid_disks) 2272 return -ENOSPC; 2273 rdev->raid_disk = slot; 2274 /* assume it is working */ 2275 clear_bit(Faulty, &rdev->flags); 2276 clear_bit(WriteMostly, &rdev->flags); 2277 set_bit(In_sync, &rdev->flags); 2278 sysfs_notify_dirent(rdev->sysfs_state); 2279 } 2280 return len; 2281 } 2282 2283 2284 static struct rdev_sysfs_entry rdev_slot = 2285 __ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store); 2286 2287 static ssize_t 2288 offset_show(mdk_rdev_t *rdev, char *page) 2289 { 2290 return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset); 2291 } 2292 2293 static ssize_t 2294 offset_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2295 { 2296 char *e; 2297 unsigned long long offset = simple_strtoull(buf, &e, 10); 2298 if (e==buf || (*e && *e != '\n')) 2299 return -EINVAL; 2300 if (rdev->mddev->pers && rdev->raid_disk >= 0) 2301 return -EBUSY; 2302 if (rdev->sectors && rdev->mddev->external) 2303 /* Must set offset before size, so overlap checks 2304 * can be sane */ 2305 return -EBUSY; 2306 rdev->data_offset = offset; 2307 return len; 2308 } 2309 2310 static struct rdev_sysfs_entry rdev_offset = 2311 __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store); 2312 2313 static ssize_t 2314 rdev_size_show(mdk_rdev_t *rdev, char *page) 2315 { 2316 return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2); 2317 } 2318 2319 static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2) 2320 { 2321 /* check if two start/length pairs overlap */ 2322 if (s1+l1 <= s2) 2323 return 0; 2324 if (s2+l2 <= s1) 2325 return 0; 2326 return 1; 2327 } 2328 2329 static int strict_blocks_to_sectors(const char *buf, sector_t *sectors) 2330 { 2331 unsigned long long blocks; 2332 sector_t new; 2333 2334 if (strict_strtoull(buf, 10, &blocks) < 0) 2335 return -EINVAL; 2336 2337 if (blocks & 1ULL << (8 * sizeof(blocks) - 1)) 2338 return -EINVAL; /* sector conversion overflow */ 2339 2340 new = blocks * 2; 2341 if (new != blocks * 2) 2342 return -EINVAL; /* unsigned long long to sector_t overflow */ 2343 2344 *sectors = new; 2345 return 0; 2346 } 2347 2348 static ssize_t 2349 rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len) 2350 { 2351 mddev_t *my_mddev = rdev->mddev; 2352 sector_t oldsectors = rdev->sectors; 2353 sector_t sectors; 2354 2355 if (strict_blocks_to_sectors(buf, §ors) < 0) 2356 return -EINVAL; 2357 if (my_mddev->pers && rdev->raid_disk >= 0) { 2358 if (my_mddev->persistent) { 2359 sectors = super_types[my_mddev->major_version]. 2360 rdev_size_change(rdev, sectors); 2361 if (!sectors) 2362 return -EBUSY; 2363 } else if (!sectors) 2364 sectors = (rdev->bdev->bd_inode->i_size >> 9) - 2365 rdev->data_offset; 2366 } 2367 if (sectors < my_mddev->dev_sectors) 2368 return -EINVAL; /* component must fit device */ 2369 2370 rdev->sectors = sectors; 2371 if (sectors > oldsectors && my_mddev->external) { 2372 /* need to check that all other rdevs with the same ->bdev 2373 * do not overlap. We need to unlock the mddev to avoid 2374 * a deadlock. We have already changed rdev->sectors, and if 2375 * we have to change it back, we will have the lock again. 2376 */ 2377 mddev_t *mddev; 2378 int overlap = 0; 2379 struct list_head *tmp; 2380 2381 mddev_unlock(my_mddev); 2382 for_each_mddev(mddev, tmp) { 2383 mdk_rdev_t *rdev2; 2384 2385 mddev_lock(mddev); 2386 list_for_each_entry(rdev2, &mddev->disks, same_set) 2387 if (test_bit(AllReserved, &rdev2->flags) || 2388 (rdev->bdev == rdev2->bdev && 2389 rdev != rdev2 && 2390 overlaps(rdev->data_offset, rdev->sectors, 2391 rdev2->data_offset, 2392 rdev2->sectors))) { 2393 overlap = 1; 2394 break; 2395 } 2396 mddev_unlock(mddev); 2397 if (overlap) { 2398 mddev_put(mddev); 2399 break; 2400 } 2401 } 2402 mddev_lock(my_mddev); 2403 if (overlap) { 2404 /* Someone else could have slipped in a size 2405 * change here, but doing so is just silly. 2406 * We put oldsectors back because we *know* it is 2407 * safe, and trust userspace not to race with 2408 * itself 2409 */ 2410 rdev->sectors = oldsectors; 2411 return -EBUSY; 2412 } 2413 } 2414 return len; 2415 } 2416 2417 static struct rdev_sysfs_entry rdev_size = 2418 __ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store); 2419 2420 static struct attribute *rdev_default_attrs[] = { 2421 &rdev_state.attr, 2422 &rdev_errors.attr, 2423 &rdev_slot.attr, 2424 &rdev_offset.attr, 2425 &rdev_size.attr, 2426 NULL, 2427 }; 2428 static ssize_t 2429 rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page) 2430 { 2431 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr); 2432 mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj); 2433 mddev_t *mddev = rdev->mddev; 2434 ssize_t rv; 2435 2436 if (!entry->show) 2437 return -EIO; 2438 2439 rv = mddev ? mddev_lock(mddev) : -EBUSY; 2440 if (!rv) { 2441 if (rdev->mddev == NULL) 2442 rv = -EBUSY; 2443 else 2444 rv = entry->show(rdev, page); 2445 mddev_unlock(mddev); 2446 } 2447 return rv; 2448 } 2449 2450 static ssize_t 2451 rdev_attr_store(struct kobject *kobj, struct attribute *attr, 2452 const char *page, size_t length) 2453 { 2454 struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr); 2455 mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj); 2456 ssize_t rv; 2457 mddev_t *mddev = rdev->mddev; 2458 2459 if (!entry->store) 2460 return -EIO; 2461 if (!capable(CAP_SYS_ADMIN)) 2462 return -EACCES; 2463 rv = mddev ? mddev_lock(mddev): -EBUSY; 2464 if (!rv) { 2465 if (rdev->mddev == NULL) 2466 rv = -EBUSY; 2467 else 2468 rv = entry->store(rdev, page, length); 2469 mddev_unlock(mddev); 2470 } 2471 return rv; 2472 } 2473 2474 static void rdev_free(struct kobject *ko) 2475 { 2476 mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj); 2477 kfree(rdev); 2478 } 2479 static struct sysfs_ops rdev_sysfs_ops = { 2480 .show = rdev_attr_show, 2481 .store = rdev_attr_store, 2482 }; 2483 static struct kobj_type rdev_ktype = { 2484 .release = rdev_free, 2485 .sysfs_ops = &rdev_sysfs_ops, 2486 .default_attrs = rdev_default_attrs, 2487 }; 2488 2489 /* 2490 * Import a device. If 'super_format' >= 0, then sanity check the superblock 2491 * 2492 * mark the device faulty if: 2493 * 2494 * - the device is nonexistent (zero size) 2495 * - the device has no valid superblock 2496 * 2497 * a faulty rdev _never_ has rdev->sb set. 2498 */ 2499 static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor) 2500 { 2501 char b[BDEVNAME_SIZE]; 2502 int err; 2503 mdk_rdev_t *rdev; 2504 sector_t size; 2505 2506 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL); 2507 if (!rdev) { 2508 printk(KERN_ERR "md: could not alloc mem for new device!\n"); 2509 return ERR_PTR(-ENOMEM); 2510 } 2511 2512 if ((err = alloc_disk_sb(rdev))) 2513 goto abort_free; 2514 2515 err = lock_rdev(rdev, newdev, super_format == -2); 2516 if (err) 2517 goto abort_free; 2518 2519 kobject_init(&rdev->kobj, &rdev_ktype); 2520 2521 rdev->desc_nr = -1; 2522 rdev->saved_raid_disk = -1; 2523 rdev->raid_disk = -1; 2524 rdev->flags = 0; 2525 rdev->data_offset = 0; 2526 rdev->sb_events = 0; 2527 atomic_set(&rdev->nr_pending, 0); 2528 atomic_set(&rdev->read_errors, 0); 2529 atomic_set(&rdev->corrected_errors, 0); 2530 2531 size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS; 2532 if (!size) { 2533 printk(KERN_WARNING 2534 "md: %s has zero or unknown size, marking faulty!\n", 2535 bdevname(rdev->bdev,b)); 2536 err = -EINVAL; 2537 goto abort_free; 2538 } 2539 2540 if (super_format >= 0) { 2541 err = super_types[super_format]. 2542 load_super(rdev, NULL, super_minor); 2543 if (err == -EINVAL) { 2544 printk(KERN_WARNING 2545 "md: %s does not have a valid v%d.%d " 2546 "superblock, not importing!\n", 2547 bdevname(rdev->bdev,b), 2548 super_format, super_minor); 2549 goto abort_free; 2550 } 2551 if (err < 0) { 2552 printk(KERN_WARNING 2553 "md: could not read %s's sb, not importing!\n", 2554 bdevname(rdev->bdev,b)); 2555 goto abort_free; 2556 } 2557 } 2558 2559 INIT_LIST_HEAD(&rdev->same_set); 2560 init_waitqueue_head(&rdev->blocked_wait); 2561 2562 return rdev; 2563 2564 abort_free: 2565 if (rdev->sb_page) { 2566 if (rdev->bdev) 2567 unlock_rdev(rdev); 2568 free_disk_sb(rdev); 2569 } 2570 kfree(rdev); 2571 return ERR_PTR(err); 2572 } 2573 2574 /* 2575 * Check a full RAID array for plausibility 2576 */ 2577 2578 2579 static void analyze_sbs(mddev_t * mddev) 2580 { 2581 int i; 2582 mdk_rdev_t *rdev, *freshest, *tmp; 2583 char b[BDEVNAME_SIZE]; 2584 2585 freshest = NULL; 2586 rdev_for_each(rdev, tmp, mddev) 2587 switch (super_types[mddev->major_version]. 2588 load_super(rdev, freshest, mddev->minor_version)) { 2589 case 1: 2590 freshest = rdev; 2591 break; 2592 case 0: 2593 break; 2594 default: 2595 printk( KERN_ERR \ 2596 "md: fatal superblock inconsistency in %s" 2597 " -- removing from array\n", 2598 bdevname(rdev->bdev,b)); 2599 kick_rdev_from_array(rdev); 2600 } 2601 2602 2603 super_types[mddev->major_version]. 2604 validate_super(mddev, freshest); 2605 2606 i = 0; 2607 rdev_for_each(rdev, tmp, mddev) { 2608 if (rdev->desc_nr >= mddev->max_disks || 2609 i > mddev->max_disks) { 2610 printk(KERN_WARNING 2611 "md: %s: %s: only %d devices permitted\n", 2612 mdname(mddev), bdevname(rdev->bdev, b), 2613 mddev->max_disks); 2614 kick_rdev_from_array(rdev); 2615 continue; 2616 } 2617 if (rdev != freshest) 2618 if (super_types[mddev->major_version]. 2619 validate_super(mddev, rdev)) { 2620 printk(KERN_WARNING "md: kicking non-fresh %s" 2621 " from array!\n", 2622 bdevname(rdev->bdev,b)); 2623 kick_rdev_from_array(rdev); 2624 continue; 2625 } 2626 if (mddev->level == LEVEL_MULTIPATH) { 2627 rdev->desc_nr = i++; 2628 rdev->raid_disk = rdev->desc_nr; 2629 set_bit(In_sync, &rdev->flags); 2630 } else if (rdev->raid_disk >= mddev->raid_disks) { 2631 rdev->raid_disk = -1; 2632 clear_bit(In_sync, &rdev->flags); 2633 } 2634 } 2635 } 2636 2637 static void md_safemode_timeout(unsigned long data); 2638 2639 static ssize_t 2640 safe_delay_show(mddev_t *mddev, char *page) 2641 { 2642 int msec = (mddev->safemode_delay*1000)/HZ; 2643 return sprintf(page, "%d.%03d\n", msec/1000, msec%1000); 2644 } 2645 static ssize_t 2646 safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len) 2647 { 2648 int scale=1; 2649 int dot=0; 2650 int i; 2651 unsigned long msec; 2652 char buf[30]; 2653 2654 /* remove a period, and count digits after it */ 2655 if (len >= sizeof(buf)) 2656 return -EINVAL; 2657 strlcpy(buf, cbuf, sizeof(buf)); 2658 for (i=0; i<len; i++) { 2659 if (dot) { 2660 if (isdigit(buf[i])) { 2661 buf[i-1] = buf[i]; 2662 scale *= 10; 2663 } 2664 buf[i] = 0; 2665 } else if (buf[i] == '.') { 2666 dot=1; 2667 buf[i] = 0; 2668 } 2669 } 2670 if (strict_strtoul(buf, 10, &msec) < 0) 2671 return -EINVAL; 2672 msec = (msec * 1000) / scale; 2673 if (msec == 0) 2674 mddev->safemode_delay = 0; 2675 else { 2676 unsigned long old_delay = mddev->safemode_delay; 2677 mddev->safemode_delay = (msec*HZ)/1000; 2678 if (mddev->safemode_delay == 0) 2679 mddev->safemode_delay = 1; 2680 if (mddev->safemode_delay < old_delay) 2681 md_safemode_timeout((unsigned long)mddev); 2682 } 2683 return len; 2684 } 2685 static struct md_sysfs_entry md_safe_delay = 2686 __ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store); 2687 2688 static ssize_t 2689 level_show(mddev_t *mddev, char *page) 2690 { 2691 struct mdk_personality *p = mddev->pers; 2692 if (p) 2693 return sprintf(page, "%s\n", p->name); 2694 else if (mddev->clevel[0]) 2695 return sprintf(page, "%s\n", mddev->clevel); 2696 else if (mddev->level != LEVEL_NONE) 2697 return sprintf(page, "%d\n", mddev->level); 2698 else 2699 return 0; 2700 } 2701 2702 static ssize_t 2703 level_store(mddev_t *mddev, const char *buf, size_t len) 2704 { 2705 char level[16]; 2706 ssize_t rv = len; 2707 struct mdk_personality *pers; 2708 void *priv; 2709 mdk_rdev_t *rdev; 2710 2711 if (mddev->pers == NULL) { 2712 if (len == 0) 2713 return 0; 2714 if (len >= sizeof(mddev->clevel)) 2715 return -ENOSPC; 2716 strncpy(mddev->clevel, buf, len); 2717 if (mddev->clevel[len-1] == '\n') 2718 len--; 2719 mddev->clevel[len] = 0; 2720 mddev->level = LEVEL_NONE; 2721 return rv; 2722 } 2723 2724 /* request to change the personality. Need to ensure: 2725 * - array is not engaged in resync/recovery/reshape 2726 * - old personality can be suspended 2727 * - new personality will access other array. 2728 */ 2729 2730 if (mddev->sync_thread || mddev->reshape_position != MaxSector) 2731 return -EBUSY; 2732 2733 if (!mddev->pers->quiesce) { 2734 printk(KERN_WARNING "md: %s: %s does not support online personality change\n", 2735 mdname(mddev), mddev->pers->name); 2736 return -EINVAL; 2737 } 2738 2739 /* Now find the new personality */ 2740 if (len == 0 || len >= sizeof(level)) 2741 return -EINVAL; 2742 strncpy(level, buf, len); 2743 if (level[len-1] == '\n') 2744 len--; 2745 level[len] = 0; 2746 2747 request_module("md-%s", level); 2748 spin_lock(&pers_lock); 2749 pers = find_pers(LEVEL_NONE, level); 2750 if (!pers || !try_module_get(pers->owner)) { 2751 spin_unlock(&pers_lock); 2752 printk(KERN_WARNING "md: personality %s not loaded\n", level); 2753 return -EINVAL; 2754 } 2755 spin_unlock(&pers_lock); 2756 2757 if (pers == mddev->pers) { 2758 /* Nothing to do! */ 2759 module_put(pers->owner); 2760 return rv; 2761 } 2762 if (!pers->takeover) { 2763 module_put(pers->owner); 2764 printk(KERN_WARNING "md: %s: %s does not support personality takeover\n", 2765 mdname(mddev), level); 2766 return -EINVAL; 2767 } 2768 2769 /* ->takeover must set new_* and/or delta_disks 2770 * if it succeeds, and may set them when it fails. 2771 */ 2772 priv = pers->takeover(mddev); 2773 if (IS_ERR(priv)) { 2774 mddev->new_level = mddev->level; 2775 mddev->new_layout = mddev->layout; 2776 mddev->new_chunk_sectors = mddev->chunk_sectors; 2777 mddev->raid_disks -= mddev->delta_disks; 2778 mddev->delta_disks = 0; 2779 module_put(pers->owner); 2780 printk(KERN_WARNING "md: %s: %s would not accept array\n", 2781 mdname(mddev), level); 2782 return PTR_ERR(priv); 2783 } 2784 2785 /* Looks like we have a winner */ 2786 mddev_suspend(mddev); 2787 mddev->pers->stop(mddev); 2788 module_put(mddev->pers->owner); 2789 /* Invalidate devices that are now superfluous */ 2790 list_for_each_entry(rdev, &mddev->disks, same_set) 2791 if (rdev->raid_disk >= mddev->raid_disks) { 2792 rdev->raid_disk = -1; 2793 clear_bit(In_sync, &rdev->flags); 2794 } 2795 mddev->pers = pers; 2796 mddev->private = priv; 2797 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel)); 2798 mddev->level = mddev->new_level; 2799 mddev->layout = mddev->new_layout; 2800 mddev->chunk_sectors = mddev->new_chunk_sectors; 2801 mddev->delta_disks = 0; 2802 pers->run(mddev); 2803 mddev_resume(mddev); 2804 set_bit(MD_CHANGE_DEVS, &mddev->flags); 2805 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 2806 md_wakeup_thread(mddev->thread); 2807 return rv; 2808 } 2809 2810 static struct md_sysfs_entry md_level = 2811 __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store); 2812 2813 2814 static ssize_t 2815 layout_show(mddev_t *mddev, char *page) 2816 { 2817 /* just a number, not meaningful for all levels */ 2818 if (mddev->reshape_position != MaxSector && 2819 mddev->layout != mddev->new_layout) 2820 return sprintf(page, "%d (%d)\n", 2821 mddev->new_layout, mddev->layout); 2822 return sprintf(page, "%d\n", mddev->layout); 2823 } 2824 2825 static ssize_t 2826 layout_store(mddev_t *mddev, const char *buf, size_t len) 2827 { 2828 char *e; 2829 unsigned long n = simple_strtoul(buf, &e, 10); 2830 2831 if (!*buf || (*e && *e != '\n')) 2832 return -EINVAL; 2833 2834 if (mddev->pers) { 2835 int err; 2836 if (mddev->pers->check_reshape == NULL) 2837 return -EBUSY; 2838 mddev->new_layout = n; 2839 err = mddev->pers->check_reshape(mddev); 2840 if (err) { 2841 mddev->new_layout = mddev->layout; 2842 return err; 2843 } 2844 } else { 2845 mddev->new_layout = n; 2846 if (mddev->reshape_position == MaxSector) 2847 mddev->layout = n; 2848 } 2849 return len; 2850 } 2851 static struct md_sysfs_entry md_layout = 2852 __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store); 2853 2854 2855 static ssize_t 2856 raid_disks_show(mddev_t *mddev, char *page) 2857 { 2858 if (mddev->raid_disks == 0) 2859 return 0; 2860 if (mddev->reshape_position != MaxSector && 2861 mddev->delta_disks != 0) 2862 return sprintf(page, "%d (%d)\n", mddev->raid_disks, 2863 mddev->raid_disks - mddev->delta_disks); 2864 return sprintf(page, "%d\n", mddev->raid_disks); 2865 } 2866 2867 static int update_raid_disks(mddev_t *mddev, int raid_disks); 2868 2869 static ssize_t 2870 raid_disks_store(mddev_t *mddev, const char *buf, size_t len) 2871 { 2872 char *e; 2873 int rv = 0; 2874 unsigned long n = simple_strtoul(buf, &e, 10); 2875 2876 if (!*buf || (*e && *e != '\n')) 2877 return -EINVAL; 2878 2879 if (mddev->pers) 2880 rv = update_raid_disks(mddev, n); 2881 else if (mddev->reshape_position != MaxSector) { 2882 int olddisks = mddev->raid_disks - mddev->delta_disks; 2883 mddev->delta_disks = n - olddisks; 2884 mddev->raid_disks = n; 2885 } else 2886 mddev->raid_disks = n; 2887 return rv ? rv : len; 2888 } 2889 static struct md_sysfs_entry md_raid_disks = 2890 __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store); 2891 2892 static ssize_t 2893 chunk_size_show(mddev_t *mddev, char *page) 2894 { 2895 if (mddev->reshape_position != MaxSector && 2896 mddev->chunk_sectors != mddev->new_chunk_sectors) 2897 return sprintf(page, "%d (%d)\n", 2898 mddev->new_chunk_sectors << 9, 2899 mddev->chunk_sectors << 9); 2900 return sprintf(page, "%d\n", mddev->chunk_sectors << 9); 2901 } 2902 2903 static ssize_t 2904 chunk_size_store(mddev_t *mddev, const char *buf, size_t len) 2905 { 2906 char *e; 2907 unsigned long n = simple_strtoul(buf, &e, 10); 2908 2909 if (!*buf || (*e && *e != '\n')) 2910 return -EINVAL; 2911 2912 if (mddev->pers) { 2913 int err; 2914 if (mddev->pers->check_reshape == NULL) 2915 return -EBUSY; 2916 mddev->new_chunk_sectors = n >> 9; 2917 err = mddev->pers->check_reshape(mddev); 2918 if (err) { 2919 mddev->new_chunk_sectors = mddev->chunk_sectors; 2920 return err; 2921 } 2922 } else { 2923 mddev->new_chunk_sectors = n >> 9; 2924 if (mddev->reshape_position == MaxSector) 2925 mddev->chunk_sectors = n >> 9; 2926 } 2927 return len; 2928 } 2929 static struct md_sysfs_entry md_chunk_size = 2930 __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store); 2931 2932 static ssize_t 2933 resync_start_show(mddev_t *mddev, char *page) 2934 { 2935 if (mddev->recovery_cp == MaxSector) 2936 return sprintf(page, "none\n"); 2937 return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp); 2938 } 2939 2940 static ssize_t 2941 resync_start_store(mddev_t *mddev, const char *buf, size_t len) 2942 { 2943 char *e; 2944 unsigned long long n = simple_strtoull(buf, &e, 10); 2945 2946 if (mddev->pers) 2947 return -EBUSY; 2948 if (!*buf || (*e && *e != '\n')) 2949 return -EINVAL; 2950 2951 mddev->recovery_cp = n; 2952 return len; 2953 } 2954 static struct md_sysfs_entry md_resync_start = 2955 __ATTR(resync_start, S_IRUGO|S_IWUSR, resync_start_show, resync_start_store); 2956 2957 /* 2958 * The array state can be: 2959 * 2960 * clear 2961 * No devices, no size, no level 2962 * Equivalent to STOP_ARRAY ioctl 2963 * inactive 2964 * May have some settings, but array is not active 2965 * all IO results in error 2966 * When written, doesn't tear down array, but just stops it 2967 * suspended (not supported yet) 2968 * All IO requests will block. The array can be reconfigured. 2969 * Writing this, if accepted, will block until array is quiescent 2970 * readonly 2971 * no resync can happen. no superblocks get written. 2972 * write requests fail 2973 * read-auto 2974 * like readonly, but behaves like 'clean' on a write request. 2975 * 2976 * clean - no pending writes, but otherwise active. 2977 * When written to inactive array, starts without resync 2978 * If a write request arrives then 2979 * if metadata is known, mark 'dirty' and switch to 'active'. 2980 * if not known, block and switch to write-pending 2981 * If written to an active array that has pending writes, then fails. 2982 * active 2983 * fully active: IO and resync can be happening. 2984 * When written to inactive array, starts with resync 2985 * 2986 * write-pending 2987 * clean, but writes are blocked waiting for 'active' to be written. 2988 * 2989 * active-idle 2990 * like active, but no writes have been seen for a while (100msec). 2991 * 2992 */ 2993 enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active, 2994 write_pending, active_idle, bad_word}; 2995 static char *array_states[] = { 2996 "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active", 2997 "write-pending", "active-idle", NULL }; 2998 2999 static int match_word(const char *word, char **list) 3000 { 3001 int n; 3002 for (n=0; list[n]; n++) 3003 if (cmd_match(word, list[n])) 3004 break; 3005 return n; 3006 } 3007 3008 static ssize_t 3009 array_state_show(mddev_t *mddev, char *page) 3010 { 3011 enum array_state st = inactive; 3012 3013 if (mddev->pers) 3014 switch(mddev->ro) { 3015 case 1: 3016 st = readonly; 3017 break; 3018 case 2: 3019 st = read_auto; 3020 break; 3021 case 0: 3022 if (mddev->in_sync) 3023 st = clean; 3024 else if (test_bit(MD_CHANGE_CLEAN, &mddev->flags)) 3025 st = write_pending; 3026 else if (mddev->safemode) 3027 st = active_idle; 3028 else 3029 st = active; 3030 } 3031 else { 3032 if (list_empty(&mddev->disks) && 3033 mddev->raid_disks == 0 && 3034 mddev->dev_sectors == 0) 3035 st = clear; 3036 else 3037 st = inactive; 3038 } 3039 return sprintf(page, "%s\n", array_states[st]); 3040 } 3041 3042 static int do_md_stop(mddev_t * mddev, int ro, int is_open); 3043 static int do_md_run(mddev_t * mddev); 3044 static int restart_array(mddev_t *mddev); 3045 3046 static ssize_t 3047 array_state_store(mddev_t *mddev, const char *buf, size_t len) 3048 { 3049 int err = -EINVAL; 3050 enum array_state st = match_word(buf, array_states); 3051 switch(st) { 3052 case bad_word: 3053 break; 3054 case clear: 3055 /* stopping an active array */ 3056 if (atomic_read(&mddev->openers) > 0) 3057 return -EBUSY; 3058 err = do_md_stop(mddev, 0, 0); 3059 break; 3060 case inactive: 3061 /* stopping an active array */ 3062 if (mddev->pers) { 3063 if (atomic_read(&mddev->openers) > 0) 3064 return -EBUSY; 3065 err = do_md_stop(mddev, 2, 0); 3066 } else 3067 err = 0; /* already inactive */ 3068 break; 3069 case suspended: 3070 break; /* not supported yet */ 3071 case readonly: 3072 if (mddev->pers) 3073 err = do_md_stop(mddev, 1, 0); 3074 else { 3075 mddev->ro = 1; 3076 set_disk_ro(mddev->gendisk, 1); 3077 err = do_md_run(mddev); 3078 } 3079 break; 3080 case read_auto: 3081 if (mddev->pers) { 3082 if (mddev->ro == 0) 3083 err = do_md_stop(mddev, 1, 0); 3084 else if (mddev->ro == 1) 3085 err = restart_array(mddev); 3086 if (err == 0) { 3087 mddev->ro = 2; 3088 set_disk_ro(mddev->gendisk, 0); 3089 } 3090 } else { 3091 mddev->ro = 2; 3092 err = do_md_run(mddev); 3093 } 3094 break; 3095 case clean: 3096 if (mddev->pers) { 3097 restart_array(mddev); 3098 spin_lock_irq(&mddev->write_lock); 3099 if (atomic_read(&mddev->writes_pending) == 0) { 3100 if (mddev->in_sync == 0) { 3101 mddev->in_sync = 1; 3102 if (mddev->safemode == 1) 3103 mddev->safemode = 0; 3104 if (mddev->persistent) 3105 set_bit(MD_CHANGE_CLEAN, 3106 &mddev->flags); 3107 } 3108 err = 0; 3109 } else 3110 err = -EBUSY; 3111 spin_unlock_irq(&mddev->write_lock); 3112 } else 3113 err = -EINVAL; 3114 break; 3115 case active: 3116 if (mddev->pers) { 3117 restart_array(mddev); 3118 if (mddev->external) 3119 clear_bit(MD_CHANGE_CLEAN, &mddev->flags); 3120 wake_up(&mddev->sb_wait); 3121 err = 0; 3122 } else { 3123 mddev->ro = 0; 3124 set_disk_ro(mddev->gendisk, 0); 3125 err = do_md_run(mddev); 3126 } 3127 break; 3128 case write_pending: 3129 case active_idle: 3130 /* these cannot be set */ 3131 break; 3132 } 3133 if (err) 3134 return err; 3135 else { 3136 sysfs_notify_dirent(mddev->sysfs_state); 3137 return len; 3138 } 3139 } 3140 static struct md_sysfs_entry md_array_state = 3141 __ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store); 3142 3143 static ssize_t 3144 null_show(mddev_t *mddev, char *page) 3145 { 3146 return -EINVAL; 3147 } 3148 3149 static ssize_t 3150 new_dev_store(mddev_t *mddev, const char *buf, size_t len) 3151 { 3152 /* buf must be %d:%d\n? giving major and minor numbers */ 3153 /* The new device is added to the array. 3154 * If the array has a persistent superblock, we read the 3155 * superblock to initialise info and check validity. 3156 * Otherwise, only checking done is that in bind_rdev_to_array, 3157 * which mainly checks size. 3158 */ 3159 char *e; 3160 int major = simple_strtoul(buf, &e, 10); 3161 int minor; 3162 dev_t dev; 3163 mdk_rdev_t *rdev; 3164 int err; 3165 3166 if (!*buf || *e != ':' || !e[1] || e[1] == '\n') 3167 return -EINVAL; 3168 minor = simple_strtoul(e+1, &e, 10); 3169 if (*e && *e != '\n') 3170 return -EINVAL; 3171 dev = MKDEV(major, minor); 3172 if (major != MAJOR(dev) || 3173 minor != MINOR(dev)) 3174 return -EOVERFLOW; 3175 3176 3177 if (mddev->persistent) { 3178 rdev = md_import_device(dev, mddev->major_version, 3179 mddev->minor_version); 3180 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) { 3181 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next, 3182 mdk_rdev_t, same_set); 3183 err = super_types[mddev->major_version] 3184 .load_super(rdev, rdev0, mddev->minor_version); 3185 if (err < 0) 3186 goto out; 3187 } 3188 } else if (mddev->external) 3189 rdev = md_import_device(dev, -2, -1); 3190 else 3191 rdev = md_import_device(dev, -1, -1); 3192 3193 if (IS_ERR(rdev)) 3194 return PTR_ERR(rdev); 3195 err = bind_rdev_to_array(rdev, mddev); 3196 out: 3197 if (err) 3198 export_rdev(rdev); 3199 return err ? err : len; 3200 } 3201 3202 static struct md_sysfs_entry md_new_device = 3203 __ATTR(new_dev, S_IWUSR, null_show, new_dev_store); 3204 3205 static ssize_t 3206 bitmap_store(mddev_t *mddev, const char *buf, size_t len) 3207 { 3208 char *end; 3209 unsigned long chunk, end_chunk; 3210 3211 if (!mddev->bitmap) 3212 goto out; 3213 /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */ 3214 while (*buf) { 3215 chunk = end_chunk = simple_strtoul(buf, &end, 0); 3216 if (buf == end) break; 3217 if (*end == '-') { /* range */ 3218 buf = end + 1; 3219 end_chunk = simple_strtoul(buf, &end, 0); 3220 if (buf == end) break; 3221 } 3222 if (*end && !isspace(*end)) break; 3223 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk); 3224 buf = end; 3225 while (isspace(*buf)) buf++; 3226 } 3227 bitmap_unplug(mddev->bitmap); /* flush the bits to disk */ 3228 out: 3229 return len; 3230 } 3231 3232 static struct md_sysfs_entry md_bitmap = 3233 __ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store); 3234 3235 static ssize_t 3236 size_show(mddev_t *mddev, char *page) 3237 { 3238 return sprintf(page, "%llu\n", 3239 (unsigned long long)mddev->dev_sectors / 2); 3240 } 3241 3242 static int update_size(mddev_t *mddev, sector_t num_sectors); 3243 3244 static ssize_t 3245 size_store(mddev_t *mddev, const char *buf, size_t len) 3246 { 3247 /* If array is inactive, we can reduce the component size, but 3248 * not increase it (except from 0). 3249 * If array is active, we can try an on-line resize 3250 */ 3251 sector_t sectors; 3252 int err = strict_blocks_to_sectors(buf, §ors); 3253 3254 if (err < 0) 3255 return err; 3256 if (mddev->pers) { 3257 err = update_size(mddev, sectors); 3258 md_update_sb(mddev, 1); 3259 } else { 3260 if (mddev->dev_sectors == 0 || 3261 mddev->dev_sectors > sectors) 3262 mddev->dev_sectors = sectors; 3263 else 3264 err = -ENOSPC; 3265 } 3266 return err ? err : len; 3267 } 3268 3269 static struct md_sysfs_entry md_size = 3270 __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store); 3271 3272 3273 /* Metdata version. 3274 * This is one of 3275 * 'none' for arrays with no metadata (good luck...) 3276 * 'external' for arrays with externally managed metadata, 3277 * or N.M for internally known formats 3278 */ 3279 static ssize_t 3280 metadata_show(mddev_t *mddev, char *page) 3281 { 3282 if (mddev->persistent) 3283 return sprintf(page, "%d.%d\n", 3284 mddev->major_version, mddev->minor_version); 3285 else if (mddev->external) 3286 return sprintf(page, "external:%s\n", mddev->metadata_type); 3287 else 3288 return sprintf(page, "none\n"); 3289 } 3290 3291 static ssize_t 3292 metadata_store(mddev_t *mddev, const char *buf, size_t len) 3293 { 3294 int major, minor; 3295 char *e; 3296 /* Changing the details of 'external' metadata is 3297 * always permitted. Otherwise there must be 3298 * no devices attached to the array. 3299 */ 3300 if (mddev->external && strncmp(buf, "external:", 9) == 0) 3301 ; 3302 else if (!list_empty(&mddev->disks)) 3303 return -EBUSY; 3304 3305 if (cmd_match(buf, "none")) { 3306 mddev->persistent = 0; 3307 mddev->external = 0; 3308 mddev->major_version = 0; 3309 mddev->minor_version = 90; 3310 return len; 3311 } 3312 if (strncmp(buf, "external:", 9) == 0) { 3313 size_t namelen = len-9; 3314 if (namelen >= sizeof(mddev->metadata_type)) 3315 namelen = sizeof(mddev->metadata_type)-1; 3316 strncpy(mddev->metadata_type, buf+9, namelen); 3317 mddev->metadata_type[namelen] = 0; 3318 if (namelen && mddev->metadata_type[namelen-1] == '\n') 3319 mddev->metadata_type[--namelen] = 0; 3320 mddev->persistent = 0; 3321 mddev->external = 1; 3322 mddev->major_version = 0; 3323 mddev->minor_version = 90; 3324 return len; 3325 } 3326 major = simple_strtoul(buf, &e, 10); 3327 if (e==buf || *e != '.') 3328 return -EINVAL; 3329 buf = e+1; 3330 minor = simple_strtoul(buf, &e, 10); 3331 if (e==buf || (*e && *e != '\n') ) 3332 return -EINVAL; 3333 if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL) 3334 return -ENOENT; 3335 mddev->major_version = major; 3336 mddev->minor_version = minor; 3337 mddev->persistent = 1; 3338 mddev->external = 0; 3339 return len; 3340 } 3341 3342 static struct md_sysfs_entry md_metadata = 3343 __ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store); 3344 3345 static ssize_t 3346 action_show(mddev_t *mddev, char *page) 3347 { 3348 char *type = "idle"; 3349 if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) 3350 type = "frozen"; 3351 else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) || 3352 (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) { 3353 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) 3354 type = "reshape"; 3355 else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) { 3356 if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) 3357 type = "resync"; 3358 else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) 3359 type = "check"; 3360 else 3361 type = "repair"; 3362 } else if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery)) 3363 type = "recover"; 3364 } 3365 return sprintf(page, "%s\n", type); 3366 } 3367 3368 static ssize_t 3369 action_store(mddev_t *mddev, const char *page, size_t len) 3370 { 3371 if (!mddev->pers || !mddev->pers->sync_request) 3372 return -EINVAL; 3373 3374 if (cmd_match(page, "frozen")) 3375 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 3376 else 3377 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 3378 3379 if (cmd_match(page, "idle") || cmd_match(page, "frozen")) { 3380 if (mddev->sync_thread) { 3381 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 3382 md_unregister_thread(mddev->sync_thread); 3383 mddev->sync_thread = NULL; 3384 mddev->recovery = 0; 3385 } 3386 } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) || 3387 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) 3388 return -EBUSY; 3389 else if (cmd_match(page, "resync")) 3390 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 3391 else if (cmd_match(page, "recover")) { 3392 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 3393 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 3394 } else if (cmd_match(page, "reshape")) { 3395 int err; 3396 if (mddev->pers->start_reshape == NULL) 3397 return -EINVAL; 3398 err = mddev->pers->start_reshape(mddev); 3399 if (err) 3400 return err; 3401 sysfs_notify(&mddev->kobj, NULL, "degraded"); 3402 } else { 3403 if (cmd_match(page, "check")) 3404 set_bit(MD_RECOVERY_CHECK, &mddev->recovery); 3405 else if (!cmd_match(page, "repair")) 3406 return -EINVAL; 3407 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); 3408 set_bit(MD_RECOVERY_SYNC, &mddev->recovery); 3409 } 3410 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 3411 md_wakeup_thread(mddev->thread); 3412 sysfs_notify_dirent(mddev->sysfs_action); 3413 return len; 3414 } 3415 3416 static ssize_t 3417 mismatch_cnt_show(mddev_t *mddev, char *page) 3418 { 3419 return sprintf(page, "%llu\n", 3420 (unsigned long long) mddev->resync_mismatches); 3421 } 3422 3423 static struct md_sysfs_entry md_scan_mode = 3424 __ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store); 3425 3426 3427 static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt); 3428 3429 static ssize_t 3430 sync_min_show(mddev_t *mddev, char *page) 3431 { 3432 return sprintf(page, "%d (%s)\n", speed_min(mddev), 3433 mddev->sync_speed_min ? "local": "system"); 3434 } 3435 3436 static ssize_t 3437 sync_min_store(mddev_t *mddev, const char *buf, size_t len) 3438 { 3439 int min; 3440 char *e; 3441 if (strncmp(buf, "system", 6)==0) { 3442 mddev->sync_speed_min = 0; 3443 return len; 3444 } 3445 min = simple_strtoul(buf, &e, 10); 3446 if (buf == e || (*e && *e != '\n') || min <= 0) 3447 return -EINVAL; 3448 mddev->sync_speed_min = min; 3449 return len; 3450 } 3451 3452 static struct md_sysfs_entry md_sync_min = 3453 __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store); 3454 3455 static ssize_t 3456 sync_max_show(mddev_t *mddev, char *page) 3457 { 3458 return sprintf(page, "%d (%s)\n", speed_max(mddev), 3459 mddev->sync_speed_max ? "local": "system"); 3460 } 3461 3462 static ssize_t 3463 sync_max_store(mddev_t *mddev, const char *buf, size_t len) 3464 { 3465 int max; 3466 char *e; 3467 if (strncmp(buf, "system", 6)==0) { 3468 mddev->sync_speed_max = 0; 3469 return len; 3470 } 3471 max = simple_strtoul(buf, &e, 10); 3472 if (buf == e || (*e && *e != '\n') || max <= 0) 3473 return -EINVAL; 3474 mddev->sync_speed_max = max; 3475 return len; 3476 } 3477 3478 static struct md_sysfs_entry md_sync_max = 3479 __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store); 3480 3481 static ssize_t 3482 degraded_show(mddev_t *mddev, char *page) 3483 { 3484 return sprintf(page, "%d\n", mddev->degraded); 3485 } 3486 static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded); 3487 3488 static ssize_t 3489 sync_force_parallel_show(mddev_t *mddev, char *page) 3490 { 3491 return sprintf(page, "%d\n", mddev->parallel_resync); 3492 } 3493 3494 static ssize_t 3495 sync_force_parallel_store(mddev_t *mddev, const char *buf, size_t len) 3496 { 3497 long n; 3498 3499 if (strict_strtol(buf, 10, &n)) 3500 return -EINVAL; 3501 3502 if (n != 0 && n != 1) 3503 return -EINVAL; 3504 3505 mddev->parallel_resync = n; 3506 3507 if (mddev->sync_thread) 3508 wake_up(&resync_wait); 3509 3510 return len; 3511 } 3512 3513 /* force parallel resync, even with shared block devices */ 3514 static struct md_sysfs_entry md_sync_force_parallel = 3515 __ATTR(sync_force_parallel, S_IRUGO|S_IWUSR, 3516 sync_force_parallel_show, sync_force_parallel_store); 3517 3518 static ssize_t 3519 sync_speed_show(mddev_t *mddev, char *page) 3520 { 3521 unsigned long resync, dt, db; 3522 if (mddev->curr_resync == 0) 3523 return sprintf(page, "none\n"); 3524 resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active); 3525 dt = (jiffies - mddev->resync_mark) / HZ; 3526 if (!dt) dt++; 3527 db = resync - mddev->resync_mark_cnt; 3528 return sprintf(page, "%lu\n", db/dt/2); /* K/sec */ 3529 } 3530 3531 static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed); 3532 3533 static ssize_t 3534 sync_completed_show(mddev_t *mddev, char *page) 3535 { 3536 unsigned long max_sectors, resync; 3537 3538 if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 3539 return sprintf(page, "none\n"); 3540 3541 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) 3542 max_sectors = mddev->resync_max_sectors; 3543 else 3544 max_sectors = mddev->dev_sectors; 3545 3546 resync = mddev->curr_resync_completed; 3547 return sprintf(page, "%lu / %lu\n", resync, max_sectors); 3548 } 3549 3550 static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed); 3551 3552 static ssize_t 3553 min_sync_show(mddev_t *mddev, char *page) 3554 { 3555 return sprintf(page, "%llu\n", 3556 (unsigned long long)mddev->resync_min); 3557 } 3558 static ssize_t 3559 min_sync_store(mddev_t *mddev, const char *buf, size_t len) 3560 { 3561 unsigned long long min; 3562 if (strict_strtoull(buf, 10, &min)) 3563 return -EINVAL; 3564 if (min > mddev->resync_max) 3565 return -EINVAL; 3566 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 3567 return -EBUSY; 3568 3569 /* Must be a multiple of chunk_size */ 3570 if (mddev->chunk_sectors) { 3571 sector_t temp = min; 3572 if (sector_div(temp, mddev->chunk_sectors)) 3573 return -EINVAL; 3574 } 3575 mddev->resync_min = min; 3576 3577 return len; 3578 } 3579 3580 static struct md_sysfs_entry md_min_sync = 3581 __ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store); 3582 3583 static ssize_t 3584 max_sync_show(mddev_t *mddev, char *page) 3585 { 3586 if (mddev->resync_max == MaxSector) 3587 return sprintf(page, "max\n"); 3588 else 3589 return sprintf(page, "%llu\n", 3590 (unsigned long long)mddev->resync_max); 3591 } 3592 static ssize_t 3593 max_sync_store(mddev_t *mddev, const char *buf, size_t len) 3594 { 3595 if (strncmp(buf, "max", 3) == 0) 3596 mddev->resync_max = MaxSector; 3597 else { 3598 unsigned long long max; 3599 if (strict_strtoull(buf, 10, &max)) 3600 return -EINVAL; 3601 if (max < mddev->resync_min) 3602 return -EINVAL; 3603 if (max < mddev->resync_max && 3604 test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) 3605 return -EBUSY; 3606 3607 /* Must be a multiple of chunk_size */ 3608 if (mddev->chunk_sectors) { 3609 sector_t temp = max; 3610 if (sector_div(temp, mddev->chunk_sectors)) 3611 return -EINVAL; 3612 } 3613 mddev->resync_max = max; 3614 } 3615 wake_up(&mddev->recovery_wait); 3616 return len; 3617 } 3618 3619 static struct md_sysfs_entry md_max_sync = 3620 __ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store); 3621 3622 static ssize_t 3623 suspend_lo_show(mddev_t *mddev, char *page) 3624 { 3625 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo); 3626 } 3627 3628 static ssize_t 3629 suspend_lo_store(mddev_t *mddev, const char *buf, size_t len) 3630 { 3631 char *e; 3632 unsigned long long new = simple_strtoull(buf, &e, 10); 3633 3634 if (mddev->pers == NULL || 3635 mddev->pers->quiesce == NULL) 3636 return -EINVAL; 3637 if (buf == e || (*e && *e != '\n')) 3638 return -EINVAL; 3639 if (new >= mddev->suspend_hi || 3640 (new > mddev->suspend_lo && new < mddev->suspend_hi)) { 3641 mddev->suspend_lo = new; 3642 mddev->pers->quiesce(mddev, 2); 3643 return len; 3644 } else 3645 return -EINVAL; 3646 } 3647 static struct md_sysfs_entry md_suspend_lo = 3648 __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store); 3649 3650 3651 static ssize_t 3652 suspend_hi_show(mddev_t *mddev, char *page) 3653 { 3654 return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi); 3655 } 3656 3657 static ssize_t 3658 suspend_hi_store(mddev_t *mddev, const char *buf, size_t len) 3659 { 3660 char *e; 3661 unsigned long long new = simple_strtoull(buf, &e, 10); 3662 3663 if (mddev->pers == NULL || 3664 mddev->pers->quiesce == NULL) 3665 return -EINVAL; 3666 if (buf == e || (*e && *e != '\n')) 3667 return -EINVAL; 3668 if ((new <= mddev->suspend_lo && mddev->suspend_lo >= mddev->suspend_hi) || 3669 (new > mddev->suspend_lo && new > mddev->suspend_hi)) { 3670 mddev->suspend_hi = new; 3671 mddev->pers->quiesce(mddev, 1); 3672 mddev->pers->quiesce(mddev, 0); 3673 return len; 3674 } else 3675 return -EINVAL; 3676 } 3677 static struct md_sysfs_entry md_suspend_hi = 3678 __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store); 3679 3680 static ssize_t 3681 reshape_position_show(mddev_t *mddev, char *page) 3682 { 3683 if (mddev->reshape_position != MaxSector) 3684 return sprintf(page, "%llu\n", 3685 (unsigned long long)mddev->reshape_position); 3686 strcpy(page, "none\n"); 3687 return 5; 3688 } 3689 3690 static ssize_t 3691 reshape_position_store(mddev_t *mddev, const char *buf, size_t len) 3692 { 3693 char *e; 3694 unsigned long long new = simple_strtoull(buf, &e, 10); 3695 if (mddev->pers) 3696 return -EBUSY; 3697 if (buf == e || (*e && *e != '\n')) 3698 return -EINVAL; 3699 mddev->reshape_position = new; 3700 mddev->delta_disks = 0; 3701 mddev->new_level = mddev->level; 3702 mddev->new_layout = mddev->layout; 3703 mddev->new_chunk_sectors = mddev->chunk_sectors; 3704 return len; 3705 } 3706 3707 static struct md_sysfs_entry md_reshape_position = 3708 __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show, 3709 reshape_position_store); 3710 3711 static ssize_t 3712 array_size_show(mddev_t *mddev, char *page) 3713 { 3714 if (mddev->external_size) 3715 return sprintf(page, "%llu\n", 3716 (unsigned long long)mddev->array_sectors/2); 3717 else 3718 return sprintf(page, "default\n"); 3719 } 3720 3721 static ssize_t 3722 array_size_store(mddev_t *mddev, const char *buf, size_t len) 3723 { 3724 sector_t sectors; 3725 3726 if (strncmp(buf, "default", 7) == 0) { 3727 if (mddev->pers) 3728 sectors = mddev->pers->size(mddev, 0, 0); 3729 else 3730 sectors = mddev->array_sectors; 3731 3732 mddev->external_size = 0; 3733 } else { 3734 if (strict_blocks_to_sectors(buf, §ors) < 0) 3735 return -EINVAL; 3736 if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors) 3737 return -E2BIG; 3738 3739 mddev->external_size = 1; 3740 } 3741 3742 mddev->array_sectors = sectors; 3743 set_capacity(mddev->gendisk, mddev->array_sectors); 3744 if (mddev->pers) 3745 revalidate_disk(mddev->gendisk); 3746 3747 return len; 3748 } 3749 3750 static struct md_sysfs_entry md_array_size = 3751 __ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show, 3752 array_size_store); 3753 3754 static struct attribute *md_default_attrs[] = { 3755 &md_level.attr, 3756 &md_layout.attr, 3757 &md_raid_disks.attr, 3758 &md_chunk_size.attr, 3759 &md_size.attr, 3760 &md_resync_start.attr, 3761 &md_metadata.attr, 3762 &md_new_device.attr, 3763 &md_safe_delay.attr, 3764 &md_array_state.attr, 3765 &md_reshape_position.attr, 3766 &md_array_size.attr, 3767 NULL, 3768 }; 3769 3770 static struct attribute *md_redundancy_attrs[] = { 3771 &md_scan_mode.attr, 3772 &md_mismatches.attr, 3773 &md_sync_min.attr, 3774 &md_sync_max.attr, 3775 &md_sync_speed.attr, 3776 &md_sync_force_parallel.attr, 3777 &md_sync_completed.attr, 3778 &md_min_sync.attr, 3779 &md_max_sync.attr, 3780 &md_suspend_lo.attr, 3781 &md_suspend_hi.attr, 3782 &md_bitmap.attr, 3783 &md_degraded.attr, 3784 NULL, 3785 }; 3786 static struct attribute_group md_redundancy_group = { 3787 .name = NULL, 3788 .attrs = md_redundancy_attrs, 3789 }; 3790 3791 3792 static ssize_t 3793 md_attr_show(struct kobject *kobj, struct attribute *attr, char *page) 3794 { 3795 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr); 3796 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj); 3797 ssize_t rv; 3798 3799 if (!entry->show) 3800 return -EIO; 3801 rv = mddev_lock(mddev); 3802 if (!rv) { 3803 rv = entry->show(mddev, page); 3804 mddev_unlock(mddev); 3805 } 3806 return rv; 3807 } 3808 3809 static ssize_t 3810 md_attr_store(struct kobject *kobj, struct attribute *attr, 3811 const char *page, size_t length) 3812 { 3813 struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr); 3814 mddev_t *mddev = container_of(kobj, struct mddev_s, kobj); 3815 ssize_t rv; 3816 3817 if (!entry->store) 3818 return -EIO; 3819 if (!capable(CAP_SYS_ADMIN)) 3820 return -EACCES; 3821 rv = mddev_lock(mddev); 3822 if (mddev->hold_active == UNTIL_IOCTL) 3823 mddev->hold_active = 0; 3824 if (!rv) { 3825 rv = entry->store(mddev, page, length); 3826 mddev_unlock(mddev); 3827 } 3828 return rv; 3829 } 3830 3831 static void md_free(struct kobject *ko) 3832 { 3833 mddev_t *mddev = container_of(ko, mddev_t, kobj); 3834 3835 if (mddev->sysfs_state) 3836 sysfs_put(mddev->sysfs_state); 3837 3838 if (mddev->gendisk) { 3839 del_gendisk(mddev->gendisk); 3840 put_disk(mddev->gendisk); 3841 } 3842 if (mddev->queue) 3843 blk_cleanup_queue(mddev->queue); 3844 3845 kfree(mddev); 3846 } 3847 3848 static struct sysfs_ops md_sysfs_ops = { 3849 .show = md_attr_show, 3850 .store = md_attr_store, 3851 }; 3852 static struct kobj_type md_ktype = { 3853 .release = md_free, 3854 .sysfs_ops = &md_sysfs_ops, 3855 .default_attrs = md_default_attrs, 3856 }; 3857 3858 int mdp_major = 0; 3859 3860 static void mddev_delayed_delete(struct work_struct *ws) 3861 { 3862 mddev_t *mddev = container_of(ws, mddev_t, del_work); 3863 3864 if (mddev->private == &md_redundancy_group) { 3865 sysfs_remove_group(&mddev->kobj, &md_redundancy_group); 3866 if (mddev->sysfs_action) 3867 sysfs_put(mddev->sysfs_action); 3868 mddev->sysfs_action = NULL; 3869 mddev->private = NULL; 3870 } 3871 kobject_del(&mddev->kobj); 3872 kobject_put(&mddev->kobj); 3873 } 3874 3875 static int md_alloc(dev_t dev, char *name) 3876 { 3877 static DEFINE_MUTEX(disks_mutex); 3878 mddev_t *mddev = mddev_find(dev); 3879 struct gendisk *disk; 3880 int partitioned; 3881 int shift; 3882 int unit; 3883 int error; 3884 3885 if (!mddev) 3886 return -ENODEV; 3887 3888 partitioned = (MAJOR(mddev->unit) != MD_MAJOR); 3889 shift = partitioned ? MdpMinorShift : 0; 3890 unit = MINOR(mddev->unit) >> shift; 3891 3892 /* wait for any previous instance if this device 3893 * to be completed removed (mddev_delayed_delete). 3894 */ 3895 flush_scheduled_work(); 3896 3897 mutex_lock(&disks_mutex); 3898 error = -EEXIST; 3899 if (mddev->gendisk) 3900 goto abort; 3901 3902 if (name) { 3903 /* Need to ensure that 'name' is not a duplicate. 3904 */ 3905 mddev_t *mddev2; 3906 spin_lock(&all_mddevs_lock); 3907 3908 list_for_each_entry(mddev2, &all_mddevs, all_mddevs) 3909 if (mddev2->gendisk && 3910 strcmp(mddev2->gendisk->disk_name, name) == 0) { 3911 spin_unlock(&all_mddevs_lock); 3912 goto abort; 3913 } 3914 spin_unlock(&all_mddevs_lock); 3915 } 3916 3917 error = -ENOMEM; 3918 mddev->queue = blk_alloc_queue(GFP_KERNEL); 3919 if (!mddev->queue) 3920 goto abort; 3921 mddev->queue->queuedata = mddev; 3922 3923 /* Can be unlocked because the queue is new: no concurrency */ 3924 queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, mddev->queue); 3925 3926 blk_queue_make_request(mddev->queue, md_make_request); 3927 3928 disk = alloc_disk(1 << shift); 3929 if (!disk) { 3930 blk_cleanup_queue(mddev->queue); 3931 mddev->queue = NULL; 3932 goto abort; 3933 } 3934 disk->major = MAJOR(mddev->unit); 3935 disk->first_minor = unit << shift; 3936 if (name) 3937 strcpy(disk->disk_name, name); 3938 else if (partitioned) 3939 sprintf(disk->disk_name, "md_d%d", unit); 3940 else 3941 sprintf(disk->disk_name, "md%d", unit); 3942 disk->fops = &md_fops; 3943 disk->private_data = mddev; 3944 disk->queue = mddev->queue; 3945 /* Allow extended partitions. This makes the 3946 * 'mdp' device redundant, but we can't really 3947 * remove it now. 3948 */ 3949 disk->flags |= GENHD_FL_EXT_DEVT; 3950 add_disk(disk); 3951 mddev->gendisk = disk; 3952 error = kobject_init_and_add(&mddev->kobj, &md_ktype, 3953 &disk_to_dev(disk)->kobj, "%s", "md"); 3954 if (error) { 3955 /* This isn't possible, but as kobject_init_and_add is marked 3956 * __must_check, we must do something with the result 3957 */ 3958 printk(KERN_WARNING "md: cannot register %s/md - name in use\n", 3959 disk->disk_name); 3960 error = 0; 3961 } 3962 abort: 3963 mutex_unlock(&disks_mutex); 3964 if (!error) { 3965 kobject_uevent(&mddev->kobj, KOBJ_ADD); 3966 mddev->sysfs_state = sysfs_get_dirent(mddev->kobj.sd, "array_state"); 3967 } 3968 mddev_put(mddev); 3969 return error; 3970 } 3971 3972 static struct kobject *md_probe(dev_t dev, int *part, void *data) 3973 { 3974 md_alloc(dev, NULL); 3975 return NULL; 3976 } 3977 3978 static int add_named_array(const char *val, struct kernel_param *kp) 3979 { 3980 /* val must be "md_*" where * is not all digits. 3981 * We allocate an array with a large free minor number, and 3982 * set the name to val. val must not already be an active name. 3983 */ 3984 int len = strlen(val); 3985 char buf[DISK_NAME_LEN]; 3986 3987 while (len && val[len-1] == '\n') 3988 len--; 3989 if (len >= DISK_NAME_LEN) 3990 return -E2BIG; 3991 strlcpy(buf, val, len+1); 3992 if (strncmp(buf, "md_", 3) != 0) 3993 return -EINVAL; 3994 return md_alloc(0, buf); 3995 } 3996 3997 static void md_safemode_timeout(unsigned long data) 3998 { 3999 mddev_t *mddev = (mddev_t *) data; 4000 4001 if (!atomic_read(&mddev->writes_pending)) { 4002 mddev->safemode = 1; 4003 if (mddev->external) 4004 sysfs_notify_dirent(mddev->sysfs_state); 4005 } 4006 md_wakeup_thread(mddev->thread); 4007 } 4008 4009 static int start_dirty_degraded; 4010 4011 static int do_md_run(mddev_t * mddev) 4012 { 4013 int err; 4014 mdk_rdev_t *rdev; 4015 struct gendisk *disk; 4016 struct mdk_personality *pers; 4017 4018 if (list_empty(&mddev->disks)) 4019 /* cannot run an array with no devices.. */ 4020 return -EINVAL; 4021 4022 if (mddev->pers) 4023 return -EBUSY; 4024 4025 /* 4026 * Analyze all RAID superblock(s) 4027 */ 4028 if (!mddev->raid_disks) { 4029 if (!mddev->persistent) 4030 return -EINVAL; 4031 analyze_sbs(mddev); 4032 } 4033 4034 if (mddev->level != LEVEL_NONE) 4035 request_module("md-level-%d", mddev->level); 4036 else if (mddev->clevel[0]) 4037 request_module("md-%s", mddev->clevel); 4038 4039 /* 4040 * Drop all container device buffers, from now on 4041 * the only valid external interface is through the md 4042 * device. 4043 */ 4044 list_for_each_entry(rdev, &mddev->disks, same_set) { 4045 if (test_bit(Faulty, &rdev->flags)) 4046 continue; 4047 sync_blockdev(rdev->bdev); 4048 invalidate_bdev(rdev->bdev); 4049 4050 /* perform some consistency tests on the device. 4051 * We don't want the data to overlap the metadata, 4052 * Internal Bitmap issues have been handled elsewhere. 4053 */ 4054 if (rdev->data_offset < rdev->sb_start) { 4055 if (mddev->dev_sectors && 4056 rdev->data_offset + mddev->dev_sectors 4057 > rdev->sb_start) { 4058 printk("md: %s: data overlaps metadata\n", 4059 mdname(mddev)); 4060 return -EINVAL; 4061 } 4062 } else { 4063 if (rdev->sb_start + rdev->sb_size/512 4064 > rdev->data_offset) { 4065 printk("md: %s: metadata overlaps data\n", 4066 mdname(mddev)); 4067 return -EINVAL; 4068 } 4069 } 4070 sysfs_notify_dirent(rdev->sysfs_state); 4071 } 4072 4073 md_probe(mddev->unit, NULL, NULL); 4074 disk = mddev->gendisk; 4075 if (!disk) 4076 return -ENOMEM; 4077 4078 spin_lock(&pers_lock); 4079 pers = find_pers(mddev->level, mddev->clevel); 4080 if (!pers || !try_module_get(pers->owner)) { 4081 spin_unlock(&pers_lock); 4082 if (mddev->level != LEVEL_NONE) 4083 printk(KERN_WARNING "md: personality for level %d is not loaded!\n", 4084 mddev->level); 4085 else 4086 printk(KERN_WARNING "md: personality for level %s is not loaded!\n", 4087 mddev->clevel); 4088 return -EINVAL; 4089 } 4090 mddev->pers = pers; 4091 spin_unlock(&pers_lock); 4092 if (mddev->level != pers->level) { 4093 mddev->level = pers->level; 4094 mddev->new_level = pers->level; 4095 } 4096 strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel)); 4097 4098 if (mddev->reshape_position != MaxSector && 4099 pers->start_reshape == NULL) { 4100 /* This personality cannot handle reshaping... */ 4101 mddev->pers = NULL; 4102 module_put(pers->owner); 4103 return -EINVAL; 4104 } 4105 4106 if (pers->sync_request) { 4107 /* Warn if this is a potentially silly 4108 * configuration. 4109 */ 4110 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 4111 mdk_rdev_t *rdev2; 4112 int warned = 0; 4113 4114 list_for_each_entry(rdev, &mddev->disks, same_set) 4115 list_for_each_entry(rdev2, &mddev->disks, same_set) { 4116 if (rdev < rdev2 && 4117 rdev->bdev->bd_contains == 4118 rdev2->bdev->bd_contains) { 4119 printk(KERN_WARNING 4120 "%s: WARNING: %s appears to be" 4121 " on the same physical disk as" 4122 " %s.\n", 4123 mdname(mddev), 4124 bdevname(rdev->bdev,b), 4125 bdevname(rdev2->bdev,b2)); 4126 warned = 1; 4127 } 4128 } 4129 4130 if (warned) 4131 printk(KERN_WARNING 4132 "True protection against single-disk" 4133 " failure might be compromised.\n"); 4134 } 4135 4136 mddev->recovery = 0; 4137 /* may be over-ridden by personality */ 4138 mddev->resync_max_sectors = mddev->dev_sectors; 4139 4140 mddev->barriers_work = 1; 4141 mddev->ok_start_degraded = start_dirty_degraded; 4142 4143 if (start_readonly) 4144 mddev->ro = 2; /* read-only, but switch on first write */ 4145 4146 err = mddev->pers->run(mddev); 4147 if (err) 4148 printk(KERN_ERR "md: pers->run() failed ...\n"); 4149 else if (mddev->pers->size(mddev, 0, 0) < mddev->array_sectors) { 4150 WARN_ONCE(!mddev->external_size, "%s: default size too small," 4151 " but 'external_size' not in effect?\n", __func__); 4152 printk(KERN_ERR 4153 "md: invalid array_size %llu > default size %llu\n", 4154 (unsigned long long)mddev->array_sectors / 2, 4155 (unsigned long long)mddev->pers->size(mddev, 0, 0) / 2); 4156 err = -EINVAL; 4157 mddev->pers->stop(mddev); 4158 } 4159 if (err == 0 && mddev->pers->sync_request) { 4160 err = bitmap_create(mddev); 4161 if (err) { 4162 printk(KERN_ERR "%s: failed to create bitmap (%d)\n", 4163 mdname(mddev), err); 4164 mddev->pers->stop(mddev); 4165 } 4166 } 4167 if (err) { 4168 module_put(mddev->pers->owner); 4169 mddev->pers = NULL; 4170 bitmap_destroy(mddev); 4171 return err; 4172 } 4173 if (mddev->pers->sync_request) { 4174 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group)) 4175 printk(KERN_WARNING 4176 "md: cannot register extra attributes for %s\n", 4177 mdname(mddev)); 4178 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action"); 4179 } else if (mddev->ro == 2) /* auto-readonly not meaningful */ 4180 mddev->ro = 0; 4181 4182 atomic_set(&mddev->writes_pending,0); 4183 mddev->safemode = 0; 4184 mddev->safemode_timer.function = md_safemode_timeout; 4185 mddev->safemode_timer.data = (unsigned long) mddev; 4186 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */ 4187 mddev->in_sync = 1; 4188 4189 list_for_each_entry(rdev, &mddev->disks, same_set) 4190 if (rdev->raid_disk >= 0) { 4191 char nm[20]; 4192 sprintf(nm, "rd%d", rdev->raid_disk); 4193 if (sysfs_create_link(&mddev->kobj, &rdev->kobj, nm)) 4194 printk("md: cannot register %s for %s\n", 4195 nm, mdname(mddev)); 4196 } 4197 4198 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 4199 4200 if (mddev->flags) 4201 md_update_sb(mddev, 0); 4202 4203 set_capacity(disk, mddev->array_sectors); 4204 4205 /* If there is a partially-recovered drive we need to 4206 * start recovery here. If we leave it to md_check_recovery, 4207 * it will remove the drives and not do the right thing 4208 */ 4209 if (mddev->degraded && !mddev->sync_thread) { 4210 int spares = 0; 4211 list_for_each_entry(rdev, &mddev->disks, same_set) 4212 if (rdev->raid_disk >= 0 && 4213 !test_bit(In_sync, &rdev->flags) && 4214 !test_bit(Faulty, &rdev->flags)) 4215 /* complete an interrupted recovery */ 4216 spares++; 4217 if (spares && mddev->pers->sync_request) { 4218 mddev->recovery = 0; 4219 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery); 4220 mddev->sync_thread = md_register_thread(md_do_sync, 4221 mddev, 4222 "%s_resync"); 4223 if (!mddev->sync_thread) { 4224 printk(KERN_ERR "%s: could not start resync" 4225 " thread...\n", 4226 mdname(mddev)); 4227 /* leave the spares where they are, it shouldn't hurt */ 4228 mddev->recovery = 0; 4229 } 4230 } 4231 } 4232 md_wakeup_thread(mddev->thread); 4233 md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */ 4234 4235 revalidate_disk(mddev->gendisk); 4236 mddev->changed = 1; 4237 md_new_event(mddev); 4238 sysfs_notify_dirent(mddev->sysfs_state); 4239 if (mddev->sysfs_action) 4240 sysfs_notify_dirent(mddev->sysfs_action); 4241 sysfs_notify(&mddev->kobj, NULL, "degraded"); 4242 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE); 4243 return 0; 4244 } 4245 4246 static int restart_array(mddev_t *mddev) 4247 { 4248 struct gendisk *disk = mddev->gendisk; 4249 4250 /* Complain if it has no devices */ 4251 if (list_empty(&mddev->disks)) 4252 return -ENXIO; 4253 if (!mddev->pers) 4254 return -EINVAL; 4255 if (!mddev->ro) 4256 return -EBUSY; 4257 mddev->safemode = 0; 4258 mddev->ro = 0; 4259 set_disk_ro(disk, 0); 4260 printk(KERN_INFO "md: %s switched to read-write mode.\n", 4261 mdname(mddev)); 4262 /* Kick recovery or resync if necessary */ 4263 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 4264 md_wakeup_thread(mddev->thread); 4265 md_wakeup_thread(mddev->sync_thread); 4266 sysfs_notify_dirent(mddev->sysfs_state); 4267 return 0; 4268 } 4269 4270 /* similar to deny_write_access, but accounts for our holding a reference 4271 * to the file ourselves */ 4272 static int deny_bitmap_write_access(struct file * file) 4273 { 4274 struct inode *inode = file->f_mapping->host; 4275 4276 spin_lock(&inode->i_lock); 4277 if (atomic_read(&inode->i_writecount) > 1) { 4278 spin_unlock(&inode->i_lock); 4279 return -ETXTBSY; 4280 } 4281 atomic_set(&inode->i_writecount, -1); 4282 spin_unlock(&inode->i_lock); 4283 4284 return 0; 4285 } 4286 4287 static void restore_bitmap_write_access(struct file *file) 4288 { 4289 struct inode *inode = file->f_mapping->host; 4290 4291 spin_lock(&inode->i_lock); 4292 atomic_set(&inode->i_writecount, 1); 4293 spin_unlock(&inode->i_lock); 4294 } 4295 4296 /* mode: 4297 * 0 - completely stop and dis-assemble array 4298 * 1 - switch to readonly 4299 * 2 - stop but do not disassemble array 4300 */ 4301 static int do_md_stop(mddev_t * mddev, int mode, int is_open) 4302 { 4303 int err = 0; 4304 struct gendisk *disk = mddev->gendisk; 4305 mdk_rdev_t *rdev; 4306 4307 if (atomic_read(&mddev->openers) > is_open) { 4308 printk("md: %s still in use.\n",mdname(mddev)); 4309 return -EBUSY; 4310 } 4311 4312 if (mddev->pers) { 4313 4314 if (mddev->sync_thread) { 4315 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 4316 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 4317 md_unregister_thread(mddev->sync_thread); 4318 mddev->sync_thread = NULL; 4319 } 4320 4321 del_timer_sync(&mddev->safemode_timer); 4322 4323 switch(mode) { 4324 case 1: /* readonly */ 4325 err = -ENXIO; 4326 if (mddev->ro==1) 4327 goto out; 4328 mddev->ro = 1; 4329 break; 4330 case 0: /* disassemble */ 4331 case 2: /* stop */ 4332 bitmap_flush(mddev); 4333 md_super_wait(mddev); 4334 if (mddev->ro) 4335 set_disk_ro(disk, 0); 4336 4337 mddev->pers->stop(mddev); 4338 mddev->queue->merge_bvec_fn = NULL; 4339 mddev->queue->unplug_fn = NULL; 4340 mddev->queue->backing_dev_info.congested_fn = NULL; 4341 module_put(mddev->pers->owner); 4342 if (mddev->pers->sync_request) 4343 mddev->private = &md_redundancy_group; 4344 mddev->pers = NULL; 4345 /* tell userspace to handle 'inactive' */ 4346 sysfs_notify_dirent(mddev->sysfs_state); 4347 4348 list_for_each_entry(rdev, &mddev->disks, same_set) 4349 if (rdev->raid_disk >= 0) { 4350 char nm[20]; 4351 sprintf(nm, "rd%d", rdev->raid_disk); 4352 sysfs_remove_link(&mddev->kobj, nm); 4353 } 4354 4355 set_capacity(disk, 0); 4356 mddev->changed = 1; 4357 4358 if (mddev->ro) 4359 mddev->ro = 0; 4360 } 4361 if (!mddev->in_sync || mddev->flags) { 4362 /* mark array as shutdown cleanly */ 4363 mddev->in_sync = 1; 4364 md_update_sb(mddev, 1); 4365 } 4366 if (mode == 1) 4367 set_disk_ro(disk, 1); 4368 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 4369 } 4370 4371 /* 4372 * Free resources if final stop 4373 */ 4374 if (mode == 0) { 4375 4376 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev)); 4377 4378 bitmap_destroy(mddev); 4379 if (mddev->bitmap_file) { 4380 restore_bitmap_write_access(mddev->bitmap_file); 4381 fput(mddev->bitmap_file); 4382 mddev->bitmap_file = NULL; 4383 } 4384 mddev->bitmap_offset = 0; 4385 4386 /* make sure all md_delayed_delete calls have finished */ 4387 flush_scheduled_work(); 4388 4389 export_array(mddev); 4390 4391 mddev->array_sectors = 0; 4392 mddev->external_size = 0; 4393 mddev->dev_sectors = 0; 4394 mddev->raid_disks = 0; 4395 mddev->recovery_cp = 0; 4396 mddev->resync_min = 0; 4397 mddev->resync_max = MaxSector; 4398 mddev->reshape_position = MaxSector; 4399 mddev->external = 0; 4400 mddev->persistent = 0; 4401 mddev->level = LEVEL_NONE; 4402 mddev->clevel[0] = 0; 4403 mddev->flags = 0; 4404 mddev->ro = 0; 4405 mddev->metadata_type[0] = 0; 4406 mddev->chunk_sectors = 0; 4407 mddev->ctime = mddev->utime = 0; 4408 mddev->layout = 0; 4409 mddev->max_disks = 0; 4410 mddev->events = 0; 4411 mddev->delta_disks = 0; 4412 mddev->new_level = LEVEL_NONE; 4413 mddev->new_layout = 0; 4414 mddev->new_chunk_sectors = 0; 4415 mddev->curr_resync = 0; 4416 mddev->resync_mismatches = 0; 4417 mddev->suspend_lo = mddev->suspend_hi = 0; 4418 mddev->sync_speed_min = mddev->sync_speed_max = 0; 4419 mddev->recovery = 0; 4420 mddev->in_sync = 0; 4421 mddev->changed = 0; 4422 mddev->degraded = 0; 4423 mddev->barriers_work = 0; 4424 mddev->safemode = 0; 4425 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE); 4426 if (mddev->hold_active == UNTIL_STOP) 4427 mddev->hold_active = 0; 4428 4429 } else if (mddev->pers) 4430 printk(KERN_INFO "md: %s switched to read-only mode.\n", 4431 mdname(mddev)); 4432 err = 0; 4433 blk_integrity_unregister(disk); 4434 md_new_event(mddev); 4435 sysfs_notify_dirent(mddev->sysfs_state); 4436 out: 4437 return err; 4438 } 4439 4440 #ifndef MODULE 4441 static void autorun_array(mddev_t *mddev) 4442 { 4443 mdk_rdev_t *rdev; 4444 int err; 4445 4446 if (list_empty(&mddev->disks)) 4447 return; 4448 4449 printk(KERN_INFO "md: running: "); 4450 4451 list_for_each_entry(rdev, &mddev->disks, same_set) { 4452 char b[BDEVNAME_SIZE]; 4453 printk("<%s>", bdevname(rdev->bdev,b)); 4454 } 4455 printk("\n"); 4456 4457 err = do_md_run(mddev); 4458 if (err) { 4459 printk(KERN_WARNING "md: do_md_run() returned %d\n", err); 4460 do_md_stop(mddev, 0, 0); 4461 } 4462 } 4463 4464 /* 4465 * lets try to run arrays based on all disks that have arrived 4466 * until now. (those are in pending_raid_disks) 4467 * 4468 * the method: pick the first pending disk, collect all disks with 4469 * the same UUID, remove all from the pending list and put them into 4470 * the 'same_array' list. Then order this list based on superblock 4471 * update time (freshest comes first), kick out 'old' disks and 4472 * compare superblocks. If everything's fine then run it. 4473 * 4474 * If "unit" is allocated, then bump its reference count 4475 */ 4476 static void autorun_devices(int part) 4477 { 4478 mdk_rdev_t *rdev0, *rdev, *tmp; 4479 mddev_t *mddev; 4480 char b[BDEVNAME_SIZE]; 4481 4482 printk(KERN_INFO "md: autorun ...\n"); 4483 while (!list_empty(&pending_raid_disks)) { 4484 int unit; 4485 dev_t dev; 4486 LIST_HEAD(candidates); 4487 rdev0 = list_entry(pending_raid_disks.next, 4488 mdk_rdev_t, same_set); 4489 4490 printk(KERN_INFO "md: considering %s ...\n", 4491 bdevname(rdev0->bdev,b)); 4492 INIT_LIST_HEAD(&candidates); 4493 rdev_for_each_list(rdev, tmp, &pending_raid_disks) 4494 if (super_90_load(rdev, rdev0, 0) >= 0) { 4495 printk(KERN_INFO "md: adding %s ...\n", 4496 bdevname(rdev->bdev,b)); 4497 list_move(&rdev->same_set, &candidates); 4498 } 4499 /* 4500 * now we have a set of devices, with all of them having 4501 * mostly sane superblocks. It's time to allocate the 4502 * mddev. 4503 */ 4504 if (part) { 4505 dev = MKDEV(mdp_major, 4506 rdev0->preferred_minor << MdpMinorShift); 4507 unit = MINOR(dev) >> MdpMinorShift; 4508 } else { 4509 dev = MKDEV(MD_MAJOR, rdev0->preferred_minor); 4510 unit = MINOR(dev); 4511 } 4512 if (rdev0->preferred_minor != unit) { 4513 printk(KERN_INFO "md: unit number in %s is bad: %d\n", 4514 bdevname(rdev0->bdev, b), rdev0->preferred_minor); 4515 break; 4516 } 4517 4518 md_probe(dev, NULL, NULL); 4519 mddev = mddev_find(dev); 4520 if (!mddev || !mddev->gendisk) { 4521 if (mddev) 4522 mddev_put(mddev); 4523 printk(KERN_ERR 4524 "md: cannot allocate memory for md drive.\n"); 4525 break; 4526 } 4527 if (mddev_lock(mddev)) 4528 printk(KERN_WARNING "md: %s locked, cannot run\n", 4529 mdname(mddev)); 4530 else if (mddev->raid_disks || mddev->major_version 4531 || !list_empty(&mddev->disks)) { 4532 printk(KERN_WARNING 4533 "md: %s already running, cannot run %s\n", 4534 mdname(mddev), bdevname(rdev0->bdev,b)); 4535 mddev_unlock(mddev); 4536 } else { 4537 printk(KERN_INFO "md: created %s\n", mdname(mddev)); 4538 mddev->persistent = 1; 4539 rdev_for_each_list(rdev, tmp, &candidates) { 4540 list_del_init(&rdev->same_set); 4541 if (bind_rdev_to_array(rdev, mddev)) 4542 export_rdev(rdev); 4543 } 4544 autorun_array(mddev); 4545 mddev_unlock(mddev); 4546 } 4547 /* on success, candidates will be empty, on error 4548 * it won't... 4549 */ 4550 rdev_for_each_list(rdev, tmp, &candidates) { 4551 list_del_init(&rdev->same_set); 4552 export_rdev(rdev); 4553 } 4554 mddev_put(mddev); 4555 } 4556 printk(KERN_INFO "md: ... autorun DONE.\n"); 4557 } 4558 #endif /* !MODULE */ 4559 4560 static int get_version(void __user * arg) 4561 { 4562 mdu_version_t ver; 4563 4564 ver.major = MD_MAJOR_VERSION; 4565 ver.minor = MD_MINOR_VERSION; 4566 ver.patchlevel = MD_PATCHLEVEL_VERSION; 4567 4568 if (copy_to_user(arg, &ver, sizeof(ver))) 4569 return -EFAULT; 4570 4571 return 0; 4572 } 4573 4574 static int get_array_info(mddev_t * mddev, void __user * arg) 4575 { 4576 mdu_array_info_t info; 4577 int nr,working,active,failed,spare; 4578 mdk_rdev_t *rdev; 4579 4580 nr=working=active=failed=spare=0; 4581 list_for_each_entry(rdev, &mddev->disks, same_set) { 4582 nr++; 4583 if (test_bit(Faulty, &rdev->flags)) 4584 failed++; 4585 else { 4586 working++; 4587 if (test_bit(In_sync, &rdev->flags)) 4588 active++; 4589 else 4590 spare++; 4591 } 4592 } 4593 4594 info.major_version = mddev->major_version; 4595 info.minor_version = mddev->minor_version; 4596 info.patch_version = MD_PATCHLEVEL_VERSION; 4597 info.ctime = mddev->ctime; 4598 info.level = mddev->level; 4599 info.size = mddev->dev_sectors / 2; 4600 if (info.size != mddev->dev_sectors / 2) /* overflow */ 4601 info.size = -1; 4602 info.nr_disks = nr; 4603 info.raid_disks = mddev->raid_disks; 4604 info.md_minor = mddev->md_minor; 4605 info.not_persistent= !mddev->persistent; 4606 4607 info.utime = mddev->utime; 4608 info.state = 0; 4609 if (mddev->in_sync) 4610 info.state = (1<<MD_SB_CLEAN); 4611 if (mddev->bitmap && mddev->bitmap_offset) 4612 info.state = (1<<MD_SB_BITMAP_PRESENT); 4613 info.active_disks = active; 4614 info.working_disks = working; 4615 info.failed_disks = failed; 4616 info.spare_disks = spare; 4617 4618 info.layout = mddev->layout; 4619 info.chunk_size = mddev->chunk_sectors << 9; 4620 4621 if (copy_to_user(arg, &info, sizeof(info))) 4622 return -EFAULT; 4623 4624 return 0; 4625 } 4626 4627 static int get_bitmap_file(mddev_t * mddev, void __user * arg) 4628 { 4629 mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */ 4630 char *ptr, *buf = NULL; 4631 int err = -ENOMEM; 4632 4633 if (md_allow_write(mddev)) 4634 file = kmalloc(sizeof(*file), GFP_NOIO); 4635 else 4636 file = kmalloc(sizeof(*file), GFP_KERNEL); 4637 4638 if (!file) 4639 goto out; 4640 4641 /* bitmap disabled, zero the first byte and copy out */ 4642 if (!mddev->bitmap || !mddev->bitmap->file) { 4643 file->pathname[0] = '\0'; 4644 goto copy_out; 4645 } 4646 4647 buf = kmalloc(sizeof(file->pathname), GFP_KERNEL); 4648 if (!buf) 4649 goto out; 4650 4651 ptr = d_path(&mddev->bitmap->file->f_path, buf, sizeof(file->pathname)); 4652 if (IS_ERR(ptr)) 4653 goto out; 4654 4655 strcpy(file->pathname, ptr); 4656 4657 copy_out: 4658 err = 0; 4659 if (copy_to_user(arg, file, sizeof(*file))) 4660 err = -EFAULT; 4661 out: 4662 kfree(buf); 4663 kfree(file); 4664 return err; 4665 } 4666 4667 static int get_disk_info(mddev_t * mddev, void __user * arg) 4668 { 4669 mdu_disk_info_t info; 4670 mdk_rdev_t *rdev; 4671 4672 if (copy_from_user(&info, arg, sizeof(info))) 4673 return -EFAULT; 4674 4675 rdev = find_rdev_nr(mddev, info.number); 4676 if (rdev) { 4677 info.major = MAJOR(rdev->bdev->bd_dev); 4678 info.minor = MINOR(rdev->bdev->bd_dev); 4679 info.raid_disk = rdev->raid_disk; 4680 info.state = 0; 4681 if (test_bit(Faulty, &rdev->flags)) 4682 info.state |= (1<<MD_DISK_FAULTY); 4683 else if (test_bit(In_sync, &rdev->flags)) { 4684 info.state |= (1<<MD_DISK_ACTIVE); 4685 info.state |= (1<<MD_DISK_SYNC); 4686 } 4687 if (test_bit(WriteMostly, &rdev->flags)) 4688 info.state |= (1<<MD_DISK_WRITEMOSTLY); 4689 } else { 4690 info.major = info.minor = 0; 4691 info.raid_disk = -1; 4692 info.state = (1<<MD_DISK_REMOVED); 4693 } 4694 4695 if (copy_to_user(arg, &info, sizeof(info))) 4696 return -EFAULT; 4697 4698 return 0; 4699 } 4700 4701 static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info) 4702 { 4703 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE]; 4704 mdk_rdev_t *rdev; 4705 dev_t dev = MKDEV(info->major,info->minor); 4706 4707 if (info->major != MAJOR(dev) || info->minor != MINOR(dev)) 4708 return -EOVERFLOW; 4709 4710 if (!mddev->raid_disks) { 4711 int err; 4712 /* expecting a device which has a superblock */ 4713 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version); 4714 if (IS_ERR(rdev)) { 4715 printk(KERN_WARNING 4716 "md: md_import_device returned %ld\n", 4717 PTR_ERR(rdev)); 4718 return PTR_ERR(rdev); 4719 } 4720 if (!list_empty(&mddev->disks)) { 4721 mdk_rdev_t *rdev0 = list_entry(mddev->disks.next, 4722 mdk_rdev_t, same_set); 4723 int err = super_types[mddev->major_version] 4724 .load_super(rdev, rdev0, mddev->minor_version); 4725 if (err < 0) { 4726 printk(KERN_WARNING 4727 "md: %s has different UUID to %s\n", 4728 bdevname(rdev->bdev,b), 4729 bdevname(rdev0->bdev,b2)); 4730 export_rdev(rdev); 4731 return -EINVAL; 4732 } 4733 } 4734 err = bind_rdev_to_array(rdev, mddev); 4735 if (err) 4736 export_rdev(rdev); 4737 return err; 4738 } 4739 4740 /* 4741 * add_new_disk can be used once the array is assembled 4742 * to add "hot spares". They must already have a superblock 4743 * written 4744 */ 4745 if (mddev->pers) { 4746 int err; 4747 if (!mddev->pers->hot_add_disk) { 4748 printk(KERN_WARNING 4749 "%s: personality does not support diskops!\n", 4750 mdname(mddev)); 4751 return -EINVAL; 4752 } 4753 if (mddev->persistent) 4754 rdev = md_import_device(dev, mddev->major_version, 4755 mddev->minor_version); 4756 else 4757 rdev = md_import_device(dev, -1, -1); 4758 if (IS_ERR(rdev)) { 4759 printk(KERN_WARNING 4760 "md: md_import_device returned %ld\n", 4761 PTR_ERR(rdev)); 4762 return PTR_ERR(rdev); 4763 } 4764 /* set save_raid_disk if appropriate */ 4765 if (!mddev->persistent) { 4766 if (info->state & (1<<MD_DISK_SYNC) && 4767 info->raid_disk < mddev->raid_disks) 4768 rdev->raid_disk = info->raid_disk; 4769 else 4770 rdev->raid_disk = -1; 4771 } else 4772 super_types[mddev->major_version]. 4773 validate_super(mddev, rdev); 4774 rdev->saved_raid_disk = rdev->raid_disk; 4775 4776 clear_bit(In_sync, &rdev->flags); /* just to be sure */ 4777 if (info->state & (1<<MD_DISK_WRITEMOSTLY)) 4778 set_bit(WriteMostly, &rdev->flags); 4779 else 4780 clear_bit(WriteMostly, &rdev->flags); 4781 4782 rdev->raid_disk = -1; 4783 err = bind_rdev_to_array(rdev, mddev); 4784 if (!err && !mddev->pers->hot_remove_disk) { 4785 /* If there is hot_add_disk but no hot_remove_disk 4786 * then added disks for geometry changes, 4787 * and should be added immediately. 4788 */ 4789 super_types[mddev->major_version]. 4790 validate_super(mddev, rdev); 4791 err = mddev->pers->hot_add_disk(mddev, rdev); 4792 if (err) 4793 unbind_rdev_from_array(rdev); 4794 } 4795 if (err) 4796 export_rdev(rdev); 4797 else 4798 sysfs_notify_dirent(rdev->sysfs_state); 4799 4800 md_update_sb(mddev, 1); 4801 if (mddev->degraded) 4802 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 4803 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 4804 md_wakeup_thread(mddev->thread); 4805 return err; 4806 } 4807 4808 /* otherwise, add_new_disk is only allowed 4809 * for major_version==0 superblocks 4810 */ 4811 if (mddev->major_version != 0) { 4812 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n", 4813 mdname(mddev)); 4814 return -EINVAL; 4815 } 4816 4817 if (!(info->state & (1<<MD_DISK_FAULTY))) { 4818 int err; 4819 rdev = md_import_device(dev, -1, 0); 4820 if (IS_ERR(rdev)) { 4821 printk(KERN_WARNING 4822 "md: error, md_import_device() returned %ld\n", 4823 PTR_ERR(rdev)); 4824 return PTR_ERR(rdev); 4825 } 4826 rdev->desc_nr = info->number; 4827 if (info->raid_disk < mddev->raid_disks) 4828 rdev->raid_disk = info->raid_disk; 4829 else 4830 rdev->raid_disk = -1; 4831 4832 if (rdev->raid_disk < mddev->raid_disks) 4833 if (info->state & (1<<MD_DISK_SYNC)) 4834 set_bit(In_sync, &rdev->flags); 4835 4836 if (info->state & (1<<MD_DISK_WRITEMOSTLY)) 4837 set_bit(WriteMostly, &rdev->flags); 4838 4839 if (!mddev->persistent) { 4840 printk(KERN_INFO "md: nonpersistent superblock ...\n"); 4841 rdev->sb_start = rdev->bdev->bd_inode->i_size / 512; 4842 } else 4843 rdev->sb_start = calc_dev_sboffset(rdev->bdev); 4844 rdev->sectors = rdev->sb_start; 4845 4846 err = bind_rdev_to_array(rdev, mddev); 4847 if (err) { 4848 export_rdev(rdev); 4849 return err; 4850 } 4851 } 4852 4853 return 0; 4854 } 4855 4856 static int hot_remove_disk(mddev_t * mddev, dev_t dev) 4857 { 4858 char b[BDEVNAME_SIZE]; 4859 mdk_rdev_t *rdev; 4860 4861 rdev = find_rdev(mddev, dev); 4862 if (!rdev) 4863 return -ENXIO; 4864 4865 if (rdev->raid_disk >= 0) 4866 goto busy; 4867 4868 kick_rdev_from_array(rdev); 4869 md_update_sb(mddev, 1); 4870 md_new_event(mddev); 4871 4872 return 0; 4873 busy: 4874 printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n", 4875 bdevname(rdev->bdev,b), mdname(mddev)); 4876 return -EBUSY; 4877 } 4878 4879 static int hot_add_disk(mddev_t * mddev, dev_t dev) 4880 { 4881 char b[BDEVNAME_SIZE]; 4882 int err; 4883 mdk_rdev_t *rdev; 4884 4885 if (!mddev->pers) 4886 return -ENODEV; 4887 4888 if (mddev->major_version != 0) { 4889 printk(KERN_WARNING "%s: HOT_ADD may only be used with" 4890 " version-0 superblocks.\n", 4891 mdname(mddev)); 4892 return -EINVAL; 4893 } 4894 if (!mddev->pers->hot_add_disk) { 4895 printk(KERN_WARNING 4896 "%s: personality does not support diskops!\n", 4897 mdname(mddev)); 4898 return -EINVAL; 4899 } 4900 4901 rdev = md_import_device(dev, -1, 0); 4902 if (IS_ERR(rdev)) { 4903 printk(KERN_WARNING 4904 "md: error, md_import_device() returned %ld\n", 4905 PTR_ERR(rdev)); 4906 return -EINVAL; 4907 } 4908 4909 if (mddev->persistent) 4910 rdev->sb_start = calc_dev_sboffset(rdev->bdev); 4911 else 4912 rdev->sb_start = rdev->bdev->bd_inode->i_size / 512; 4913 4914 rdev->sectors = rdev->sb_start; 4915 4916 if (test_bit(Faulty, &rdev->flags)) { 4917 printk(KERN_WARNING 4918 "md: can not hot-add faulty %s disk to %s!\n", 4919 bdevname(rdev->bdev,b), mdname(mddev)); 4920 err = -EINVAL; 4921 goto abort_export; 4922 } 4923 clear_bit(In_sync, &rdev->flags); 4924 rdev->desc_nr = -1; 4925 rdev->saved_raid_disk = -1; 4926 err = bind_rdev_to_array(rdev, mddev); 4927 if (err) 4928 goto abort_export; 4929 4930 /* 4931 * The rest should better be atomic, we can have disk failures 4932 * noticed in interrupt contexts ... 4933 */ 4934 4935 rdev->raid_disk = -1; 4936 4937 md_update_sb(mddev, 1); 4938 4939 /* 4940 * Kick recovery, maybe this spare has to be added to the 4941 * array immediately. 4942 */ 4943 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 4944 md_wakeup_thread(mddev->thread); 4945 md_new_event(mddev); 4946 return 0; 4947 4948 abort_export: 4949 export_rdev(rdev); 4950 return err; 4951 } 4952 4953 static int set_bitmap_file(mddev_t *mddev, int fd) 4954 { 4955 int err; 4956 4957 if (mddev->pers) { 4958 if (!mddev->pers->quiesce) 4959 return -EBUSY; 4960 if (mddev->recovery || mddev->sync_thread) 4961 return -EBUSY; 4962 /* we should be able to change the bitmap.. */ 4963 } 4964 4965 4966 if (fd >= 0) { 4967 if (mddev->bitmap) 4968 return -EEXIST; /* cannot add when bitmap is present */ 4969 mddev->bitmap_file = fget(fd); 4970 4971 if (mddev->bitmap_file == NULL) { 4972 printk(KERN_ERR "%s: error: failed to get bitmap file\n", 4973 mdname(mddev)); 4974 return -EBADF; 4975 } 4976 4977 err = deny_bitmap_write_access(mddev->bitmap_file); 4978 if (err) { 4979 printk(KERN_ERR "%s: error: bitmap file is already in use\n", 4980 mdname(mddev)); 4981 fput(mddev->bitmap_file); 4982 mddev->bitmap_file = NULL; 4983 return err; 4984 } 4985 mddev->bitmap_offset = 0; /* file overrides offset */ 4986 } else if (mddev->bitmap == NULL) 4987 return -ENOENT; /* cannot remove what isn't there */ 4988 err = 0; 4989 if (mddev->pers) { 4990 mddev->pers->quiesce(mddev, 1); 4991 if (fd >= 0) 4992 err = bitmap_create(mddev); 4993 if (fd < 0 || err) { 4994 bitmap_destroy(mddev); 4995 fd = -1; /* make sure to put the file */ 4996 } 4997 mddev->pers->quiesce(mddev, 0); 4998 } 4999 if (fd < 0) { 5000 if (mddev->bitmap_file) { 5001 restore_bitmap_write_access(mddev->bitmap_file); 5002 fput(mddev->bitmap_file); 5003 } 5004 mddev->bitmap_file = NULL; 5005 } 5006 5007 return err; 5008 } 5009 5010 /* 5011 * set_array_info is used two different ways 5012 * The original usage is when creating a new array. 5013 * In this usage, raid_disks is > 0 and it together with 5014 * level, size, not_persistent,layout,chunksize determine the 5015 * shape of the array. 5016 * This will always create an array with a type-0.90.0 superblock. 5017 * The newer usage is when assembling an array. 5018 * In this case raid_disks will be 0, and the major_version field is 5019 * use to determine which style super-blocks are to be found on the devices. 5020 * The minor and patch _version numbers are also kept incase the 5021 * super_block handler wishes to interpret them. 5022 */ 5023 static int set_array_info(mddev_t * mddev, mdu_array_info_t *info) 5024 { 5025 5026 if (info->raid_disks == 0) { 5027 /* just setting version number for superblock loading */ 5028 if (info->major_version < 0 || 5029 info->major_version >= ARRAY_SIZE(super_types) || 5030 super_types[info->major_version].name == NULL) { 5031 /* maybe try to auto-load a module? */ 5032 printk(KERN_INFO 5033 "md: superblock version %d not known\n", 5034 info->major_version); 5035 return -EINVAL; 5036 } 5037 mddev->major_version = info->major_version; 5038 mddev->minor_version = info->minor_version; 5039 mddev->patch_version = info->patch_version; 5040 mddev->persistent = !info->not_persistent; 5041 return 0; 5042 } 5043 mddev->major_version = MD_MAJOR_VERSION; 5044 mddev->minor_version = MD_MINOR_VERSION; 5045 mddev->patch_version = MD_PATCHLEVEL_VERSION; 5046 mddev->ctime = get_seconds(); 5047 5048 mddev->level = info->level; 5049 mddev->clevel[0] = 0; 5050 mddev->dev_sectors = 2 * (sector_t)info->size; 5051 mddev->raid_disks = info->raid_disks; 5052 /* don't set md_minor, it is determined by which /dev/md* was 5053 * openned 5054 */ 5055 if (info->state & (1<<MD_SB_CLEAN)) 5056 mddev->recovery_cp = MaxSector; 5057 else 5058 mddev->recovery_cp = 0; 5059 mddev->persistent = ! info->not_persistent; 5060 mddev->external = 0; 5061 5062 mddev->layout = info->layout; 5063 mddev->chunk_sectors = info->chunk_size >> 9; 5064 5065 mddev->max_disks = MD_SB_DISKS; 5066 5067 if (mddev->persistent) 5068 mddev->flags = 0; 5069 set_bit(MD_CHANGE_DEVS, &mddev->flags); 5070 5071 mddev->default_bitmap_offset = MD_SB_BYTES >> 9; 5072 mddev->bitmap_offset = 0; 5073 5074 mddev->reshape_position = MaxSector; 5075 5076 /* 5077 * Generate a 128 bit UUID 5078 */ 5079 get_random_bytes(mddev->uuid, 16); 5080 5081 mddev->new_level = mddev->level; 5082 mddev->new_chunk_sectors = mddev->chunk_sectors; 5083 mddev->new_layout = mddev->layout; 5084 mddev->delta_disks = 0; 5085 5086 return 0; 5087 } 5088 5089 void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors) 5090 { 5091 WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__); 5092 5093 if (mddev->external_size) 5094 return; 5095 5096 mddev->array_sectors = array_sectors; 5097 } 5098 EXPORT_SYMBOL(md_set_array_sectors); 5099 5100 static int update_size(mddev_t *mddev, sector_t num_sectors) 5101 { 5102 mdk_rdev_t *rdev; 5103 int rv; 5104 int fit = (num_sectors == 0); 5105 5106 if (mddev->pers->resize == NULL) 5107 return -EINVAL; 5108 /* The "num_sectors" is the number of sectors of each device that 5109 * is used. This can only make sense for arrays with redundancy. 5110 * linear and raid0 always use whatever space is available. We can only 5111 * consider changing this number if no resync or reconstruction is 5112 * happening, and if the new size is acceptable. It must fit before the 5113 * sb_start or, if that is <data_offset, it must fit before the size 5114 * of each device. If num_sectors is zero, we find the largest size 5115 * that fits. 5116 5117 */ 5118 if (mddev->sync_thread) 5119 return -EBUSY; 5120 if (mddev->bitmap) 5121 /* Sorry, cannot grow a bitmap yet, just remove it, 5122 * grow, and re-add. 5123 */ 5124 return -EBUSY; 5125 list_for_each_entry(rdev, &mddev->disks, same_set) { 5126 sector_t avail = rdev->sectors; 5127 5128 if (fit && (num_sectors == 0 || num_sectors > avail)) 5129 num_sectors = avail; 5130 if (avail < num_sectors) 5131 return -ENOSPC; 5132 } 5133 rv = mddev->pers->resize(mddev, num_sectors); 5134 if (!rv) 5135 revalidate_disk(mddev->gendisk); 5136 return rv; 5137 } 5138 5139 static int update_raid_disks(mddev_t *mddev, int raid_disks) 5140 { 5141 int rv; 5142 /* change the number of raid disks */ 5143 if (mddev->pers->check_reshape == NULL) 5144 return -EINVAL; 5145 if (raid_disks <= 0 || 5146 raid_disks >= mddev->max_disks) 5147 return -EINVAL; 5148 if (mddev->sync_thread || mddev->reshape_position != MaxSector) 5149 return -EBUSY; 5150 mddev->delta_disks = raid_disks - mddev->raid_disks; 5151 5152 rv = mddev->pers->check_reshape(mddev); 5153 return rv; 5154 } 5155 5156 5157 /* 5158 * update_array_info is used to change the configuration of an 5159 * on-line array. 5160 * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size 5161 * fields in the info are checked against the array. 5162 * Any differences that cannot be handled will cause an error. 5163 * Normally, only one change can be managed at a time. 5164 */ 5165 static int update_array_info(mddev_t *mddev, mdu_array_info_t *info) 5166 { 5167 int rv = 0; 5168 int cnt = 0; 5169 int state = 0; 5170 5171 /* calculate expected state,ignoring low bits */ 5172 if (mddev->bitmap && mddev->bitmap_offset) 5173 state |= (1 << MD_SB_BITMAP_PRESENT); 5174 5175 if (mddev->major_version != info->major_version || 5176 mddev->minor_version != info->minor_version || 5177 /* mddev->patch_version != info->patch_version || */ 5178 mddev->ctime != info->ctime || 5179 mddev->level != info->level || 5180 /* mddev->layout != info->layout || */ 5181 !mddev->persistent != info->not_persistent|| 5182 mddev->chunk_sectors != info->chunk_size >> 9 || 5183 /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */ 5184 ((state^info->state) & 0xfffffe00) 5185 ) 5186 return -EINVAL; 5187 /* Check there is only one change */ 5188 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size) 5189 cnt++; 5190 if (mddev->raid_disks != info->raid_disks) 5191 cnt++; 5192 if (mddev->layout != info->layout) 5193 cnt++; 5194 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) 5195 cnt++; 5196 if (cnt == 0) 5197 return 0; 5198 if (cnt > 1) 5199 return -EINVAL; 5200 5201 if (mddev->layout != info->layout) { 5202 /* Change layout 5203 * we don't need to do anything at the md level, the 5204 * personality will take care of it all. 5205 */ 5206 if (mddev->pers->check_reshape == NULL) 5207 return -EINVAL; 5208 else { 5209 mddev->new_layout = info->layout; 5210 rv = mddev->pers->check_reshape(mddev); 5211 if (rv) 5212 mddev->new_layout = mddev->layout; 5213 return rv; 5214 } 5215 } 5216 if (info->size >= 0 && mddev->dev_sectors / 2 != info->size) 5217 rv = update_size(mddev, (sector_t)info->size * 2); 5218 5219 if (mddev->raid_disks != info->raid_disks) 5220 rv = update_raid_disks(mddev, info->raid_disks); 5221 5222 if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) { 5223 if (mddev->pers->quiesce == NULL) 5224 return -EINVAL; 5225 if (mddev->recovery || mddev->sync_thread) 5226 return -EBUSY; 5227 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) { 5228 /* add the bitmap */ 5229 if (mddev->bitmap) 5230 return -EEXIST; 5231 if (mddev->default_bitmap_offset == 0) 5232 return -EINVAL; 5233 mddev->bitmap_offset = mddev->default_bitmap_offset; 5234 mddev->pers->quiesce(mddev, 1); 5235 rv = bitmap_create(mddev); 5236 if (rv) 5237 bitmap_destroy(mddev); 5238 mddev->pers->quiesce(mddev, 0); 5239 } else { 5240 /* remove the bitmap */ 5241 if (!mddev->bitmap) 5242 return -ENOENT; 5243 if (mddev->bitmap->file) 5244 return -EINVAL; 5245 mddev->pers->quiesce(mddev, 1); 5246 bitmap_destroy(mddev); 5247 mddev->pers->quiesce(mddev, 0); 5248 mddev->bitmap_offset = 0; 5249 } 5250 } 5251 md_update_sb(mddev, 1); 5252 return rv; 5253 } 5254 5255 static int set_disk_faulty(mddev_t *mddev, dev_t dev) 5256 { 5257 mdk_rdev_t *rdev; 5258 5259 if (mddev->pers == NULL) 5260 return -ENODEV; 5261 5262 rdev = find_rdev(mddev, dev); 5263 if (!rdev) 5264 return -ENODEV; 5265 5266 md_error(mddev, rdev); 5267 return 0; 5268 } 5269 5270 /* 5271 * We have a problem here : there is no easy way to give a CHS 5272 * virtual geometry. We currently pretend that we have a 2 heads 5273 * 4 sectors (with a BIG number of cylinders...). This drives 5274 * dosfs just mad... ;-) 5275 */ 5276 static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo) 5277 { 5278 mddev_t *mddev = bdev->bd_disk->private_data; 5279 5280 geo->heads = 2; 5281 geo->sectors = 4; 5282 geo->cylinders = get_capacity(mddev->gendisk) / 8; 5283 return 0; 5284 } 5285 5286 static int md_ioctl(struct block_device *bdev, fmode_t mode, 5287 unsigned int cmd, unsigned long arg) 5288 { 5289 int err = 0; 5290 void __user *argp = (void __user *)arg; 5291 mddev_t *mddev = NULL; 5292 5293 if (!capable(CAP_SYS_ADMIN)) 5294 return -EACCES; 5295 5296 /* 5297 * Commands dealing with the RAID driver but not any 5298 * particular array: 5299 */ 5300 switch (cmd) 5301 { 5302 case RAID_VERSION: 5303 err = get_version(argp); 5304 goto done; 5305 5306 case PRINT_RAID_DEBUG: 5307 err = 0; 5308 md_print_devices(); 5309 goto done; 5310 5311 #ifndef MODULE 5312 case RAID_AUTORUN: 5313 err = 0; 5314 autostart_arrays(arg); 5315 goto done; 5316 #endif 5317 default:; 5318 } 5319 5320 /* 5321 * Commands creating/starting a new array: 5322 */ 5323 5324 mddev = bdev->bd_disk->private_data; 5325 5326 if (!mddev) { 5327 BUG(); 5328 goto abort; 5329 } 5330 5331 err = mddev_lock(mddev); 5332 if (err) { 5333 printk(KERN_INFO 5334 "md: ioctl lock interrupted, reason %d, cmd %d\n", 5335 err, cmd); 5336 goto abort; 5337 } 5338 5339 switch (cmd) 5340 { 5341 case SET_ARRAY_INFO: 5342 { 5343 mdu_array_info_t info; 5344 if (!arg) 5345 memset(&info, 0, sizeof(info)); 5346 else if (copy_from_user(&info, argp, sizeof(info))) { 5347 err = -EFAULT; 5348 goto abort_unlock; 5349 } 5350 if (mddev->pers) { 5351 err = update_array_info(mddev, &info); 5352 if (err) { 5353 printk(KERN_WARNING "md: couldn't update" 5354 " array info. %d\n", err); 5355 goto abort_unlock; 5356 } 5357 goto done_unlock; 5358 } 5359 if (!list_empty(&mddev->disks)) { 5360 printk(KERN_WARNING 5361 "md: array %s already has disks!\n", 5362 mdname(mddev)); 5363 err = -EBUSY; 5364 goto abort_unlock; 5365 } 5366 if (mddev->raid_disks) { 5367 printk(KERN_WARNING 5368 "md: array %s already initialised!\n", 5369 mdname(mddev)); 5370 err = -EBUSY; 5371 goto abort_unlock; 5372 } 5373 err = set_array_info(mddev, &info); 5374 if (err) { 5375 printk(KERN_WARNING "md: couldn't set" 5376 " array info. %d\n", err); 5377 goto abort_unlock; 5378 } 5379 } 5380 goto done_unlock; 5381 5382 default:; 5383 } 5384 5385 /* 5386 * Commands querying/configuring an existing array: 5387 */ 5388 /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY, 5389 * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */ 5390 if ((!mddev->raid_disks && !mddev->external) 5391 && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY 5392 && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE 5393 && cmd != GET_BITMAP_FILE) { 5394 err = -ENODEV; 5395 goto abort_unlock; 5396 } 5397 5398 /* 5399 * Commands even a read-only array can execute: 5400 */ 5401 switch (cmd) 5402 { 5403 case GET_ARRAY_INFO: 5404 err = get_array_info(mddev, argp); 5405 goto done_unlock; 5406 5407 case GET_BITMAP_FILE: 5408 err = get_bitmap_file(mddev, argp); 5409 goto done_unlock; 5410 5411 case GET_DISK_INFO: 5412 err = get_disk_info(mddev, argp); 5413 goto done_unlock; 5414 5415 case RESTART_ARRAY_RW: 5416 err = restart_array(mddev); 5417 goto done_unlock; 5418 5419 case STOP_ARRAY: 5420 err = do_md_stop(mddev, 0, 1); 5421 goto done_unlock; 5422 5423 case STOP_ARRAY_RO: 5424 err = do_md_stop(mddev, 1, 1); 5425 goto done_unlock; 5426 5427 } 5428 5429 /* 5430 * The remaining ioctls are changing the state of the 5431 * superblock, so we do not allow them on read-only arrays. 5432 * However non-MD ioctls (e.g. get-size) will still come through 5433 * here and hit the 'default' below, so only disallow 5434 * 'md' ioctls, and switch to rw mode if started auto-readonly. 5435 */ 5436 if (_IOC_TYPE(cmd) == MD_MAJOR && mddev->ro && mddev->pers) { 5437 if (mddev->ro == 2) { 5438 mddev->ro = 0; 5439 sysfs_notify_dirent(mddev->sysfs_state); 5440 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 5441 md_wakeup_thread(mddev->thread); 5442 } else { 5443 err = -EROFS; 5444 goto abort_unlock; 5445 } 5446 } 5447 5448 switch (cmd) 5449 { 5450 case ADD_NEW_DISK: 5451 { 5452 mdu_disk_info_t info; 5453 if (copy_from_user(&info, argp, sizeof(info))) 5454 err = -EFAULT; 5455 else 5456 err = add_new_disk(mddev, &info); 5457 goto done_unlock; 5458 } 5459 5460 case HOT_REMOVE_DISK: 5461 err = hot_remove_disk(mddev, new_decode_dev(arg)); 5462 goto done_unlock; 5463 5464 case HOT_ADD_DISK: 5465 err = hot_add_disk(mddev, new_decode_dev(arg)); 5466 goto done_unlock; 5467 5468 case SET_DISK_FAULTY: 5469 err = set_disk_faulty(mddev, new_decode_dev(arg)); 5470 goto done_unlock; 5471 5472 case RUN_ARRAY: 5473 err = do_md_run(mddev); 5474 goto done_unlock; 5475 5476 case SET_BITMAP_FILE: 5477 err = set_bitmap_file(mddev, (int)arg); 5478 goto done_unlock; 5479 5480 default: 5481 err = -EINVAL; 5482 goto abort_unlock; 5483 } 5484 5485 done_unlock: 5486 abort_unlock: 5487 if (mddev->hold_active == UNTIL_IOCTL && 5488 err != -EINVAL) 5489 mddev->hold_active = 0; 5490 mddev_unlock(mddev); 5491 5492 return err; 5493 done: 5494 if (err) 5495 MD_BUG(); 5496 abort: 5497 return err; 5498 } 5499 5500 static int md_open(struct block_device *bdev, fmode_t mode) 5501 { 5502 /* 5503 * Succeed if we can lock the mddev, which confirms that 5504 * it isn't being stopped right now. 5505 */ 5506 mddev_t *mddev = mddev_find(bdev->bd_dev); 5507 int err; 5508 5509 if (mddev->gendisk != bdev->bd_disk) { 5510 /* we are racing with mddev_put which is discarding this 5511 * bd_disk. 5512 */ 5513 mddev_put(mddev); 5514 /* Wait until bdev->bd_disk is definitely gone */ 5515 flush_scheduled_work(); 5516 /* Then retry the open from the top */ 5517 return -ERESTARTSYS; 5518 } 5519 BUG_ON(mddev != bdev->bd_disk->private_data); 5520 5521 if ((err = mutex_lock_interruptible_nested(&mddev->reconfig_mutex, 1))) 5522 goto out; 5523 5524 err = 0; 5525 atomic_inc(&mddev->openers); 5526 mddev_unlock(mddev); 5527 5528 check_disk_change(bdev); 5529 out: 5530 return err; 5531 } 5532 5533 static int md_release(struct gendisk *disk, fmode_t mode) 5534 { 5535 mddev_t *mddev = disk->private_data; 5536 5537 BUG_ON(!mddev); 5538 atomic_dec(&mddev->openers); 5539 mddev_put(mddev); 5540 5541 return 0; 5542 } 5543 5544 static int md_media_changed(struct gendisk *disk) 5545 { 5546 mddev_t *mddev = disk->private_data; 5547 5548 return mddev->changed; 5549 } 5550 5551 static int md_revalidate(struct gendisk *disk) 5552 { 5553 mddev_t *mddev = disk->private_data; 5554 5555 mddev->changed = 0; 5556 return 0; 5557 } 5558 static struct block_device_operations md_fops = 5559 { 5560 .owner = THIS_MODULE, 5561 .open = md_open, 5562 .release = md_release, 5563 .ioctl = md_ioctl, 5564 .getgeo = md_getgeo, 5565 .media_changed = md_media_changed, 5566 .revalidate_disk= md_revalidate, 5567 }; 5568 5569 static int md_thread(void * arg) 5570 { 5571 mdk_thread_t *thread = arg; 5572 5573 /* 5574 * md_thread is a 'system-thread', it's priority should be very 5575 * high. We avoid resource deadlocks individually in each 5576 * raid personality. (RAID5 does preallocation) We also use RR and 5577 * the very same RT priority as kswapd, thus we will never get 5578 * into a priority inversion deadlock. 5579 * 5580 * we definitely have to have equal or higher priority than 5581 * bdflush, otherwise bdflush will deadlock if there are too 5582 * many dirty RAID5 blocks. 5583 */ 5584 5585 allow_signal(SIGKILL); 5586 while (!kthread_should_stop()) { 5587 5588 /* We need to wait INTERRUPTIBLE so that 5589 * we don't add to the load-average. 5590 * That means we need to be sure no signals are 5591 * pending 5592 */ 5593 if (signal_pending(current)) 5594 flush_signals(current); 5595 5596 wait_event_interruptible_timeout 5597 (thread->wqueue, 5598 test_bit(THREAD_WAKEUP, &thread->flags) 5599 || kthread_should_stop(), 5600 thread->timeout); 5601 5602 clear_bit(THREAD_WAKEUP, &thread->flags); 5603 5604 thread->run(thread->mddev); 5605 } 5606 5607 return 0; 5608 } 5609 5610 void md_wakeup_thread(mdk_thread_t *thread) 5611 { 5612 if (thread) { 5613 dprintk("md: waking up MD thread %s.\n", thread->tsk->comm); 5614 set_bit(THREAD_WAKEUP, &thread->flags); 5615 wake_up(&thread->wqueue); 5616 } 5617 } 5618 5619 mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev, 5620 const char *name) 5621 { 5622 mdk_thread_t *thread; 5623 5624 thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL); 5625 if (!thread) 5626 return NULL; 5627 5628 init_waitqueue_head(&thread->wqueue); 5629 5630 thread->run = run; 5631 thread->mddev = mddev; 5632 thread->timeout = MAX_SCHEDULE_TIMEOUT; 5633 thread->tsk = kthread_run(md_thread, thread, name, mdname(thread->mddev)); 5634 if (IS_ERR(thread->tsk)) { 5635 kfree(thread); 5636 return NULL; 5637 } 5638 return thread; 5639 } 5640 5641 void md_unregister_thread(mdk_thread_t *thread) 5642 { 5643 if (!thread) 5644 return; 5645 dprintk("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk)); 5646 5647 kthread_stop(thread->tsk); 5648 kfree(thread); 5649 } 5650 5651 void md_error(mddev_t *mddev, mdk_rdev_t *rdev) 5652 { 5653 if (!mddev) { 5654 MD_BUG(); 5655 return; 5656 } 5657 5658 if (!rdev || test_bit(Faulty, &rdev->flags)) 5659 return; 5660 5661 if (mddev->external) 5662 set_bit(Blocked, &rdev->flags); 5663 /* 5664 dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n", 5665 mdname(mddev), 5666 MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev), 5667 __builtin_return_address(0),__builtin_return_address(1), 5668 __builtin_return_address(2),__builtin_return_address(3)); 5669 */ 5670 if (!mddev->pers) 5671 return; 5672 if (!mddev->pers->error_handler) 5673 return; 5674 mddev->pers->error_handler(mddev,rdev); 5675 if (mddev->degraded) 5676 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 5677 set_bit(StateChanged, &rdev->flags); 5678 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 5679 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 5680 md_wakeup_thread(mddev->thread); 5681 md_new_event_inintr(mddev); 5682 } 5683 5684 /* seq_file implementation /proc/mdstat */ 5685 5686 static void status_unused(struct seq_file *seq) 5687 { 5688 int i = 0; 5689 mdk_rdev_t *rdev; 5690 5691 seq_printf(seq, "unused devices: "); 5692 5693 list_for_each_entry(rdev, &pending_raid_disks, same_set) { 5694 char b[BDEVNAME_SIZE]; 5695 i++; 5696 seq_printf(seq, "%s ", 5697 bdevname(rdev->bdev,b)); 5698 } 5699 if (!i) 5700 seq_printf(seq, "<none>"); 5701 5702 seq_printf(seq, "\n"); 5703 } 5704 5705 5706 static void status_resync(struct seq_file *seq, mddev_t * mddev) 5707 { 5708 sector_t max_sectors, resync, res; 5709 unsigned long dt, db; 5710 sector_t rt; 5711 int scale; 5712 unsigned int per_milli; 5713 5714 resync = mddev->curr_resync - atomic_read(&mddev->recovery_active); 5715 5716 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) 5717 max_sectors = mddev->resync_max_sectors; 5718 else 5719 max_sectors = mddev->dev_sectors; 5720 5721 /* 5722 * Should not happen. 5723 */ 5724 if (!max_sectors) { 5725 MD_BUG(); 5726 return; 5727 } 5728 /* Pick 'scale' such that (resync>>scale)*1000 will fit 5729 * in a sector_t, and (max_sectors>>scale) will fit in a 5730 * u32, as those are the requirements for sector_div. 5731 * Thus 'scale' must be at least 10 5732 */ 5733 scale = 10; 5734 if (sizeof(sector_t) > sizeof(unsigned long)) { 5735 while ( max_sectors/2 > (1ULL<<(scale+32))) 5736 scale++; 5737 } 5738 res = (resync>>scale)*1000; 5739 sector_div(res, (u32)((max_sectors>>scale)+1)); 5740 5741 per_milli = res; 5742 { 5743 int i, x = per_milli/50, y = 20-x; 5744 seq_printf(seq, "["); 5745 for (i = 0; i < x; i++) 5746 seq_printf(seq, "="); 5747 seq_printf(seq, ">"); 5748 for (i = 0; i < y; i++) 5749 seq_printf(seq, "."); 5750 seq_printf(seq, "] "); 5751 } 5752 seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)", 5753 (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)? 5754 "reshape" : 5755 (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)? 5756 "check" : 5757 (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ? 5758 "resync" : "recovery"))), 5759 per_milli/10, per_milli % 10, 5760 (unsigned long long) resync/2, 5761 (unsigned long long) max_sectors/2); 5762 5763 /* 5764 * dt: time from mark until now 5765 * db: blocks written from mark until now 5766 * rt: remaining time 5767 * 5768 * rt is a sector_t, so could be 32bit or 64bit. 5769 * So we divide before multiply in case it is 32bit and close 5770 * to the limit. 5771 * We scale the divisor (db) by 32 to avoid loosing precision 5772 * near the end of resync when the number of remaining sectors 5773 * is close to 'db'. 5774 * We then divide rt by 32 after multiplying by db to compensate. 5775 * The '+1' avoids division by zero if db is very small. 5776 */ 5777 dt = ((jiffies - mddev->resync_mark) / HZ); 5778 if (!dt) dt++; 5779 db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active)) 5780 - mddev->resync_mark_cnt; 5781 5782 rt = max_sectors - resync; /* number of remaining sectors */ 5783 sector_div(rt, db/32+1); 5784 rt *= dt; 5785 rt >>= 5; 5786 5787 seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60, 5788 ((unsigned long)rt % 60)/6); 5789 5790 seq_printf(seq, " speed=%ldK/sec", db/2/dt); 5791 } 5792 5793 static void *md_seq_start(struct seq_file *seq, loff_t *pos) 5794 { 5795 struct list_head *tmp; 5796 loff_t l = *pos; 5797 mddev_t *mddev; 5798 5799 if (l >= 0x10000) 5800 return NULL; 5801 if (!l--) 5802 /* header */ 5803 return (void*)1; 5804 5805 spin_lock(&all_mddevs_lock); 5806 list_for_each(tmp,&all_mddevs) 5807 if (!l--) { 5808 mddev = list_entry(tmp, mddev_t, all_mddevs); 5809 mddev_get(mddev); 5810 spin_unlock(&all_mddevs_lock); 5811 return mddev; 5812 } 5813 spin_unlock(&all_mddevs_lock); 5814 if (!l--) 5815 return (void*)2;/* tail */ 5816 return NULL; 5817 } 5818 5819 static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos) 5820 { 5821 struct list_head *tmp; 5822 mddev_t *next_mddev, *mddev = v; 5823 5824 ++*pos; 5825 if (v == (void*)2) 5826 return NULL; 5827 5828 spin_lock(&all_mddevs_lock); 5829 if (v == (void*)1) 5830 tmp = all_mddevs.next; 5831 else 5832 tmp = mddev->all_mddevs.next; 5833 if (tmp != &all_mddevs) 5834 next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs)); 5835 else { 5836 next_mddev = (void*)2; 5837 *pos = 0x10000; 5838 } 5839 spin_unlock(&all_mddevs_lock); 5840 5841 if (v != (void*)1) 5842 mddev_put(mddev); 5843 return next_mddev; 5844 5845 } 5846 5847 static void md_seq_stop(struct seq_file *seq, void *v) 5848 { 5849 mddev_t *mddev = v; 5850 5851 if (mddev && v != (void*)1 && v != (void*)2) 5852 mddev_put(mddev); 5853 } 5854 5855 struct mdstat_info { 5856 int event; 5857 }; 5858 5859 static int md_seq_show(struct seq_file *seq, void *v) 5860 { 5861 mddev_t *mddev = v; 5862 sector_t sectors; 5863 mdk_rdev_t *rdev; 5864 struct mdstat_info *mi = seq->private; 5865 struct bitmap *bitmap; 5866 5867 if (v == (void*)1) { 5868 struct mdk_personality *pers; 5869 seq_printf(seq, "Personalities : "); 5870 spin_lock(&pers_lock); 5871 list_for_each_entry(pers, &pers_list, list) 5872 seq_printf(seq, "[%s] ", pers->name); 5873 5874 spin_unlock(&pers_lock); 5875 seq_printf(seq, "\n"); 5876 mi->event = atomic_read(&md_event_count); 5877 return 0; 5878 } 5879 if (v == (void*)2) { 5880 status_unused(seq); 5881 return 0; 5882 } 5883 5884 if (mddev_lock(mddev) < 0) 5885 return -EINTR; 5886 5887 if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) { 5888 seq_printf(seq, "%s : %sactive", mdname(mddev), 5889 mddev->pers ? "" : "in"); 5890 if (mddev->pers) { 5891 if (mddev->ro==1) 5892 seq_printf(seq, " (read-only)"); 5893 if (mddev->ro==2) 5894 seq_printf(seq, " (auto-read-only)"); 5895 seq_printf(seq, " %s", mddev->pers->name); 5896 } 5897 5898 sectors = 0; 5899 list_for_each_entry(rdev, &mddev->disks, same_set) { 5900 char b[BDEVNAME_SIZE]; 5901 seq_printf(seq, " %s[%d]", 5902 bdevname(rdev->bdev,b), rdev->desc_nr); 5903 if (test_bit(WriteMostly, &rdev->flags)) 5904 seq_printf(seq, "(W)"); 5905 if (test_bit(Faulty, &rdev->flags)) { 5906 seq_printf(seq, "(F)"); 5907 continue; 5908 } else if (rdev->raid_disk < 0) 5909 seq_printf(seq, "(S)"); /* spare */ 5910 sectors += rdev->sectors; 5911 } 5912 5913 if (!list_empty(&mddev->disks)) { 5914 if (mddev->pers) 5915 seq_printf(seq, "\n %llu blocks", 5916 (unsigned long long) 5917 mddev->array_sectors / 2); 5918 else 5919 seq_printf(seq, "\n %llu blocks", 5920 (unsigned long long)sectors / 2); 5921 } 5922 if (mddev->persistent) { 5923 if (mddev->major_version != 0 || 5924 mddev->minor_version != 90) { 5925 seq_printf(seq," super %d.%d", 5926 mddev->major_version, 5927 mddev->minor_version); 5928 } 5929 } else if (mddev->external) 5930 seq_printf(seq, " super external:%s", 5931 mddev->metadata_type); 5932 else 5933 seq_printf(seq, " super non-persistent"); 5934 5935 if (mddev->pers) { 5936 mddev->pers->status(seq, mddev); 5937 seq_printf(seq, "\n "); 5938 if (mddev->pers->sync_request) { 5939 if (mddev->curr_resync > 2) { 5940 status_resync(seq, mddev); 5941 seq_printf(seq, "\n "); 5942 } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2) 5943 seq_printf(seq, "\tresync=DELAYED\n "); 5944 else if (mddev->recovery_cp < MaxSector) 5945 seq_printf(seq, "\tresync=PENDING\n "); 5946 } 5947 } else 5948 seq_printf(seq, "\n "); 5949 5950 if ((bitmap = mddev->bitmap)) { 5951 unsigned long chunk_kb; 5952 unsigned long flags; 5953 spin_lock_irqsave(&bitmap->lock, flags); 5954 chunk_kb = bitmap->chunksize >> 10; 5955 seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], " 5956 "%lu%s chunk", 5957 bitmap->pages - bitmap->missing_pages, 5958 bitmap->pages, 5959 (bitmap->pages - bitmap->missing_pages) 5960 << (PAGE_SHIFT - 10), 5961 chunk_kb ? chunk_kb : bitmap->chunksize, 5962 chunk_kb ? "KB" : "B"); 5963 if (bitmap->file) { 5964 seq_printf(seq, ", file: "); 5965 seq_path(seq, &bitmap->file->f_path, " \t\n"); 5966 } 5967 5968 seq_printf(seq, "\n"); 5969 spin_unlock_irqrestore(&bitmap->lock, flags); 5970 } 5971 5972 seq_printf(seq, "\n"); 5973 } 5974 mddev_unlock(mddev); 5975 5976 return 0; 5977 } 5978 5979 static const struct seq_operations md_seq_ops = { 5980 .start = md_seq_start, 5981 .next = md_seq_next, 5982 .stop = md_seq_stop, 5983 .show = md_seq_show, 5984 }; 5985 5986 static int md_seq_open(struct inode *inode, struct file *file) 5987 { 5988 int error; 5989 struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL); 5990 if (mi == NULL) 5991 return -ENOMEM; 5992 5993 error = seq_open(file, &md_seq_ops); 5994 if (error) 5995 kfree(mi); 5996 else { 5997 struct seq_file *p = file->private_data; 5998 p->private = mi; 5999 mi->event = atomic_read(&md_event_count); 6000 } 6001 return error; 6002 } 6003 6004 static unsigned int mdstat_poll(struct file *filp, poll_table *wait) 6005 { 6006 struct seq_file *m = filp->private_data; 6007 struct mdstat_info *mi = m->private; 6008 int mask; 6009 6010 poll_wait(filp, &md_event_waiters, wait); 6011 6012 /* always allow read */ 6013 mask = POLLIN | POLLRDNORM; 6014 6015 if (mi->event != atomic_read(&md_event_count)) 6016 mask |= POLLERR | POLLPRI; 6017 return mask; 6018 } 6019 6020 static const struct file_operations md_seq_fops = { 6021 .owner = THIS_MODULE, 6022 .open = md_seq_open, 6023 .read = seq_read, 6024 .llseek = seq_lseek, 6025 .release = seq_release_private, 6026 .poll = mdstat_poll, 6027 }; 6028 6029 int register_md_personality(struct mdk_personality *p) 6030 { 6031 spin_lock(&pers_lock); 6032 list_add_tail(&p->list, &pers_list); 6033 printk(KERN_INFO "md: %s personality registered for level %d\n", p->name, p->level); 6034 spin_unlock(&pers_lock); 6035 return 0; 6036 } 6037 6038 int unregister_md_personality(struct mdk_personality *p) 6039 { 6040 printk(KERN_INFO "md: %s personality unregistered\n", p->name); 6041 spin_lock(&pers_lock); 6042 list_del_init(&p->list); 6043 spin_unlock(&pers_lock); 6044 return 0; 6045 } 6046 6047 static int is_mddev_idle(mddev_t *mddev, int init) 6048 { 6049 mdk_rdev_t * rdev; 6050 int idle; 6051 int curr_events; 6052 6053 idle = 1; 6054 rcu_read_lock(); 6055 rdev_for_each_rcu(rdev, mddev) { 6056 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk; 6057 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 6058 (int)part_stat_read(&disk->part0, sectors[1]) - 6059 atomic_read(&disk->sync_io); 6060 /* sync IO will cause sync_io to increase before the disk_stats 6061 * as sync_io is counted when a request starts, and 6062 * disk_stats is counted when it completes. 6063 * So resync activity will cause curr_events to be smaller than 6064 * when there was no such activity. 6065 * non-sync IO will cause disk_stat to increase without 6066 * increasing sync_io so curr_events will (eventually) 6067 * be larger than it was before. Once it becomes 6068 * substantially larger, the test below will cause 6069 * the array to appear non-idle, and resync will slow 6070 * down. 6071 * If there is a lot of outstanding resync activity when 6072 * we set last_event to curr_events, then all that activity 6073 * completing might cause the array to appear non-idle 6074 * and resync will be slowed down even though there might 6075 * not have been non-resync activity. This will only 6076 * happen once though. 'last_events' will soon reflect 6077 * the state where there is little or no outstanding 6078 * resync requests, and further resync activity will 6079 * always make curr_events less than last_events. 6080 * 6081 */ 6082 if (init || curr_events - rdev->last_events > 64) { 6083 rdev->last_events = curr_events; 6084 idle = 0; 6085 } 6086 } 6087 rcu_read_unlock(); 6088 return idle; 6089 } 6090 6091 void md_done_sync(mddev_t *mddev, int blocks, int ok) 6092 { 6093 /* another "blocks" (512byte) blocks have been synced */ 6094 atomic_sub(blocks, &mddev->recovery_active); 6095 wake_up(&mddev->recovery_wait); 6096 if (!ok) { 6097 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 6098 md_wakeup_thread(mddev->thread); 6099 // stop recovery, signal do_sync .... 6100 } 6101 } 6102 6103 6104 /* md_write_start(mddev, bi) 6105 * If we need to update some array metadata (e.g. 'active' flag 6106 * in superblock) before writing, schedule a superblock update 6107 * and wait for it to complete. 6108 */ 6109 void md_write_start(mddev_t *mddev, struct bio *bi) 6110 { 6111 int did_change = 0; 6112 if (bio_data_dir(bi) != WRITE) 6113 return; 6114 6115 BUG_ON(mddev->ro == 1); 6116 if (mddev->ro == 2) { 6117 /* need to switch to read/write */ 6118 mddev->ro = 0; 6119 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 6120 md_wakeup_thread(mddev->thread); 6121 md_wakeup_thread(mddev->sync_thread); 6122 did_change = 1; 6123 } 6124 atomic_inc(&mddev->writes_pending); 6125 if (mddev->safemode == 1) 6126 mddev->safemode = 0; 6127 if (mddev->in_sync) { 6128 spin_lock_irq(&mddev->write_lock); 6129 if (mddev->in_sync) { 6130 mddev->in_sync = 0; 6131 set_bit(MD_CHANGE_CLEAN, &mddev->flags); 6132 md_wakeup_thread(mddev->thread); 6133 did_change = 1; 6134 } 6135 spin_unlock_irq(&mddev->write_lock); 6136 } 6137 if (did_change) 6138 sysfs_notify_dirent(mddev->sysfs_state); 6139 wait_event(mddev->sb_wait, 6140 !test_bit(MD_CHANGE_CLEAN, &mddev->flags) && 6141 !test_bit(MD_CHANGE_PENDING, &mddev->flags)); 6142 } 6143 6144 void md_write_end(mddev_t *mddev) 6145 { 6146 if (atomic_dec_and_test(&mddev->writes_pending)) { 6147 if (mddev->safemode == 2) 6148 md_wakeup_thread(mddev->thread); 6149 else if (mddev->safemode_delay) 6150 mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay); 6151 } 6152 } 6153 6154 /* md_allow_write(mddev) 6155 * Calling this ensures that the array is marked 'active' so that writes 6156 * may proceed without blocking. It is important to call this before 6157 * attempting a GFP_KERNEL allocation while holding the mddev lock. 6158 * Must be called with mddev_lock held. 6159 * 6160 * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock 6161 * is dropped, so return -EAGAIN after notifying userspace. 6162 */ 6163 int md_allow_write(mddev_t *mddev) 6164 { 6165 if (!mddev->pers) 6166 return 0; 6167 if (mddev->ro) 6168 return 0; 6169 if (!mddev->pers->sync_request) 6170 return 0; 6171 6172 spin_lock_irq(&mddev->write_lock); 6173 if (mddev->in_sync) { 6174 mddev->in_sync = 0; 6175 set_bit(MD_CHANGE_CLEAN, &mddev->flags); 6176 if (mddev->safemode_delay && 6177 mddev->safemode == 0) 6178 mddev->safemode = 1; 6179 spin_unlock_irq(&mddev->write_lock); 6180 md_update_sb(mddev, 0); 6181 sysfs_notify_dirent(mddev->sysfs_state); 6182 } else 6183 spin_unlock_irq(&mddev->write_lock); 6184 6185 if (test_bit(MD_CHANGE_CLEAN, &mddev->flags)) 6186 return -EAGAIN; 6187 else 6188 return 0; 6189 } 6190 EXPORT_SYMBOL_GPL(md_allow_write); 6191 6192 #define SYNC_MARKS 10 6193 #define SYNC_MARK_STEP (3*HZ) 6194 void md_do_sync(mddev_t *mddev) 6195 { 6196 mddev_t *mddev2; 6197 unsigned int currspeed = 0, 6198 window; 6199 sector_t max_sectors,j, io_sectors; 6200 unsigned long mark[SYNC_MARKS]; 6201 sector_t mark_cnt[SYNC_MARKS]; 6202 int last_mark,m; 6203 struct list_head *tmp; 6204 sector_t last_check; 6205 int skipped = 0; 6206 mdk_rdev_t *rdev; 6207 char *desc; 6208 6209 /* just incase thread restarts... */ 6210 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery)) 6211 return; 6212 if (mddev->ro) /* never try to sync a read-only array */ 6213 return; 6214 6215 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) { 6216 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) 6217 desc = "data-check"; 6218 else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) 6219 desc = "requested-resync"; 6220 else 6221 desc = "resync"; 6222 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) 6223 desc = "reshape"; 6224 else 6225 desc = "recovery"; 6226 6227 /* we overload curr_resync somewhat here. 6228 * 0 == not engaged in resync at all 6229 * 2 == checking that there is no conflict with another sync 6230 * 1 == like 2, but have yielded to allow conflicting resync to 6231 * commense 6232 * other == active in resync - this many blocks 6233 * 6234 * Before starting a resync we must have set curr_resync to 6235 * 2, and then checked that every "conflicting" array has curr_resync 6236 * less than ours. When we find one that is the same or higher 6237 * we wait on resync_wait. To avoid deadlock, we reduce curr_resync 6238 * to 1 if we choose to yield (based arbitrarily on address of mddev structure). 6239 * This will mean we have to start checking from the beginning again. 6240 * 6241 */ 6242 6243 do { 6244 mddev->curr_resync = 2; 6245 6246 try_again: 6247 if (kthread_should_stop()) { 6248 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 6249 goto skip; 6250 } 6251 for_each_mddev(mddev2, tmp) { 6252 if (mddev2 == mddev) 6253 continue; 6254 if (!mddev->parallel_resync 6255 && mddev2->curr_resync 6256 && match_mddev_units(mddev, mddev2)) { 6257 DEFINE_WAIT(wq); 6258 if (mddev < mddev2 && mddev->curr_resync == 2) { 6259 /* arbitrarily yield */ 6260 mddev->curr_resync = 1; 6261 wake_up(&resync_wait); 6262 } 6263 if (mddev > mddev2 && mddev->curr_resync == 1) 6264 /* no need to wait here, we can wait the next 6265 * time 'round when curr_resync == 2 6266 */ 6267 continue; 6268 /* We need to wait 'interruptible' so as not to 6269 * contribute to the load average, and not to 6270 * be caught by 'softlockup' 6271 */ 6272 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE); 6273 if (!kthread_should_stop() && 6274 mddev2->curr_resync >= mddev->curr_resync) { 6275 printk(KERN_INFO "md: delaying %s of %s" 6276 " until %s has finished (they" 6277 " share one or more physical units)\n", 6278 desc, mdname(mddev), mdname(mddev2)); 6279 mddev_put(mddev2); 6280 if (signal_pending(current)) 6281 flush_signals(current); 6282 schedule(); 6283 finish_wait(&resync_wait, &wq); 6284 goto try_again; 6285 } 6286 finish_wait(&resync_wait, &wq); 6287 } 6288 } 6289 } while (mddev->curr_resync < 2); 6290 6291 j = 0; 6292 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) { 6293 /* resync follows the size requested by the personality, 6294 * which defaults to physical size, but can be virtual size 6295 */ 6296 max_sectors = mddev->resync_max_sectors; 6297 mddev->resync_mismatches = 0; 6298 /* we don't use the checkpoint if there's a bitmap */ 6299 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) 6300 j = mddev->resync_min; 6301 else if (!mddev->bitmap) 6302 j = mddev->recovery_cp; 6303 6304 } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) 6305 max_sectors = mddev->dev_sectors; 6306 else { 6307 /* recovery follows the physical size of devices */ 6308 max_sectors = mddev->dev_sectors; 6309 j = MaxSector; 6310 list_for_each_entry(rdev, &mddev->disks, same_set) 6311 if (rdev->raid_disk >= 0 && 6312 !test_bit(Faulty, &rdev->flags) && 6313 !test_bit(In_sync, &rdev->flags) && 6314 rdev->recovery_offset < j) 6315 j = rdev->recovery_offset; 6316 } 6317 6318 printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev)); 6319 printk(KERN_INFO "md: minimum _guaranteed_ speed:" 6320 " %d KB/sec/disk.\n", speed_min(mddev)); 6321 printk(KERN_INFO "md: using maximum available idle IO bandwidth " 6322 "(but not more than %d KB/sec) for %s.\n", 6323 speed_max(mddev), desc); 6324 6325 is_mddev_idle(mddev, 1); /* this initializes IO event counters */ 6326 6327 io_sectors = 0; 6328 for (m = 0; m < SYNC_MARKS; m++) { 6329 mark[m] = jiffies; 6330 mark_cnt[m] = io_sectors; 6331 } 6332 last_mark = 0; 6333 mddev->resync_mark = mark[last_mark]; 6334 mddev->resync_mark_cnt = mark_cnt[last_mark]; 6335 6336 /* 6337 * Tune reconstruction: 6338 */ 6339 window = 32*(PAGE_SIZE/512); 6340 printk(KERN_INFO "md: using %dk window, over a total of %llu blocks.\n", 6341 window/2,(unsigned long long) max_sectors/2); 6342 6343 atomic_set(&mddev->recovery_active, 0); 6344 last_check = 0; 6345 6346 if (j>2) { 6347 printk(KERN_INFO 6348 "md: resuming %s of %s from checkpoint.\n", 6349 desc, mdname(mddev)); 6350 mddev->curr_resync = j; 6351 } 6352 6353 while (j < max_sectors) { 6354 sector_t sectors; 6355 6356 skipped = 0; 6357 6358 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 6359 ((mddev->curr_resync > mddev->curr_resync_completed && 6360 (mddev->curr_resync - mddev->curr_resync_completed) 6361 > (max_sectors >> 4)) || 6362 (j - mddev->curr_resync_completed)*2 6363 >= mddev->resync_max - mddev->curr_resync_completed 6364 )) { 6365 /* time to update curr_resync_completed */ 6366 blk_unplug(mddev->queue); 6367 wait_event(mddev->recovery_wait, 6368 atomic_read(&mddev->recovery_active) == 0); 6369 mddev->curr_resync_completed = 6370 mddev->curr_resync; 6371 set_bit(MD_CHANGE_CLEAN, &mddev->flags); 6372 sysfs_notify(&mddev->kobj, NULL, "sync_completed"); 6373 } 6374 6375 while (j >= mddev->resync_max && !kthread_should_stop()) { 6376 /* As this condition is controlled by user-space, 6377 * we can block indefinitely, so use '_interruptible' 6378 * to avoid triggering warnings. 6379 */ 6380 flush_signals(current); /* just in case */ 6381 wait_event_interruptible(mddev->recovery_wait, 6382 mddev->resync_max > j 6383 || kthread_should_stop()); 6384 } 6385 6386 if (kthread_should_stop()) 6387 goto interrupted; 6388 6389 sectors = mddev->pers->sync_request(mddev, j, &skipped, 6390 currspeed < speed_min(mddev)); 6391 if (sectors == 0) { 6392 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 6393 goto out; 6394 } 6395 6396 if (!skipped) { /* actual IO requested */ 6397 io_sectors += sectors; 6398 atomic_add(sectors, &mddev->recovery_active); 6399 } 6400 6401 j += sectors; 6402 if (j>1) mddev->curr_resync = j; 6403 mddev->curr_mark_cnt = io_sectors; 6404 if (last_check == 0) 6405 /* this is the earliers that rebuilt will be 6406 * visible in /proc/mdstat 6407 */ 6408 md_new_event(mddev); 6409 6410 if (last_check + window > io_sectors || j == max_sectors) 6411 continue; 6412 6413 last_check = io_sectors; 6414 6415 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) 6416 break; 6417 6418 repeat: 6419 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) { 6420 /* step marks */ 6421 int next = (last_mark+1) % SYNC_MARKS; 6422 6423 mddev->resync_mark = mark[next]; 6424 mddev->resync_mark_cnt = mark_cnt[next]; 6425 mark[next] = jiffies; 6426 mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active); 6427 last_mark = next; 6428 } 6429 6430 6431 if (kthread_should_stop()) 6432 goto interrupted; 6433 6434 6435 /* 6436 * this loop exits only if either when we are slower than 6437 * the 'hard' speed limit, or the system was IO-idle for 6438 * a jiffy. 6439 * the system might be non-idle CPU-wise, but we only care 6440 * about not overloading the IO subsystem. (things like an 6441 * e2fsck being done on the RAID array should execute fast) 6442 */ 6443 blk_unplug(mddev->queue); 6444 cond_resched(); 6445 6446 currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2 6447 /((jiffies-mddev->resync_mark)/HZ +1) +1; 6448 6449 if (currspeed > speed_min(mddev)) { 6450 if ((currspeed > speed_max(mddev)) || 6451 !is_mddev_idle(mddev, 0)) { 6452 msleep(500); 6453 goto repeat; 6454 } 6455 } 6456 } 6457 printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc); 6458 /* 6459 * this also signals 'finished resyncing' to md_stop 6460 */ 6461 out: 6462 blk_unplug(mddev->queue); 6463 6464 wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active)); 6465 6466 /* tell personality that we are finished */ 6467 mddev->pers->sync_request(mddev, max_sectors, &skipped, 1); 6468 6469 if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) && 6470 mddev->curr_resync > 2) { 6471 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) { 6472 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) { 6473 if (mddev->curr_resync >= mddev->recovery_cp) { 6474 printk(KERN_INFO 6475 "md: checkpointing %s of %s.\n", 6476 desc, mdname(mddev)); 6477 mddev->recovery_cp = mddev->curr_resync; 6478 } 6479 } else 6480 mddev->recovery_cp = MaxSector; 6481 } else { 6482 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) 6483 mddev->curr_resync = MaxSector; 6484 list_for_each_entry(rdev, &mddev->disks, same_set) 6485 if (rdev->raid_disk >= 0 && 6486 !test_bit(Faulty, &rdev->flags) && 6487 !test_bit(In_sync, &rdev->flags) && 6488 rdev->recovery_offset < mddev->curr_resync) 6489 rdev->recovery_offset = mddev->curr_resync; 6490 } 6491 } 6492 set_bit(MD_CHANGE_DEVS, &mddev->flags); 6493 6494 skip: 6495 mddev->curr_resync = 0; 6496 mddev->curr_resync_completed = 0; 6497 mddev->resync_min = 0; 6498 mddev->resync_max = MaxSector; 6499 sysfs_notify(&mddev->kobj, NULL, "sync_completed"); 6500 wake_up(&resync_wait); 6501 set_bit(MD_RECOVERY_DONE, &mddev->recovery); 6502 md_wakeup_thread(mddev->thread); 6503 return; 6504 6505 interrupted: 6506 /* 6507 * got a signal, exit. 6508 */ 6509 printk(KERN_INFO 6510 "md: md_do_sync() got signal ... exiting\n"); 6511 set_bit(MD_RECOVERY_INTR, &mddev->recovery); 6512 goto out; 6513 6514 } 6515 EXPORT_SYMBOL_GPL(md_do_sync); 6516 6517 6518 static int remove_and_add_spares(mddev_t *mddev) 6519 { 6520 mdk_rdev_t *rdev; 6521 int spares = 0; 6522 6523 mddev->curr_resync_completed = 0; 6524 6525 list_for_each_entry(rdev, &mddev->disks, same_set) 6526 if (rdev->raid_disk >= 0 && 6527 !test_bit(Blocked, &rdev->flags) && 6528 (test_bit(Faulty, &rdev->flags) || 6529 ! test_bit(In_sync, &rdev->flags)) && 6530 atomic_read(&rdev->nr_pending)==0) { 6531 if (mddev->pers->hot_remove_disk( 6532 mddev, rdev->raid_disk)==0) { 6533 char nm[20]; 6534 sprintf(nm,"rd%d", rdev->raid_disk); 6535 sysfs_remove_link(&mddev->kobj, nm); 6536 rdev->raid_disk = -1; 6537 } 6538 } 6539 6540 if (mddev->degraded && ! mddev->ro && !mddev->recovery_disabled) { 6541 list_for_each_entry(rdev, &mddev->disks, same_set) { 6542 if (rdev->raid_disk >= 0 && 6543 !test_bit(In_sync, &rdev->flags) && 6544 !test_bit(Blocked, &rdev->flags)) 6545 spares++; 6546 if (rdev->raid_disk < 0 6547 && !test_bit(Faulty, &rdev->flags)) { 6548 rdev->recovery_offset = 0; 6549 if (mddev->pers-> 6550 hot_add_disk(mddev, rdev) == 0) { 6551 char nm[20]; 6552 sprintf(nm, "rd%d", rdev->raid_disk); 6553 if (sysfs_create_link(&mddev->kobj, 6554 &rdev->kobj, nm)) 6555 printk(KERN_WARNING 6556 "md: cannot register " 6557 "%s for %s\n", 6558 nm, mdname(mddev)); 6559 spares++; 6560 md_new_event(mddev); 6561 } else 6562 break; 6563 } 6564 } 6565 } 6566 return spares; 6567 } 6568 /* 6569 * This routine is regularly called by all per-raid-array threads to 6570 * deal with generic issues like resync and super-block update. 6571 * Raid personalities that don't have a thread (linear/raid0) do not 6572 * need this as they never do any recovery or update the superblock. 6573 * 6574 * It does not do any resync itself, but rather "forks" off other threads 6575 * to do that as needed. 6576 * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in 6577 * "->recovery" and create a thread at ->sync_thread. 6578 * When the thread finishes it sets MD_RECOVERY_DONE 6579 * and wakeups up this thread which will reap the thread and finish up. 6580 * This thread also removes any faulty devices (with nr_pending == 0). 6581 * 6582 * The overall approach is: 6583 * 1/ if the superblock needs updating, update it. 6584 * 2/ If a recovery thread is running, don't do anything else. 6585 * 3/ If recovery has finished, clean up, possibly marking spares active. 6586 * 4/ If there are any faulty devices, remove them. 6587 * 5/ If array is degraded, try to add spares devices 6588 * 6/ If array has spares or is not in-sync, start a resync thread. 6589 */ 6590 void md_check_recovery(mddev_t *mddev) 6591 { 6592 mdk_rdev_t *rdev; 6593 6594 6595 if (mddev->bitmap) 6596 bitmap_daemon_work(mddev->bitmap); 6597 6598 if (mddev->ro) 6599 return; 6600 6601 if (signal_pending(current)) { 6602 if (mddev->pers->sync_request && !mddev->external) { 6603 printk(KERN_INFO "md: %s in immediate safe mode\n", 6604 mdname(mddev)); 6605 mddev->safemode = 2; 6606 } 6607 flush_signals(current); 6608 } 6609 6610 if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) 6611 return; 6612 if ( ! ( 6613 (mddev->flags && !mddev->external) || 6614 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) || 6615 test_bit(MD_RECOVERY_DONE, &mddev->recovery) || 6616 (mddev->external == 0 && mddev->safemode == 1) || 6617 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending) 6618 && !mddev->in_sync && mddev->recovery_cp == MaxSector) 6619 )) 6620 return; 6621 6622 if (mddev_trylock(mddev)) { 6623 int spares = 0; 6624 6625 if (mddev->ro) { 6626 /* Only thing we do on a ro array is remove 6627 * failed devices. 6628 */ 6629 remove_and_add_spares(mddev); 6630 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 6631 goto unlock; 6632 } 6633 6634 if (!mddev->external) { 6635 int did_change = 0; 6636 spin_lock_irq(&mddev->write_lock); 6637 if (mddev->safemode && 6638 !atomic_read(&mddev->writes_pending) && 6639 !mddev->in_sync && 6640 mddev->recovery_cp == MaxSector) { 6641 mddev->in_sync = 1; 6642 did_change = 1; 6643 if (mddev->persistent) 6644 set_bit(MD_CHANGE_CLEAN, &mddev->flags); 6645 } 6646 if (mddev->safemode == 1) 6647 mddev->safemode = 0; 6648 spin_unlock_irq(&mddev->write_lock); 6649 if (did_change) 6650 sysfs_notify_dirent(mddev->sysfs_state); 6651 } 6652 6653 if (mddev->flags) 6654 md_update_sb(mddev, 0); 6655 6656 list_for_each_entry(rdev, &mddev->disks, same_set) 6657 if (test_and_clear_bit(StateChanged, &rdev->flags)) 6658 sysfs_notify_dirent(rdev->sysfs_state); 6659 6660 6661 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) && 6662 !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) { 6663 /* resync/recovery still happening */ 6664 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 6665 goto unlock; 6666 } 6667 if (mddev->sync_thread) { 6668 /* resync has finished, collect result */ 6669 md_unregister_thread(mddev->sync_thread); 6670 mddev->sync_thread = NULL; 6671 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) && 6672 !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) { 6673 /* success...*/ 6674 /* activate any spares */ 6675 if (mddev->pers->spare_active(mddev)) 6676 sysfs_notify(&mddev->kobj, NULL, 6677 "degraded"); 6678 } 6679 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) && 6680 mddev->pers->finish_reshape) 6681 mddev->pers->finish_reshape(mddev); 6682 md_update_sb(mddev, 1); 6683 6684 /* if array is no-longer degraded, then any saved_raid_disk 6685 * information must be scrapped 6686 */ 6687 if (!mddev->degraded) 6688 list_for_each_entry(rdev, &mddev->disks, same_set) 6689 rdev->saved_raid_disk = -1; 6690 6691 mddev->recovery = 0; 6692 /* flag recovery needed just to double check */ 6693 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 6694 sysfs_notify_dirent(mddev->sysfs_action); 6695 md_new_event(mddev); 6696 goto unlock; 6697 } 6698 /* Set RUNNING before clearing NEEDED to avoid 6699 * any transients in the value of "sync_action". 6700 */ 6701 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery); 6702 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery); 6703 /* Clear some bits that don't mean anything, but 6704 * might be left set 6705 */ 6706 clear_bit(MD_RECOVERY_INTR, &mddev->recovery); 6707 clear_bit(MD_RECOVERY_DONE, &mddev->recovery); 6708 6709 if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) 6710 goto unlock; 6711 /* no recovery is running. 6712 * remove any failed drives, then 6713 * add spares if possible. 6714 * Spare are also removed and re-added, to allow 6715 * the personality to fail the re-add. 6716 */ 6717 6718 if (mddev->reshape_position != MaxSector) { 6719 if (mddev->pers->check_reshape == NULL || 6720 mddev->pers->check_reshape(mddev) != 0) 6721 /* Cannot proceed */ 6722 goto unlock; 6723 set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery); 6724 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 6725 } else if ((spares = remove_and_add_spares(mddev))) { 6726 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery); 6727 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery); 6728 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery); 6729 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 6730 } else if (mddev->recovery_cp < MaxSector) { 6731 set_bit(MD_RECOVERY_SYNC, &mddev->recovery); 6732 clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery); 6733 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) 6734 /* nothing to be done ... */ 6735 goto unlock; 6736 6737 if (mddev->pers->sync_request) { 6738 if (spares && mddev->bitmap && ! mddev->bitmap->file) { 6739 /* We are adding a device or devices to an array 6740 * which has the bitmap stored on all devices. 6741 * So make sure all bitmap pages get written 6742 */ 6743 bitmap_write_all(mddev->bitmap); 6744 } 6745 mddev->sync_thread = md_register_thread(md_do_sync, 6746 mddev, 6747 "%s_resync"); 6748 if (!mddev->sync_thread) { 6749 printk(KERN_ERR "%s: could not start resync" 6750 " thread...\n", 6751 mdname(mddev)); 6752 /* leave the spares where they are, it shouldn't hurt */ 6753 mddev->recovery = 0; 6754 } else 6755 md_wakeup_thread(mddev->sync_thread); 6756 sysfs_notify_dirent(mddev->sysfs_action); 6757 md_new_event(mddev); 6758 } 6759 unlock: 6760 if (!mddev->sync_thread) { 6761 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery); 6762 if (test_and_clear_bit(MD_RECOVERY_RECOVER, 6763 &mddev->recovery)) 6764 if (mddev->sysfs_action) 6765 sysfs_notify_dirent(mddev->sysfs_action); 6766 } 6767 mddev_unlock(mddev); 6768 } 6769 } 6770 6771 void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev) 6772 { 6773 sysfs_notify_dirent(rdev->sysfs_state); 6774 wait_event_timeout(rdev->blocked_wait, 6775 !test_bit(Blocked, &rdev->flags), 6776 msecs_to_jiffies(5000)); 6777 rdev_dec_pending(rdev, mddev); 6778 } 6779 EXPORT_SYMBOL(md_wait_for_blocked_rdev); 6780 6781 static int md_notify_reboot(struct notifier_block *this, 6782 unsigned long code, void *x) 6783 { 6784 struct list_head *tmp; 6785 mddev_t *mddev; 6786 6787 if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) { 6788 6789 printk(KERN_INFO "md: stopping all md devices.\n"); 6790 6791 for_each_mddev(mddev, tmp) 6792 if (mddev_trylock(mddev)) { 6793 /* Force a switch to readonly even array 6794 * appears to still be in use. Hence 6795 * the '100'. 6796 */ 6797 do_md_stop(mddev, 1, 100); 6798 mddev_unlock(mddev); 6799 } 6800 /* 6801 * certain more exotic SCSI devices are known to be 6802 * volatile wrt too early system reboots. While the 6803 * right place to handle this issue is the given 6804 * driver, we do want to have a safe RAID driver ... 6805 */ 6806 mdelay(1000*1); 6807 } 6808 return NOTIFY_DONE; 6809 } 6810 6811 static struct notifier_block md_notifier = { 6812 .notifier_call = md_notify_reboot, 6813 .next = NULL, 6814 .priority = INT_MAX, /* before any real devices */ 6815 }; 6816 6817 static void md_geninit(void) 6818 { 6819 dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t)); 6820 6821 proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops); 6822 } 6823 6824 static int __init md_init(void) 6825 { 6826 if (register_blkdev(MD_MAJOR, "md")) 6827 return -1; 6828 if ((mdp_major=register_blkdev(0, "mdp"))<=0) { 6829 unregister_blkdev(MD_MAJOR, "md"); 6830 return -1; 6831 } 6832 blk_register_region(MKDEV(MD_MAJOR, 0), 1UL<<MINORBITS, THIS_MODULE, 6833 md_probe, NULL, NULL); 6834 blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE, 6835 md_probe, NULL, NULL); 6836 6837 register_reboot_notifier(&md_notifier); 6838 raid_table_header = register_sysctl_table(raid_root_table); 6839 6840 md_geninit(); 6841 return 0; 6842 } 6843 6844 6845 #ifndef MODULE 6846 6847 /* 6848 * Searches all registered partitions for autorun RAID arrays 6849 * at boot time. 6850 */ 6851 6852 static LIST_HEAD(all_detected_devices); 6853 struct detected_devices_node { 6854 struct list_head list; 6855 dev_t dev; 6856 }; 6857 6858 void md_autodetect_dev(dev_t dev) 6859 { 6860 struct detected_devices_node *node_detected_dev; 6861 6862 node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL); 6863 if (node_detected_dev) { 6864 node_detected_dev->dev = dev; 6865 list_add_tail(&node_detected_dev->list, &all_detected_devices); 6866 } else { 6867 printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed" 6868 ", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev)); 6869 } 6870 } 6871 6872 6873 static void autostart_arrays(int part) 6874 { 6875 mdk_rdev_t *rdev; 6876 struct detected_devices_node *node_detected_dev; 6877 dev_t dev; 6878 int i_scanned, i_passed; 6879 6880 i_scanned = 0; 6881 i_passed = 0; 6882 6883 printk(KERN_INFO "md: Autodetecting RAID arrays.\n"); 6884 6885 while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) { 6886 i_scanned++; 6887 node_detected_dev = list_entry(all_detected_devices.next, 6888 struct detected_devices_node, list); 6889 list_del(&node_detected_dev->list); 6890 dev = node_detected_dev->dev; 6891 kfree(node_detected_dev); 6892 rdev = md_import_device(dev,0, 90); 6893 if (IS_ERR(rdev)) 6894 continue; 6895 6896 if (test_bit(Faulty, &rdev->flags)) { 6897 MD_BUG(); 6898 continue; 6899 } 6900 set_bit(AutoDetected, &rdev->flags); 6901 list_add(&rdev->same_set, &pending_raid_disks); 6902 i_passed++; 6903 } 6904 6905 printk(KERN_INFO "md: Scanned %d and added %d devices.\n", 6906 i_scanned, i_passed); 6907 6908 autorun_devices(part); 6909 } 6910 6911 #endif /* !MODULE */ 6912 6913 static __exit void md_exit(void) 6914 { 6915 mddev_t *mddev; 6916 struct list_head *tmp; 6917 6918 blk_unregister_region(MKDEV(MD_MAJOR,0), 1U << MINORBITS); 6919 blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS); 6920 6921 unregister_blkdev(MD_MAJOR,"md"); 6922 unregister_blkdev(mdp_major, "mdp"); 6923 unregister_reboot_notifier(&md_notifier); 6924 unregister_sysctl_table(raid_table_header); 6925 remove_proc_entry("mdstat", NULL); 6926 for_each_mddev(mddev, tmp) { 6927 export_array(mddev); 6928 mddev->hold_active = 0; 6929 } 6930 } 6931 6932 subsys_initcall(md_init); 6933 module_exit(md_exit) 6934 6935 static int get_ro(char *buffer, struct kernel_param *kp) 6936 { 6937 return sprintf(buffer, "%d", start_readonly); 6938 } 6939 static int set_ro(const char *val, struct kernel_param *kp) 6940 { 6941 char *e; 6942 int num = simple_strtoul(val, &e, 10); 6943 if (*val && (*e == '\0' || *e == '\n')) { 6944 start_readonly = num; 6945 return 0; 6946 } 6947 return -EINVAL; 6948 } 6949 6950 module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR); 6951 module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR); 6952 6953 module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR); 6954 6955 EXPORT_SYMBOL(register_md_personality); 6956 EXPORT_SYMBOL(unregister_md_personality); 6957 EXPORT_SYMBOL(md_error); 6958 EXPORT_SYMBOL(md_done_sync); 6959 EXPORT_SYMBOL(md_write_start); 6960 EXPORT_SYMBOL(md_write_end); 6961 EXPORT_SYMBOL(md_register_thread); 6962 EXPORT_SYMBOL(md_unregister_thread); 6963 EXPORT_SYMBOL(md_wakeup_thread); 6964 EXPORT_SYMBOL(md_check_recovery); 6965 MODULE_LICENSE("GPL"); 6966 MODULE_ALIAS("md"); 6967 MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR); 6968