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