drivers/md/md.c

   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/module.h>
  36 #include <linux/config.h>
  37 #include <linux/kthread.h>
  38 #include <linux/linkage.h>
  39 #include <linux/raid/md.h>
  40 #include <linux/raid/bitmap.h>
  41 #include <linux/sysctl.h>
  42 #include <linux/devfs_fs_kernel.h>
  43 #include <linux/buffer_head.h> /* for invalidate_bdev */
  44 #include <linux/suspend.h>
  45 #include <linux/poll.h>
  46
  47 #include <linux/init.h>
  48
  49 #include <linux/file.h>
  50
  51 #ifdef CONFIG_KMOD
  52 #include <linux/kmod.h>
  53 #endif
  54
  55 #include <asm/unaligned.h>
  56
  57 #define MAJOR_NR MD_MAJOR
  58 #define MD_DRIVER
  59
  60 /* 63 partitions with the alternate major number (mdp) */
  61 #define MdpMinorShift 6
  62
  63 #define DEBUG 0
  64 #define dprintk(x...) ((void)(DEBUG && printk(x)))
  65
  66
  67 #ifndef MODULE
  68 static void autostart_arrays (int part);
  69 #endif
  70
  71 static LIST_HEAD(pers_list);
  72 static DEFINE_SPINLOCK(pers_lock);
  73
  74 /*
  75  * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
  76  * is 1000 KB/sec, so the extra system load does not show up that much.
  77  * Increase it if you want to have more _guaranteed_ speed. Note that
  78  * the RAID driver will use the maximum available bandwidth if the IO
  79  * subsystem is idle. There is also an 'absolute maximum' reconstruction
  80  * speed limit - in case reconstruction slows down your system despite
  81  * idle IO detection.
  82  *
  83  * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
  84  * or /sys/block/mdX/md/sync_speed_{min,max}
  85  */
  86
  87 static int sysctl_speed_limit_min = 1000;
  88 static int sysctl_speed_limit_max = 200000;
  89 static inline int speed_min(mddev_t *mddev)
  90 {
  91         return mddev->sync_speed_min ?
  92                 mddev->sync_speed_min : sysctl_speed_limit_min;
  93 }
  94
  95 static inline int speed_max(mddev_t *mddev)
  96 {
  97         return mddev->sync_speed_max ?
  98                 mddev->sync_speed_max : sysctl_speed_limit_max;
  99 }
 100
 101 static struct ctl_table_header *raid_table_header;
 102
 103 static ctl_table raid_table[] = {
 104         {
 105                 .ctl_name       = DEV_RAID_SPEED_LIMIT_MIN,
 106                 .procname       = "speed_limit_min",
 107                 .data           = &sysctl_speed_limit_min,
 108                 .maxlen         = sizeof(int),
 109                 .mode           = 0644,
 110                 .proc_handler   = &proc_dointvec,
 111         },
 112         {
 113                 .ctl_name       = DEV_RAID_SPEED_LIMIT_MAX,
 114                 .procname       = "speed_limit_max",
 115                 .data           = &sysctl_speed_limit_max,
 116                 .maxlen         = sizeof(int),
 117                 .mode           = 0644,
 118                 .proc_handler   = &proc_dointvec,
 119         },
 120         { .ctl_name = 0 }
 121 };
 122
 123 static ctl_table raid_dir_table[] = {
 124         {
 125                 .ctl_name       = DEV_RAID,
 126                 .procname       = "raid",
 127                 .maxlen         = 0,
 128                 .mode           = 0555,
 129                 .child          = raid_table,
 130         },
 131         { .ctl_name = 0 }
 132 };
 133
 134 static ctl_table raid_root_table[] = {
 135         {
 136                 .ctl_name       = CTL_DEV,
 137                 .procname       = "dev",
 138                 .maxlen         = 0,
 139                 .mode           = 0555,
 140                 .child          = raid_dir_table,
 141         },
 142         { .ctl_name = 0 }
 143 };
 144
 145 static struct block_device_operations md_fops;
 146
 147 static int start_readonly;
 148
 149 /*
 150  * We have a system wide 'event count' that is incremented
 151  * on any 'interesting' event, and readers of /proc/mdstat
 152  * can use 'poll' or 'select' to find out when the event
 153  * count increases.
 154  *
 155  * Events are:
 156  *  start array, stop array, error, add device, remove device,
 157  *  start build, activate spare
 158  */
 159 static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
 160 static atomic_t md_event_count;
 161 static void md_new_event(mddev_t *mddev)
 162 {
 163         atomic_inc(&md_event_count);
 164         wake_up(&md_event_waiters);
 165 }
 166
 167 /*
 168  * Enables to iterate over all existing md arrays
 169  * all_mddevs_lock protects this list.
 170  */
 171 static LIST_HEAD(all_mddevs);
 172 static DEFINE_SPINLOCK(all_mddevs_lock);
 173
 174
 175 /*
 176  * iterates through all used mddevs in the system.
 177  * We take care to grab the all_mddevs_lock whenever navigating
 178  * the list, and to always hold a refcount when unlocked.
 179  * Any code which breaks out of this loop while own
 180  * a reference to the current mddev and must mddev_put it.
 181  */
 182 #define ITERATE_MDDEV(mddev,tmp)                                        \
 183                                                                         \
 184         for (({ spin_lock(&all_mddevs_lock);                            \
 185                 tmp = all_mddevs.next;                                  \
 186                 mddev = NULL;});                                        \
 187              ({ if (tmp != &all_mddevs)                                 \
 188                         mddev_get(list_entry(tmp, mddev_t, all_mddevs));\
 189                 spin_unlock(&all_mddevs_lock);                          \
 190                 if (mddev) mddev_put(mddev);                            \
 191                 mddev = list_entry(tmp, mddev_t, all_mddevs);           \
 192                 tmp != &all_mddevs;});                                  \
 193              ({ spin_lock(&all_mddevs_lock);                            \
 194                 tmp = tmp->next;})                                      \
 195                 )
 196
 197
 198 static int md_fail_request (request_queue_t *q, struct bio *bio)
 199 {
 200         bio_io_error(bio, bio->bi_size);
 201         return 0;
 202 }
 203
 204 static inline mddev_t *mddev_get(mddev_t *mddev)
 205 {
 206         atomic_inc(&mddev->active);
 207         return mddev;
 208 }
 209
 210 static void mddev_put(mddev_t *mddev)
 211 {
 212         if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
 213                 return;
 214         if (!mddev->raid_disks && list_empty(&mddev->disks)) {
 215                 list_del(&mddev->all_mddevs);
 216                 blk_put_queue(mddev->queue);
 217                 kobject_unregister(&mddev->kobj);
 218         }
 219         spin_unlock(&all_mddevs_lock);
 220 }
 221
 222 static mddev_t * mddev_find(dev_t unit)
 223 {
 224         mddev_t *mddev, *new = NULL;
 225
 226  retry:
 227         spin_lock(&all_mddevs_lock);
 228         list_for_each_entry(mddev, &all_mddevs, all_mddevs)
 229                 if (mddev->unit == unit) {
 230                         mddev_get(mddev);
 231                         spin_unlock(&all_mddevs_lock);
 232                         kfree(new);
 233                         return mddev;
 234                 }
 235
 236         if (new) {
 237                 list_add(&new->all_mddevs, &all_mddevs);
 238                 spin_unlock(&all_mddevs_lock);
 239                 return new;
 240         }
 241         spin_unlock(&all_mddevs_lock);
 242
 243         new = kzalloc(sizeof(*new), GFP_KERNEL);
 244         if (!new)
 245                 return NULL;
 246
 247         new->unit = unit;
 248         if (MAJOR(unit) == MD_MAJOR)
 249                 new->md_minor = MINOR(unit);
 250         else
 251                 new->md_minor = MINOR(unit) >> MdpMinorShift;
 252
 253         init_MUTEX(&new->reconfig_sem);
 254         INIT_LIST_HEAD(&new->disks);
 255         INIT_LIST_HEAD(&new->all_mddevs);
 256         init_timer(&new->safemode_timer);
 257         atomic_set(&new->active, 1);
 258         spin_lock_init(&new->write_lock);
 259         init_waitqueue_head(&new->sb_wait);
 260
 261         new->queue = blk_alloc_queue(GFP_KERNEL);
 262         if (!new->queue) {
 263                 kfree(new);
 264                 return NULL;
 265         }
 266
 267         blk_queue_make_request(new->queue, md_fail_request);
 268
 269         goto retry;
 270 }
 271
 272 static inline int mddev_lock(mddev_t * mddev)
 273 {
 274         return down_interruptible(&mddev->reconfig_sem);
 275 }
 276
 277 static inline void mddev_lock_uninterruptible(mddev_t * mddev)
 278 {
 279         down(&mddev->reconfig_sem);
 280 }
 281
 282 static inline int mddev_trylock(mddev_t * mddev)
 283 {
 284         return down_trylock(&mddev->reconfig_sem);
 285 }
 286
 287 static inline void mddev_unlock(mddev_t * mddev)
 288 {
 289         up(&mddev->reconfig_sem);
 290
 291         md_wakeup_thread(mddev->thread);
 292 }
 293
 294 static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
 295 {
 296         mdk_rdev_t * rdev;
 297         struct list_head *tmp;
 298
 299         ITERATE_RDEV(mddev,rdev,tmp) {
 300                 if (rdev->desc_nr == nr)
 301                         return rdev;
 302         }
 303         return NULL;
 304 }
 305
 306 static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
 307 {
 308         struct list_head *tmp;
 309         mdk_rdev_t *rdev;
 310
 311         ITERATE_RDEV(mddev,rdev,tmp) {
 312                 if (rdev->bdev->bd_dev == dev)
 313                         return rdev;
 314         }
 315         return NULL;
 316 }
 317
 318 static struct mdk_personality *find_pers(int level, char *clevel)
 319 {
 320         struct mdk_personality *pers;
 321         list_for_each_entry(pers, &pers_list, list) {
 322                 if (level != LEVEL_NONE && pers->level == level)
 323                         return pers;
 324                 if (strcmp(pers->name, clevel)==0)
 325                         return pers;
 326         }
 327         return NULL;
 328 }
 329
 330 static inline sector_t calc_dev_sboffset(struct block_device *bdev)
 331 {
 332         sector_t size = bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
 333         return MD_NEW_SIZE_BLOCKS(size);
 334 }
 335
 336 static sector_t calc_dev_size(mdk_rdev_t *rdev, unsigned chunk_size)
 337 {
 338         sector_t size;
 339
 340         size = rdev->sb_offset;
 341
 342         if (chunk_size)
 343                 size &= ~((sector_t)chunk_size/1024 - 1);
 344         return size;
 345 }
 346
 347 static int alloc_disk_sb(mdk_rdev_t * rdev)
 348 {
 349         if (rdev->sb_page)
 350                 MD_BUG();
 351
 352         rdev->sb_page = alloc_page(GFP_KERNEL);
 353         if (!rdev->sb_page) {
 354                 printk(KERN_ALERT "md: out of memory.\n");
 355                 return -EINVAL;
 356         }
 357
 358         return 0;
 359 }
 360
 361 static void free_disk_sb(mdk_rdev_t * rdev)
 362 {
 363         if (rdev->sb_page) {
 364                 put_page(rdev->sb_page);
 365                 rdev->sb_loaded = 0;
 366                 rdev->sb_page = NULL;
 367                 rdev->sb_offset = 0;
 368                 rdev->size = 0;
 369         }
 370 }
 371
 372
 373 static int super_written(struct bio *bio, unsigned int bytes_done, int error)
 374 {
 375         mdk_rdev_t *rdev = bio->bi_private;
 376         mddev_t *mddev = rdev->mddev;
 377         if (bio->bi_size)
 378                 return 1;
 379
 380         if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags))
 381                 md_error(mddev, rdev);
 382
 383         if (atomic_dec_and_test(&mddev->pending_writes))
 384                 wake_up(&mddev->sb_wait);
 385         bio_put(bio);
 386         return 0;
 387 }
 388
 389 static int super_written_barrier(struct bio *bio, unsigned int bytes_done, int error)
 390 {
 391         struct bio *bio2 = bio->bi_private;
 392         mdk_rdev_t *rdev = bio2->bi_private;
 393         mddev_t *mddev = rdev->mddev;
 394         if (bio->bi_size)
 395                 return 1;
 396
 397         if (!test_bit(BIO_UPTODATE, &bio->bi_flags) &&
 398             error == -EOPNOTSUPP) {
 399                 unsigned long flags;
 400                 /* barriers don't appear to be supported :-( */
 401                 set_bit(BarriersNotsupp, &rdev->flags);
 402                 mddev->barriers_work = 0;
 403                 spin_lock_irqsave(&mddev->write_lock, flags);
 404                 bio2->bi_next = mddev->biolist;
 405                 mddev->biolist = bio2;
 406                 spin_unlock_irqrestore(&mddev->write_lock, flags);
 407                 wake_up(&mddev->sb_wait);
 408                 bio_put(bio);
 409                 return 0;
 410         }
 411         bio_put(bio2);
 412         bio->bi_private = rdev;
 413         return super_written(bio, bytes_done, error);
 414 }
 415
 416 void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
 417                    sector_t sector, int size, struct page *page)
 418 {
 419         /* write first size bytes of page to sector of rdev
 420          * Increment mddev->pending_writes before returning
 421          * and decrement it on completion, waking up sb_wait
 422          * if zero is reached.
 423          * If an error occurred, call md_error
 424          *
 425          * As we might need to resubmit the request if BIO_RW_BARRIER
 426          * causes ENOTSUPP, we allocate a spare bio...
 427          */
 428         struct bio *bio = bio_alloc(GFP_NOIO, 1);
 429         int rw = (1<<BIO_RW) | (1<<BIO_RW_SYNC);
 430
 431         bio->bi_bdev = rdev->bdev;
 432         bio->bi_sector = sector;
 433         bio_add_page(bio, page, size, 0);
 434         bio->bi_private = rdev;
 435         bio->bi_end_io = super_written;
 436         bio->bi_rw = rw;
 437
 438         atomic_inc(&mddev->pending_writes);
 439         if (!test_bit(BarriersNotsupp, &rdev->flags)) {
 440                 struct bio *rbio;
 441                 rw |= (1<<BIO_RW_BARRIER);
 442                 rbio = bio_clone(bio, GFP_NOIO);
 443                 rbio->bi_private = bio;
 444                 rbio->bi_end_io = super_written_barrier;
 445                 submit_bio(rw, rbio);
 446         } else
 447                 submit_bio(rw, bio);
 448 }
 449
 450 void md_super_wait(mddev_t *mddev)
 451 {
 452         /* wait for all superblock writes that were scheduled to complete.
 453          * if any had to be retried (due to BARRIER problems), retry them
 454          */
 455         DEFINE_WAIT(wq);
 456         for(;;) {
 457                 prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
 458                 if (atomic_read(&mddev->pending_writes)==0)
 459                         break;
 460                 while (mddev->biolist) {
 461                         struct bio *bio;
 462                         spin_lock_irq(&mddev->write_lock);
 463                         bio = mddev->biolist;
 464                         mddev->biolist = bio->bi_next ;
 465                         bio->bi_next = NULL;
 466                         spin_unlock_irq(&mddev->write_lock);
 467                         submit_bio(bio->bi_rw, bio);
 468                 }
 469                 schedule();
 470         }
 471         finish_wait(&mddev->sb_wait, &wq);
 472 }
 473
 474 static int bi_complete(struct bio *bio, unsigned int bytes_done, int error)
 475 {
 476         if (bio->bi_size)
 477                 return 1;
 478
 479         complete((struct completion*)bio->bi_private);
 480         return 0;
 481 }
 482
 483 int sync_page_io(struct block_device *bdev, sector_t sector, int size,
 484                    struct page *page, int rw)
 485 {
 486         struct bio *bio = bio_alloc(GFP_NOIO, 1);
 487         struct completion event;
 488         int ret;
 489
 490         rw |= (1 << BIO_RW_SYNC);
 491
 492         bio->bi_bdev = bdev;
 493         bio->bi_sector = sector;
 494         bio_add_page(bio, page, size, 0);
 495         init_completion(&event);
 496         bio->bi_private = &event;
 497         bio->bi_end_io = bi_complete;
 498         submit_bio(rw, bio);
 499         wait_for_completion(&event);
 500
 501         ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
 502         bio_put(bio);
 503         return ret;
 504 }
 505 EXPORT_SYMBOL_GPL(sync_page_io);
 506
 507 static int read_disk_sb(mdk_rdev_t * rdev, int size)
 508 {
 509         char b[BDEVNAME_SIZE];
 510         if (!rdev->sb_page) {
 511                 MD_BUG();
 512                 return -EINVAL;
 513         }
 514         if (rdev->sb_loaded)
 515                 return 0;
 516
 517
 518         if (!sync_page_io(rdev->bdev, rdev->sb_offset<<1, size, rdev->sb_page, READ))
 519                 goto fail;
 520         rdev->sb_loaded = 1;
 521         return 0;
 522
 523 fail:
 524         printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
 525                 bdevname(rdev->bdev,b));
 526         return -EINVAL;
 527 }
 528
 529 static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
 530 {
 531         if (    (sb1->set_uuid0 == sb2->set_uuid0) &&
 532                 (sb1->set_uuid1 == sb2->set_uuid1) &&
 533                 (sb1->set_uuid2 == sb2->set_uuid2) &&
 534                 (sb1->set_uuid3 == sb2->set_uuid3))
 535
 536                 return 1;
 537
 538         return 0;
 539 }
 540
 541
 542 static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
 543 {
 544         int ret;
 545         mdp_super_t *tmp1, *tmp2;
 546
 547         tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
 548         tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
 549
 550         if (!tmp1 || !tmp2) {
 551                 ret = 0;
 552                 printk(KERN_INFO "md.c: sb1 is not equal to sb2!\n");
 553                 goto abort;
 554         }
 555
 556         *tmp1 = *sb1;
 557         *tmp2 = *sb2;
 558
 559         /*
 560          * nr_disks is not constant
 561          */
 562         tmp1->nr_disks = 0;
 563         tmp2->nr_disks = 0;
 564
 565         if (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4))
 566                 ret = 0;
 567         else
 568                 ret = 1;
 569
 570 abort:
 571         kfree(tmp1);
 572         kfree(tmp2);
 573         return ret;
 574 }
 575
 576 static unsigned int calc_sb_csum(mdp_super_t * sb)
 577 {
 578         unsigned int disk_csum, csum;
 579
 580         disk_csum = sb->sb_csum;
 581         sb->sb_csum = 0;
 582         csum = csum_partial((void *)sb, MD_SB_BYTES, 0);
 583         sb->sb_csum = disk_csum;
 584         return csum;
 585 }
 586
 587
 588 /*
 589  * Handle superblock details.
 590  * We want to be able to handle multiple superblock formats
 591  * so we have a common interface to them all, and an array of
 592  * different handlers.
 593  * We rely on user-space to write the initial superblock, and support
 594  * reading and updating of superblocks.
 595  * Interface methods are:
 596  *   int load_super(mdk_rdev_t *dev, mdk_rdev_t *refdev, int minor_version)
 597  *      loads and validates a superblock on dev.
 598  *      if refdev != NULL, compare superblocks on both devices
 599  *    Return:
 600  *      0 - dev has a superblock that is compatible with refdev
 601  *      1 - dev has a superblock that is compatible and newer than refdev
 602  *          so dev should be used as the refdev in future
 603  *     -EINVAL superblock incompatible or invalid
 604  *     -othererror e.g. -EIO
 605  *
 606  *   int validate_super(mddev_t *mddev, mdk_rdev_t *dev)
 607  *      Verify that dev is acceptable into mddev.
 608  *       The first time, mddev->raid_disks will be 0, and data from
 609  *       dev should be merged in.  Subsequent calls check that dev
 610  *       is new enough.  Return 0 or -EINVAL
 611  *
 612  *   void sync_super(mddev_t *mddev, mdk_rdev_t *dev)
 613  *     Update the superblock for rdev with data in mddev
 614  *     This does not write to disc.
 615  *
 616  */
 617
 618 struct super_type  {
 619         char            *name;
 620         struct module   *owner;
 621         int             (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version);
 622         int             (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
 623         void            (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
 624 };
 625
 626 /*
 627  * load_super for 0.90.0
 628  */
 629 static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
 630 {
 631         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
 632         mdp_super_t *sb;
 633         int ret;
 634         sector_t sb_offset;
 635
 636         /*
 637          * Calculate the position of the superblock,
 638          * it's at the end of the disk.
 639          *
 640          * It also happens to be a multiple of 4Kb.
 641          */
 642         sb_offset = calc_dev_sboffset(rdev->bdev);
 643         rdev->sb_offset = sb_offset;
 644
 645         ret = read_disk_sb(rdev, MD_SB_BYTES);
 646         if (ret) return ret;
 647
 648         ret = -EINVAL;
 649
 650         bdevname(rdev->bdev, b);
 651         sb = (mdp_super_t*)page_address(rdev->sb_page);
 652
 653         if (sb->md_magic != MD_SB_MAGIC) {
 654                 printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
 655                        b);
 656                 goto abort;
 657         }
 658
 659         if (sb->major_version != 0 ||
 660             sb->minor_version != 90) {
 661                 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
 662                         sb->major_version, sb->minor_version,
 663                         b);
 664                 goto abort;
 665         }
 666
 667         if (sb->raid_disks <= 0)
 668                 goto abort;
 669
 670         if (csum_fold(calc_sb_csum(sb)) != csum_fold(sb->sb_csum)) {
 671                 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
 672                         b);
 673                 goto abort;
 674         }
 675
 676         rdev->preferred_minor = sb->md_minor;
 677         rdev->data_offset = 0;
 678         rdev->sb_size = MD_SB_BYTES;
 679
 680         if (sb->level == LEVEL_MULTIPATH)
 681                 rdev->desc_nr = -1;
 682         else
 683                 rdev->desc_nr = sb->this_disk.number;
 684
 685         if (refdev == 0)
 686                 ret = 1;
 687         else {
 688                 __u64 ev1, ev2;
 689                 mdp_super_t *refsb = (mdp_super_t*)page_address(refdev->sb_page);
 690                 if (!uuid_equal(refsb, sb)) {
 691                         printk(KERN_WARNING "md: %s has different UUID to %s\n",
 692                                 b, bdevname(refdev->bdev,b2));
 693                         goto abort;
 694                 }
 695                 if (!sb_equal(refsb, sb)) {
 696                         printk(KERN_WARNING "md: %s has same UUID"
 697                                " but different superblock to %s\n",
 698                                b, bdevname(refdev->bdev, b2));
 699                         goto abort;
 700                 }
 701                 ev1 = md_event(sb);
 702                 ev2 = md_event(refsb);
 703                 if (ev1 > ev2)
 704                         ret = 1;
 705                 else
 706                         ret = 0;
 707         }
 708         rdev->size = calc_dev_size(rdev, sb->chunk_size);
 709
 710         if (rdev->size < sb->size && sb->level > 1)
 711                 /* "this cannot possibly happen" ... */
 712                 ret = -EINVAL;
 713
 714  abort:
 715         return ret;
 716 }
 717
 718 /*
 719  * validate_super for 0.90.0
 720  */
 721 static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
 722 {
 723         mdp_disk_t *desc;
 724         mdp_super_t *sb = (mdp_super_t *)page_address(rdev->sb_page);
 725
 726         rdev->raid_disk = -1;
 727         rdev->flags = 0;
 728         if (mddev->raid_disks == 0) {
 729                 mddev->major_version = 0;
 730                 mddev->minor_version = sb->minor_version;
 731                 mddev->patch_version = sb->patch_version;
 732                 mddev->persistent = ! sb->not_persistent;
 733                 mddev->chunk_size = sb->chunk_size;
 734                 mddev->ctime = sb->ctime;
 735                 mddev->utime = sb->utime;
 736                 mddev->level = sb->level;
 737                 mddev->clevel[0] = 0;
 738                 mddev->layout = sb->layout;
 739                 mddev->raid_disks = sb->raid_disks;
 740                 mddev->size = sb->size;
 741                 mddev->events = md_event(sb);
 742                 mddev->bitmap_offset = 0;
 743                 mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
 744
 745                 if (sb->state & (1<<MD_SB_CLEAN))
 746                         mddev->recovery_cp = MaxSector;
 747                 else {
 748                         if (sb->events_hi == sb->cp_events_hi &&
 749                                 sb->events_lo == sb->cp_events_lo) {
 750                                 mddev->recovery_cp = sb->recovery_cp;
 751                         } else
 752                                 mddev->recovery_cp = 0;
 753                 }
 754
 755                 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
 756                 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
 757                 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
 758                 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
 759
 760                 mddev->max_disks = MD_SB_DISKS;
 761
 762                 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
 763                     mddev->bitmap_file == NULL) {
 764                         if (mddev->level != 1 && mddev->level != 5 && mddev->level != 6
 765                             && mddev->level != 10) {
 766                                 /* FIXME use a better test */
 767                                 printk(KERN_WARNING "md: bitmaps not supported for this level.\n");
 768                                 return -EINVAL;
 769                         }
 770                         mddev->bitmap_offset = mddev->default_bitmap_offset;
 771                 }
 772
 773         } else if (mddev->pers == NULL) {
 774                 /* Insist on good event counter while assembling */
 775                 __u64 ev1 = md_event(sb);
 776                 ++ev1;
 777                 if (ev1 < mddev->events)
 778                         return -EINVAL;
 779         } else if (mddev->bitmap) {
 780                 /* if adding to array with a bitmap, then we can accept an
 781                  * older device ... but not too old.
 782                  */
 783                 __u64 ev1 = md_event(sb);
 784                 if (ev1 < mddev->bitmap->events_cleared)
 785                         return 0;
 786         } else /* just a hot-add of a new device, leave raid_disk at -1 */
 787                 return 0;
 788
 789         if (mddev->level != LEVEL_MULTIPATH) {
 790                 desc = sb->disks + rdev->desc_nr;
 791
 792                 if (desc->state & (1<<MD_DISK_FAULTY))
 793                         set_bit(Faulty, &rdev->flags);
 794                 else if (desc->state & (1<<MD_DISK_SYNC) &&
 795                          desc->raid_disk < mddev->raid_disks) {
 796                         set_bit(In_sync, &rdev->flags);
 797                         rdev->raid_disk = desc->raid_disk;
 798                 }
 799                 if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
 800                         set_bit(WriteMostly, &rdev->flags);
 801         } else /* MULTIPATH are always insync */
 802                 set_bit(In_sync, &rdev->flags);
 803         return 0;
 804 }
 805
 806 /*
 807  * sync_super for 0.90.0
 808  */
 809 static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
 810 {
 811         mdp_super_t *sb;
 812         struct list_head *tmp;
 813         mdk_rdev_t *rdev2;
 814         int next_spare = mddev->raid_disks;
 815
 816
 817         /* make rdev->sb match mddev data..
 818          *
 819          * 1/ zero out disks
 820          * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
 821          * 3/ any empty disks < next_spare become removed
 822          *
 823          * disks[0] gets initialised to REMOVED because
 824          * we cannot be sure from other fields if it has
 825          * been initialised or not.
 826          */
 827         int i;
 828         int active=0, working=0,failed=0,spare=0,nr_disks=0;
 829
 830         rdev->sb_size = MD_SB_BYTES;
 831
 832         sb = (mdp_super_t*)page_address(rdev->sb_page);
 833
 834         memset(sb, 0, sizeof(*sb));
 835
 836         sb->md_magic = MD_SB_MAGIC;
 837         sb->major_version = mddev->major_version;
 838         sb->minor_version = mddev->minor_version;
 839         sb->patch_version = mddev->patch_version;
 840         sb->gvalid_words  = 0; /* ignored */
 841         memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
 842         memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
 843         memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
 844         memcpy(&sb->set_uuid3, mddev->uuid+12,4);
 845
 846         sb->ctime = mddev->ctime;
 847         sb->level = mddev->level;
 848         sb->size  = mddev->size;
 849         sb->raid_disks = mddev->raid_disks;
 850         sb->md_minor = mddev->md_minor;
 851         sb->not_persistent = !mddev->persistent;
 852         sb->utime = mddev->utime;
 853         sb->state = 0;
 854         sb->events_hi = (mddev->events>>32);
 855         sb->events_lo = (u32)mddev->events;
 856
 857         if (mddev->in_sync)
 858         {
 859                 sb->recovery_cp = mddev->recovery_cp;
 860                 sb->cp_events_hi = (mddev->events>>32);
 861                 sb->cp_events_lo = (u32)mddev->events;
 862                 if (mddev->recovery_cp == MaxSector)
 863                         sb->state = (1<< MD_SB_CLEAN);
 864         } else
 865                 sb->recovery_cp = 0;
 866
 867         sb->layout = mddev->layout;
 868         sb->chunk_size = mddev->chunk_size;
 869
 870         if (mddev->bitmap && mddev->bitmap_file == NULL)
 871                 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
 872
 873         sb->disks[0].state = (1<<MD_DISK_REMOVED);
 874         ITERATE_RDEV(mddev,rdev2,tmp) {
 875                 mdp_disk_t *d;
 876                 int desc_nr;
 877                 if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags)
 878                     && !test_bit(Faulty, &rdev2->flags))
 879                         desc_nr = rdev2->raid_disk;
 880                 else
 881                         desc_nr = next_spare++;
 882                 rdev2->desc_nr = desc_nr;
 883                 d = &sb->disks[rdev2->desc_nr];
 884                 nr_disks++;
 885                 d->number = rdev2->desc_nr;
 886                 d->major = MAJOR(rdev2->bdev->bd_dev);
 887                 d->minor = MINOR(rdev2->bdev->bd_dev);
 888                 if (rdev2->raid_disk >= 0 && test_bit(In_sync, &rdev2->flags)
 889                     && !test_bit(Faulty, &rdev2->flags))
 890                         d->raid_disk = rdev2->raid_disk;
 891                 else
 892                         d->raid_disk = rdev2->desc_nr; /* compatibility */
 893                 if (test_bit(Faulty, &rdev2->flags)) {
 894                         d->state = (1<<MD_DISK_FAULTY);
 895                         failed++;
 896                 } else if (test_bit(In_sync, &rdev2->flags)) {
 897                         d->state = (1<<MD_DISK_ACTIVE);
 898                         d->state |= (1<<MD_DISK_SYNC);
 899                         active++;
 900                         working++;
 901                 } else {
 902                         d->state = 0;
 903                         spare++;
 904                         working++;
 905                 }
 906                 if (test_bit(WriteMostly, &rdev2->flags))
 907                         d->state |= (1<<MD_DISK_WRITEMOSTLY);
 908         }
 909         /* now set the "removed" and "faulty" bits on any missing devices */
 910         for (i=0 ; i < mddev->raid_disks ; i++) {
 911                 mdp_disk_t *d = &sb->disks[i];
 912                 if (d->state == 0 && d->number == 0) {
 913                         d->number = i;
 914                         d->raid_disk = i;
 915                         d->state = (1<<MD_DISK_REMOVED);
 916                         d->state |= (1<<MD_DISK_FAULTY);
 917                         failed++;
 918                 }
 919         }
 920         sb->nr_disks = nr_disks;
 921         sb->active_disks = active;
 922         sb->working_disks = working;
 923         sb->failed_disks = failed;
 924         sb->spare_disks = spare;
 925
 926         sb->this_disk = sb->disks[rdev->desc_nr];
 927         sb->sb_csum = calc_sb_csum(sb);
 928 }
 929
 930 /*
 931  * version 1 superblock
 932  */
 933
 934 static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
 935 {
 936         unsigned int disk_csum, csum;
 937         unsigned long long newcsum;
 938         int size = 256 + le32_to_cpu(sb->max_dev)*2;
 939         unsigned int *isuper = (unsigned int*)sb;
 940         int i;
 941
 942         disk_csum = sb->sb_csum;
 943         sb->sb_csum = 0;
 944         newcsum = 0;
 945         for (i=0; size>=4; size -= 4 )
 946                 newcsum += le32_to_cpu(*isuper++);
 947
 948         if (size == 2)
 949                 newcsum += le16_to_cpu(*(unsigned short*) isuper);
 950
 951         csum = (newcsum & 0xffffffff) + (newcsum >> 32);
 952         sb->sb_csum = disk_csum;
 953         return cpu_to_le32(csum);
 954 }
 955
 956 static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
 957 {
 958         struct mdp_superblock_1 *sb;
 959         int ret;
 960         sector_t sb_offset;
 961         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
 962         int bmask;
 963
 964         /*
 965          * Calculate the position of the superblock.
 966          * It is always aligned to a 4K boundary and
 967          * depeding on minor_version, it can be:
 968          * 0: At least 8K, but less than 12K, from end of device
 969          * 1: At start of device
 970          * 2: 4K from start of device.
 971          */
 972         switch(minor_version) {
 973         case 0:
 974                 sb_offset = rdev->bdev->bd_inode->i_size >> 9;
 975                 sb_offset -= 8*2;
 976                 sb_offset &= ~(sector_t)(4*2-1);
 977                 /* convert from sectors to K */
 978                 sb_offset /= 2;
 979                 break;
 980         case 1:
 981                 sb_offset = 0;
 982                 break;
 983         case 2:
 984                 sb_offset = 4;
 985                 break;
 986         default:
 987                 return -EINVAL;
 988         }
 989         rdev->sb_offset = sb_offset;
 990
 991         /* superblock is rarely larger than 1K, but it can be larger,
 992          * and it is safe to read 4k, so we do that
 993          */
 994         ret = read_disk_sb(rdev, 4096);
 995         if (ret) return ret;
 996
 997
 998         sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
 999
1000         if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1001             sb->major_version != cpu_to_le32(1) ||
1002             le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
1003             le64_to_cpu(sb->super_offset) != (rdev->sb_offset<<1) ||
1004             (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
1005                 return -EINVAL;
1006
1007         if (calc_sb_1_csum(sb) != sb->sb_csum) {
1008                 printk("md: invalid superblock checksum on %s\n",
1009                         bdevname(rdev->bdev,b));
1010                 return -EINVAL;
1011         }
1012         if (le64_to_cpu(sb->data_size) < 10) {
1013                 printk("md: data_size too small on %s\n",
1014                        bdevname(rdev->bdev,b));
1015                 return -EINVAL;
1016         }
1017         rdev->preferred_minor = 0xffff;
1018         rdev->data_offset = le64_to_cpu(sb->data_offset);
1019         atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
1020
1021         rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1022         bmask = queue_hardsect_size(rdev->bdev->bd_disk->queue)-1;
1023         if (rdev->sb_size & bmask)
1024                 rdev-> sb_size = (rdev->sb_size | bmask)+1;
1025
1026         if (refdev == 0)
1027                 return 1;
1028         else {
1029                 __u64 ev1, ev2;
1030                 struct mdp_superblock_1 *refsb =
1031                         (struct mdp_superblock_1*)page_address(refdev->sb_page);
1032
1033                 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1034                     sb->level != refsb->level ||
1035                     sb->layout != refsb->layout ||
1036                     sb->chunksize != refsb->chunksize) {
1037                         printk(KERN_WARNING "md: %s has strangely different"
1038                                 " superblock to %s\n",
1039                                 bdevname(rdev->bdev,b),
1040                                 bdevname(refdev->bdev,b2));
1041                         return -EINVAL;
1042                 }
1043                 ev1 = le64_to_cpu(sb->events);
1044                 ev2 = le64_to_cpu(refsb->events);
1045
1046                 if (ev1 > ev2)
1047                         return 1;
1048         }
1049         if (minor_version)
1050                 rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2;
1051         else
1052                 rdev->size = rdev->sb_offset;
1053         if (rdev->size < le64_to_cpu(sb->data_size)/2)
1054                 return -EINVAL;
1055         rdev->size = le64_to_cpu(sb->data_size)/2;
1056         if (le32_to_cpu(sb->chunksize))
1057                 rdev->size &= ~((sector_t)le32_to_cpu(sb->chunksize)/2 - 1);
1058
1059         if (le32_to_cpu(sb->size) > rdev->size*2)
1060                 return -EINVAL;
1061         return 0;
1062 }
1063
1064 static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
1065 {
1066         struct mdp_superblock_1 *sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
1067
1068         rdev->raid_disk = -1;
1069         rdev->flags = 0;
1070         if (mddev->raid_disks == 0) {
1071                 mddev->major_version = 1;
1072                 mddev->patch_version = 0;
1073                 mddev->persistent = 1;
1074                 mddev->chunk_size = le32_to_cpu(sb->chunksize) << 9;
1075                 mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
1076                 mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
1077                 mddev->level = le32_to_cpu(sb->level);
1078                 mddev->clevel[0] = 0;
1079                 mddev->layout = le32_to_cpu(sb->layout);
1080                 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1081                 mddev->size = le64_to_cpu(sb->size)/2;
1082                 mddev->events = le64_to_cpu(sb->events);
1083                 mddev->bitmap_offset = 0;
1084                 mddev->default_bitmap_offset = 1024;
1085
1086                 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1087                 memcpy(mddev->uuid, sb->set_uuid, 16);
1088
1089                 mddev->max_disks =  (4096-256)/2;
1090
1091                 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1092                     mddev->bitmap_file == NULL ) {
1093                         if (mddev->level != 1 && mddev->level != 5 && mddev->level != 6
1094                             && mddev->level != 10) {
1095                                 printk(KERN_WARNING "md: bitmaps not supported for this level.\n");
1096                                 return -EINVAL;
1097                         }
1098                         mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset);
1099                 }
1100         } else if (mddev->pers == NULL) {
1101                 /* Insist of good event counter while assembling */
1102                 __u64 ev1 = le64_to_cpu(sb->events);
1103                 ++ev1;
1104                 if (ev1 < mddev->events)
1105                         return -EINVAL;
1106         } else if (mddev->bitmap) {
1107                 /* If adding to array with a bitmap, then we can accept an
1108                  * older device, but not too old.
1109                  */
1110                 __u64 ev1 = le64_to_cpu(sb->events);
1111                 if (ev1 < mddev->bitmap->events_cleared)
1112                         return 0;
1113         } else /* just a hot-add of a new device, leave raid_disk at -1 */
1114                 return 0;
1115
1116         if (mddev->level != LEVEL_MULTIPATH) {
1117                 int role;
1118                 rdev->desc_nr = le32_to_cpu(sb->dev_number);
1119                 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
1120                 switch(role) {
1121                 case 0xffff: /* spare */
1122                         break;
1123                 case 0xfffe: /* faulty */
1124                         set_bit(Faulty, &rdev->flags);
1125                         break;
1126                 default:
1127                         set_bit(In_sync, &rdev->flags);
1128                         rdev->raid_disk = role;
1129                         break;
1130                 }
1131                 if (sb->devflags & WriteMostly1)
1132                         set_bit(WriteMostly, &rdev->flags);
1133         } else /* MULTIPATH are always insync */
1134                 set_bit(In_sync, &rdev->flags);
1135
1136         return 0;
1137 }
1138
1139 static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
1140 {
1141         struct mdp_superblock_1 *sb;
1142         struct list_head *tmp;
1143         mdk_rdev_t *rdev2;
1144         int max_dev, i;
1145         /* make rdev->sb match mddev and rdev data. */
1146
1147         sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
1148
1149         sb->feature_map = 0;
1150         sb->pad0 = 0;
1151         memset(sb->pad1, 0, sizeof(sb->pad1));
1152         memset(sb->pad2, 0, sizeof(sb->pad2));
1153         memset(sb->pad3, 0, sizeof(sb->pad3));
1154
1155         sb->utime = cpu_to_le64((__u64)mddev->utime);
1156         sb->events = cpu_to_le64(mddev->events);
1157         if (mddev->in_sync)
1158                 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1159         else
1160                 sb->resync_offset = cpu_to_le64(0);
1161
1162         sb->cnt_corrected_read = atomic_read(&rdev->corrected_errors);
1163
1164         sb->raid_disks = cpu_to_le32(mddev->raid_disks);
1165         sb->size = cpu_to_le64(mddev->size);
1166
1167         if (mddev->bitmap && mddev->bitmap_file == NULL) {
1168                 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset);
1169                 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1170         }
1171
1172         max_dev = 0;
1173         ITERATE_RDEV(mddev,rdev2,tmp)
1174                 if (rdev2->desc_nr+1 > max_dev)
1175                         max_dev = rdev2->desc_nr+1;
1176
1177         sb->max_dev = cpu_to_le32(max_dev);
1178         for (i=0; i<max_dev;i++)
1179                 sb->dev_roles[i] = cpu_to_le16(0xfffe);
1180
1181         ITERATE_RDEV(mddev,rdev2,tmp) {
1182                 i = rdev2->desc_nr;
1183                 if (test_bit(Faulty, &rdev2->flags))
1184                         sb->dev_roles[i] = cpu_to_le16(0xfffe);
1185                 else if (test_bit(In_sync, &rdev2->flags))
1186                         sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1187                 else
1188                         sb->dev_roles[i] = cpu_to_le16(0xffff);
1189         }
1190
1191         sb->recovery_offset = cpu_to_le64(0); /* not supported yet */
1192         sb->sb_csum = calc_sb_1_csum(sb);
1193 }
1194
1195
1196 static struct super_type super_types[] = {
1197         [0] = {
1198                 .name   = "0.90.0",
1199                 .owner  = THIS_MODULE,
1200                 .load_super     = super_90_load,
1201                 .validate_super = super_90_validate,
1202                 .sync_super     = super_90_sync,
1203         },
1204         [1] = {
1205                 .name   = "md-1",
1206                 .owner  = THIS_MODULE,
1207                 .load_super     = super_1_load,
1208                 .validate_super = super_1_validate,
1209                 .sync_super     = super_1_sync,
1210         },
1211 };
1212
1213 static mdk_rdev_t * match_dev_unit(mddev_t *mddev, mdk_rdev_t *dev)
1214 {
1215         struct list_head *tmp;
1216         mdk_rdev_t *rdev;
1217
1218         ITERATE_RDEV(mddev,rdev,tmp)
1219                 if (rdev->bdev->bd_contains == dev->bdev->bd_contains)
1220                         return rdev;
1221
1222         return NULL;
1223 }
1224
1225 static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
1226 {
1227         struct list_head *tmp;
1228         mdk_rdev_t *rdev;
1229
1230         ITERATE_RDEV(mddev1,rdev,tmp)
1231                 if (match_dev_unit(mddev2, rdev))
1232                         return 1;
1233
1234         return 0;
1235 }
1236
1237 static LIST_HEAD(pending_raid_disks);
1238
1239 static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
1240 {
1241         mdk_rdev_t *same_pdev;
1242         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1243         struct kobject *ko;
1244         char *s;
1245
1246         if (rdev->mddev) {
1247                 MD_BUG();
1248                 return -EINVAL;
1249         }
1250         /* make sure rdev->size exceeds mddev->size */
1251         if (rdev->size && (mddev->size == 0 || rdev->size < mddev->size)) {
1252                 if (mddev->pers)
1253                         /* Cannot change size, so fail */
1254                         return -ENOSPC;
1255                 else
1256                         mddev->size = rdev->size;
1257         }
1258         same_pdev = match_dev_unit(mddev, rdev);
1259         if (same_pdev)
1260                 printk(KERN_WARNING
1261                         "%s: WARNING: %s appears to be on the same physical"
1262                         " disk as %s. True\n     protection against single-disk"
1263                         " failure might be compromised.\n",
1264                         mdname(mddev), bdevname(rdev->bdev,b),
1265                         bdevname(same_pdev->bdev,b2));
1266
1267         /* Verify rdev->desc_nr is unique.
1268          * If it is -1, assign a free number, else
1269          * check number is not in use
1270          */
1271         if (rdev->desc_nr < 0) {
1272                 int choice = 0;
1273                 if (mddev->pers) choice = mddev->raid_disks;
1274                 while (find_rdev_nr(mddev, choice))
1275                         choice++;
1276                 rdev->desc_nr = choice;
1277         } else {
1278                 if (find_rdev_nr(mddev, rdev->desc_nr))
1279                         return -EBUSY;
1280         }
1281         bdevname(rdev->bdev,b);
1282         if (kobject_set_name(&rdev->kobj, "dev-%s", b) < 0)
1283                 return -ENOMEM;
1284         while ( (s=strchr(rdev->kobj.k_name, '/')) != NULL)
1285                 *s = '!';
1286
1287         list_add(&rdev->same_set, &mddev->disks);
1288         rdev->mddev = mddev;
1289         printk(KERN_INFO "md: bind<%s>\n", b);
1290
1291         rdev->kobj.parent = &mddev->kobj;
1292         kobject_add(&rdev->kobj);
1293
1294         if (rdev->bdev->bd_part)
1295                 ko = &rdev->bdev->bd_part->kobj;
1296         else
1297                 ko = &rdev->bdev->bd_disk->kobj;
1298         sysfs_create_link(&rdev->kobj, ko, "block");
1299         return 0;
1300 }
1301
1302 static void unbind_rdev_from_array(mdk_rdev_t * rdev)
1303 {
1304         char b[BDEVNAME_SIZE];
1305         if (!rdev->mddev) {
1306                 MD_BUG();
1307                 return;
1308         }
1309         list_del_init(&rdev->same_set);
1310         printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
1311         rdev->mddev = NULL;
1312         sysfs_remove_link(&rdev->kobj, "block");
1313         kobject_del(&rdev->kobj);
1314 }
1315
1316 /*
1317  * prevent the device from being mounted, repartitioned or
1318  * otherwise reused by a RAID array (or any other kernel
1319  * subsystem), by bd_claiming the device.
1320  */
1321 static int lock_rdev(mdk_rdev_t *rdev, dev_t dev)
1322 {
1323         int err = 0;
1324         struct block_device *bdev;
1325         char b[BDEVNAME_SIZE];
1326
1327         bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
1328         if (IS_ERR(bdev)) {
1329                 printk(KERN_ERR "md: could not open %s.\n",
1330                         __bdevname(dev, b));
1331                 return PTR_ERR(bdev);
1332         }
1333         err = bd_claim(bdev, rdev);
1334         if (err) {
1335                 printk(KERN_ERR "md: could not bd_claim %s.\n",
1336                         bdevname(bdev, b));
1337                 blkdev_put(bdev);
1338                 return err;
1339         }
1340         rdev->bdev = bdev;
1341         return err;
1342 }
1343
1344 static void unlock_rdev(mdk_rdev_t *rdev)
1345 {
1346         struct block_device *bdev = rdev->bdev;
1347         rdev->bdev = NULL;
1348         if (!bdev)
1349                 MD_BUG();
1350         bd_release(bdev);
1351         blkdev_put(bdev);
1352 }
1353
1354 void md_autodetect_dev(dev_t dev);
1355
1356 static void export_rdev(mdk_rdev_t * rdev)
1357 {
1358         char b[BDEVNAME_SIZE];
1359         printk(KERN_INFO "md: export_rdev(%s)\n",
1360                 bdevname(rdev->bdev,b));
1361         if (rdev->mddev)
1362                 MD_BUG();
1363         free_disk_sb(rdev);
1364         list_del_init(&rdev->same_set);
1365 #ifndef MODULE
1366         md_autodetect_dev(rdev->bdev->bd_dev);
1367 #endif
1368         unlock_rdev(rdev);
1369         kobject_put(&rdev->kobj);
1370 }
1371
1372 static void kick_rdev_from_array(mdk_rdev_t * rdev)
1373 {
1374         unbind_rdev_from_array(rdev);
1375         export_rdev(rdev);
1376 }
1377
1378 static void export_array(mddev_t *mddev)
1379 {
1380         struct list_head *tmp;
1381         mdk_rdev_t *rdev;
1382
1383         ITERATE_RDEV(mddev,rdev,tmp) {
1384                 if (!rdev->mddev) {
1385                         MD_BUG();
1386                         continue;
1387                 }
1388                 kick_rdev_from_array(rdev);
1389         }
1390         if (!list_empty(&mddev->disks))
1391                 MD_BUG();
1392         mddev->raid_disks = 0;
1393         mddev->major_version = 0;
1394 }
1395
1396 static void print_desc(mdp_disk_t *desc)
1397 {
1398         printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number,
1399                 desc->major,desc->minor,desc->raid_disk,desc->state);
1400 }
1401
1402 static void print_sb(mdp_super_t *sb)
1403 {
1404         int i;
1405
1406         printk(KERN_INFO
1407                 "md:  SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
1408                 sb->major_version, sb->minor_version, sb->patch_version,
1409                 sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
1410                 sb->ctime);
1411         printk(KERN_INFO "md:     L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n",
1412                 sb->level, sb->size, sb->nr_disks, sb->raid_disks,
1413                 sb->md_minor, sb->layout, sb->chunk_size);
1414         printk(KERN_INFO "md:     UT:%08x ST:%d AD:%d WD:%d"
1415                 " FD:%d SD:%d CSUM:%08x E:%08lx\n",
1416                 sb->utime, sb->state, sb->active_disks, sb->working_disks,
1417                 sb->failed_disks, sb->spare_disks,
1418                 sb->sb_csum, (unsigned long)sb->events_lo);
1419
1420         printk(KERN_INFO);
1421         for (i = 0; i < MD_SB_DISKS; i++) {
1422                 mdp_disk_t *desc;
1423
1424                 desc = sb->disks + i;
1425                 if (desc->number || desc->major || desc->minor ||
1426                     desc->raid_disk || (desc->state && (desc->state != 4))) {
1427                         printk("     D %2d: ", i);
1428                         print_desc(desc);
1429                 }
1430         }
1431         printk(KERN_INFO "md:     THIS: ");
1432         print_desc(&sb->this_disk);
1433
1434 }
1435
1436 static void print_rdev(mdk_rdev_t *rdev)
1437 {
1438         char b[BDEVNAME_SIZE];
1439         printk(KERN_INFO "md: rdev %s, SZ:%08llu F:%d S:%d DN:%u\n",
1440                 bdevname(rdev->bdev,b), (unsigned long long)rdev->size,
1441                 test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
1442                 rdev->desc_nr);
1443         if (rdev->sb_loaded) {
1444                 printk(KERN_INFO "md: rdev superblock:\n");
1445                 print_sb((mdp_super_t*)page_address(rdev->sb_page));
1446         } else
1447                 printk(KERN_INFO "md: no rdev superblock!\n");
1448 }
1449
1450 void md_print_devices(void)
1451 {
1452         struct list_head *tmp, *tmp2;
1453         mdk_rdev_t *rdev;
1454         mddev_t *mddev;
1455         char b[BDEVNAME_SIZE];
1456
1457         printk("\n");
1458         printk("md:     **********************************\n");
1459         printk("md:     * <COMPLETE RAID STATE PRINTOUT> *\n");
1460         printk("md:     **********************************\n");
1461         ITERATE_MDDEV(mddev,tmp) {
1462
1463                 if (mddev->bitmap)
1464                         bitmap_print_sb(mddev->bitmap);
1465                 else
1466                         printk("%s: ", mdname(mddev));
1467                 ITERATE_RDEV(mddev,rdev,tmp2)
1468                         printk("<%s>", bdevname(rdev->bdev,b));
1469                 printk("\n");
1470
1471                 ITERATE_RDEV(mddev,rdev,tmp2)
1472                         print_rdev(rdev);
1473         }
1474         printk("md:     **********************************\n");
1475         printk("\n");
1476 }
1477
1478
1479 static void sync_sbs(mddev_t * mddev)
1480 {
1481         mdk_rdev_t *rdev;
1482         struct list_head *tmp;
1483
1484         ITERATE_RDEV(mddev,rdev,tmp) {
1485                 super_types[mddev->major_version].
1486                         sync_super(mddev, rdev);
1487                 rdev->sb_loaded = 1;
1488         }
1489 }
1490
1491 static void md_update_sb(mddev_t * mddev)
1492 {
1493         int err;
1494         struct list_head *tmp;
1495         mdk_rdev_t *rdev;
1496         int sync_req;
1497
1498 repeat:
1499         spin_lock_irq(&mddev->write_lock);
1500         sync_req = mddev->in_sync;
1501         mddev->utime = get_seconds();
1502         mddev->events ++;
1503
1504         if (!mddev->events) {
1505                 /*
1506                  * oops, this 64-bit counter should never wrap.
1507                  * Either we are in around ~1 trillion A.C., assuming
1508                  * 1 reboot per second, or we have a bug:
1509                  */
1510                 MD_BUG();
1511                 mddev->events --;
1512         }
1513         mddev->sb_dirty = 2;
1514         sync_sbs(mddev);
1515
1516         /*
1517          * do not write anything to disk if using
1518          * nonpersistent superblocks
1519          */
1520         if (!mddev->persistent) {
1521                 mddev->sb_dirty = 0;
1522                 spin_unlock_irq(&mddev->write_lock);
1523                 wake_up(&mddev->sb_wait);
1524                 return;
1525         }
1526         spin_unlock_irq(&mddev->write_lock);
1527
1528         dprintk(KERN_INFO
1529                 "md: updating %s RAID superblock on device (in sync %d)\n",
1530                 mdname(mddev),mddev->in_sync);
1531
1532         err = bitmap_update_sb(mddev->bitmap);
1533         ITERATE_RDEV(mddev,rdev,tmp) {
1534                 char b[BDEVNAME_SIZE];
1535                 dprintk(KERN_INFO "md: ");
1536                 if (test_bit(Faulty, &rdev->flags))
1537                         dprintk("(skipping faulty ");
1538
1539                 dprintk("%s ", bdevname(rdev->bdev,b));
1540                 if (!test_bit(Faulty, &rdev->flags)) {
1541                         md_super_write(mddev,rdev,
1542                                        rdev->sb_offset<<1, rdev->sb_size,
1543                                        rdev->sb_page);
1544                         dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
1545                                 bdevname(rdev->bdev,b),
1546                                 (unsigned long long)rdev->sb_offset);
1547
1548                 } else
1549                         dprintk(")\n");
1550                 if (mddev->level == LEVEL_MULTIPATH)
1551                         /* only need to write one superblock... */
1552                         break;
1553         }
1554         md_super_wait(mddev);
1555         /* if there was a failure, sb_dirty was set to 1, and we re-write super */
1556
1557         spin_lock_irq(&mddev->write_lock);
1558         if (mddev->in_sync != sync_req|| mddev->sb_dirty == 1) {
1559                 /* have to write it out again */
1560                 spin_unlock_irq(&mddev->write_lock);
1561                 goto repeat;
1562         }
1563         mddev->sb_dirty = 0;
1564         spin_unlock_irq(&mddev->write_lock);
1565         wake_up(&mddev->sb_wait);
1566
1567 }
1568
1569 /* words written to sysfs files may, or my not, be \n terminated.
1570  * We want to accept with case. For this we use cmd_match.
1571  */
1572 static int cmd_match(const char *cmd, const char *str)
1573 {
1574         /* See if cmd, written into a sysfs file, matches
1575          * str.  They must either be the same, or cmd can
1576          * have a trailing newline
1577          */
1578         while (*cmd && *str && *cmd == *str) {
1579                 cmd++;
1580                 str++;
1581         }
1582         if (*cmd == '\n')
1583                 cmd++;
1584         if (*str || *cmd)
1585                 return 0;
1586         return 1;
1587 }
1588
1589 struct rdev_sysfs_entry {
1590         struct attribute attr;
1591         ssize_t (*show)(mdk_rdev_t *, char *);
1592         ssize_t (*store)(mdk_rdev_t *, const char *, size_t);
1593 };
1594
1595 static ssize_t
1596 state_show(mdk_rdev_t *rdev, char *page)
1597 {
1598         char *sep = "";
1599         int len=0;
1600
1601         if (test_bit(Faulty, &rdev->flags)) {
1602                 len+= sprintf(page+len, "%sfaulty",sep);
1603                 sep = ",";
1604         }
1605         if (test_bit(In_sync, &rdev->flags)) {
1606                 len += sprintf(page+len, "%sin_sync",sep);
1607                 sep = ",";
1608         }
1609         if (!test_bit(Faulty, &rdev->flags) &&
1610             !test_bit(In_sync, &rdev->flags)) {
1611                 len += sprintf(page+len, "%sspare", sep);
1612                 sep = ",";
1613         }
1614         return len+sprintf(page+len, "\n");
1615 }
1616
1617 static struct rdev_sysfs_entry
1618 rdev_state = __ATTR_RO(state);
1619
1620 static ssize_t
1621 super_show(mdk_rdev_t *rdev, char *page)
1622 {
1623         if (rdev->sb_loaded && rdev->sb_size) {
1624                 memcpy(page, page_address(rdev->sb_page), rdev->sb_size);
1625                 return rdev->sb_size;
1626         } else
1627                 return 0;
1628 }
1629 static struct rdev_sysfs_entry rdev_super = __ATTR_RO(super);
1630
1631 static ssize_t
1632 errors_show(mdk_rdev_t *rdev, char *page)
1633 {
1634         return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
1635 }
1636
1637 static ssize_t
1638 errors_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1639 {
1640         char *e;
1641         unsigned long n = simple_strtoul(buf, &e, 10);
1642         if (*buf && (*e == 0 || *e == '\n')) {
1643                 atomic_set(&rdev->corrected_errors, n);
1644                 return len;
1645         }
1646         return -EINVAL;
1647 }
1648 static struct rdev_sysfs_entry rdev_errors =
1649 __ATTR(errors, 0644, errors_show, errors_store);
1650
1651 static ssize_t
1652 slot_show(mdk_rdev_t *rdev, char *page)
1653 {
1654         if (rdev->raid_disk < 0)
1655                 return sprintf(page, "none\n");
1656         else
1657                 return sprintf(page, "%d\n", rdev->raid_disk);
1658 }
1659
1660 static ssize_t
1661 slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1662 {
1663         char *e;
1664         int slot = simple_strtoul(buf, &e, 10);
1665         if (strncmp(buf, "none", 4)==0)
1666                 slot = -1;
1667         else if (e==buf || (*e && *e!= '\n'))
1668                 return -EINVAL;
1669         if (rdev->mddev->pers)
1670                 /* Cannot set slot in active array (yet) */
1671                 return -EBUSY;
1672         if (slot >= rdev->mddev->raid_disks)
1673                 return -ENOSPC;
1674         rdev->raid_disk = slot;
1675         /* assume it is working */
1676         rdev->flags = 0;
1677         set_bit(In_sync, &rdev->flags);
1678         return len;
1679 }
1680
1681
1682 static struct rdev_sysfs_entry rdev_slot =
1683 __ATTR(slot, 0644, slot_show, slot_store);
1684
1685 static ssize_t
1686 offset_show(mdk_rdev_t *rdev, char *page)
1687 {
1688         return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
1689 }
1690
1691 static ssize_t
1692 offset_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1693 {
1694         char *e;
1695         unsigned long long offset = simple_strtoull(buf, &e, 10);
1696         if (e==buf || (*e && *e != '\n'))
1697                 return -EINVAL;
1698         if (rdev->mddev->pers)
1699                 return -EBUSY;
1700         rdev->data_offset = offset;
1701         return len;
1702 }
1703
1704 static struct rdev_sysfs_entry rdev_offset =
1705 __ATTR(offset, 0644, offset_show, offset_store);
1706
1707 static ssize_t
1708 rdev_size_show(mdk_rdev_t *rdev, char *page)
1709 {
1710         return sprintf(page, "%llu\n", (unsigned long long)rdev->size);
1711 }
1712
1713 static ssize_t
1714 rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
1715 {
1716         char *e;
1717         unsigned long long size = simple_strtoull(buf, &e, 10);
1718         if (e==buf || (*e && *e != '\n'))
1719                 return -EINVAL;
1720         if (rdev->mddev->pers)
1721                 return -EBUSY;
1722         rdev->size = size;
1723         if (size < rdev->mddev->size || rdev->mddev->size == 0)
1724                 rdev->mddev->size = size;
1725         return len;
1726 }
1727
1728 static struct rdev_sysfs_entry rdev_size =
1729 __ATTR(size, 0644, rdev_size_show, rdev_size_store);
1730
1731 static struct attribute *rdev_default_attrs[] = {
1732         &rdev_state.attr,
1733         &rdev_super.attr,
1734         &rdev_errors.attr,
1735         &rdev_slot.attr,
1736         &rdev_offset.attr,
1737         &rdev_size.attr,
1738         NULL,
1739 };
1740 static ssize_t
1741 rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
1742 {
1743         struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
1744         mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
1745
1746         if (!entry->show)
1747                 return -EIO;
1748         return entry->show(rdev, page);
1749 }
1750
1751 static ssize_t
1752 rdev_attr_store(struct kobject *kobj, struct attribute *attr,
1753               const char *page, size_t length)
1754 {
1755         struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
1756         mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
1757
1758         if (!entry->store)
1759                 return -EIO;
1760         return entry->store(rdev, page, length);
1761 }
1762
1763 static void rdev_free(struct kobject *ko)
1764 {
1765         mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
1766         kfree(rdev);
1767 }
1768 static struct sysfs_ops rdev_sysfs_ops = {
1769         .show           = rdev_attr_show,
1770         .store          = rdev_attr_store,
1771 };
1772 static struct kobj_type rdev_ktype = {
1773         .release        = rdev_free,
1774         .sysfs_ops      = &rdev_sysfs_ops,
1775         .default_attrs  = rdev_default_attrs,
1776 };
1777
1778 /*
1779  * Import a device. If 'super_format' >= 0, then sanity check the superblock
1780  *
1781  * mark the device faulty if:
1782  *
1783  *   - the device is nonexistent (zero size)
1784  *   - the device has no valid superblock
1785  *
1786  * a faulty rdev _never_ has rdev->sb set.
1787  */
1788 static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor)
1789 {
1790         char b[BDEVNAME_SIZE];
1791         int err;
1792         mdk_rdev_t *rdev;
1793         sector_t size;
1794
1795         rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
1796         if (!rdev) {
1797                 printk(KERN_ERR "md: could not alloc mem for new device!\n");
1798                 return ERR_PTR(-ENOMEM);
1799         }
1800
1801         if ((err = alloc_disk_sb(rdev)))
1802                 goto abort_free;
1803
1804         err = lock_rdev(rdev, newdev);
1805         if (err)
1806                 goto abort_free;
1807
1808         rdev->kobj.parent = NULL;
1809         rdev->kobj.ktype = &rdev_ktype;
1810         kobject_init(&rdev->kobj);
1811
1812         rdev->desc_nr = -1;
1813         rdev->flags = 0;
1814         rdev->data_offset = 0;
1815         atomic_set(&rdev->nr_pending, 0);
1816         atomic_set(&rdev->read_errors, 0);
1817         atomic_set(&rdev->corrected_errors, 0);
1818
1819         size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
1820         if (!size) {
1821                 printk(KERN_WARNING
1822                         "md: %s has zero or unknown size, marking faulty!\n",
1823                         bdevname(rdev->bdev,b));
1824                 err = -EINVAL;
1825                 goto abort_free;
1826         }
1827
1828         if (super_format >= 0) {
1829                 err = super_types[super_format].
1830                         load_super(rdev, NULL, super_minor);
1831                 if (err == -EINVAL) {
1832                         printk(KERN_WARNING
1833                                 "md: %s has invalid sb, not importing!\n",
1834                                 bdevname(rdev->bdev,b));
1835                         goto abort_free;
1836                 }
1837                 if (err < 0) {
1838                         printk(KERN_WARNING
1839                                 "md: could not read %s's sb, not importing!\n",
1840                                 bdevname(rdev->bdev,b));
1841                         goto abort_free;
1842                 }
1843         }
1844         INIT_LIST_HEAD(&rdev->same_set);
1845
1846         return rdev;
1847
1848 abort_free:
1849         if (rdev->sb_page) {
1850                 if (rdev->bdev)
1851                         unlock_rdev(rdev);
1852                 free_disk_sb(rdev);
1853         }
1854         kfree(rdev);
1855         return ERR_PTR(err);
1856 }
1857
1858 /*
1859  * Check a full RAID array for plausibility
1860  */
1861
1862
1863 static void analyze_sbs(mddev_t * mddev)
1864 {
1865         int i;
1866         struct list_head *tmp;
1867         mdk_rdev_t *rdev, *freshest;
1868         char b[BDEVNAME_SIZE];
1869
1870         freshest = NULL;
1871         ITERATE_RDEV(mddev,rdev,tmp)
1872                 switch (super_types[mddev->major_version].
1873                         load_super(rdev, freshest, mddev->minor_version)) {
1874                 case 1:
1875                         freshest = rdev;
1876                         break;
1877                 case 0:
1878                         break;
1879                 default:
1880                         printk( KERN_ERR \
1881                                 "md: fatal superblock inconsistency in %s"
1882                                 " -- removing from array\n",
1883                                 bdevname(rdev->bdev,b));
1884                         kick_rdev_from_array(rdev);
1885                 }
1886
1887
1888         super_types[mddev->major_version].
1889                 validate_super(mddev, freshest);
1890
1891         i = 0;
1892         ITERATE_RDEV(mddev,rdev,tmp) {
1893                 if (rdev != freshest)
1894                         if (super_types[mddev->major_version].
1895                             validate_super(mddev, rdev)) {
1896                                 printk(KERN_WARNING "md: kicking non-fresh %s"
1897                                         " from array!\n",
1898                                         bdevname(rdev->bdev,b));
1899                                 kick_rdev_from_array(rdev);
1900                                 continue;
1901                         }
1902                 if (mddev->level == LEVEL_MULTIPATH) {
1903                         rdev->desc_nr = i++;
1904                         rdev->raid_disk = rdev->desc_nr;
1905                         set_bit(In_sync, &rdev->flags);
1906                 }
1907         }
1908
1909
1910
1911         if (mddev->recovery_cp != MaxSector &&
1912             mddev->level >= 1)
1913                 printk(KERN_ERR "md: %s: raid array is not clean"
1914                        " -- starting background reconstruction\n",
1915                        mdname(mddev));
1916
1917 }
1918
1919 static ssize_t
1920 level_show(mddev_t *mddev, char *page)
1921 {
1922         struct mdk_personality *p = mddev->pers;
1923         if (p)
1924                 return sprintf(page, "%s\n", p->name);
1925         else if (mddev->clevel[0])
1926                 return sprintf(page, "%s\n", mddev->clevel);
1927         else if (mddev->level != LEVEL_NONE)
1928                 return sprintf(page, "%d\n", mddev->level);
1929         else
1930                 return 0;
1931 }
1932
1933 static ssize_t
1934 level_store(mddev_t *mddev, const char *buf, size_t len)
1935 {
1936         int rv = len;
1937         if (mddev->pers)
1938                 return -EBUSY;
1939         if (len == 0)
1940                 return 0;
1941         if (len >= sizeof(mddev->clevel))
1942                 return -ENOSPC;
1943         strncpy(mddev->clevel, buf, len);
1944         if (mddev->clevel[len-1] == '\n')
1945                 len--;
1946         mddev->clevel[len] = 0;
1947         mddev->level = LEVEL_NONE;
1948         return rv;
1949 }
1950
1951 static struct md_sysfs_entry md_level =
1952 __ATTR(level, 0644, level_show, level_store);
1953
1954 static ssize_t
1955 raid_disks_show(mddev_t *mddev, char *page)
1956 {
1957         if (mddev->raid_disks == 0)
1958                 return 0;
1959         return sprintf(page, "%d\n", mddev->raid_disks);
1960 }
1961
1962 static int update_raid_disks(mddev_t *mddev, int raid_disks);
1963
1964 static ssize_t
1965 raid_disks_store(mddev_t *mddev, const char *buf, size_t len)
1966 {
1967         /* can only set raid_disks if array is not yet active */
1968         char *e;
1969         int rv = 0;
1970         unsigned long n = simple_strtoul(buf, &e, 10);
1971
1972         if (!*buf || (*e && *e != '\n'))
1973                 return -EINVAL;
1974
1975         if (mddev->pers)
1976                 rv = update_raid_disks(mddev, n);
1977         else
1978                 mddev->raid_disks = n;
1979         return rv ? rv : len;
1980 }
1981 static struct md_sysfs_entry md_raid_disks =
1982 __ATTR(raid_disks, 0644, raid_disks_show, raid_disks_store);
1983
1984 static ssize_t
1985 chunk_size_show(mddev_t *mddev, char *page)
1986 {
1987         return sprintf(page, "%d\n", mddev->chunk_size);
1988 }
1989
1990 static ssize_t
1991 chunk_size_store(mddev_t *mddev, const char *buf, size_t len)
1992 {
1993         /* can only set chunk_size if array is not yet active */
1994         char *e;
1995         unsigned long n = simple_strtoul(buf, &e, 10);
1996
1997         if (mddev->pers)
1998                 return -EBUSY;
1999         if (!*buf || (*e && *e != '\n'))
2000                 return -EINVAL;
2001
2002         mddev->chunk_size = n;
2003         return len;
2004 }
2005 static struct md_sysfs_entry md_chunk_size =
2006 __ATTR(chunk_size, 0644, chunk_size_show, chunk_size_store);
2007
2008 static ssize_t
2009 null_show(mddev_t *mddev, char *page)
2010 {
2011         return -EINVAL;
2012 }
2013
2014 static ssize_t
2015 new_dev_store(mddev_t *mddev, const char *buf, size_t len)
2016 {
2017         /* buf must be %d:%d\n? giving major and minor numbers */
2018         /* The new device is added to the array.
2019          * If the array has a persistent superblock, we read the
2020          * superblock to initialise info and check validity.
2021          * Otherwise, only checking done is that in bind_rdev_to_array,
2022          * which mainly checks size.
2023          */
2024         char *e;
2025         int major = simple_strtoul(buf, &e, 10);
2026         int minor;
2027         dev_t dev;
2028         mdk_rdev_t *rdev;
2029         int err;
2030
2031         if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
2032                 return -EINVAL;
2033         minor = simple_strtoul(e+1, &e, 10);
2034         if (*e && *e != '\n')
2035                 return -EINVAL;
2036         dev = MKDEV(major, minor);
2037         if (major != MAJOR(dev) ||
2038             minor != MINOR(dev))
2039                 return -EOVERFLOW;
2040
2041
2042         if (mddev->persistent) {
2043                 rdev = md_import_device(dev, mddev->major_version,
2044                                         mddev->minor_version);
2045                 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
2046                         mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
2047                                                        mdk_rdev_t, same_set);
2048                         err = super_types[mddev->major_version]
2049                                 .load_super(rdev, rdev0, mddev->minor_version);
2050                         if (err < 0)
2051                                 goto out;
2052                 }
2053         } else
2054                 rdev = md_import_device(dev, -1, -1);
2055
2056         if (IS_ERR(rdev))
2057                 return PTR_ERR(rdev);
2058         err = bind_rdev_to_array(rdev, mddev);
2059  out:
2060         if (err)
2061                 export_rdev(rdev);
2062         return err ? err : len;
2063 }
2064
2065 static struct md_sysfs_entry md_new_device =
2066 __ATTR(new_dev, 0200, null_show, new_dev_store);
2067
2068 static ssize_t
2069 size_show(mddev_t *mddev, char *page)
2070 {
2071         return sprintf(page, "%llu\n", (unsigned long long)mddev->size);
2072 }
2073
2074 static int update_size(mddev_t *mddev, unsigned long size);
2075
2076 static ssize_t
2077 size_store(mddev_t *mddev, const char *buf, size_t len)
2078 {
2079         /* If array is inactive, we can reduce the component size, but
2080          * not increase it (except from 0).
2081          * If array is active, we can try an on-line resize
2082          */
2083         char *e;
2084         int err = 0;
2085         unsigned long long size = simple_strtoull(buf, &e, 10);
2086         if (!*buf || *buf == '\n' ||
2087             (*e && *e != '\n'))
2088                 return -EINVAL;
2089
2090         if (mddev->pers) {
2091                 err = update_size(mddev, size);
2092                 md_update_sb(mddev);
2093         } else {
2094                 if (mddev->size == 0 ||
2095                     mddev->size > size)
2096                         mddev->size = size;
2097                 else
2098                         err = -ENOSPC;
2099         }
2100         return err ? err : len;
2101 }
2102
2103 static struct md_sysfs_entry md_size =
2104 __ATTR(component_size, 0644, size_show, size_store);
2105
2106
2107 /* Metdata version.
2108  * This is either 'none' for arrays with externally managed metadata,
2109  * or N.M for internally known formats
2110  */
2111 static ssize_t
2112 metadata_show(mddev_t *mddev, char *page)
2113 {
2114         if (mddev->persistent)
2115                 return sprintf(page, "%d.%d\n",
2116                                mddev->major_version, mddev->minor_version);
2117         else
2118                 return sprintf(page, "none\n");
2119 }
2120
2121 static ssize_t
2122 metadata_store(mddev_t *mddev, const char *buf, size_t len)
2123 {
2124         int major, minor;
2125         char *e;
2126         if (!list_empty(&mddev->disks))
2127                 return -EBUSY;
2128
2129         if (cmd_match(buf, "none")) {
2130                 mddev->persistent = 0;
2131                 mddev->major_version = 0;
2132                 mddev->minor_version = 90;
2133                 return len;
2134         }
2135         major = simple_strtoul(buf, &e, 10);
2136         if (e==buf || *e != '.')
2137                 return -EINVAL;
2138         buf = e+1;
2139         minor = simple_strtoul(buf, &e, 10);
2140         if (e==buf || *e != '\n')
2141                 return -EINVAL;
2142         if (major >= sizeof(super_types)/sizeof(super_types[0]) ||
2143             super_types[major].name == NULL)
2144                 return -ENOENT;
2145         mddev->major_version = major;
2146         mddev->minor_version = minor;
2147         mddev->persistent = 1;
2148         return len;
2149 }
2150
2151 static struct md_sysfs_entry md_metadata =
2152 __ATTR(metadata_version, 0644, metadata_show, metadata_store);
2153
2154 static ssize_t
2155 action_show(mddev_t *mddev, char *page)
2156 {
2157         char *type = "idle";
2158         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
2159             test_bit(MD_RECOVERY_NEEDED, &mddev->recovery)) {
2160                 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
2161                         if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
2162                                 type = "resync";
2163                         else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
2164                                 type = "check";
2165                         else
2166                                 type = "repair";
2167                 } else
2168                         type = "recover";
2169         }
2170         return sprintf(page, "%s\n", type);
2171 }
2172
2173 static ssize_t
2174 action_store(mddev_t *mddev, const char *page, size_t len)
2175 {
2176         if (!mddev->pers || !mddev->pers->sync_request)
2177                 return -EINVAL;
2178
2179         if (cmd_match(page, "idle")) {
2180                 if (mddev->sync_thread) {
2181                         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
2182                         md_unregister_thread(mddev->sync_thread);
2183                         mddev->sync_thread = NULL;
2184                         mddev->recovery = 0;
2185                 }
2186         } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
2187                    test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
2188                 return -EBUSY;
2189         else if (cmd_match(page, "resync") || cmd_match(page, "recover"))
2190                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2191         else {
2192                 if (cmd_match(page, "check"))
2193                         set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
2194                 else if (cmd_match(page, "repair"))
2195                         return -EINVAL;
2196                 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
2197                 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
2198         }
2199         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2200         md_wakeup_thread(mddev->thread);
2201         return len;
2202 }
2203
2204 static ssize_t
2205 mismatch_cnt_show(mddev_t *mddev, char *page)
2206 {
2207         return sprintf(page, "%llu\n",
2208                        (unsigned long long) mddev->resync_mismatches);
2209 }
2210
2211 static struct md_sysfs_entry
2212 md_scan_mode = __ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
2213
2214
2215 static struct md_sysfs_entry
2216 md_mismatches = __ATTR_RO(mismatch_cnt);
2217
2218 static ssize_t
2219 sync_min_show(mddev_t *mddev, char *page)
2220 {
2221         return sprintf(page, "%d (%s)\n", speed_min(mddev),
2222                        mddev->sync_speed_min ? "local": "system");
2223 }
2224
2225 static ssize_t
2226 sync_min_store(mddev_t *mddev, const char *buf, size_t len)
2227 {
2228         int min;
2229         char *e;
2230         if (strncmp(buf, "system", 6)==0) {
2231                 mddev->sync_speed_min = 0;
2232                 return len;
2233         }
2234         min = simple_strtoul(buf, &e, 10);
2235         if (buf == e || (*e && *e != '\n') || min <= 0)
2236                 return -EINVAL;
2237         mddev->sync_speed_min = min;
2238         return len;
2239 }
2240
2241 static struct md_sysfs_entry md_sync_min =
2242 __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
2243
2244 static ssize_t
2245 sync_max_show(mddev_t *mddev, char *page)
2246 {
2247         return sprintf(page, "%d (%s)\n", speed_max(mddev),
2248                        mddev->sync_speed_max ? "local": "system");
2249 }
2250
2251 static ssize_t
2252 sync_max_store(mddev_t *mddev, const char *buf, size_t len)
2253 {
2254         int max;
2255         char *e;
2256         if (strncmp(buf, "system", 6)==0) {
2257                 mddev->sync_speed_max = 0;
2258                 return len;
2259         }
2260         max = simple_strtoul(buf, &e, 10);
2261         if (buf == e || (*e && *e != '\n') || max <= 0)
2262                 return -EINVAL;
2263         mddev->sync_speed_max = max;
2264         return len;
2265 }
2266
2267 static struct md_sysfs_entry md_sync_max =
2268 __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
2269
2270
2271 static ssize_t
2272 sync_speed_show(mddev_t *mddev, char *page)
2273 {
2274         unsigned long resync, dt, db;
2275         resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active));
2276         dt = ((jiffies - mddev->resync_mark) / HZ);
2277         if (!dt) dt++;
2278         db = resync - (mddev->resync_mark_cnt);
2279         return sprintf(page, "%ld\n", db/dt/2); /* K/sec */
2280 }
2281
2282 static struct md_sysfs_entry
2283 md_sync_speed = __ATTR_RO(sync_speed);
2284
2285 static ssize_t
2286 sync_completed_show(mddev_t *mddev, char *page)
2287 {
2288         unsigned long max_blocks, resync;
2289
2290         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
2291                 max_blocks = mddev->resync_max_sectors;
2292         else
2293                 max_blocks = mddev->size << 1;
2294
2295         resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active));
2296         return sprintf(page, "%lu / %lu\n", resync, max_blocks);
2297 }
2298
2299 static struct md_sysfs_entry
2300 md_sync_completed = __ATTR_RO(sync_completed);
2301
2302 static struct attribute *md_default_attrs[] = {
2303         &md_level.attr,
2304         &md_raid_disks.attr,
2305         &md_chunk_size.attr,
2306         &md_size.attr,
2307         &md_metadata.attr,
2308         &md_new_device.attr,
2309         NULL,
2310 };
2311
2312 static struct attribute *md_redundancy_attrs[] = {
2313         &md_scan_mode.attr,
2314         &md_mismatches.attr,
2315         &md_sync_min.attr,
2316         &md_sync_max.attr,
2317         &md_sync_speed.attr,
2318         &md_sync_completed.attr,
2319         NULL,
2320 };
2321 static struct attribute_group md_redundancy_group = {
2322         .name = NULL,
2323         .attrs = md_redundancy_attrs,
2324 };
2325
2326
2327 static ssize_t
2328 md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
2329 {
2330         struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
2331         mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
2332         ssize_t rv;
2333
2334         if (!entry->show)
2335                 return -EIO;
2336         mddev_lock(mddev);
2337         rv = entry->show(mddev, page);
2338         mddev_unlock(mddev);
2339         return rv;
2340 }
2341
2342 static ssize_t
2343 md_attr_store(struct kobject *kobj, struct attribute *attr,
2344               const char *page, size_t length)
2345 {
2346         struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
2347         mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
2348         ssize_t rv;
2349
2350         if (!entry->store)
2351                 return -EIO;
2352         mddev_lock(mddev);
2353         rv = entry->store(mddev, page, length);
2354         mddev_unlock(mddev);
2355         return rv;
2356 }
2357
2358 static void md_free(struct kobject *ko)
2359 {
2360         mddev_t *mddev = container_of(ko, mddev_t, kobj);
2361         kfree(mddev);
2362 }
2363
2364 static struct sysfs_ops md_sysfs_ops = {
2365         .show   = md_attr_show,
2366         .store  = md_attr_store,
2367 };
2368 static struct kobj_type md_ktype = {
2369         .release        = md_free,
2370         .sysfs_ops      = &md_sysfs_ops,
2371         .default_attrs  = md_default_attrs,
2372 };
2373
2374 int mdp_major = 0;
2375
2376 static struct kobject *md_probe(dev_t dev, int *part, void *data)
2377 {
2378         static DECLARE_MUTEX(disks_sem);
2379         mddev_t *mddev = mddev_find(dev);
2380         struct gendisk *disk;
2381         int partitioned = (MAJOR(dev) != MD_MAJOR);
2382         int shift = partitioned ? MdpMinorShift : 0;
2383         int unit = MINOR(dev) >> shift;
2384
2385         if (!mddev)
2386                 return NULL;
2387
2388         down(&disks_sem);
2389         if (mddev->gendisk) {
2390                 up(&disks_sem);
2391                 mddev_put(mddev);
2392                 return NULL;
2393         }
2394         disk = alloc_disk(1 << shift);
2395         if (!disk) {
2396                 up(&disks_sem);
2397                 mddev_put(mddev);
2398                 return NULL;
2399         }
2400         disk->major = MAJOR(dev);
2401         disk->first_minor = unit << shift;
2402         if (partitioned) {
2403                 sprintf(disk->disk_name, "md_d%d", unit);
2404                 sprintf(disk->devfs_name, "md/d%d", unit);
2405         } else {
2406                 sprintf(disk->disk_name, "md%d", unit);
2407                 sprintf(disk->devfs_name, "md/%d", unit);
2408         }
2409         disk->fops = &md_fops;
2410         disk->private_data = mddev;
2411         disk->queue = mddev->queue;
2412         add_disk(disk);
2413         mddev->gendisk = disk;
2414         up(&disks_sem);
2415         mddev->kobj.parent = &disk->kobj;
2416         mddev->kobj.k_name = NULL;
2417         snprintf(mddev->kobj.name, KOBJ_NAME_LEN, "%s", "md");
2418         mddev->kobj.ktype = &md_ktype;
2419         kobject_register(&mddev->kobj);
2420         return NULL;
2421 }
2422
2423 void md_wakeup_thread(mdk_thread_t *thread);
2424
2425 static void md_safemode_timeout(unsigned long data)
2426 {
2427         mddev_t *mddev = (mddev_t *) data;
2428
2429         mddev->safemode = 1;
2430         md_wakeup_thread(mddev->thread);
2431 }
2432
2433 static int start_dirty_degraded;
2434
2435 static int do_md_run(mddev_t * mddev)
2436 {
2437         int err;
2438         int chunk_size;
2439         struct list_head *tmp;
2440         mdk_rdev_t *rdev;
2441         struct gendisk *disk;
2442         struct mdk_personality *pers;
2443         char b[BDEVNAME_SIZE];
2444
2445         if (list_empty(&mddev->disks))
2446                 /* cannot run an array with no devices.. */
2447                 return -EINVAL;
2448
2449         if (mddev->pers)
2450                 return -EBUSY;
2451
2452         /*
2453          * Analyze all RAID superblock(s)
2454          */
2455         if (!mddev->raid_disks)
2456                 analyze_sbs(mddev);
2457
2458         chunk_size = mddev->chunk_size;
2459
2460         if (chunk_size) {
2461                 if (chunk_size > MAX_CHUNK_SIZE) {
2462                         printk(KERN_ERR "too big chunk_size: %d > %d\n",
2463                                 chunk_size, MAX_CHUNK_SIZE);
2464                         return -EINVAL;
2465                 }
2466                 /*
2467                  * chunk-size has to be a power of 2 and multiples of PAGE_SIZE
2468                  */
2469                 if ( (1 << ffz(~chunk_size)) != chunk_size) {
2470                         printk(KERN_ERR "chunk_size of %d not valid\n", chunk_size);
2471                         return -EINVAL;
2472                 }
2473                 if (chunk_size < PAGE_SIZE) {
2474                         printk(KERN_ERR "too small chunk_size: %d < %ld\n",
2475                                 chunk_size, PAGE_SIZE);
2476                         return -EINVAL;
2477                 }
2478
2479                 /* devices must have minimum size of one chunk */
2480                 ITERATE_RDEV(mddev,rdev,tmp) {
2481                         if (test_bit(Faulty, &rdev->flags))
2482                                 continue;
2483                         if (rdev->size < chunk_size / 1024) {
2484                                 printk(KERN_WARNING
2485                                         "md: Dev %s smaller than chunk_size:"
2486                                         " %lluk < %dk\n",
2487                                         bdevname(rdev->bdev,b),
2488                                         (unsigned long long)rdev->size,
2489                                         chunk_size / 1024);
2490                                 return -EINVAL;
2491                         }
2492                 }
2493         }
2494
2495 #ifdef CONFIG_KMOD
2496         if (mddev->level != LEVEL_NONE)
2497                 request_module("md-level-%d", mddev->level);
2498         else if (mddev->clevel[0])
2499                 request_module("md-%s", mddev->clevel);
2500 #endif
2501
2502         /*
2503          * Drop all container device buffers, from now on
2504          * the only valid external interface is through the md
2505          * device.
2506          * Also find largest hardsector size
2507          */
2508         ITERATE_RDEV(mddev,rdev,tmp) {
2509                 if (test_bit(Faulty, &rdev->flags))
2510                         continue;
2511                 sync_blockdev(rdev->bdev);
2512                 invalidate_bdev(rdev->bdev, 0);
2513         }
2514
2515         md_probe(mddev->unit, NULL, NULL);
2516         disk = mddev->gendisk;
2517         if (!disk)
2518                 return -ENOMEM;
2519
2520         spin_lock(&pers_lock);
2521         pers = find_pers(mddev->level, mddev->clevel);
2522         if (!pers || !try_module_get(pers->owner)) {
2523                 spin_unlock(&pers_lock);
2524                 if (mddev->level != LEVEL_NONE)
2525                         printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
2526                                mddev->level);
2527                 else
2528                         printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
2529                                mddev->clevel);
2530                 return -EINVAL;
2531         }
2532         mddev->pers = pers;
2533         spin_unlock(&pers_lock);
2534         mddev->level = pers->level;
2535         strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
2536
2537         mddev->recovery = 0;
2538         mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */
2539         mddev->barriers_work = 1;
2540         mddev->ok_start_degraded = start_dirty_degraded;
2541
2542         if (start_readonly)
2543                 mddev->ro = 2; /* read-only, but switch on first write */
2544
2545         err = mddev->pers->run(mddev);
2546         if (!err && mddev->pers->sync_request) {
2547                 err = bitmap_create(mddev);
2548                 if (err) {
2549                         printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
2550                                mdname(mddev), err);
2551                         mddev->pers->stop(mddev);
2552                 }
2553         }
2554         if (err) {
2555                 printk(KERN_ERR "md: pers->run() failed ...\n");
2556                 module_put(mddev->pers->owner);
2557                 mddev->pers = NULL;
2558                 bitmap_destroy(mddev);
2559                 return err;
2560         }
2561         if (mddev->pers->sync_request)
2562                 sysfs_create_group(&mddev->kobj, &md_redundancy_group);
2563         else if (mddev->ro == 2) /* auto-readonly not meaningful */
2564                 mddev->ro = 0;
2565
2566         atomic_set(&mddev->writes_pending,0);
2567         mddev->safemode = 0;
2568         mddev->safemode_timer.function = md_safemode_timeout;
2569         mddev->safemode_timer.data = (unsigned long) mddev;
2570         mddev->safemode_delay = (20 * HZ)/1000 +1; /* 20 msec delay */
2571         mddev->in_sync = 1;
2572
2573         ITERATE_RDEV(mddev,rdev,tmp)
2574                 if (rdev->raid_disk >= 0) {
2575                         char nm[20];
2576                         sprintf(nm, "rd%d", rdev->raid_disk);
2577                         sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
2578                 }
2579
2580         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2581         md_wakeup_thread(mddev->thread);
2582
2583         if (mddev->sb_dirty)
2584                 md_update_sb(mddev);
2585
2586         set_capacity(disk, mddev->array_size<<1);
2587
2588         /* If we call blk_queue_make_request here, it will
2589          * re-initialise max_sectors etc which may have been
2590          * refined inside -> run.  So just set the bits we need to set.
2591          * Most initialisation happended when we called
2592          * blk_queue_make_request(..., md_fail_request)
2593          * earlier.
2594          */
2595         mddev->queue->queuedata = mddev;
2596         mddev->queue->make_request_fn = mddev->pers->make_request;
2597
2598         mddev->changed = 1;
2599         md_new_event(mddev);
2600         return 0;
2601 }
2602
2603 static int restart_array(mddev_t *mddev)
2604 {
2605         struct gendisk *disk = mddev->gendisk;
2606         int err;
2607
2608         /*
2609          * Complain if it has no devices
2610          */
2611         err = -ENXIO;
2612         if (list_empty(&mddev->disks))
2613                 goto out;
2614
2615         if (mddev->pers) {
2616                 err = -EBUSY;
2617                 if (!mddev->ro)
2618                         goto out;
2619
2620                 mddev->safemode = 0;
2621                 mddev->ro = 0;
2622                 set_disk_ro(disk, 0);
2623
2624                 printk(KERN_INFO "md: %s switched to read-write mode.\n",
2625                         mdname(mddev));
2626                 /*
2627                  * Kick recovery or resync if necessary
2628                  */
2629                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2630                 md_wakeup_thread(mddev->thread);
2631                 err = 0;
2632         } else {
2633                 printk(KERN_ERR "md: %s has no personality assigned.\n",
2634                         mdname(mddev));
2635                 err = -EINVAL;
2636         }
2637
2638 out:
2639         return err;
2640 }
2641
2642 static int do_md_stop(mddev_t * mddev, int ro)
2643 {
2644         int err = 0;
2645         struct gendisk *disk = mddev->gendisk;
2646
2647         if (mddev->pers) {
2648                 if (atomic_read(&mddev->active)>2) {
2649                         printk("md: %s still in use.\n",mdname(mddev));
2650                         return -EBUSY;
2651                 }
2652
2653                 if (mddev->sync_thread) {
2654                         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
2655                         md_unregister_thread(mddev->sync_thread);
2656                         mddev->sync_thread = NULL;
2657                 }
2658
2659                 del_timer_sync(&mddev->safemode_timer);
2660
2661                 invalidate_partition(disk, 0);
2662
2663                 if (ro) {
2664                         err  = -ENXIO;
2665                         if (mddev->ro==1)
2666                                 goto out;
2667                         mddev->ro = 1;
2668                 } else {
2669                         bitmap_flush(mddev);
2670                         md_super_wait(mddev);
2671                         if (mddev->ro)
2672                                 set_disk_ro(disk, 0);
2673                         blk_queue_make_request(mddev->queue, md_fail_request);
2674                         mddev->pers->stop(mddev);
2675                         if (mddev->pers->sync_request)
2676                                 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
2677
2678                         module_put(mddev->pers->owner);
2679                         mddev->pers = NULL;
2680                         if (mddev->ro)
2681                                 mddev->ro = 0;
2682                 }
2683                 if (!mddev->in_sync) {
2684                         /* mark array as shutdown cleanly */
2685                         mddev->in_sync = 1;
2686                         md_update_sb(mddev);
2687                 }
2688                 if (ro)
2689                         set_disk_ro(disk, 1);
2690         }
2691
2692         bitmap_destroy(mddev);
2693         if (mddev->bitmap_file) {
2694                 atomic_set(&mddev->bitmap_file->f_dentry->d_inode->i_writecount, 1);
2695                 fput(mddev->bitmap_file);
2696                 mddev->bitmap_file = NULL;
2697         }
2698         mddev->bitmap_offset = 0;
2699
2700         /*
2701          * Free resources if final stop
2702          */
2703         if (!ro) {
2704                 mdk_rdev_t *rdev;
2705                 struct list_head *tmp;
2706                 struct gendisk *disk;
2707                 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
2708
2709                 ITERATE_RDEV(mddev,rdev,tmp)
2710                         if (rdev->raid_disk >= 0) {
2711                                 char nm[20];
2712                                 sprintf(nm, "rd%d", rdev->raid_disk);
2713                                 sysfs_remove_link(&mddev->kobj, nm);
2714                         }
2715
2716                 export_array(mddev);
2717
2718                 mddev->array_size = 0;
2719                 disk = mddev->gendisk;
2720                 if (disk)
2721                         set_capacity(disk, 0);
2722                 mddev->changed = 1;
2723         } else
2724                 printk(KERN_INFO "md: %s switched to read-only mode.\n",
2725                         mdname(mddev));
2726         err = 0;
2727         md_new_event(mddev);
2728 out:
2729         return err;
2730 }
2731
2732 static void autorun_array(mddev_t *mddev)
2733 {
2734         mdk_rdev_t *rdev;
2735         struct list_head *tmp;
2736         int err;
2737
2738         if (list_empty(&mddev->disks))
2739                 return;
2740
2741         printk(KERN_INFO "md: running: ");
2742
2743         ITERATE_RDEV(mddev,rdev,tmp) {
2744                 char b[BDEVNAME_SIZE];
2745                 printk("<%s>", bdevname(rdev->bdev,b));
2746         }
2747         printk("\n");
2748
2749         err = do_md_run (mddev);
2750         if (err) {
2751                 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
2752                 do_md_stop (mddev, 0);
2753         }
2754 }
2755
2756 /*
2757  * lets try to run arrays based on all disks that have arrived
2758  * until now. (those are in pending_raid_disks)
2759  *
2760  * the method: pick the first pending disk, collect all disks with
2761  * the same UUID, remove all from the pending list and put them into
2762  * the 'same_array' list. Then order this list based on superblock
2763  * update time (freshest comes first), kick out 'old' disks and
2764  * compare superblocks. If everything's fine then run it.
2765  *
2766  * If "unit" is allocated, then bump its reference count
2767  */
2768 static void autorun_devices(int part)
2769 {
2770         struct list_head candidates;
2771         struct list_head *tmp;
2772         mdk_rdev_t *rdev0, *rdev;
2773         mddev_t *mddev;
2774         char b[BDEVNAME_SIZE];
2775
2776         printk(KERN_INFO "md: autorun ...\n");
2777         while (!list_empty(&pending_raid_disks)) {
2778                 dev_t dev;
2779                 rdev0 = list_entry(pending_raid_disks.next,
2780                                          mdk_rdev_t, same_set);
2781
2782                 printk(KERN_INFO "md: considering %s ...\n",
2783                         bdevname(rdev0->bdev,b));
2784                 INIT_LIST_HEAD(&candidates);
2785                 ITERATE_RDEV_PENDING(rdev,tmp)
2786                         if (super_90_load(rdev, rdev0, 0) >= 0) {
2787                                 printk(KERN_INFO "md:  adding %s ...\n",
2788                                         bdevname(rdev->bdev,b));
2789                                 list_move(&rdev->same_set, &candidates);
2790                         }
2791                 /*
2792                  * now we have a set of devices, with all of them having
2793                  * mostly sane superblocks. It's time to allocate the
2794                  * mddev.
2795                  */
2796                 if (rdev0->preferred_minor < 0 || rdev0->preferred_minor >= MAX_MD_DEVS) {
2797                         printk(KERN_INFO "md: unit number in %s is bad: %d\n",
2798                                bdevname(rdev0->bdev, b), rdev0->preferred_minor);
2799                         break;
2800                 }
2801                 if (part)
2802                         dev = MKDEV(mdp_major,
2803                                     rdev0->preferred_minor << MdpMinorShift);
2804                 else
2805                         dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
2806
2807                 md_probe(dev, NULL, NULL);
2808                 mddev = mddev_find(dev);
2809                 if (!mddev) {
2810                         printk(KERN_ERR
2811                                 "md: cannot allocate memory for md drive.\n");
2812                         break;
2813                 }
2814                 if (mddev_lock(mddev))
2815                         printk(KERN_WARNING "md: %s locked, cannot run\n",
2816                                mdname(mddev));
2817                 else if (mddev->raid_disks || mddev->major_version
2818                          || !list_empty(&mddev->disks)) {
2819                         printk(KERN_WARNING
2820                                 "md: %s already running, cannot run %s\n",
2821                                 mdname(mddev), bdevname(rdev0->bdev,b));
2822                         mddev_unlock(mddev);
2823                 } else {
2824                         printk(KERN_INFO "md: created %s\n", mdname(mddev));
2825                         ITERATE_RDEV_GENERIC(candidates,rdev,tmp) {
2826                                 list_del_init(&rdev->same_set);
2827                                 if (bind_rdev_to_array(rdev, mddev))
2828                                         export_rdev(rdev);
2829                         }
2830                         autorun_array(mddev);
2831                         mddev_unlock(mddev);
2832                 }
2833                 /* on success, candidates will be empty, on error
2834                  * it won't...
2835                  */
2836                 ITERATE_RDEV_GENERIC(candidates,rdev,tmp)
2837                         export_rdev(rdev);
2838                 mddev_put(mddev);
2839         }
2840         printk(KERN_INFO "md: ... autorun DONE.\n");
2841 }
2842
2843 /*
2844  * import RAID devices based on one partition
2845  * if possible, the array gets run as well.
2846  */
2847
2848 static int autostart_array(dev_t startdev)
2849 {
2850         char b[BDEVNAME_SIZE];
2851         int err = -EINVAL, i;
2852         mdp_super_t *sb = NULL;
2853         mdk_rdev_t *start_rdev = NULL, *rdev;
2854
2855         start_rdev = md_import_device(startdev, 0, 0);
2856         if (IS_ERR(start_rdev))
2857                 return err;
2858
2859
2860         /* NOTE: this can only work for 0.90.0 superblocks */
2861         sb = (mdp_super_t*)page_address(start_rdev->sb_page);
2862         if (sb->major_version != 0 ||
2863             sb->minor_version != 90 ) {
2864                 printk(KERN_WARNING "md: can only autostart 0.90.0 arrays\n");
2865                 export_rdev(start_rdev);
2866                 return err;
2867         }
2868
2869         if (test_bit(Faulty, &start_rdev->flags)) {
2870                 printk(KERN_WARNING
2871                         "md: can not autostart based on faulty %s!\n",
2872                         bdevname(start_rdev->bdev,b));
2873                 export_rdev(start_rdev);
2874                 return err;
2875         }
2876         list_add(&start_rdev->same_set, &pending_raid_disks);
2877
2878         for (i = 0; i < MD_SB_DISKS; i++) {
2879                 mdp_disk_t *desc = sb->disks + i;
2880                 dev_t dev = MKDEV(desc->major, desc->minor);
2881
2882                 if (!dev)
2883                         continue;
2884                 if (dev == startdev)
2885                         continue;
2886                 if (MAJOR(dev) != desc->major || MINOR(dev) != desc->minor)
2887                         continue;
2888                 rdev = md_import_device(dev, 0, 0);
2889                 if (IS_ERR(rdev))
2890                         continue;
2891
2892                 list_add(&rdev->same_set, &pending_raid_disks);
2893         }
2894
2895         /*
2896          * possibly return codes
2897          */
2898         autorun_devices(0);
2899         return 0;
2900
2901 }
2902
2903
2904 static int get_version(void __user * arg)
2905 {
2906         mdu_version_t ver;
2907
2908         ver.major = MD_MAJOR_VERSION;
2909         ver.minor = MD_MINOR_VERSION;
2910         ver.patchlevel = MD_PATCHLEVEL_VERSION;
2911
2912         if (copy_to_user(arg, &ver, sizeof(ver)))
2913                 return -EFAULT;
2914
2915         return 0;
2916 }
2917
2918 static int get_array_info(mddev_t * mddev, void __user * arg)
2919 {
2920         mdu_array_info_t info;
2921         int nr,working,active,failed,spare;
2922         mdk_rdev_t *rdev;
2923         struct list_head *tmp;
2924
2925         nr=working=active=failed=spare=0;
2926         ITERATE_RDEV(mddev,rdev,tmp) {
2927                 nr++;
2928                 if (test_bit(Faulty, &rdev->flags))
2929                         failed++;
2930                 else {
2931                         working++;
2932                         if (test_bit(In_sync, &rdev->flags))
2933                                 active++;
2934                         else
2935                                 spare++;
2936                 }
2937         }
2938
2939         info.major_version = mddev->major_version;
2940         info.minor_version = mddev->minor_version;
2941         info.patch_version = MD_PATCHLEVEL_VERSION;
2942         info.ctime         = mddev->ctime;
2943         info.level         = mddev->level;
2944         info.size          = mddev->size;
2945         info.nr_disks      = nr;
2946         info.raid_disks    = mddev->raid_disks;
2947         info.md_minor      = mddev->md_minor;
2948         info.not_persistent= !mddev->persistent;
2949
2950         info.utime         = mddev->utime;
2951         info.state         = 0;
2952         if (mddev->in_sync)
2953                 info.state = (1<<MD_SB_CLEAN);
2954         if (mddev->bitmap && mddev->bitmap_offset)
2955                 info.state = (1<<MD_SB_BITMAP_PRESENT);
2956         info.active_disks  = active;
2957         info.working_disks = working;
2958         info.failed_disks  = failed;
2959         info.spare_disks   = spare;
2960
2961         info.layout        = mddev->layout;
2962         info.chunk_size    = mddev->chunk_size;
2963
2964         if (copy_to_user(arg, &info, sizeof(info)))
2965                 return -EFAULT;
2966
2967         return 0;
2968 }
2969
2970 static int get_bitmap_file(mddev_t * mddev, void __user * arg)
2971 {
2972         mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
2973         char *ptr, *buf = NULL;
2974         int err = -ENOMEM;
2975
2976         file = kmalloc(sizeof(*file), GFP_KERNEL);
2977         if (!file)
2978                 goto out;
2979
2980         /* bitmap disabled, zero the first byte and copy out */
2981         if (!mddev->bitmap || !mddev->bitmap->file) {
2982                 file->pathname[0] = '\0';
2983                 goto copy_out;
2984         }
2985
2986         buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
2987         if (!buf)
2988                 goto out;
2989
2990         ptr = file_path(mddev->bitmap->file, buf, sizeof(file->pathname));
2991         if (!ptr)
2992                 goto out;
2993
2994         strcpy(file->pathname, ptr);
2995
2996 copy_out:
2997         err = 0;
2998         if (copy_to_user(arg, file, sizeof(*file)))
2999                 err = -EFAULT;
3000 out:
3001         kfree(buf);
3002         kfree(file);
3003         return err;
3004 }
3005
3006 static int get_disk_info(mddev_t * mddev, void __user * arg)
3007 {
3008         mdu_disk_info_t info;
3009         unsigned int nr;
3010         mdk_rdev_t *rdev;
3011
3012         if (copy_from_user(&info, arg, sizeof(info)))
3013                 return -EFAULT;
3014
3015         nr = info.number;
3016
3017         rdev = find_rdev_nr(mddev, nr);
3018         if (rdev) {
3019                 info.major = MAJOR(rdev->bdev->bd_dev);
3020                 info.minor = MINOR(rdev->bdev->bd_dev);
3021                 info.raid_disk = rdev->raid_disk;
3022                 info.state = 0;
3023                 if (test_bit(Faulty, &rdev->flags))
3024                         info.state |= (1<<MD_DISK_FAULTY);
3025                 else if (test_bit(In_sync, &rdev->flags)) {
3026                         info.state |= (1<<MD_DISK_ACTIVE);
3027                         info.state |= (1<<MD_DISK_SYNC);
3028                 }
3029                 if (test_bit(WriteMostly, &rdev->flags))
3030                         info.state |= (1<<MD_DISK_WRITEMOSTLY);
3031         } else {
3032                 info.major = info.minor = 0;
3033                 info.raid_disk = -1;
3034                 info.state = (1<<MD_DISK_REMOVED);
3035         }
3036
3037         if (copy_to_user(arg, &info, sizeof(info)))
3038                 return -EFAULT;
3039
3040         return 0;
3041 }
3042
3043 static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
3044 {
3045         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
3046         mdk_rdev_t *rdev;
3047         dev_t dev = MKDEV(info->major,info->minor);
3048
3049         if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
3050                 return -EOVERFLOW;
3051
3052         if (!mddev->raid_disks) {
3053                 int err;
3054                 /* expecting a device which has a superblock */
3055                 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
3056                 if (IS_ERR(rdev)) {
3057                         printk(KERN_WARNING
3058                                 "md: md_import_device returned %ld\n",
3059                                 PTR_ERR(rdev));
3060                         return PTR_ERR(rdev);
3061                 }
3062                 if (!list_empty(&mddev->disks)) {
3063                         mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
3064                                                         mdk_rdev_t, same_set);
3065                         int err = super_types[mddev->major_version]
3066                                 .load_super(rdev, rdev0, mddev->minor_version);
3067                         if (err < 0) {
3068                                 printk(KERN_WARNING
3069                                         "md: %s has different UUID to %s\n",
3070                                         bdevname(rdev->bdev,b),
3071                                         bdevname(rdev0->bdev,b2));
3072                                 export_rdev(rdev);
3073                                 return -EINVAL;
3074                         }
3075                 }
3076                 err = bind_rdev_to_array(rdev, mddev);
3077                 if (err)
3078                         export_rdev(rdev);
3079                 return err;
3080         }
3081
3082         /*
3083          * add_new_disk can be used once the array is assembled
3084          * to add "hot spares".  They must already have a superblock
3085          * written
3086          */
3087         if (mddev->pers) {
3088                 int err;
3089                 if (!mddev->pers->hot_add_disk) {
3090                         printk(KERN_WARNING
3091                                 "%s: personality does not support diskops!\n",
3092                                mdname(mddev));
3093                         return -EINVAL;
3094                 }
3095                 if (mddev->persistent)
3096                         rdev = md_import_device(dev, mddev->major_version,
3097                                                 mddev->minor_version);
3098                 else
3099                         rdev = md_import_device(dev, -1, -1);
3100                 if (IS_ERR(rdev)) {
3101                         printk(KERN_WARNING
3102                                 "md: md_import_device returned %ld\n",
3103                                 PTR_ERR(rdev));
3104                         return PTR_ERR(rdev);
3105                 }
3106                 /* set save_raid_disk if appropriate */
3107                 if (!mddev->persistent) {
3108                         if (info->state & (1<<MD_DISK_SYNC)  &&
3109                             info->raid_disk < mddev->raid_disks)
3110                                 rdev->raid_disk = info->raid_disk;
3111                         else
3112                                 rdev->raid_disk = -1;
3113                 } else
3114                         super_types[mddev->major_version].
3115                                 validate_super(mddev, rdev);
3116                 rdev->saved_raid_disk = rdev->raid_disk;
3117
3118                 clear_bit(In_sync, &rdev->flags); /* just to be sure */
3119                 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
3120                         set_bit(WriteMostly, &rdev->flags);
3121
3122                 rdev->raid_disk = -1;
3123                 err = bind_rdev_to_array(rdev, mddev);
3124                 if (err)
3125                         export_rdev(rdev);
3126
3127                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3128                 md_wakeup_thread(mddev->thread);
3129                 return err;
3130         }
3131
3132         /* otherwise, add_new_disk is only allowed
3133          * for major_version==0 superblocks
3134          */
3135         if (mddev->major_version != 0) {
3136                 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
3137                        mdname(mddev));
3138                 return -EINVAL;
3139         }
3140
3141         if (!(info->state & (1<<MD_DISK_FAULTY))) {
3142                 int err;
3143                 rdev = md_import_device (dev, -1, 0);
3144                 if (IS_ERR(rdev)) {
3145                         printk(KERN_WARNING
3146                                 "md: error, md_import_device() returned %ld\n",
3147                                 PTR_ERR(rdev));
3148                         return PTR_ERR(rdev);
3149                 }
3150                 rdev->desc_nr = info->number;
3151                 if (info->raid_disk < mddev->raid_disks)
3152                         rdev->raid_disk = info->raid_disk;
3153                 else
3154                         rdev->raid_disk = -1;
3155
3156                 rdev->flags = 0;
3157
3158                 if (rdev->raid_disk < mddev->raid_disks)
3159                         if (info->state & (1<<MD_DISK_SYNC))
3160                                 set_bit(In_sync, &rdev->flags);
3161
3162                 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
3163                         set_bit(WriteMostly, &rdev->flags);
3164
3165                 if (!mddev->persistent) {
3166                         printk(KERN_INFO "md: nonpersistent superblock ...\n");
3167                         rdev->sb_offset = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
3168                 } else
3169                         rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
3170                 rdev->size = calc_dev_size(rdev, mddev->chunk_size);
3171
3172                 err = bind_rdev_to_array(rdev, mddev);
3173                 if (err) {
3174                         export_rdev(rdev);
3175                         return err;
3176                 }
3177         }
3178
3179         return 0;
3180 }
3181
3182 static int hot_remove_disk(mddev_t * mddev, dev_t dev)
3183 {
3184         char b[BDEVNAME_SIZE];
3185         mdk_rdev_t *rdev;
3186
3187         if (!mddev->pers)
3188                 return -ENODEV;
3189
3190         rdev = find_rdev(mddev, dev);
3191         if (!rdev)
3192                 return -ENXIO;
3193
3194         if (rdev->raid_disk >= 0)
3195                 goto busy;
3196
3197         kick_rdev_from_array(rdev);
3198         md_update_sb(mddev);
3199         md_new_event(mddev);
3200
3201         return 0;
3202 busy:
3203         printk(KERN_WARNING "md: cannot remove active disk %s from %s ... \n",
3204                 bdevname(rdev->bdev,b), mdname(mddev));
3205         return -EBUSY;
3206 }
3207
3208 static int hot_add_disk(mddev_t * mddev, dev_t dev)
3209 {
3210         char b[BDEVNAME_SIZE];
3211         int err;
3212         unsigned int size;
3213         mdk_rdev_t *rdev;
3214
3215         if (!mddev->pers)
3216                 return -ENODEV;
3217
3218         if (mddev->major_version != 0) {
3219                 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
3220                         " version-0 superblocks.\n",
3221                         mdname(mddev));
3222                 return -EINVAL;
3223         }
3224         if (!mddev->pers->hot_add_disk) {
3225                 printk(KERN_WARNING
3226                         "%s: personality does not support diskops!\n",
3227                         mdname(mddev));
3228                 return -EINVAL;
3229         }
3230
3231         rdev = md_import_device (dev, -1, 0);
3232         if (IS_ERR(rdev)) {
3233                 printk(KERN_WARNING
3234                         "md: error, md_import_device() returned %ld\n",
3235                         PTR_ERR(rdev));
3236                 return -EINVAL;
3237         }
3238
3239         if (mddev->persistent)
3240                 rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
3241         else
3242                 rdev->sb_offset =
3243                         rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
3244
3245         size = calc_dev_size(rdev, mddev->chunk_size);
3246         rdev->size = size;
3247
3248         if (test_bit(Faulty, &rdev->flags)) {
3249                 printk(KERN_WARNING
3250                         "md: can not hot-add faulty %s disk to %s!\n",
3251                         bdevname(rdev->bdev,b), mdname(mddev));
3252                 err = -EINVAL;
3253                 goto abort_export;
3254         }
3255         clear_bit(In_sync, &rdev->flags);
3256         rdev->desc_nr = -1;
3257         err = bind_rdev_to_array(rdev, mddev);
3258         if (err)
3259                 goto abort_export;
3260
3261         /*
3262          * The rest should better be atomic, we can have disk failures
3263          * noticed in interrupt contexts ...
3264          */
3265
3266         if (rdev->desc_nr == mddev->max_disks) {
3267                 printk(KERN_WARNING "%s: can not hot-add to full array!\n",
3268                         mdname(mddev));
3269                 err = -EBUSY;
3270                 goto abort_unbind_export;
3271         }
3272
3273         rdev->raid_disk = -1;
3274
3275         md_update_sb(mddev);
3276
3277         /*
3278          * Kick recovery, maybe this spare has to be added to the
3279          * array immediately.
3280          */
3281         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3282         md_wakeup_thread(mddev->thread);
3283         md_new_event(mddev);
3284         return 0;
3285
3286 abort_unbind_export:
3287         unbind_rdev_from_array(rdev);
3288
3289 abort_export:
3290         export_rdev(rdev);
3291         return err;
3292 }
3293
3294 /* similar to deny_write_access, but accounts for our holding a reference
3295  * to the file ourselves */
3296 static int deny_bitmap_write_access(struct file * file)
3297 {
3298         struct inode *inode = file->f_mapping->host;
3299
3300         spin_lock(&inode->i_lock);
3301         if (atomic_read(&inode->i_writecount) > 1) {
3302                 spin_unlock(&inode->i_lock);
3303                 return -ETXTBSY;
3304         }
3305         atomic_set(&inode->i_writecount, -1);
3306         spin_unlock(&inode->i_lock);
3307
3308         return 0;
3309 }
3310
3311 static int set_bitmap_file(mddev_t *mddev, int fd)
3312 {
3313         int err;
3314
3315         if (mddev->pers) {
3316                 if (!mddev->pers->quiesce)
3317                         return -EBUSY;
3318                 if (mddev->recovery || mddev->sync_thread)
3319                         return -EBUSY;
3320                 /* we should be able to change the bitmap.. */
3321         }
3322
3323
3324         if (fd >= 0) {
3325                 if (mddev->bitmap)
3326                         return -EEXIST; /* cannot add when bitmap is present */
3327                 mddev->bitmap_file = fget(fd);
3328
3329                 if (mddev->bitmap_file == NULL) {
3330                         printk(KERN_ERR "%s: error: failed to get bitmap file\n",
3331                                mdname(mddev));
3332                         return -EBADF;
3333                 }
3334
3335                 err = deny_bitmap_write_access(mddev->bitmap_file);
3336                 if (err) {
3337                         printk(KERN_ERR "%s: error: bitmap file is already in use\n",
3338                                mdname(mddev));
3339                         fput(mddev->bitmap_file);
3340                         mddev->bitmap_file = NULL;
3341                         return err;
3342                 }
3343                 mddev->bitmap_offset = 0; /* file overrides offset */
3344         } else if (mddev->bitmap == NULL)
3345                 return -ENOENT; /* cannot remove what isn't there */
3346         err = 0;
3347         if (mddev->pers) {
3348                 mddev->pers->quiesce(mddev, 1);
3349                 if (fd >= 0)
3350                         err = bitmap_create(mddev);
3351                 if (fd < 0 || err)
3352                         bitmap_destroy(mddev);
3353                 mddev->pers->quiesce(mddev, 0);
3354         } else if (fd < 0) {
3355                 if (mddev->bitmap_file)
3356                         fput(mddev->bitmap_file);
3357                 mddev->bitmap_file = NULL;
3358         }
3359
3360         return err;
3361 }
3362
3363 /*
3364  * set_array_info is used two different ways
3365  * The original usage is when creating a new array.
3366  * In this usage, raid_disks is > 0 and it together with
3367  *  level, size, not_persistent,layout,chunksize determine the
3368  *  shape of the array.
3369  *  This will always create an array with a type-0.90.0 superblock.
3370  * The newer usage is when assembling an array.
3371  *  In this case raid_disks will be 0, and the major_version field is
3372  *  use to determine which style super-blocks are to be found on the devices.
3373  *  The minor and patch _version numbers are also kept incase the
3374  *  super_block handler wishes to interpret them.
3375  */
3376 static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
3377 {
3378
3379         if (info->raid_disks == 0) {
3380                 /* just setting version number for superblock loading */
3381                 if (info->major_version < 0 ||
3382                     info->major_version >= sizeof(super_types)/sizeof(super_types[0]) ||
3383                     super_types[info->major_version].name == NULL) {
3384                         /* maybe try to auto-load a module? */
3385                         printk(KERN_INFO
3386                                 "md: superblock version %d not known\n",
3387                                 info->major_version);
3388                         return -EINVAL;
3389                 }
3390                 mddev->major_version = info->major_version;
3391                 mddev->minor_version = info->minor_version;
3392                 mddev->patch_version = info->patch_version;
3393                 return 0;
3394         }
3395         mddev->major_version = MD_MAJOR_VERSION;
3396         mddev->minor_version = MD_MINOR_VERSION;
3397         mddev->patch_version = MD_PATCHLEVEL_VERSION;
3398         mddev->ctime         = get_seconds();
3399
3400         mddev->level         = info->level;
3401         mddev->clevel[0]     = 0;
3402         mddev->size          = info->size;
3403         mddev->raid_disks    = info->raid_disks;
3404         /* don't set md_minor, it is determined by which /dev/md* was
3405          * openned
3406          */
3407         if (info->state & (1<<MD_SB_CLEAN))
3408                 mddev->recovery_cp = MaxSector;
3409         else
3410                 mddev->recovery_cp = 0;
3411         mddev->persistent    = ! info->not_persistent;
3412
3413         mddev->layout        = info->layout;
3414         mddev->chunk_size    = info->chunk_size;
3415
3416         mddev->max_disks     = MD_SB_DISKS;
3417
3418         mddev->sb_dirty      = 1;
3419
3420         mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
3421         mddev->bitmap_offset = 0;
3422
3423         /*
3424          * Generate a 128 bit UUID
3425          */
3426         get_random_bytes(mddev->uuid, 16);
3427
3428         return 0;
3429 }
3430
3431 static int update_size(mddev_t *mddev, unsigned long size)
3432 {
3433         mdk_rdev_t * rdev;
3434         int rv;
3435         struct list_head *tmp;
3436
3437         if (mddev->pers->resize == NULL)
3438                 return -EINVAL;
3439         /* The "size" is the amount of each device that is used.
3440          * This can only make sense for arrays with redundancy.
3441          * linear and raid0 always use whatever space is available
3442          * We can only consider changing the size if no resync
3443          * or reconstruction is happening, and if the new size
3444          * is acceptable. It must fit before the sb_offset or,
3445          * if that is <data_offset, it must fit before the
3446          * size of each device.
3447          * If size is zero, we find the largest size that fits.
3448          */
3449         if (mddev->sync_thread)
3450                 return -EBUSY;
3451         ITERATE_RDEV(mddev,rdev,tmp) {
3452                 sector_t avail;
3453                 int fit = (size == 0);
3454                 if (rdev->sb_offset > rdev->data_offset)
3455                         avail = (rdev->sb_offset*2) - rdev->data_offset;
3456                 else
3457                         avail = get_capacity(rdev->bdev->bd_disk)
3458                                 - rdev->data_offset;
3459                 if (fit && (size == 0 || size > avail/2))
3460                         size = avail/2;
3461                 if (avail < ((sector_t)size << 1))
3462                         return -ENOSPC;
3463         }
3464         rv = mddev->pers->resize(mddev, (sector_t)size *2);
3465         if (!rv) {
3466                 struct block_device *bdev;
3467
3468                 bdev = bdget_disk(mddev->gendisk, 0);
3469                 if (bdev) {
3470                         mutex_lock(&bdev->bd_inode->i_mutex);
3471                         i_size_write(bdev->bd_inode, (loff_t)mddev->array_size << 10);
3472                         mutex_unlock(&bdev->bd_inode->i_mutex);
3473                         bdput(bdev);
3474                 }
3475         }
3476         return rv;
3477 }
3478
3479 static int update_raid_disks(mddev_t *mddev, int raid_disks)
3480 {
3481         int rv;
3482         /* change the number of raid disks */
3483         if (mddev->pers->reshape == NULL)
3484                 return -EINVAL;
3485         if (raid_disks <= 0 ||
3486             raid_disks >= mddev->max_disks)
3487                 return -EINVAL;
3488         if (mddev->sync_thread)
3489                 return -EBUSY;
3490         rv = mddev->pers->reshape(mddev, raid_disks);
3491         return rv;
3492 }
3493
3494
3495 /*
3496  * update_array_info is used to change the configuration of an
3497  * on-line array.
3498  * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
3499  * fields in the info are checked against the array.
3500  * Any differences that cannot be handled will cause an error.
3501  * Normally, only one change can be managed at a time.
3502  */
3503 static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
3504 {
3505         int rv = 0;
3506         int cnt = 0;
3507         int state = 0;
3508
3509         /* calculate expected state,ignoring low bits */
3510         if (mddev->bitmap && mddev->bitmap_offset)
3511                 state |= (1 << MD_SB_BITMAP_PRESENT);
3512
3513         if (mddev->major_version != info->major_version ||
3514             mddev->minor_version != info->minor_version ||
3515 /*          mddev->patch_version != info->patch_version || */
3516             mddev->ctime         != info->ctime         ||
3517             mddev->level         != info->level         ||
3518 /*          mddev->layout        != info->layout        || */
3519             !mddev->persistent   != info->not_persistent||
3520             mddev->chunk_size    != info->chunk_size    ||
3521             /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
3522             ((state^info->state) & 0xfffffe00)
3523                 )
3524                 return -EINVAL;
3525         /* Check there is only one change */
3526         if (mddev->size != info->size) cnt++;
3527         if (mddev->raid_disks != info->raid_disks) cnt++;
3528         if (mddev->layout != info->layout) cnt++;
3529         if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) cnt++;
3530         if (cnt == 0) return 0;
3531         if (cnt > 1) return -EINVAL;
3532
3533         if (mddev->layout != info->layout) {
3534                 /* Change layout
3535                  * we don't need to do anything at the md level, the
3536                  * personality will take care of it all.
3537                  */
3538                 if (mddev->pers->reconfig == NULL)
3539                         return -EINVAL;
3540                 else
3541                         return mddev->pers->reconfig(mddev, info->layout, -1);
3542         }
3543         if (mddev->size != info->size)
3544                 rv = update_size(mddev, info->size);
3545
3546         if (mddev->raid_disks    != info->raid_disks)
3547                 rv = update_raid_disks(mddev, info->raid_disks);
3548
3549         if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
3550                 if (mddev->pers->quiesce == NULL)
3551                         return -EINVAL;
3552                 if (mddev->recovery || mddev->sync_thread)
3553                         return -EBUSY;
3554                 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
3555                         /* add the bitmap */
3556                         if (mddev->bitmap)
3557                                 return -EEXIST;
3558                         if (mddev->default_bitmap_offset == 0)
3559                                 return -EINVAL;
3560                         mddev->bitmap_offset = mddev->default_bitmap_offset;
3561                         mddev->pers->quiesce(mddev, 1);
3562                         rv = bitmap_create(mddev);
3563                         if (rv)
3564                                 bitmap_destroy(mddev);
3565                         mddev->pers->quiesce(mddev, 0);
3566                 } else {
3567                         /* remove the bitmap */
3568                         if (!mddev->bitmap)
3569                                 return -ENOENT;
3570                         if (mddev->bitmap->file)
3571                                 return -EINVAL;
3572                         mddev->pers->quiesce(mddev, 1);
3573                         bitmap_destroy(mddev);
3574                         mddev->pers->quiesce(mddev, 0);
3575                         mddev->bitmap_offset = 0;
3576                 }
3577         }
3578         md_update_sb(mddev);
3579         return rv;
3580 }
3581
3582 static int set_disk_faulty(mddev_t *mddev, dev_t dev)
3583 {
3584         mdk_rdev_t *rdev;
3585
3586         if (mddev->pers == NULL)
3587                 return -ENODEV;
3588
3589         rdev = find_rdev(mddev, dev);
3590         if (!rdev)
3591                 return -ENODEV;
3592
3593         md_error(mddev, rdev);
3594         return 0;
3595 }
3596
3597 static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
3598 {
3599         mddev_t *mddev = bdev->bd_disk->private_data;
3600
3601         geo->heads = 2;
3602         geo->sectors = 4;
3603         geo->cylinders = get_capacity(mddev->gendisk) / 8;
3604         return 0;
3605 }
3606
3607 static int md_ioctl(struct inode *inode, struct file *file,
3608                         unsigned int cmd, unsigned long arg)
3609 {
3610         int err = 0;
3611         void __user *argp = (void __user *)arg;
3612         mddev_t *mddev = NULL;
3613
3614         if (!capable(CAP_SYS_ADMIN))
3615                 return -EACCES;
3616
3617         /*
3618          * Commands dealing with the RAID driver but not any
3619          * particular array:
3620          */
3621         switch (cmd)
3622         {
3623                 case RAID_VERSION:
3624                         err = get_version(argp);
3625                         goto done;
3626
3627                 case PRINT_RAID_DEBUG:
3628                         err = 0;
3629                         md_print_devices();
3630                         goto done;
3631
3632 #ifndef MODULE
3633                 case RAID_AUTORUN:
3634                         err = 0;
3635                         autostart_arrays(arg);
3636                         goto done;
3637 #endif
3638                 default:;
3639         }
3640
3641         /*
3642          * Commands creating/starting a new array:
3643          */
3644
3645         mddev = inode->i_bdev->bd_disk->private_data;
3646
3647         if (!mddev) {
3648                 BUG();
3649                 goto abort;
3650         }
3651
3652
3653         if (cmd == START_ARRAY) {
3654                 /* START_ARRAY doesn't need to lock the array as autostart_array
3655                  * does the locking, and it could even be a different array
3656                  */
3657                 static int cnt = 3;
3658                 if (cnt > 0 ) {
3659                         printk(KERN_WARNING
3660                                "md: %s(pid %d) used deprecated START_ARRAY ioctl. "
3661                                "This will not be supported beyond July 2006\n",
3662                                current->comm, current->pid);
3663                         cnt--;
3664                 }
3665                 err = autostart_array(new_decode_dev(arg));
3666                 if (err) {
3667                         printk(KERN_WARNING "md: autostart failed!\n");
3668                         goto abort;
3669                 }
3670                 goto done;
3671         }
3672
3673         err = mddev_lock(mddev);
3674         if (err) {
3675                 printk(KERN_INFO
3676                         "md: ioctl lock interrupted, reason %d, cmd %d\n",
3677                         err, cmd);
3678                 goto abort;
3679         }
3680
3681         switch (cmd)
3682         {
3683                 case SET_ARRAY_INFO:
3684                         {
3685                                 mdu_array_info_t info;
3686                                 if (!arg)
3687                                         memset(&info, 0, sizeof(info));
3688                                 else if (copy_from_user(&info, argp, sizeof(info))) {
3689                                         err = -EFAULT;
3690                                         goto abort_unlock;
3691                                 }
3692                                 if (mddev->pers) {
3693                                         err = update_array_info(mddev, &info);
3694                                         if (err) {
3695                                                 printk(KERN_WARNING "md: couldn't update"
3696                                                        " array info. %d\n", err);
3697                                                 goto abort_unlock;
3698                                         }
3699                                         goto done_unlock;
3700                                 }
3701                                 if (!list_empty(&mddev->disks)) {
3702                                         printk(KERN_WARNING
3703                                                "md: array %s already has disks!\n",
3704                                                mdname(mddev));
3705                                         err = -EBUSY;
3706                                         goto abort_unlock;
3707                                 }
3708                                 if (mddev->raid_disks) {
3709                                         printk(KERN_WARNING
3710                                                "md: array %s already initialised!\n",
3711                                                mdname(mddev));
3712                                         err = -EBUSY;
3713                                         goto abort_unlock;
3714                                 }
3715                                 err = set_array_info(mddev, &info);
3716                                 if (err) {
3717                                         printk(KERN_WARNING "md: couldn't set"
3718                                                " array info. %d\n", err);
3719                                         goto abort_unlock;
3720                                 }
3721                         }
3722                         goto done_unlock;
3723
3724                 default:;
3725         }
3726
3727         /*
3728          * Commands querying/configuring an existing array:
3729          */
3730         /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
3731          * RUN_ARRAY, and SET_BITMAP_FILE are allowed */
3732         if (!mddev->raid_disks && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
3733                         && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE) {
3734                 err = -ENODEV;
3735                 goto abort_unlock;
3736         }
3737
3738         /*
3739          * Commands even a read-only array can execute:
3740          */
3741         switch (cmd)
3742         {
3743                 case GET_ARRAY_INFO:
3744                         err = get_array_info(mddev, argp);
3745                         goto done_unlock;
3746
3747                 case GET_BITMAP_FILE:
3748                         err = get_bitmap_file(mddev, argp);
3749                         goto done_unlock;
3750
3751                 case GET_DISK_INFO:
3752                         err = get_disk_info(mddev, argp);
3753                         goto done_unlock;
3754
3755                 case RESTART_ARRAY_RW:
3756                         err = restart_array(mddev);
3757                         goto done_unlock;
3758
3759                 case STOP_ARRAY:
3760                         err = do_md_stop (mddev, 0);
3761                         goto done_unlock;
3762
3763                 case STOP_ARRAY_RO:
3764                         err = do_md_stop (mddev, 1);
3765                         goto done_unlock;
3766
3767         /*
3768          * We have a problem here : there is no easy way to give a CHS
3769          * virtual geometry. We currently pretend that we have a 2 heads
3770          * 4 sectors (with a BIG number of cylinders...). This drives
3771          * dosfs just mad... ;-)
3772          */
3773         }
3774
3775         /*
3776          * The remaining ioctls are changing the state of the
3777          * superblock, so we do not allow them on read-only arrays.
3778          * However non-MD ioctls (e.g. get-size) will still come through
3779          * here and hit the 'default' below, so only disallow
3780          * 'md' ioctls, and switch to rw mode if started auto-readonly.
3781          */
3782         if (_IOC_TYPE(cmd) == MD_MAJOR &&
3783             mddev->ro && mddev->pers) {
3784                 if (mddev->ro == 2) {
3785                         mddev->ro = 0;
3786                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3787                 md_wakeup_thread(mddev->thread);
3788
3789                 } else {
3790                         err = -EROFS;
3791                         goto abort_unlock;
3792                 }
3793         }
3794
3795         switch (cmd)
3796         {
3797                 case ADD_NEW_DISK:
3798                 {
3799                         mdu_disk_info_t info;
3800                         if (copy_from_user(&info, argp, sizeof(info)))
3801                                 err = -EFAULT;
3802                         else
3803                                 err = add_new_disk(mddev, &info);
3804                         goto done_unlock;
3805                 }
3806
3807                 case HOT_REMOVE_DISK:
3808                         err = hot_remove_disk(mddev, new_decode_dev(arg));
3809                         goto done_unlock;
3810
3811                 case HOT_ADD_DISK:
3812                         err = hot_add_disk(mddev, new_decode_dev(arg));
3813                         goto done_unlock;
3814
3815                 case SET_DISK_FAULTY:
3816                         err = set_disk_faulty(mddev, new_decode_dev(arg));
3817                         goto done_unlock;
3818
3819                 case RUN_ARRAY:
3820                         err = do_md_run (mddev);
3821                         goto done_unlock;
3822
3823                 case SET_BITMAP_FILE:
3824                         err = set_bitmap_file(mddev, (int)arg);
3825                         goto done_unlock;
3826
3827                 default:
3828                         if (_IOC_TYPE(cmd) == MD_MAJOR)
3829                                 printk(KERN_WARNING "md: %s(pid %d) used"
3830                                         " obsolete MD ioctl, upgrade your"
3831                                         " software to use new ictls.\n",
3832                                         current->comm, current->pid);
3833                         err = -EINVAL;
3834                         goto abort_unlock;
3835         }
3836
3837 done_unlock:
3838 abort_unlock:
3839         mddev_unlock(mddev);
3840
3841         return err;
3842 done:
3843         if (err)
3844                 MD_BUG();
3845 abort:
3846         return err;
3847 }
3848
3849 static int md_open(struct inode *inode, struct file *file)
3850 {
3851         /*
3852          * Succeed if we can lock the mddev, which confirms that
3853          * it isn't being stopped right now.
3854          */
3855         mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
3856         int err;
3857
3858         if ((err = mddev_lock(mddev)))
3859                 goto out;
3860
3861         err = 0;
3862         mddev_get(mddev);
3863         mddev_unlock(mddev);
3864
3865         check_disk_change(inode->i_bdev);
3866  out:
3867         return err;
3868 }
3869
3870 static int md_release(struct inode *inode, struct file * file)
3871 {
3872         mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
3873
3874         if (!mddev)
3875                 BUG();
3876         mddev_put(mddev);
3877
3878         return 0;
3879 }
3880
3881 static int md_media_changed(struct gendisk *disk)
3882 {
3883         mddev_t *mddev = disk->private_data;
3884
3885         return mddev->changed;
3886 }
3887
3888 static int md_revalidate(struct gendisk *disk)
3889 {
3890         mddev_t *mddev = disk->private_data;
3891
3892         mddev->changed = 0;
3893         return 0;
3894 }
3895 static struct block_device_operations md_fops =
3896 {
3897         .owner          = THIS_MODULE,
3898         .open           = md_open,
3899         .release        = md_release,
3900         .ioctl          = md_ioctl,
3901         .getgeo         = md_getgeo,
3902         .media_changed  = md_media_changed,
3903         .revalidate_disk= md_revalidate,
3904 };
3905
3906 static int md_thread(void * arg)
3907 {
3908         mdk_thread_t *thread = arg;
3909
3910         /*
3911          * md_thread is a 'system-thread', it's priority should be very
3912          * high. We avoid resource deadlocks individually in each
3913          * raid personality. (RAID5 does preallocation) We also use RR and
3914          * the very same RT priority as kswapd, thus we will never get
3915          * into a priority inversion deadlock.
3916          *
3917          * we definitely have to have equal or higher priority than
3918          * bdflush, otherwise bdflush will deadlock if there are too
3919          * many dirty RAID5 blocks.
3920          */
3921
3922         allow_signal(SIGKILL);
3923         while (!kthread_should_stop()) {
3924
3925                 /* We need to wait INTERRUPTIBLE so that
3926                  * we don't add to the load-average.
3927                  * That means we need to be sure no signals are
3928                  * pending
3929                  */
3930                 if (signal_pending(current))
3931                         flush_signals(current);
3932
3933                 wait_event_interruptible_timeout
3934                         (thread->wqueue,
3935                          test_bit(THREAD_WAKEUP, &thread->flags)
3936                          || kthread_should_stop(),
3937                          thread->timeout);
3938                 try_to_freeze();
3939
3940                 clear_bit(THREAD_WAKEUP, &thread->flags);
3941
3942                 thread->run(thread->mddev);
3943         }
3944
3945         return 0;
3946 }
3947
3948 void md_wakeup_thread(mdk_thread_t *thread)
3949 {
3950         if (thread) {
3951                 dprintk("md: waking up MD thread %s.\n", thread->tsk->comm);
3952                 set_bit(THREAD_WAKEUP, &thread->flags);
3953                 wake_up(&thread->wqueue);
3954         }
3955 }
3956
3957 mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
3958                                  const char *name)
3959 {
3960         mdk_thread_t *thread;
3961
3962         thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL);
3963         if (!thread)
3964                 return NULL;
3965
3966         init_waitqueue_head(&thread->wqueue);
3967
3968         thread->run = run;
3969         thread->mddev = mddev;
3970         thread->timeout = MAX_SCHEDULE_TIMEOUT;
3971         thread->tsk = kthread_run(md_thread, thread, name, mdname(thread->mddev));
3972         if (IS_ERR(thread->tsk)) {
3973                 kfree(thread);
3974                 return NULL;
3975         }
3976         return thread;
3977 }
3978
3979 void md_unregister_thread(mdk_thread_t *thread)
3980 {
3981         dprintk("interrupting MD-thread pid %d\n", thread->tsk->pid);
3982
3983         kthread_stop(thread->tsk);
3984         kfree(thread);
3985 }
3986
3987 void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
3988 {
3989         if (!mddev) {
3990                 MD_BUG();
3991                 return;
3992         }
3993
3994         if (!rdev || test_bit(Faulty, &rdev->flags))
3995                 return;
3996 /*
3997         dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",
3998                 mdname(mddev),
3999                 MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev),
4000                 __builtin_return_address(0),__builtin_return_address(1),
4001                 __builtin_return_address(2),__builtin_return_address(3));
4002 */
4003         if (!mddev->pers->error_handler)
4004                 return;
4005         mddev->pers->error_handler(mddev,rdev);
4006         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4007         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4008         md_wakeup_thread(mddev->thread);
4009         md_new_event(mddev);
4010 }
4011
4012 /* seq_file implementation /proc/mdstat */
4013
4014 static void status_unused(struct seq_file *seq)
4015 {
4016         int i = 0;
4017         mdk_rdev_t *rdev;
4018         struct list_head *tmp;
4019
4020         seq_printf(seq, "unused devices: ");
4021
4022         ITERATE_RDEV_PENDING(rdev,tmp) {
4023                 char b[BDEVNAME_SIZE];
4024                 i++;
4025                 seq_printf(seq, "%s ",
4026                               bdevname(rdev->bdev,b));
4027         }
4028         if (!i)
4029                 seq_printf(seq, "<none>");
4030
4031         seq_printf(seq, "\n");
4032 }
4033
4034
4035 static void status_resync(struct seq_file *seq, mddev_t * mddev)
4036 {
4037         unsigned long max_blocks, resync, res, dt, db, rt;
4038
4039         resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
4040
4041         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
4042                 max_blocks = mddev->resync_max_sectors >> 1;
4043         else
4044                 max_blocks = mddev->size;
4045
4046         /*
4047          * Should not happen.
4048          */
4049         if (!max_blocks) {
4050                 MD_BUG();
4051                 return;
4052         }
4053         res = (resync/1024)*1000/(max_blocks/1024 + 1);
4054         {
4055                 int i, x = res/50, y = 20-x;
4056                 seq_printf(seq, "[");
4057                 for (i = 0; i < x; i++)
4058                         seq_printf(seq, "=");
4059                 seq_printf(seq, ">");
4060                 for (i = 0; i < y; i++)
4061                         seq_printf(seq, ".");
4062                 seq_printf(seq, "] ");
4063         }
4064         seq_printf(seq, " %s =%3lu.%lu%% (%lu/%lu)",
4065                       (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
4066                        "resync" : "recovery"),
4067                       res/10, res % 10, resync, max_blocks);
4068
4069         /*
4070          * We do not want to overflow, so the order of operands and
4071          * the * 100 / 100 trick are important. We do a +1 to be
4072          * safe against division by zero. We only estimate anyway.
4073          *
4074          * dt: time from mark until now
4075          * db: blocks written from mark until now
4076          * rt: remaining time
4077          */
4078         dt = ((jiffies - mddev->resync_mark) / HZ);
4079         if (!dt) dt++;
4080         db = resync - (mddev->resync_mark_cnt/2);
4081         rt = (dt * ((max_blocks-resync) / (db/100+1)))/100;
4082
4083         seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
4084
4085         seq_printf(seq, " speed=%ldK/sec", db/dt);
4086 }
4087
4088 static void *md_seq_start(struct seq_file *seq, loff_t *pos)
4089 {
4090         struct list_head *tmp;
4091         loff_t l = *pos;
4092         mddev_t *mddev;
4093
4094         if (l >= 0x10000)
4095                 return NULL;
4096         if (!l--)
4097                 /* header */
4098                 return (void*)1;
4099
4100         spin_lock(&all_mddevs_lock);
4101         list_for_each(tmp,&all_mddevs)
4102                 if (!l--) {
4103                         mddev = list_entry(tmp, mddev_t, all_mddevs);
4104                         mddev_get(mddev);
4105                         spin_unlock(&all_mddevs_lock);
4106                         return mddev;
4107                 }
4108         spin_unlock(&all_mddevs_lock);
4109         if (!l--)
4110                 return (void*)2;/* tail */
4111         return NULL;
4112 }
4113
4114 static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4115 {
4116         struct list_head *tmp;
4117         mddev_t *next_mddev, *mddev = v;
4118
4119         ++*pos;
4120         if (v == (void*)2)
4121                 return NULL;
4122
4123         spin_lock(&all_mddevs_lock);
4124         if (v == (void*)1)
4125                 tmp = all_mddevs.next;
4126         else
4127                 tmp = mddev->all_mddevs.next;
4128         if (tmp != &all_mddevs)
4129                 next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
4130         else {
4131                 next_mddev = (void*)2;
4132                 *pos = 0x10000;
4133         }
4134         spin_unlock(&all_mddevs_lock);
4135
4136         if (v != (void*)1)
4137                 mddev_put(mddev);
4138         return next_mddev;
4139
4140 }
4141
4142 static void md_seq_stop(struct seq_file *seq, void *v)
4143 {
4144         mddev_t *mddev = v;
4145
4146         if (mddev && v != (void*)1 && v != (void*)2)
4147                 mddev_put(mddev);
4148 }
4149
4150 struct mdstat_info {
4151         int event;
4152 };
4153
4154 static int md_seq_show(struct seq_file *seq, void *v)
4155 {
4156         mddev_t *mddev = v;
4157         sector_t size;
4158         struct list_head *tmp2;
4159         mdk_rdev_t *rdev;
4160         struct mdstat_info *mi = seq->private;
4161         struct bitmap *bitmap;
4162
4163         if (v == (void*)1) {
4164                 struct mdk_personality *pers;
4165                 seq_printf(seq, "Personalities : ");
4166                 spin_lock(&pers_lock);
4167                 list_for_each_entry(pers, &pers_list, list)
4168                         seq_printf(seq, "[%s] ", pers->name);
4169
4170                 spin_unlock(&pers_lock);
4171                 seq_printf(seq, "\n");
4172                 mi->event = atomic_read(&md_event_count);
4173                 return 0;
4174         }
4175         if (v == (void*)2) {
4176                 status_unused(seq);
4177                 return 0;
4178         }
4179
4180         if (mddev_lock(mddev)!=0)
4181                 return -EINTR;
4182         if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
4183                 seq_printf(seq, "%s : %sactive", mdname(mddev),
4184                                                 mddev->pers ? "" : "in");
4185                 if (mddev->pers) {
4186                         if (mddev->ro==1)
4187                                 seq_printf(seq, " (read-only)");
4188                         if (mddev->ro==2)
4189                                 seq_printf(seq, "(auto-read-only)");
4190                         seq_printf(seq, " %s", mddev->pers->name);
4191                 }
4192
4193                 size = 0;
4194                 ITERATE_RDEV(mddev,rdev,tmp2) {
4195                         char b[BDEVNAME_SIZE];
4196                         seq_printf(seq, " %s[%d]",
4197                                 bdevname(rdev->bdev,b), rdev->desc_nr);
4198                         if (test_bit(WriteMostly, &rdev->flags))
4199                                 seq_printf(seq, "(W)");
4200                         if (test_bit(Faulty, &rdev->flags)) {
4201                                 seq_printf(seq, "(F)");
4202                                 continue;
4203                         } else if (rdev->raid_disk < 0)
4204                                 seq_printf(seq, "(S)"); /* spare */
4205                         size += rdev->size;
4206                 }
4207
4208                 if (!list_empty(&mddev->disks)) {
4209                         if (mddev->pers)
4210                                 seq_printf(seq, "\n      %llu blocks",
4211                                         (unsigned long long)mddev->array_size);
4212                         else
4213                                 seq_printf(seq, "\n      %llu blocks",
4214                                         (unsigned long long)size);
4215                 }
4216                 if (mddev->persistent) {
4217                         if (mddev->major_version != 0 ||
4218                             mddev->minor_version != 90) {
4219                                 seq_printf(seq," super %d.%d",
4220                                            mddev->major_version,
4221                                            mddev->minor_version);
4222                         }
4223                 } else
4224                         seq_printf(seq, " super non-persistent");
4225
4226                 if (mddev->pers) {
4227                         mddev->pers->status (seq, mddev);
4228                         seq_printf(seq, "\n      ");
4229                         if (mddev->pers->sync_request) {
4230                                 if (mddev->curr_resync > 2) {
4231                                         status_resync (seq, mddev);
4232                                         seq_printf(seq, "\n      ");
4233                                 } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
4234                                         seq_printf(seq, "\tresync=DELAYED\n      ");
4235                                 else if (mddev->recovery_cp < MaxSector)
4236                                         seq_printf(seq, "\tresync=PENDING\n      ");
4237                         }
4238                 } else
4239                         seq_printf(seq, "\n       ");
4240
4241                 if ((bitmap = mddev->bitmap)) {
4242                         unsigned long chunk_kb;
4243                         unsigned long flags;
4244                         spin_lock_irqsave(&bitmap->lock, flags);
4245                         chunk_kb = bitmap->chunksize >> 10;
4246                         seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
4247                                 "%lu%s chunk",
4248                                 bitmap->pages - bitmap->missing_pages,
4249                                 bitmap->pages,
4250                                 (bitmap->pages - bitmap->missing_pages)
4251                                         << (PAGE_SHIFT - 10),
4252                                 chunk_kb ? chunk_kb : bitmap->chunksize,
4253                                 chunk_kb ? "KB" : "B");
4254                         if (bitmap->file) {
4255                                 seq_printf(seq, ", file: ");
4256                                 seq_path(seq, bitmap->file->f_vfsmnt,
4257                                          bitmap->file->f_dentry," \t\n");
4258                         }
4259
4260                         seq_printf(seq, "\n");
4261                         spin_unlock_irqrestore(&bitmap->lock, flags);
4262                 }
4263
4264                 seq_printf(seq, "\n");
4265         }
4266         mddev_unlock(mddev);
4267
4268         return 0;
4269 }
4270
4271 static struct seq_operations md_seq_ops = {
4272         .start  = md_seq_start,
4273         .next   = md_seq_next,
4274         .stop   = md_seq_stop,
4275         .show   = md_seq_show,
4276 };
4277
4278 static int md_seq_open(struct inode *inode, struct file *file)
4279 {
4280         int error;
4281         struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
4282         if (mi == NULL)
4283                 return -ENOMEM;
4284
4285         error = seq_open(file, &md_seq_ops);
4286         if (error)
4287                 kfree(mi);
4288         else {
4289                 struct seq_file *p = file->private_data;
4290                 p->private = mi;
4291                 mi->event = atomic_read(&md_event_count);
4292         }
4293         return error;
4294 }
4295
4296 static int md_seq_release(struct inode *inode, struct file *file)
4297 {
4298         struct seq_file *m = file->private_data;
4299         struct mdstat_info *mi = m->private;
4300         m->private = NULL;
4301         kfree(mi);
4302         return seq_release(inode, file);
4303 }
4304
4305 static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
4306 {
4307         struct seq_file *m = filp->private_data;
4308         struct mdstat_info *mi = m->private;
4309         int mask;
4310
4311         poll_wait(filp, &md_event_waiters, wait);
4312
4313         /* always allow read */
4314         mask = POLLIN | POLLRDNORM;
4315
4316         if (mi->event != atomic_read(&md_event_count))
4317                 mask |= POLLERR | POLLPRI;
4318         return mask;
4319 }
4320
4321 static struct file_operations md_seq_fops = {
4322         .open           = md_seq_open,
4323         .read           = seq_read,
4324         .llseek         = seq_lseek,
4325         .release        = md_seq_release,
4326         .poll           = mdstat_poll,
4327 };
4328
4329 int register_md_personality(struct mdk_personality *p)
4330 {
4331         spin_lock(&pers_lock);
4332         list_add_tail(&p->list, &pers_list);
4333         printk(KERN_INFO "md: %s personality registered for level %d\n", p->name, p->level);
4334         spin_unlock(&pers_lock);
4335         return 0;
4336 }
4337
4338 int unregister_md_personality(struct mdk_personality *p)
4339 {
4340         printk(KERN_INFO "md: %s personality unregistered\n", p->name);
4341         spin_lock(&pers_lock);
4342         list_del_init(&p->list);
4343         spin_unlock(&pers_lock);
4344         return 0;
4345 }
4346
4347 static int is_mddev_idle(mddev_t *mddev)
4348 {
4349         mdk_rdev_t * rdev;
4350         struct list_head *tmp;
4351         int idle;
4352         unsigned long curr_events;
4353
4354         idle = 1;
4355         ITERATE_RDEV(mddev,rdev,tmp) {
4356                 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
4357                 curr_events = disk_stat_read(disk, sectors[0]) +
4358                                 disk_stat_read(disk, sectors[1]) -
4359                                 atomic_read(&disk->sync_io);
4360                 /* The difference between curr_events and last_events
4361                  * will be affected by any new non-sync IO (making
4362                  * curr_events bigger) and any difference in the amount of
4363                  * in-flight syncio (making current_events bigger or smaller)
4364                  * The amount in-flight is currently limited to
4365                  * 32*64K in raid1/10 and 256*PAGE_SIZE in raid5/6
4366                  * which is at most 4096 sectors.
4367                  * These numbers are fairly fragile and should be made
4368                  * more robust, probably by enforcing the
4369                  * 'window size' that md_do_sync sort-of uses.
4370                  *
4371                  * Note: the following is an unsigned comparison.
4372                  */
4373                 if ((curr_events - rdev->last_events + 4096) > 8192) {
4374                         rdev->last_events = curr_events;
4375                         idle = 0;
4376                 }
4377         }
4378         return idle;
4379 }
4380
4381 void md_done_sync(mddev_t *mddev, int blocks, int ok)
4382 {
4383         /* another "blocks" (512byte) blocks have been synced */
4384         atomic_sub(blocks, &mddev->recovery_active);
4385         wake_up(&mddev->recovery_wait);
4386         if (!ok) {
4387                 set_bit(MD_RECOVERY_ERR, &mddev->recovery);
4388                 md_wakeup_thread(mddev->thread);
4389                 // stop recovery, signal do_sync ....
4390         }
4391 }
4392
4393
4394 /* md_write_start(mddev, bi)
4395  * If we need to update some array metadata (e.g. 'active' flag
4396  * in superblock) before writing, schedule a superblock update
4397  * and wait for it to complete.
4398  */
4399 void md_write_start(mddev_t *mddev, struct bio *bi)
4400 {
4401         if (bio_data_dir(bi) != WRITE)
4402                 return;
4403
4404         BUG_ON(mddev->ro == 1);
4405         if (mddev->ro == 2) {
4406                 /* need to switch to read/write */
4407                 mddev->ro = 0;
4408                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4409                 md_wakeup_thread(mddev->thread);
4410         }
4411         atomic_inc(&mddev->writes_pending);
4412         if (mddev->in_sync) {
4413                 spin_lock_irq(&mddev->write_lock);
4414                 if (mddev->in_sync) {
4415                         mddev->in_sync = 0;
4416                         mddev->sb_dirty = 1;
4417                         md_wakeup_thread(mddev->thread);
4418                 }
4419                 spin_unlock_irq(&mddev->write_lock);
4420         }
4421         wait_event(mddev->sb_wait, mddev->sb_dirty==0);
4422 }
4423
4424 void md_write_end(mddev_t *mddev)
4425 {
4426         if (atomic_dec_and_test(&mddev->writes_pending)) {
4427                 if (mddev->safemode == 2)
4428                         md_wakeup_thread(mddev->thread);
4429                 else
4430                         mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
4431         }
4432 }
4433
4434 static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
4435
4436 #define SYNC_MARKS      10
4437 #define SYNC_MARK_STEP  (3*HZ)
4438 static void md_do_sync(mddev_t *mddev)
4439 {
4440         mddev_t *mddev2;
4441         unsigned int currspeed = 0,
4442                  window;
4443         sector_t max_sectors,j, io_sectors;
4444         unsigned long mark[SYNC_MARKS];
4445         sector_t mark_cnt[SYNC_MARKS];
4446         int last_mark,m;
4447         struct list_head *tmp;
4448         sector_t last_check;
4449         int skipped = 0;
4450
4451         /* just incase thread restarts... */
4452         if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
4453                 return;
4454
4455         /* we overload curr_resync somewhat here.
4456          * 0 == not engaged in resync at all
4457          * 2 == checking that there is no conflict with another sync
4458          * 1 == like 2, but have yielded to allow conflicting resync to
4459          *              commense
4460          * other == active in resync - this many blocks
4461          *
4462          * Before starting a resync we must have set curr_resync to
4463          * 2, and then checked that every "conflicting" array has curr_resync
4464          * less than ours.  When we find one that is the same or higher
4465          * we wait on resync_wait.  To avoid deadlock, we reduce curr_resync
4466          * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
4467          * This will mean we have to start checking from the beginning again.
4468          *
4469          */
4470
4471         do {
4472                 mddev->curr_resync = 2;
4473
4474         try_again:
4475                 if (kthread_should_stop()) {
4476                         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4477                         goto skip;
4478                 }
4479                 ITERATE_MDDEV(mddev2,tmp) {
4480                         if (mddev2 == mddev)
4481                                 continue;
4482                         if (mddev2->curr_resync &&
4483                             match_mddev_units(mddev,mddev2)) {
4484                                 DEFINE_WAIT(wq);
4485                                 if (mddev < mddev2 && mddev->curr_resync == 2) {
4486                                         /* arbitrarily yield */
4487                                         mddev->curr_resync = 1;
4488                                         wake_up(&resync_wait);
4489                                 }
4490                                 if (mddev > mddev2 && mddev->curr_resync == 1)
4491                                         /* no need to wait here, we can wait the next
4492                                          * time 'round when curr_resync == 2
4493                                          */
4494                                         continue;
4495                                 prepare_to_wait(&resync_wait, &wq, TASK_UNINTERRUPTIBLE);
4496                                 if (!kthread_should_stop() &&
4497                                     mddev2->curr_resync >= mddev->curr_resync) {
4498                                         printk(KERN_INFO "md: delaying resync of %s"
4499                                                " until %s has finished resync (they"
4500                                                " share one or more physical units)\n",
4501                                                mdname(mddev), mdname(mddev2));
4502                                         mddev_put(mddev2);
4503                                         schedule();
4504                                         finish_wait(&resync_wait, &wq);
4505                                         goto try_again;
4506                                 }
4507                                 finish_wait(&resync_wait, &wq);
4508                         }
4509                 }
4510         } while (mddev->curr_resync < 2);
4511
4512         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
4513                 /* resync follows the size requested by the personality,
4514                  * which defaults to physical size, but can be virtual size
4515                  */
4516                 max_sectors = mddev->resync_max_sectors;
4517                 mddev->resync_mismatches = 0;
4518         } else
4519                 /* recovery follows the physical size of devices */
4520                 max_sectors = mddev->size << 1;
4521
4522         printk(KERN_INFO "md: syncing RAID array %s\n", mdname(mddev));
4523         printk(KERN_INFO "md: minimum _guaranteed_ reconstruction speed:"
4524                 " %d KB/sec/disc.\n", speed_min(mddev));
4525         printk(KERN_INFO "md: using maximum available idle IO bandwidth "
4526                "(but not more than %d KB/sec) for reconstruction.\n",
4527                speed_max(mddev));
4528
4529         is_mddev_idle(mddev); /* this also initializes IO event counters */
4530         /* we don't use the checkpoint if there's a bitmap */
4531         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) && !mddev->bitmap
4532             && ! test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
4533                 j = mddev->recovery_cp;
4534         else
4535                 j = 0;
4536         io_sectors = 0;
4537         for (m = 0; m < SYNC_MARKS; m++) {
4538                 mark[m] = jiffies;
4539                 mark_cnt[m] = io_sectors;
4540         }
4541         last_mark = 0;
4542         mddev->resync_mark = mark[last_mark];
4543         mddev->resync_mark_cnt = mark_cnt[last_mark];
4544
4545         /*
4546          * Tune reconstruction:
4547          */
4548         window = 32*(PAGE_SIZE/512);
4549         printk(KERN_INFO "md: using %dk window, over a total of %llu blocks.\n",
4550                 window/2,(unsigned long long) max_sectors/2);
4551
4552         atomic_set(&mddev->recovery_active, 0);
4553         init_waitqueue_head(&mddev->recovery_wait);
4554         last_check = 0;
4555
4556         if (j>2) {
4557                 printk(KERN_INFO
4558                         "md: resuming recovery of %s from checkpoint.\n",
4559                         mdname(mddev));
4560                 mddev->curr_resync = j;
4561         }
4562
4563         while (j < max_sectors) {
4564                 sector_t sectors;
4565
4566                 skipped = 0;
4567                 sectors = mddev->pers->sync_request(mddev, j, &skipped,
4568                                             currspeed < speed_min(mddev));
4569                 if (sectors == 0) {
4570                         set_bit(MD_RECOVERY_ERR, &mddev->recovery);
4571                         goto out;
4572                 }
4573
4574                 if (!skipped) { /* actual IO requested */
4575                         io_sectors += sectors;
4576                         atomic_add(sectors, &mddev->recovery_active);
4577                 }
4578
4579                 j += sectors;
4580                 if (j>1) mddev->curr_resync = j;
4581                 if (last_check == 0)
4582                         /* this is the earliers that rebuilt will be
4583                          * visible in /proc/mdstat
4584                          */
4585                         md_new_event(mddev);
4586
4587                 if (last_check + window > io_sectors || j == max_sectors)
4588                         continue;
4589
4590                 last_check = io_sectors;
4591
4592                 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery) ||
4593                     test_bit(MD_RECOVERY_ERR, &mddev->recovery))
4594                         break;
4595
4596         repeat:
4597                 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
4598                         /* step marks */
4599                         int next = (last_mark+1) % SYNC_MARKS;
4600
4601                         mddev->resync_mark = mark[next];
4602                         mddev->resync_mark_cnt = mark_cnt[next];
4603                         mark[next] = jiffies;
4604                         mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
4605                         last_mark = next;
4606                 }
4607
4608
4609                 if (kthread_should_stop()) {
4610                         /*
4611                          * got a signal, exit.
4612                          */
4613                         printk(KERN_INFO
4614                                 "md: md_do_sync() got signal ... exiting\n");
4615                         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4616                         goto out;
4617                 }
4618
4619                 /*
4620                  * this loop exits only if either when we are slower than
4621                  * the 'hard' speed limit, or the system was IO-idle for
4622                  * a jiffy.
4623                  * the system might be non-idle CPU-wise, but we only care
4624                  * about not overloading the IO subsystem. (things like an
4625                  * e2fsck being done on the RAID array should execute fast)
4626                  */
4627                 mddev->queue->unplug_fn(mddev->queue);
4628                 cond_resched();
4629
4630                 currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
4631                         /((jiffies-mddev->resync_mark)/HZ +1) +1;
4632
4633                 if (currspeed > speed_min(mddev)) {
4634                         if ((currspeed > speed_max(mddev)) ||
4635                                         !is_mddev_idle(mddev)) {
4636                                 msleep(500);
4637                                 goto repeat;
4638                         }
4639                 }
4640         }
4641         printk(KERN_INFO "md: %s: sync done.\n",mdname(mddev));
4642         /*
4643          * this also signals 'finished resyncing' to md_stop
4644          */
4645  out:
4646         mddev->queue->unplug_fn(mddev->queue);
4647
4648         wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
4649
4650         /* tell personality that we are finished */
4651         mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
4652
4653         if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
4654             mddev->curr_resync > 2 &&
4655             mddev->curr_resync >= mddev->recovery_cp) {
4656                 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
4657                         printk(KERN_INFO
4658                                 "md: checkpointing recovery of %s.\n",
4659                                 mdname(mddev));
4660                         mddev->recovery_cp = mddev->curr_resync;
4661                 } else
4662                         mddev->recovery_cp = MaxSector;
4663         }
4664
4665  skip:
4666         mddev->curr_resync = 0;
4667         wake_up(&resync_wait);
4668         set_bit(MD_RECOVERY_DONE, &mddev->recovery);
4669         md_wakeup_thread(mddev->thread);
4670 }
4671
4672
4673 /*
4674  * This routine is regularly called by all per-raid-array threads to
4675  * deal with generic issues like resync and super-block update.
4676  * Raid personalities that don't have a thread (linear/raid0) do not
4677  * need this as they never do any recovery or update the superblock.
4678  *
4679  * It does not do any resync itself, but rather "forks" off other threads
4680  * to do that as needed.
4681  * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
4682  * "->recovery" and create a thread at ->sync_thread.
4683  * When the thread finishes it sets MD_RECOVERY_DONE (and might set MD_RECOVERY_ERR)
4684  * and wakeups up this thread which will reap the thread and finish up.
4685  * This thread also removes any faulty devices (with nr_pending == 0).
4686  *
4687  * The overall approach is:
4688  *  1/ if the superblock needs updating, update it.
4689  *  2/ If a recovery thread is running, don't do anything else.
4690  *  3/ If recovery has finished, clean up, possibly marking spares active.
4691  *  4/ If there are any faulty devices, remove them.
4692  *  5/ If array is degraded, try to add spares devices
4693  *  6/ If array has spares or is not in-sync, start a resync thread.
4694  */
4695 void md_check_recovery(mddev_t *mddev)
4696 {
4697         mdk_rdev_t *rdev;
4698         struct list_head *rtmp;
4699
4700
4701         if (mddev->bitmap)
4702                 bitmap_daemon_work(mddev->bitmap);
4703
4704         if (mddev->ro)
4705                 return;
4706
4707         if (signal_pending(current)) {
4708                 if (mddev->pers->sync_request) {
4709                         printk(KERN_INFO "md: %s in immediate safe mode\n",
4710                                mdname(mddev));
4711                         mddev->safemode = 2;
4712                 }
4713                 flush_signals(current);
4714         }
4715
4716         if ( ! (
4717                 mddev->sb_dirty ||
4718                 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
4719                 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
4720                 (mddev->safemode == 1) ||
4721                 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
4722                  && !mddev->in_sync && mddev->recovery_cp == MaxSector)
4723                 ))
4724                 return;
4725
4726         if (mddev_trylock(mddev)==0) {
4727                 int spares =0;
4728
4729                 spin_lock_irq(&mddev->write_lock);
4730                 if (mddev->safemode && !atomic_read(&mddev->writes_pending) &&
4731                     !mddev->in_sync && mddev->recovery_cp == MaxSector) {
4732                         mddev->in_sync = 1;
4733                         mddev->sb_dirty = 1;
4734                 }
4735                 if (mddev->safemode == 1)
4736                         mddev->safemode = 0;
4737                 spin_unlock_irq(&mddev->write_lock);
4738
4739                 if (mddev->sb_dirty)
4740                         md_update_sb(mddev);
4741
4742
4743                 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
4744                     !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
4745                         /* resync/recovery still happening */
4746                         clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4747                         goto unlock;
4748                 }
4749                 if (mddev->sync_thread) {
4750                         /* resync has finished, collect result */
4751                         md_unregister_thread(mddev->sync_thread);
4752                         mddev->sync_thread = NULL;
4753                         if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
4754                             !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
4755                                 /* success...*/
4756                                 /* activate any spares */
4757                                 mddev->pers->spare_active(mddev);
4758                         }
4759                         md_update_sb(mddev);
4760
4761                         /* if array is no-longer degraded, then any saved_raid_disk
4762                          * information must be scrapped
4763                          */
4764                         if (!mddev->degraded)
4765                                 ITERATE_RDEV(mddev,rdev,rtmp)
4766                                         rdev->saved_raid_disk = -1;
4767
4768                         mddev->recovery = 0;
4769                         /* flag recovery needed just to double check */
4770                         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4771                         md_new_event(mddev);
4772                         goto unlock;
4773                 }
4774                 /* Clear some bits that don't mean anything, but
4775                  * might be left set
4776                  */
4777                 clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4778                 clear_bit(MD_RECOVERY_ERR, &mddev->recovery);
4779                 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
4780                 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
4781
4782                 /* no recovery is running.
4783                  * remove any failed drives, then
4784                  * add spares if possible.
4785                  * Spare are also removed and re-added, to allow
4786                  * the personality to fail the re-add.
4787                  */
4788                 ITERATE_RDEV(mddev,rdev,rtmp)
4789                         if (rdev->raid_disk >= 0 &&
4790                             (test_bit(Faulty, &rdev->flags) || ! test_bit(In_sync, &rdev->flags)) &&
4791                             atomic_read(&rdev->nr_pending)==0) {
4792                                 if (mddev->pers->hot_remove_disk(mddev, rdev->raid_disk)==0) {
4793                                         char nm[20];
4794                                         sprintf(nm,"rd%d", rdev->raid_disk);
4795                                         sysfs_remove_link(&mddev->kobj, nm);
4796                                         rdev->raid_disk = -1;
4797                                 }
4798                         }
4799
4800                 if (mddev->degraded) {
4801                         ITERATE_RDEV(mddev,rdev,rtmp)
4802                                 if (rdev->raid_disk < 0
4803                                     && !test_bit(Faulty, &rdev->flags)) {
4804                                         if (mddev->pers->hot_add_disk(mddev,rdev)) {
4805                                                 char nm[20];
4806                                                 sprintf(nm, "rd%d", rdev->raid_disk);
4807                                                 sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);
4808                                                 spares++;
4809                                                 md_new_event(mddev);
4810                                         } else
4811                                                 break;
4812                                 }
4813                 }
4814
4815                 if (spares) {
4816                         clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4817                         clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4818                 } else if (mddev->recovery_cp < MaxSector) {
4819                         set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4820                 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
4821                         /* nothing to be done ... */
4822                         goto unlock;
4823
4824                 if (mddev->pers->sync_request) {
4825                         set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
4826                         if (spares && mddev->bitmap && ! mddev->bitmap->file) {
4827                                 /* We are adding a device or devices to an array
4828                                  * which has the bitmap stored on all devices.
4829                                  * So make sure all bitmap pages get written
4830                                  */
4831                                 bitmap_write_all(mddev->bitmap);
4832                         }
4833                         mddev->sync_thread = md_register_thread(md_do_sync,
4834                                                                 mddev,
4835                                                                 "%s_resync");
4836                         if (!mddev->sync_thread) {
4837                                 printk(KERN_ERR "%s: could not start resync"
4838                                         " thread...\n",
4839                                         mdname(mddev));
4840                                 /* leave the spares where they are, it shouldn't hurt */
4841                                 mddev->recovery = 0;
4842                         } else
4843                                 md_wakeup_thread(mddev->sync_thread);
4844                         md_new_event(mddev);
4845                 }
4846         unlock:
4847                 mddev_unlock(mddev);
4848         }
4849 }
4850
4851 static int md_notify_reboot(struct notifier_block *this,
4852                             unsigned long code, void *x)
4853 {
4854         struct list_head *tmp;
4855         mddev_t *mddev;
4856
4857         if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) {
4858
4859                 printk(KERN_INFO "md: stopping all md devices.\n");
4860
4861                 ITERATE_MDDEV(mddev,tmp)
4862                         if (mddev_trylock(mddev)==0)
4863                                 do_md_stop (mddev, 1);
4864                 /*
4865                  * certain more exotic SCSI devices are known to be
4866                  * volatile wrt too early system reboots. While the
4867                  * right place to handle this issue is the given
4868                  * driver, we do want to have a safe RAID driver ...
4869                  */
4870                 mdelay(1000*1);
4871         }
4872         return NOTIFY_DONE;
4873 }
4874
4875 static struct notifier_block md_notifier = {
4876         .notifier_call  = md_notify_reboot,
4877         .next           = NULL,
4878         .priority       = INT_MAX, /* before any real devices */
4879 };
4880
4881 static void md_geninit(void)
4882 {
4883         struct proc_dir_entry *p;
4884
4885         dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
4886
4887         p = create_proc_entry("mdstat", S_IRUGO, NULL);
4888         if (p)
4889                 p->proc_fops = &md_seq_fops;
4890 }
4891
4892 static int __init md_init(void)
4893 {
4894         int minor;
4895
4896         printk(KERN_INFO "md: md driver %d.%d.%d MAX_MD_DEVS=%d,"
4897                         " MD_SB_DISKS=%d\n",
4898                         MD_MAJOR_VERSION, MD_MINOR_VERSION,
4899                         MD_PATCHLEVEL_VERSION, MAX_MD_DEVS, MD_SB_DISKS);
4900         printk(KERN_INFO "md: bitmap version %d.%d\n", BITMAP_MAJOR_HI,
4901                         BITMAP_MINOR);
4902
4903         if (register_blkdev(MAJOR_NR, "md"))
4904                 return -1;
4905         if ((mdp_major=register_blkdev(0, "mdp"))<=0) {
4906                 unregister_blkdev(MAJOR_NR, "md");
4907                 return -1;
4908         }
4909         devfs_mk_dir("md");
4910         blk_register_region(MKDEV(MAJOR_NR, 0), MAX_MD_DEVS, THIS_MODULE,
4911                                 md_probe, NULL, NULL);
4912         blk_register_region(MKDEV(mdp_major, 0), MAX_MD_DEVS<<MdpMinorShift, THIS_MODULE,
4913                             md_probe, NULL, NULL);
4914
4915         for (minor=0; minor < MAX_MD_DEVS; ++minor)
4916                 devfs_mk_bdev(MKDEV(MAJOR_NR, minor),
4917                                 S_IFBLK|S_IRUSR|S_IWUSR,
4918                                 "md/%d", minor);
4919
4920         for (minor=0; minor < MAX_MD_DEVS; ++minor)
4921                 devfs_mk_bdev(MKDEV(mdp_major, minor<<MdpMinorShift),
4922                               S_IFBLK|S_IRUSR|S_IWUSR,
4923                               "md/mdp%d", minor);
4924
4925
4926         register_reboot_notifier(&md_notifier);
4927         raid_table_header = register_sysctl_table(raid_root_table, 1);
4928
4929         md_geninit();
4930         return (0);
4931 }
4932
4933
4934 #ifndef MODULE
4935
4936 /*
4937  * Searches all registered partitions for autorun RAID arrays
4938  * at boot time.
4939  */
4940 static dev_t detected_devices[128];
4941 static int dev_cnt;
4942
4943 void md_autodetect_dev(dev_t dev)
4944 {
4945         if (dev_cnt >= 0 && dev_cnt < 127)
4946                 detected_devices[dev_cnt++] = dev;
4947 }
4948
4949
4950 static void autostart_arrays(int part)
4951 {
4952         mdk_rdev_t *rdev;
4953         int i;
4954
4955         printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
4956
4957         for (i = 0; i < dev_cnt; i++) {
4958                 dev_t dev = detected_devices[i];
4959
4960                 rdev = md_import_device(dev,0, 0);
4961                 if (IS_ERR(rdev))
4962                         continue;
4963
4964                 if (test_bit(Faulty, &rdev->flags)) {
4965                         MD_BUG();
4966                         continue;
4967                 }
4968                 list_add(&rdev->same_set, &pending_raid_disks);
4969         }
4970         dev_cnt = 0;
4971
4972         autorun_devices(part);
4973 }
4974
4975 #endif
4976
4977 static __exit void md_exit(void)
4978 {
4979         mddev_t *mddev;
4980         struct list_head *tmp;
4981         int i;
4982         blk_unregister_region(MKDEV(MAJOR_NR,0), MAX_MD_DEVS);
4983         blk_unregister_region(MKDEV(mdp_major,0), MAX_MD_DEVS << MdpMinorShift);
4984         for (i=0; i < MAX_MD_DEVS; i++)
4985                 devfs_remove("md/%d", i);
4986         for (i=0; i < MAX_MD_DEVS; i++)
4987                 devfs_remove("md/d%d", i);
4988
4989         devfs_remove("md");
4990
4991         unregister_blkdev(MAJOR_NR,"md");
4992         unregister_blkdev(mdp_major, "mdp");
4993         unregister_reboot_notifier(&md_notifier);
4994         unregister_sysctl_table(raid_table_header);
4995         remove_proc_entry("mdstat", NULL);
4996         ITERATE_MDDEV(mddev,tmp) {
4997                 struct gendisk *disk = mddev->gendisk;
4998                 if (!disk)
4999                         continue;
5000                 export_array(mddev);
5001                 del_gendisk(disk);
5002                 put_disk(disk);
5003                 mddev->gendisk = NULL;
5004                 mddev_put(mddev);
5005         }
5006 }
5007
5008 module_init(md_init)
5009 module_exit(md_exit)
5010
5011 static int get_ro(char *buffer, struct kernel_param *kp)
5012 {
5013         return sprintf(buffer, "%d", start_readonly);
5014 }
5015 static int set_ro(const char *val, struct kernel_param *kp)
5016 {
5017         char *e;
5018         int num = simple_strtoul(val, &e, 10);
5019         if (*val && (*e == '\0' || *e == '\n')) {
5020                 start_readonly = num;
5021                 return 0;
5022         }
5023         return -EINVAL;
5024 }
5025
5026 module_param_call(start_ro, set_ro, get_ro, NULL, 0600);
5027 module_param(start_dirty_degraded, int, 0644);
5028
5029
5030 EXPORT_SYMBOL(register_md_personality);
5031 EXPORT_SYMBOL(unregister_md_personality);
5032 EXPORT_SYMBOL(md_error);
5033 EXPORT_SYMBOL(md_done_sync);
5034 EXPORT_SYMBOL(md_write_start);
5035 EXPORT_SYMBOL(md_write_end);
5036 EXPORT_SYMBOL(md_register_thread);
5037 EXPORT_SYMBOL(md_unregister_thread);
5038 EXPORT_SYMBOL(md_wakeup_thread);
5039 EXPORT_SYMBOL(md_print_devices);
5040 EXPORT_SYMBOL(md_check_recovery);
5041 MODULE_LICENSE("GPL");
5042 MODULE_ALIAS("md");
5043 MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);