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