drivers/md/md.c

   1 /*
   2    md.c : Multiple Devices driver for Linux
   3           Copyright (C) 1998, 1999, 2000 Ingo Molnar
   4
   5      completely rewritten, based on the MD driver code from Marc Zyngier
   6
   7    Changes:
   8
   9    - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
  10    - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
  11    - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
  12    - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
  13    - kmod support by: Cyrus Durgin
  14    - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
  15    - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
  16
  17    - lots of fixes and improvements to the RAID1/RAID5 and generic
  18      RAID code (such as request based resynchronization):
  19
  20      Neil Brown <neilb@cse.unsw.edu.au>.
  21
  22    - persistent bitmap code
  23      Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
  24
  25    This program is free software; you can redistribute it and/or modify
  26    it under the terms of the GNU General Public License as published by
  27    the Free Software Foundation; either version 2, or (at your option)
  28    any later version.
  29
  30    You should have received a copy of the GNU General Public License
  31    (for example /usr/src/linux/COPYING); if not, write to the Free
  32    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  33 */
  34
  35 #include <linux/module.h>
  36 #include <linux/config.h>
  37 #include <linux/linkage.h>
  38 #include <linux/raid/md.h>
  39 #include <linux/raid/bitmap.h>
  40 #include <linux/sysctl.h>
  41 #include <linux/devfs_fs_kernel.h>
  42 #include <linux/buffer_head.h> /* for invalidate_bdev */
  43 #include <linux/suspend.h>
  44
  45 #include <linux/init.h>
  46
  47 #include <linux/file.h>
  48
  49 #ifdef CONFIG_KMOD
  50 #include <linux/kmod.h>
  51 #endif
  52
  53 #include <asm/unaligned.h>
  54
  55 #define MAJOR_NR MD_MAJOR
  56 #define MD_DRIVER
  57
  58 /* 63 partitions with the alternate major number (mdp) */
  59 #define MdpMinorShift 6
  60
  61 #define DEBUG 0
  62 #define dprintk(x...) ((void)(DEBUG && printk(x)))
  63
  64
  65 #ifndef MODULE
  66 static void autostart_arrays (int part);
  67 #endif
  68
  69 static mdk_personality_t *pers[MAX_PERSONALITY];
  70 static DEFINE_SPINLOCK(pers_lock);
  71
  72 /*
  73  * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
  74  * is 1000 KB/sec, so the extra system load does not show up that much.
  75  * Increase it if you want to have more _guaranteed_ speed. Note that
  76  * the RAID driver will use the maximum available bandwith if the IO
  77  * subsystem is idle. There is also an 'absolute maximum' reconstruction
  78  * speed limit - in case reconstruction slows down your system despite
  79  * idle IO detection.
  80  *
  81  * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
  82  */
  83
  84 static int sysctl_speed_limit_min = 1000;
  85 static int sysctl_speed_limit_max = 200000;
  86
  87 static struct ctl_table_header *raid_table_header;
  88
  89 static ctl_table raid_table[] = {
  90         {
  91                 .ctl_name       = DEV_RAID_SPEED_LIMIT_MIN,
  92                 .procname       = "speed_limit_min",
  93                 .data           = &sysctl_speed_limit_min,
  94                 .maxlen         = sizeof(int),
  95                 .mode           = 0644,
  96                 .proc_handler   = &proc_dointvec,
  97         },
  98         {
  99                 .ctl_name       = DEV_RAID_SPEED_LIMIT_MAX,
 100                 .procname       = "speed_limit_max",
 101                 .data           = &sysctl_speed_limit_max,
 102                 .maxlen         = sizeof(int),
 103                 .mode           = 0644,
 104                 .proc_handler   = &proc_dointvec,
 105         },
 106         { .ctl_name = 0 }
 107 };
 108
 109 static ctl_table raid_dir_table[] = {
 110         {
 111                 .ctl_name       = DEV_RAID,
 112                 .procname       = "raid",
 113                 .maxlen         = 0,
 114                 .mode           = 0555,
 115                 .child          = raid_table,
 116         },
 117         { .ctl_name = 0 }
 118 };
 119
 120 static ctl_table raid_root_table[] = {
 121         {
 122                 .ctl_name       = CTL_DEV,
 123                 .procname       = "dev",
 124                 .maxlen         = 0,
 125                 .mode           = 0555,
 126                 .child          = raid_dir_table,
 127         },
 128         { .ctl_name = 0 }
 129 };
 130
 131 static struct block_device_operations md_fops;
 132
 133 /*
 134  * Enables to iterate over all existing md arrays
 135  * all_mddevs_lock protects this list.
 136  */
 137 static LIST_HEAD(all_mddevs);
 138 static DEFINE_SPINLOCK(all_mddevs_lock);
 139
 140
 141 /*
 142  * iterates through all used mddevs in the system.
 143  * We take care to grab the all_mddevs_lock whenever navigating
 144  * the list, and to always hold a refcount when unlocked.
 145  * Any code which breaks out of this loop while own
 146  * a reference to the current mddev and must mddev_put it.
 147  */
 148 #define ITERATE_MDDEV(mddev,tmp)                                        \
 149                                                                         \
 150         for (({ spin_lock(&all_mddevs_lock);                            \
 151                 tmp = all_mddevs.next;                                  \
 152                 mddev = NULL;});                                        \
 153              ({ if (tmp != &all_mddevs)                                 \
 154                         mddev_get(list_entry(tmp, mddev_t, all_mddevs));\
 155                 spin_unlock(&all_mddevs_lock);                          \
 156                 if (mddev) mddev_put(mddev);                            \
 157                 mddev = list_entry(tmp, mddev_t, all_mddevs);           \
 158                 tmp != &all_mddevs;});                                  \
 159              ({ spin_lock(&all_mddevs_lock);                            \
 160                 tmp = tmp->next;})                                      \
 161                 )
 162
 163
 164 static int md_fail_request (request_queue_t *q, struct bio *bio)
 165 {
 166         bio_io_error(bio, bio->bi_size);
 167         return 0;
 168 }
 169
 170 static inline mddev_t *mddev_get(mddev_t *mddev)
 171 {
 172         atomic_inc(&mddev->active);
 173         return mddev;
 174 }
 175
 176 static void mddev_put(mddev_t *mddev)
 177 {
 178         if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
 179                 return;
 180         if (!mddev->raid_disks && list_empty(&mddev->disks)) {
 181                 list_del(&mddev->all_mddevs);
 182                 blk_put_queue(mddev->queue);
 183                 kfree(mddev);
 184         }
 185         spin_unlock(&all_mddevs_lock);
 186 }
 187
 188 static mddev_t * mddev_find(dev_t unit)
 189 {
 190         mddev_t *mddev, *new = NULL;
 191
 192  retry:
 193         spin_lock(&all_mddevs_lock);
 194         list_for_each_entry(mddev, &all_mddevs, all_mddevs)
 195                 if (mddev->unit == unit) {
 196                         mddev_get(mddev);
 197                         spin_unlock(&all_mddevs_lock);
 198                         if (new)
 199                                 kfree(new);
 200                         return mddev;
 201                 }
 202
 203         if (new) {
 204                 list_add(&new->all_mddevs, &all_mddevs);
 205                 spin_unlock(&all_mddevs_lock);
 206                 return new;
 207         }
 208         spin_unlock(&all_mddevs_lock);
 209
 210         new = (mddev_t *) kmalloc(sizeof(*new), GFP_KERNEL);
 211         if (!new)
 212                 return NULL;
 213
 214         memset(new, 0, sizeof(*new));
 215
 216         new->unit = unit;
 217         if (MAJOR(unit) == MD_MAJOR)
 218                 new->md_minor = MINOR(unit);
 219         else
 220                 new->md_minor = MINOR(unit) >> MdpMinorShift;
 221
 222         init_MUTEX(&new->reconfig_sem);
 223         INIT_LIST_HEAD(&new->disks);
 224         INIT_LIST_HEAD(&new->all_mddevs);
 225         init_timer(&new->safemode_timer);
 226         atomic_set(&new->active, 1);
 227         spin_lock_init(&new->write_lock);
 228         init_waitqueue_head(&new->sb_wait);
 229
 230         new->queue = blk_alloc_queue(GFP_KERNEL);
 231         if (!new->queue) {
 232                 kfree(new);
 233                 return NULL;
 234         }
 235
 236         blk_queue_make_request(new->queue, md_fail_request);
 237
 238         goto retry;
 239 }
 240
 241 static inline int mddev_lock(mddev_t * mddev)
 242 {
 243         return down_interruptible(&mddev->reconfig_sem);
 244 }
 245
 246 static inline void mddev_lock_uninterruptible(mddev_t * mddev)
 247 {
 248         down(&mddev->reconfig_sem);
 249 }
 250
 251 static inline int mddev_trylock(mddev_t * mddev)
 252 {
 253         return down_trylock(&mddev->reconfig_sem);
 254 }
 255
 256 static inline void mddev_unlock(mddev_t * mddev)
 257 {
 258         up(&mddev->reconfig_sem);
 259
 260         if (mddev->thread)
 261                 md_wakeup_thread(mddev->thread);
 262 }
 263
 264 mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
 265 {
 266         mdk_rdev_t * rdev;
 267         struct list_head *tmp;
 268
 269         ITERATE_RDEV(mddev,rdev,tmp) {
 270                 if (rdev->desc_nr == nr)
 271                         return rdev;
 272         }
 273         return NULL;
 274 }
 275
 276 static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
 277 {
 278         struct list_head *tmp;
 279         mdk_rdev_t *rdev;
 280
 281         ITERATE_RDEV(mddev,rdev,tmp) {
 282                 if (rdev->bdev->bd_dev == dev)
 283                         return rdev;
 284         }
 285         return NULL;
 286 }
 287
 288 inline static sector_t calc_dev_sboffset(struct block_device *bdev)
 289 {
 290         sector_t size = bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
 291         return MD_NEW_SIZE_BLOCKS(size);
 292 }
 293
 294 static sector_t calc_dev_size(mdk_rdev_t *rdev, unsigned chunk_size)
 295 {
 296         sector_t size;
 297
 298         size = rdev->sb_offset;
 299
 300         if (chunk_size)
 301                 size &= ~((sector_t)chunk_size/1024 - 1);
 302         return size;
 303 }
 304
 305 static int alloc_disk_sb(mdk_rdev_t * rdev)
 306 {
 307         if (rdev->sb_page)
 308                 MD_BUG();
 309
 310         rdev->sb_page = alloc_page(GFP_KERNEL);
 311         if (!rdev->sb_page) {
 312                 printk(KERN_ALERT "md: out of memory.\n");
 313                 return -EINVAL;
 314         }
 315
 316         return 0;
 317 }
 318
 319 static void free_disk_sb(mdk_rdev_t * rdev)
 320 {
 321         if (rdev->sb_page) {
 322                 page_cache_release(rdev->sb_page);
 323                 rdev->sb_loaded = 0;
 324                 rdev->sb_page = NULL;
 325                 rdev->sb_offset = 0;
 326                 rdev->size = 0;
 327         }
 328 }
 329
 330
 331 static int bi_complete(struct bio *bio, unsigned int bytes_done, int error)
 332 {
 333         if (bio->bi_size)
 334                 return 1;
 335
 336         complete((struct completion*)bio->bi_private);
 337         return 0;
 338 }
 339
 340 int sync_page_io(struct block_device *bdev, sector_t sector, int size,
 341                    struct page *page, int rw)
 342 {
 343         struct bio *bio = bio_alloc(GFP_NOIO, 1);
 344         struct completion event;
 345         int ret;
 346
 347         rw |= (1 << BIO_RW_SYNC);
 348
 349         bio->bi_bdev = bdev;
 350         bio->bi_sector = sector;
 351         bio_add_page(bio, page, size, 0);
 352         init_completion(&event);
 353         bio->bi_private = &event;
 354         bio->bi_end_io = bi_complete;
 355         submit_bio(rw, bio);
 356         wait_for_completion(&event);
 357
 358         ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
 359         bio_put(bio);
 360         return ret;
 361 }
 362
 363 static int read_disk_sb(mdk_rdev_t * rdev)
 364 {
 365         char b[BDEVNAME_SIZE];
 366         if (!rdev->sb_page) {
 367                 MD_BUG();
 368                 return -EINVAL;
 369         }
 370         if (rdev->sb_loaded)
 371                 return 0;
 372
 373
 374         if (!sync_page_io(rdev->bdev, rdev->sb_offset<<1, MD_SB_BYTES, rdev->sb_page, READ))
 375                 goto fail;
 376         rdev->sb_loaded = 1;
 377         return 0;
 378
 379 fail:
 380         printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
 381                 bdevname(rdev->bdev,b));
 382         return -EINVAL;
 383 }
 384
 385 static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
 386 {
 387         if (    (sb1->set_uuid0 == sb2->set_uuid0) &&
 388                 (sb1->set_uuid1 == sb2->set_uuid1) &&
 389                 (sb1->set_uuid2 == sb2->set_uuid2) &&
 390                 (sb1->set_uuid3 == sb2->set_uuid3))
 391
 392                 return 1;
 393
 394         return 0;
 395 }
 396
 397
 398 static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
 399 {
 400         int ret;
 401         mdp_super_t *tmp1, *tmp2;
 402
 403         tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
 404         tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
 405
 406         if (!tmp1 || !tmp2) {
 407                 ret = 0;
 408                 printk(KERN_INFO "md.c: sb1 is not equal to sb2!\n");
 409                 goto abort;
 410         }
 411
 412         *tmp1 = *sb1;
 413         *tmp2 = *sb2;
 414
 415         /*
 416          * nr_disks is not constant
 417          */
 418         tmp1->nr_disks = 0;
 419         tmp2->nr_disks = 0;
 420
 421         if (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4))
 422                 ret = 0;
 423         else
 424                 ret = 1;
 425
 426 abort:
 427         if (tmp1)
 428                 kfree(tmp1);
 429         if (tmp2)
 430                 kfree(tmp2);
 431
 432         return ret;
 433 }
 434
 435 static unsigned int calc_sb_csum(mdp_super_t * sb)
 436 {
 437         unsigned int disk_csum, csum;
 438
 439         disk_csum = sb->sb_csum;
 440         sb->sb_csum = 0;
 441         csum = csum_partial((void *)sb, MD_SB_BYTES, 0);
 442         sb->sb_csum = disk_csum;
 443         return csum;
 444 }
 445
 446
 447 /*
 448  * Handle superblock details.
 449  * We want to be able to handle multiple superblock formats
 450  * so we have a common interface to them all, and an array of
 451  * different handlers.
 452  * We rely on user-space to write the initial superblock, and support
 453  * reading and updating of superblocks.
 454  * Interface methods are:
 455  *   int load_super(mdk_rdev_t *dev, mdk_rdev_t *refdev, int minor_version)
 456  *      loads and validates a superblock on dev.
 457  *      if refdev != NULL, compare superblocks on both devices
 458  *    Return:
 459  *      0 - dev has a superblock that is compatible with refdev
 460  *      1 - dev has a superblock that is compatible and newer than refdev
 461  *          so dev should be used as the refdev in future
 462  *     -EINVAL superblock incompatible or invalid
 463  *     -othererror e.g. -EIO
 464  *
 465  *   int validate_super(mddev_t *mddev, mdk_rdev_t *dev)
 466  *      Verify that dev is acceptable into mddev.
 467  *       The first time, mddev->raid_disks will be 0, and data from
 468  *       dev should be merged in.  Subsequent calls check that dev
 469  *       is new enough.  Return 0 or -EINVAL
 470  *
 471  *   void sync_super(mddev_t *mddev, mdk_rdev_t *dev)
 472  *     Update the superblock for rdev with data in mddev
 473  *     This does not write to disc.
 474  *
 475  */
 476
 477 struct super_type  {
 478         char            *name;
 479         struct module   *owner;
 480         int             (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version);
 481         int             (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
 482         void            (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
 483 };
 484
 485 /*
 486  * load_super for 0.90.0
 487  */
 488 static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
 489 {
 490         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
 491         mdp_super_t *sb;
 492         int ret;
 493         sector_t sb_offset;
 494
 495         /*
 496          * Calculate the position of the superblock,
 497          * it's at the end of the disk.
 498          *
 499          * It also happens to be a multiple of 4Kb.
 500          */
 501         sb_offset = calc_dev_sboffset(rdev->bdev);
 502         rdev->sb_offset = sb_offset;
 503
 504         ret = read_disk_sb(rdev);
 505         if (ret) return ret;
 506
 507         ret = -EINVAL;
 508
 509         bdevname(rdev->bdev, b);
 510         sb = (mdp_super_t*)page_address(rdev->sb_page);
 511
 512         if (sb->md_magic != MD_SB_MAGIC) {
 513                 printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
 514                        b);
 515                 goto abort;
 516         }
 517
 518         if (sb->major_version != 0 ||
 519             sb->minor_version != 90) {
 520                 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
 521                         sb->major_version, sb->minor_version,
 522                         b);
 523                 goto abort;
 524         }
 525
 526         if (sb->raid_disks <= 0)
 527                 goto abort;
 528
 529         if (csum_fold(calc_sb_csum(sb)) != csum_fold(sb->sb_csum)) {
 530                 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
 531                         b);
 532                 goto abort;
 533         }
 534
 535         rdev->preferred_minor = sb->md_minor;
 536         rdev->data_offset = 0;
 537
 538         if (sb->level == LEVEL_MULTIPATH)
 539                 rdev->desc_nr = -1;
 540         else
 541                 rdev->desc_nr = sb->this_disk.number;
 542
 543         if (refdev == 0)
 544                 ret = 1;
 545         else {
 546                 __u64 ev1, ev2;
 547                 mdp_super_t *refsb = (mdp_super_t*)page_address(refdev->sb_page);
 548                 if (!uuid_equal(refsb, sb)) {
 549                         printk(KERN_WARNING "md: %s has different UUID to %s\n",
 550                                 b, bdevname(refdev->bdev,b2));
 551                         goto abort;
 552                 }
 553                 if (!sb_equal(refsb, sb)) {
 554                         printk(KERN_WARNING "md: %s has same UUID"
 555                                " but different superblock to %s\n",
 556                                b, bdevname(refdev->bdev, b2));
 557                         goto abort;
 558                 }
 559                 ev1 = md_event(sb);
 560                 ev2 = md_event(refsb);
 561                 if (ev1 > ev2)
 562                         ret = 1;
 563                 else
 564                         ret = 0;
 565         }
 566         rdev->size = calc_dev_size(rdev, sb->chunk_size);
 567
 568  abort:
 569         return ret;
 570 }
 571
 572 /*
 573  * validate_super for 0.90.0
 574  */
 575 static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
 576 {
 577         mdp_disk_t *desc;
 578         mdp_super_t *sb = (mdp_super_t *)page_address(rdev->sb_page);
 579
 580         rdev->raid_disk = -1;
 581         rdev->in_sync = 0;
 582         if (mddev->raid_disks == 0) {
 583                 mddev->major_version = 0;
 584                 mddev->minor_version = sb->minor_version;
 585                 mddev->patch_version = sb->patch_version;
 586                 mddev->persistent = ! sb->not_persistent;
 587                 mddev->chunk_size = sb->chunk_size;
 588                 mddev->ctime = sb->ctime;
 589                 mddev->utime = sb->utime;
 590                 mddev->level = sb->level;
 591                 mddev->layout = sb->layout;
 592                 mddev->raid_disks = sb->raid_disks;
 593                 mddev->size = sb->size;
 594                 mddev->events = md_event(sb);
 595
 596                 if (sb->state & (1<<MD_SB_CLEAN))
 597                         mddev->recovery_cp = MaxSector;
 598                 else {
 599                         if (sb->events_hi == sb->cp_events_hi &&
 600                                 sb->events_lo == sb->cp_events_lo) {
 601                                 mddev->recovery_cp = sb->recovery_cp;
 602                         } else
 603                                 mddev->recovery_cp = 0;
 604                 }
 605
 606                 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
 607                 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
 608                 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
 609                 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
 610
 611                 mddev->max_disks = MD_SB_DISKS;
 612
 613                 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
 614                     mddev->bitmap_file == NULL) {
 615                         if (mddev->level != 1) {
 616                                 /* FIXME use a better test */
 617                                 printk(KERN_WARNING "md: bitmaps only support for raid1\n");
 618                                 return -EINVAL;
 619                         }
 620                         mddev->bitmap_offset = (MD_SB_BYTES >> 9);
 621                 }
 622
 623         } else if (mddev->pers == NULL) {
 624                 /* Insist on good event counter while assembling */
 625                 __u64 ev1 = md_event(sb);
 626                 ++ev1;
 627                 if (ev1 < mddev->events)
 628                         return -EINVAL;
 629         } else if (mddev->bitmap) {
 630                 /* if adding to array with a bitmap, then we can accept an
 631                  * older device ... but not too old.
 632                  */
 633                 __u64 ev1 = md_event(sb);
 634                 if (ev1 < mddev->bitmap->events_cleared)
 635                         return 0;
 636         } else /* just a hot-add of a new device, leave raid_disk at -1 */
 637                 return 0;
 638
 639         if (mddev->level != LEVEL_MULTIPATH) {
 640                 rdev->faulty = 0;
 641                 desc = sb->disks + rdev->desc_nr;
 642
 643                 if (desc->state & (1<<MD_DISK_FAULTY))
 644                         rdev->faulty = 1;
 645                 else if (desc->state & (1<<MD_DISK_SYNC) &&
 646                          desc->raid_disk < mddev->raid_disks) {
 647                         rdev->in_sync = 1;
 648                         rdev->raid_disk = desc->raid_disk;
 649                 }
 650         } else /* MULTIPATH are always insync */
 651                 rdev->in_sync = 1;
 652         return 0;
 653 }
 654
 655 /*
 656  * sync_super for 0.90.0
 657  */
 658 static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
 659 {
 660         mdp_super_t *sb;
 661         struct list_head *tmp;
 662         mdk_rdev_t *rdev2;
 663         int next_spare = mddev->raid_disks;
 664
 665         /* make rdev->sb match mddev data..
 666          *
 667          * 1/ zero out disks
 668          * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
 669          * 3/ any empty disks < next_spare become removed
 670          *
 671          * disks[0] gets initialised to REMOVED because
 672          * we cannot be sure from other fields if it has
 673          * been initialised or not.
 674          */
 675         int i;
 676         int active=0, working=0,failed=0,spare=0,nr_disks=0;
 677
 678         sb = (mdp_super_t*)page_address(rdev->sb_page);
 679
 680         memset(sb, 0, sizeof(*sb));
 681
 682         sb->md_magic = MD_SB_MAGIC;
 683         sb->major_version = mddev->major_version;
 684         sb->minor_version = mddev->minor_version;
 685         sb->patch_version = mddev->patch_version;
 686         sb->gvalid_words  = 0; /* ignored */
 687         memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
 688         memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
 689         memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
 690         memcpy(&sb->set_uuid3, mddev->uuid+12,4);
 691
 692         sb->ctime = mddev->ctime;
 693         sb->level = mddev->level;
 694         sb->size  = mddev->size;
 695         sb->raid_disks = mddev->raid_disks;
 696         sb->md_minor = mddev->md_minor;
 697         sb->not_persistent = !mddev->persistent;
 698         sb->utime = mddev->utime;
 699         sb->state = 0;
 700         sb->events_hi = (mddev->events>>32);
 701         sb->events_lo = (u32)mddev->events;
 702
 703         if (mddev->in_sync)
 704         {
 705                 sb->recovery_cp = mddev->recovery_cp;
 706                 sb->cp_events_hi = (mddev->events>>32);
 707                 sb->cp_events_lo = (u32)mddev->events;
 708                 if (mddev->recovery_cp == MaxSector)
 709                         sb->state = (1<< MD_SB_CLEAN);
 710         } else
 711                 sb->recovery_cp = 0;
 712
 713         sb->layout = mddev->layout;
 714         sb->chunk_size = mddev->chunk_size;
 715
 716         if (mddev->bitmap && mddev->bitmap_file == NULL)
 717                 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
 718
 719         sb->disks[0].state = (1<<MD_DISK_REMOVED);
 720         ITERATE_RDEV(mddev,rdev2,tmp) {
 721                 mdp_disk_t *d;
 722                 if (rdev2->raid_disk >= 0 && rdev2->in_sync && !rdev2->faulty)
 723                         rdev2->desc_nr = rdev2->raid_disk;
 724                 else
 725                         rdev2->desc_nr = next_spare++;
 726                 d = &sb->disks[rdev2->desc_nr];
 727                 nr_disks++;
 728                 d->number = rdev2->desc_nr;
 729                 d->major = MAJOR(rdev2->bdev->bd_dev);
 730                 d->minor = MINOR(rdev2->bdev->bd_dev);
 731                 if (rdev2->raid_disk >= 0 && rdev->in_sync && !rdev2->faulty)
 732                         d->raid_disk = rdev2->raid_disk;
 733                 else
 734                         d->raid_disk = rdev2->desc_nr; /* compatibility */
 735                 if (rdev2->faulty) {
 736                         d->state = (1<<MD_DISK_FAULTY);
 737                         failed++;
 738                 } else if (rdev2->in_sync) {
 739                         d->state = (1<<MD_DISK_ACTIVE);
 740                         d->state |= (1<<MD_DISK_SYNC);
 741                         active++;
 742                         working++;
 743                 } else {
 744                         d->state = 0;
 745                         spare++;
 746                         working++;
 747                 }
 748         }
 749
 750         /* now set the "removed" and "faulty" bits on any missing devices */
 751         for (i=0 ; i < mddev->raid_disks ; i++) {
 752                 mdp_disk_t *d = &sb->disks[i];
 753                 if (d->state == 0 && d->number == 0) {
 754                         d->number = i;
 755                         d->raid_disk = i;
 756                         d->state = (1<<MD_DISK_REMOVED);
 757                         d->state |= (1<<MD_DISK_FAULTY);
 758                         failed++;
 759                 }
 760         }
 761         sb->nr_disks = nr_disks;
 762         sb->active_disks = active;
 763         sb->working_disks = working;
 764         sb->failed_disks = failed;
 765         sb->spare_disks = spare;
 766
 767         sb->this_disk = sb->disks[rdev->desc_nr];
 768         sb->sb_csum = calc_sb_csum(sb);
 769 }
 770
 771 /*
 772  * version 1 superblock
 773  */
 774
 775 static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
 776 {
 777         unsigned int disk_csum, csum;
 778         unsigned long long newcsum;
 779         int size = 256 + le32_to_cpu(sb->max_dev)*2;
 780         unsigned int *isuper = (unsigned int*)sb;
 781         int i;
 782
 783         disk_csum = sb->sb_csum;
 784         sb->sb_csum = 0;
 785         newcsum = 0;
 786         for (i=0; size>=4; size -= 4 )
 787                 newcsum += le32_to_cpu(*isuper++);
 788
 789         if (size == 2)
 790                 newcsum += le16_to_cpu(*(unsigned short*) isuper);
 791
 792         csum = (newcsum & 0xffffffff) + (newcsum >> 32);
 793         sb->sb_csum = disk_csum;
 794         return cpu_to_le32(csum);
 795 }
 796
 797 static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
 798 {
 799         struct mdp_superblock_1 *sb;
 800         int ret;
 801         sector_t sb_offset;
 802         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
 803
 804         /*
 805          * Calculate the position of the superblock.
 806          * It is always aligned to a 4K boundary and
 807          * depeding on minor_version, it can be:
 808          * 0: At least 8K, but less than 12K, from end of device
 809          * 1: At start of device
 810          * 2: 4K from start of device.
 811          */
 812         switch(minor_version) {
 813         case 0:
 814                 sb_offset = rdev->bdev->bd_inode->i_size >> 9;
 815                 sb_offset -= 8*2;
 816                 sb_offset &= ~(4*2-1);
 817                 /* convert from sectors to K */
 818                 sb_offset /= 2;
 819                 break;
 820         case 1:
 821                 sb_offset = 0;
 822                 break;
 823         case 2:
 824                 sb_offset = 4;
 825                 break;
 826         default:
 827                 return -EINVAL;
 828         }
 829         rdev->sb_offset = sb_offset;
 830
 831         ret = read_disk_sb(rdev);
 832         if (ret) return ret;
 833
 834
 835         sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
 836
 837         if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
 838             sb->major_version != cpu_to_le32(1) ||
 839             le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
 840             le64_to_cpu(sb->super_offset) != (rdev->sb_offset<<1) ||
 841             sb->feature_map != 0)
 842                 return -EINVAL;
 843
 844         if (calc_sb_1_csum(sb) != sb->sb_csum) {
 845                 printk("md: invalid superblock checksum on %s\n",
 846                         bdevname(rdev->bdev,b));
 847                 return -EINVAL;
 848         }
 849         if (le64_to_cpu(sb->data_size) < 10) {
 850                 printk("md: data_size too small on %s\n",
 851                        bdevname(rdev->bdev,b));
 852                 return -EINVAL;
 853         }
 854         rdev->preferred_minor = 0xffff;
 855         rdev->data_offset = le64_to_cpu(sb->data_offset);
 856
 857         if (refdev == 0)
 858                 return 1;
 859         else {
 860                 __u64 ev1, ev2;
 861                 struct mdp_superblock_1 *refsb =
 862                         (struct mdp_superblock_1*)page_address(refdev->sb_page);
 863
 864                 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
 865                     sb->level != refsb->level ||
 866                     sb->layout != refsb->layout ||
 867                     sb->chunksize != refsb->chunksize) {
 868                         printk(KERN_WARNING "md: %s has strangely different"
 869                                 " superblock to %s\n",
 870                                 bdevname(rdev->bdev,b),
 871                                 bdevname(refdev->bdev,b2));
 872                         return -EINVAL;
 873                 }
 874                 ev1 = le64_to_cpu(sb->events);
 875                 ev2 = le64_to_cpu(refsb->events);
 876
 877                 if (ev1 > ev2)
 878                         return 1;
 879         }
 880         if (minor_version)
 881                 rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2;
 882         else
 883                 rdev->size = rdev->sb_offset;
 884         if (rdev->size < le64_to_cpu(sb->data_size)/2)
 885                 return -EINVAL;
 886         rdev->size = le64_to_cpu(sb->data_size)/2;
 887         if (le32_to_cpu(sb->chunksize))
 888                 rdev->size &= ~((sector_t)le32_to_cpu(sb->chunksize)/2 - 1);
 889         return 0;
 890 }
 891
 892 static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
 893 {
 894         struct mdp_superblock_1 *sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
 895
 896         rdev->raid_disk = -1;
 897         rdev->in_sync = 0;
 898         if (mddev->raid_disks == 0) {
 899                 mddev->major_version = 1;
 900                 mddev->patch_version = 0;
 901                 mddev->persistent = 1;
 902                 mddev->chunk_size = le32_to_cpu(sb->chunksize) << 9;
 903                 mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
 904                 mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
 905                 mddev->level = le32_to_cpu(sb->level);
 906                 mddev->layout = le32_to_cpu(sb->layout);
 907                 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
 908                 mddev->size = le64_to_cpu(sb->size)/2;
 909                 mddev->events = le64_to_cpu(sb->events);
 910
 911                 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
 912                 memcpy(mddev->uuid, sb->set_uuid, 16);
 913
 914                 mddev->max_disks =  (4096-256)/2;
 915
 916                 if ((le32_to_cpu(sb->feature_map) & 1) &&
 917                     mddev->bitmap_file == NULL ) {
 918                         if (mddev->level != 1) {
 919                                 printk(KERN_WARNING "md: bitmaps only supported for raid1\n");
 920                                 return -EINVAL;
 921                         }
 922                         mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset);
 923                 }
 924         } else if (mddev->pers == NULL) {
 925                 /* Insist of good event counter while assembling */
 926                 __u64 ev1 = le64_to_cpu(sb->events);
 927                 ++ev1;
 928                 if (ev1 < mddev->events)
 929                         return -EINVAL;
 930         } else if (mddev->bitmap) {
 931                 /* If adding to array with a bitmap, then we can accept an
 932                  * older device, but not too old.
 933                  */
 934                 __u64 ev1 = le64_to_cpu(sb->events);
 935                 if (ev1 < mddev->bitmap->events_cleared)
 936                         return 0;
 937         } else /* just a hot-add of a new device, leave raid_disk at -1 */
 938                 return 0;
 939
 940         if (mddev->level != LEVEL_MULTIPATH) {
 941                 int role;
 942                 rdev->desc_nr = le32_to_cpu(sb->dev_number);
 943                 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
 944                 switch(role) {
 945                 case 0xffff: /* spare */
 946                         rdev->faulty = 0;
 947                         break;
 948                 case 0xfffe: /* faulty */
 949                         rdev->faulty = 1;
 950                         break;
 951                 default:
 952                         rdev->in_sync = 1;
 953                         rdev->faulty = 0;
 954                         rdev->raid_disk = role;
 955                         break;
 956                 }
 957         } else /* MULTIPATH are always insync */
 958                 rdev->in_sync = 1;
 959
 960         return 0;
 961 }
 962
 963 static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
 964 {
 965         struct mdp_superblock_1 *sb;
 966         struct list_head *tmp;
 967         mdk_rdev_t *rdev2;
 968         int max_dev, i;
 969         /* make rdev->sb match mddev and rdev data. */
 970
 971         sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
 972
 973         sb->feature_map = 0;
 974         sb->pad0 = 0;
 975         memset(sb->pad1, 0, sizeof(sb->pad1));
 976         memset(sb->pad2, 0, sizeof(sb->pad2));
 977         memset(sb->pad3, 0, sizeof(sb->pad3));
 978
 979         sb->utime = cpu_to_le64((__u64)mddev->utime);
 980         sb->events = cpu_to_le64(mddev->events);
 981         if (mddev->in_sync)
 982                 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
 983         else
 984                 sb->resync_offset = cpu_to_le64(0);
 985
 986         if (mddev->bitmap && mddev->bitmap_file == NULL) {
 987                 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset);
 988                 sb->feature_map = cpu_to_le32(1);
 989         }
 990
 991         max_dev = 0;
 992         ITERATE_RDEV(mddev,rdev2,tmp)
 993                 if (rdev2->desc_nr+1 > max_dev)
 994                         max_dev = rdev2->desc_nr+1;
 995
 996         sb->max_dev = cpu_to_le32(max_dev);
 997         for (i=0; i<max_dev;i++)
 998                 sb->dev_roles[i] = cpu_to_le16(0xfffe);
 999
1000         ITERATE_RDEV(mddev,rdev2,tmp) {
1001                 i = rdev2->desc_nr;
1002                 if (rdev2->faulty)
1003                         sb->dev_roles[i] = cpu_to_le16(0xfffe);
1004                 else if (rdev2->in_sync)
1005                         sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1006                 else
1007                         sb->dev_roles[i] = cpu_to_le16(0xffff);
1008         }
1009
1010         sb->recovery_offset = cpu_to_le64(0); /* not supported yet */
1011         sb->sb_csum = calc_sb_1_csum(sb);
1012 }
1013
1014
1015 static struct super_type super_types[] = {
1016         [0] = {
1017                 .name   = "0.90.0",
1018                 .owner  = THIS_MODULE,
1019                 .load_super     = super_90_load,
1020                 .validate_super = super_90_validate,
1021                 .sync_super     = super_90_sync,
1022         },
1023         [1] = {
1024                 .name   = "md-1",
1025                 .owner  = THIS_MODULE,
1026                 .load_super     = super_1_load,
1027                 .validate_super = super_1_validate,
1028                 .sync_super     = super_1_sync,
1029         },
1030 };
1031
1032 static mdk_rdev_t * match_dev_unit(mddev_t *mddev, mdk_rdev_t *dev)
1033 {
1034         struct list_head *tmp;
1035         mdk_rdev_t *rdev;
1036
1037         ITERATE_RDEV(mddev,rdev,tmp)
1038                 if (rdev->bdev->bd_contains == dev->bdev->bd_contains)
1039                         return rdev;
1040
1041         return NULL;
1042 }
1043
1044 static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
1045 {
1046         struct list_head *tmp;
1047         mdk_rdev_t *rdev;
1048
1049         ITERATE_RDEV(mddev1,rdev,tmp)
1050                 if (match_dev_unit(mddev2, rdev))
1051                         return 1;
1052
1053         return 0;
1054 }
1055
1056 static LIST_HEAD(pending_raid_disks);
1057
1058 static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
1059 {
1060         mdk_rdev_t *same_pdev;
1061         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1062
1063         if (rdev->mddev) {
1064                 MD_BUG();
1065                 return -EINVAL;
1066         }
1067         same_pdev = match_dev_unit(mddev, rdev);
1068         if (same_pdev)
1069                 printk(KERN_WARNING
1070                         "%s: WARNING: %s appears to be on the same physical"
1071                         " disk as %s. True\n     protection against single-disk"
1072                         " failure might be compromised.\n",
1073                         mdname(mddev), bdevname(rdev->bdev,b),
1074                         bdevname(same_pdev->bdev,b2));
1075
1076         /* Verify rdev->desc_nr is unique.
1077          * If it is -1, assign a free number, else
1078          * check number is not in use
1079          */
1080         if (rdev->desc_nr < 0) {
1081                 int choice = 0;
1082                 if (mddev->pers) choice = mddev->raid_disks;
1083                 while (find_rdev_nr(mddev, choice))
1084                         choice++;
1085                 rdev->desc_nr = choice;
1086         } else {
1087                 if (find_rdev_nr(mddev, rdev->desc_nr))
1088                         return -EBUSY;
1089         }
1090
1091         list_add(&rdev->same_set, &mddev->disks);
1092         rdev->mddev = mddev;
1093         printk(KERN_INFO "md: bind<%s>\n", bdevname(rdev->bdev,b));
1094         return 0;
1095 }
1096
1097 static void unbind_rdev_from_array(mdk_rdev_t * rdev)
1098 {
1099         char b[BDEVNAME_SIZE];
1100         if (!rdev->mddev) {
1101                 MD_BUG();
1102                 return;
1103         }
1104         list_del_init(&rdev->same_set);
1105         printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
1106         rdev->mddev = NULL;
1107 }
1108
1109 /*
1110  * prevent the device from being mounted, repartitioned or
1111  * otherwise reused by a RAID array (or any other kernel
1112  * subsystem), by bd_claiming the device.
1113  */
1114 static int lock_rdev(mdk_rdev_t *rdev, dev_t dev)
1115 {
1116         int err = 0;
1117         struct block_device *bdev;
1118         char b[BDEVNAME_SIZE];
1119
1120         bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
1121         if (IS_ERR(bdev)) {
1122                 printk(KERN_ERR "md: could not open %s.\n",
1123                         __bdevname(dev, b));
1124                 return PTR_ERR(bdev);
1125         }
1126         err = bd_claim(bdev, rdev);
1127         if (err) {
1128                 printk(KERN_ERR "md: could not bd_claim %s.\n",
1129                         bdevname(bdev, b));
1130                 blkdev_put(bdev);
1131                 return err;
1132         }
1133         rdev->bdev = bdev;
1134         return err;
1135 }
1136
1137 static void unlock_rdev(mdk_rdev_t *rdev)
1138 {
1139         struct block_device *bdev = rdev->bdev;
1140         rdev->bdev = NULL;
1141         if (!bdev)
1142                 MD_BUG();
1143         bd_release(bdev);
1144         blkdev_put(bdev);
1145 }
1146
1147 void md_autodetect_dev(dev_t dev);
1148
1149 static void export_rdev(mdk_rdev_t * rdev)
1150 {
1151         char b[BDEVNAME_SIZE];
1152         printk(KERN_INFO "md: export_rdev(%s)\n",
1153                 bdevname(rdev->bdev,b));
1154         if (rdev->mddev)
1155                 MD_BUG();
1156         free_disk_sb(rdev);
1157         list_del_init(&rdev->same_set);
1158 #ifndef MODULE
1159         md_autodetect_dev(rdev->bdev->bd_dev);
1160 #endif
1161         unlock_rdev(rdev);
1162         kfree(rdev);
1163 }
1164
1165 static void kick_rdev_from_array(mdk_rdev_t * rdev)
1166 {
1167         unbind_rdev_from_array(rdev);
1168         export_rdev(rdev);
1169 }
1170
1171 static void export_array(mddev_t *mddev)
1172 {
1173         struct list_head *tmp;
1174         mdk_rdev_t *rdev;
1175
1176         ITERATE_RDEV(mddev,rdev,tmp) {
1177                 if (!rdev->mddev) {
1178                         MD_BUG();
1179                         continue;
1180                 }
1181                 kick_rdev_from_array(rdev);
1182         }
1183         if (!list_empty(&mddev->disks))
1184                 MD_BUG();
1185         mddev->raid_disks = 0;
1186         mddev->major_version = 0;
1187 }
1188
1189 static void print_desc(mdp_disk_t *desc)
1190 {
1191         printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number,
1192                 desc->major,desc->minor,desc->raid_disk,desc->state);
1193 }
1194
1195 static void print_sb(mdp_super_t *sb)
1196 {
1197         int i;
1198
1199         printk(KERN_INFO
1200                 "md:  SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
1201                 sb->major_version, sb->minor_version, sb->patch_version,
1202                 sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
1203                 sb->ctime);
1204         printk(KERN_INFO "md:     L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n",
1205                 sb->level, sb->size, sb->nr_disks, sb->raid_disks,
1206                 sb->md_minor, sb->layout, sb->chunk_size);
1207         printk(KERN_INFO "md:     UT:%08x ST:%d AD:%d WD:%d"
1208                 " FD:%d SD:%d CSUM:%08x E:%08lx\n",
1209                 sb->utime, sb->state, sb->active_disks, sb->working_disks,
1210                 sb->failed_disks, sb->spare_disks,
1211                 sb->sb_csum, (unsigned long)sb->events_lo);
1212
1213         printk(KERN_INFO);
1214         for (i = 0; i < MD_SB_DISKS; i++) {
1215                 mdp_disk_t *desc;
1216
1217                 desc = sb->disks + i;
1218                 if (desc->number || desc->major || desc->minor ||
1219                     desc->raid_disk || (desc->state && (desc->state != 4))) {
1220                         printk("     D %2d: ", i);
1221                         print_desc(desc);
1222                 }
1223         }
1224         printk(KERN_INFO "md:     THIS: ");
1225         print_desc(&sb->this_disk);
1226
1227 }
1228
1229 static void print_rdev(mdk_rdev_t *rdev)
1230 {
1231         char b[BDEVNAME_SIZE];
1232         printk(KERN_INFO "md: rdev %s, SZ:%08llu F:%d S:%d DN:%u\n",
1233                 bdevname(rdev->bdev,b), (unsigned long long)rdev->size,
1234                 rdev->faulty, rdev->in_sync, rdev->desc_nr);
1235         if (rdev->sb_loaded) {
1236                 printk(KERN_INFO "md: rdev superblock:\n");
1237                 print_sb((mdp_super_t*)page_address(rdev->sb_page));
1238         } else
1239                 printk(KERN_INFO "md: no rdev superblock!\n");
1240 }
1241
1242 void md_print_devices(void)
1243 {
1244         struct list_head *tmp, *tmp2;
1245         mdk_rdev_t *rdev;
1246         mddev_t *mddev;
1247         char b[BDEVNAME_SIZE];
1248
1249         printk("\n");
1250         printk("md:     **********************************\n");
1251         printk("md:     * <COMPLETE RAID STATE PRINTOUT> *\n");
1252         printk("md:     **********************************\n");
1253         ITERATE_MDDEV(mddev,tmp) {
1254
1255                 if (mddev->bitmap)
1256                         bitmap_print_sb(mddev->bitmap);
1257                 else
1258                         printk("%s: ", mdname(mddev));
1259                 ITERATE_RDEV(mddev,rdev,tmp2)
1260                         printk("<%s>", bdevname(rdev->bdev,b));
1261                 printk("\n");
1262
1263                 ITERATE_RDEV(mddev,rdev,tmp2)
1264                         print_rdev(rdev);
1265         }
1266         printk("md:     **********************************\n");
1267         printk("\n");
1268 }
1269
1270
1271 static int write_disk_sb(mdk_rdev_t * rdev)
1272 {
1273         char b[BDEVNAME_SIZE];
1274         if (!rdev->sb_loaded) {
1275                 MD_BUG();
1276                 return 1;
1277         }
1278         if (rdev->faulty) {
1279                 MD_BUG();
1280                 return 1;
1281         }
1282
1283         dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
1284                 bdevname(rdev->bdev,b),
1285                (unsigned long long)rdev->sb_offset);
1286
1287         if (sync_page_io(rdev->bdev, rdev->sb_offset<<1, MD_SB_BYTES, rdev->sb_page, WRITE))
1288                 return 0;
1289
1290         printk("md: write_disk_sb failed for device %s\n",
1291                 bdevname(rdev->bdev,b));
1292         return 1;
1293 }
1294
1295 static void sync_sbs(mddev_t * mddev)
1296 {
1297         mdk_rdev_t *rdev;
1298         struct list_head *tmp;
1299
1300         ITERATE_RDEV(mddev,rdev,tmp) {
1301                 super_types[mddev->major_version].
1302                         sync_super(mddev, rdev);
1303                 rdev->sb_loaded = 1;
1304         }
1305 }
1306
1307 static void md_update_sb(mddev_t * mddev)
1308 {
1309         int err, count = 100;
1310         struct list_head *tmp;
1311         mdk_rdev_t *rdev;
1312         int sync_req;
1313
1314 repeat:
1315         spin_lock(&mddev->write_lock);
1316         sync_req = mddev->in_sync;
1317         mddev->utime = get_seconds();
1318         mddev->events ++;
1319
1320         if (!mddev->events) {
1321                 /*
1322                  * oops, this 64-bit counter should never wrap.
1323                  * Either we are in around ~1 trillion A.C., assuming
1324                  * 1 reboot per second, or we have a bug:
1325                  */
1326                 MD_BUG();
1327                 mddev->events --;
1328         }
1329         sync_sbs(mddev);
1330
1331         /*
1332          * do not write anything to disk if using
1333          * nonpersistent superblocks
1334          */
1335         if (!mddev->persistent) {
1336                 mddev->sb_dirty = 0;
1337                 spin_unlock(&mddev->write_lock);
1338                 wake_up(&mddev->sb_wait);
1339                 return;
1340         }
1341         spin_unlock(&mddev->write_lock);
1342
1343         dprintk(KERN_INFO
1344                 "md: updating %s RAID superblock on device (in sync %d)\n",
1345                 mdname(mddev),mddev->in_sync);
1346
1347         err = bitmap_update_sb(mddev->bitmap);
1348         ITERATE_RDEV(mddev,rdev,tmp) {
1349                 char b[BDEVNAME_SIZE];
1350                 dprintk(KERN_INFO "md: ");
1351                 if (rdev->faulty)
1352                         dprintk("(skipping faulty ");
1353
1354                 dprintk("%s ", bdevname(rdev->bdev,b));
1355                 if (!rdev->faulty) {
1356                         err += write_disk_sb(rdev);
1357                 } else
1358                         dprintk(")\n");
1359                 if (!err && mddev->level == LEVEL_MULTIPATH)
1360                         /* only need to write one superblock... */
1361                         break;
1362         }
1363         if (err) {
1364                 if (--count) {
1365                         printk(KERN_ERR "md: errors occurred during superblock"
1366                                 " update, repeating\n");
1367                         goto repeat;
1368                 }
1369                 printk(KERN_ERR \
1370                         "md: excessive errors occurred during superblock update, exiting\n");
1371         }
1372         spin_lock(&mddev->write_lock);
1373         if (mddev->in_sync != sync_req) {
1374                 /* have to write it out again */
1375                 spin_unlock(&mddev->write_lock);
1376                 goto repeat;
1377         }
1378         mddev->sb_dirty = 0;
1379         spin_unlock(&mddev->write_lock);
1380         wake_up(&mddev->sb_wait);
1381
1382 }
1383
1384 /*
1385  * Import a device. If 'super_format' >= 0, then sanity check the superblock
1386  *
1387  * mark the device faulty if:
1388  *
1389  *   - the device is nonexistent (zero size)
1390  *   - the device has no valid superblock
1391  *
1392  * a faulty rdev _never_ has rdev->sb set.
1393  */
1394 static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor)
1395 {
1396         char b[BDEVNAME_SIZE];
1397         int err;
1398         mdk_rdev_t *rdev;
1399         sector_t size;
1400
1401         rdev = (mdk_rdev_t *) kmalloc(sizeof(*rdev), GFP_KERNEL);
1402         if (!rdev) {
1403                 printk(KERN_ERR "md: could not alloc mem for new device!\n");
1404                 return ERR_PTR(-ENOMEM);
1405         }
1406         memset(rdev, 0, sizeof(*rdev));
1407
1408         if ((err = alloc_disk_sb(rdev)))
1409                 goto abort_free;
1410
1411         err = lock_rdev(rdev, newdev);
1412         if (err)
1413                 goto abort_free;
1414
1415         rdev->desc_nr = -1;
1416         rdev->faulty = 0;
1417         rdev->in_sync = 0;
1418         rdev->data_offset = 0;
1419         atomic_set(&rdev->nr_pending, 0);
1420
1421         size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
1422         if (!size) {
1423                 printk(KERN_WARNING
1424                         "md: %s has zero or unknown size, marking faulty!\n",
1425                         bdevname(rdev->bdev,b));
1426                 err = -EINVAL;
1427                 goto abort_free;
1428         }
1429
1430         if (super_format >= 0) {
1431                 err = super_types[super_format].
1432                         load_super(rdev, NULL, super_minor);
1433                 if (err == -EINVAL) {
1434                         printk(KERN_WARNING
1435                                 "md: %s has invalid sb, not importing!\n",
1436                                 bdevname(rdev->bdev,b));
1437                         goto abort_free;
1438                 }
1439                 if (err < 0) {
1440                         printk(KERN_WARNING
1441                                 "md: could not read %s's sb, not importing!\n",
1442                                 bdevname(rdev->bdev,b));
1443                         goto abort_free;
1444                 }
1445         }
1446         INIT_LIST_HEAD(&rdev->same_set);
1447
1448         return rdev;
1449
1450 abort_free:
1451         if (rdev->sb_page) {
1452                 if (rdev->bdev)
1453                         unlock_rdev(rdev);
1454                 free_disk_sb(rdev);
1455         }
1456         kfree(rdev);
1457         return ERR_PTR(err);
1458 }
1459
1460 /*
1461  * Check a full RAID array for plausibility
1462  */
1463
1464
1465 static void analyze_sbs(mddev_t * mddev)
1466 {
1467         int i;
1468         struct list_head *tmp;
1469         mdk_rdev_t *rdev, *freshest;
1470         char b[BDEVNAME_SIZE];
1471
1472         freshest = NULL;
1473         ITERATE_RDEV(mddev,rdev,tmp)
1474                 switch (super_types[mddev->major_version].
1475                         load_super(rdev, freshest, mddev->minor_version)) {
1476                 case 1:
1477                         freshest = rdev;
1478                         break;
1479                 case 0:
1480                         break;
1481                 default:
1482                         printk( KERN_ERR \
1483                                 "md: fatal superblock inconsistency in %s"
1484                                 " -- removing from array\n",
1485                                 bdevname(rdev->bdev,b));
1486                         kick_rdev_from_array(rdev);
1487                 }
1488
1489
1490         super_types[mddev->major_version].
1491                 validate_super(mddev, freshest);
1492
1493         i = 0;
1494         ITERATE_RDEV(mddev,rdev,tmp) {
1495                 if (rdev != freshest)
1496                         if (super_types[mddev->major_version].
1497                             validate_super(mddev, rdev)) {
1498                                 printk(KERN_WARNING "md: kicking non-fresh %s"
1499                                         " from array!\n",
1500                                         bdevname(rdev->bdev,b));
1501                                 kick_rdev_from_array(rdev);
1502                                 continue;
1503                         }
1504                 if (mddev->level == LEVEL_MULTIPATH) {
1505                         rdev->desc_nr = i++;
1506                         rdev->raid_disk = rdev->desc_nr;
1507                         rdev->in_sync = 1;
1508                 }
1509         }
1510
1511
1512
1513         if (mddev->recovery_cp != MaxSector &&
1514             mddev->level >= 1)
1515                 printk(KERN_ERR "md: %s: raid array is not clean"
1516                        " -- starting background reconstruction\n",
1517                        mdname(mddev));
1518
1519 }
1520
1521 int mdp_major = 0;
1522
1523 static struct kobject *md_probe(dev_t dev, int *part, void *data)
1524 {
1525         static DECLARE_MUTEX(disks_sem);
1526         mddev_t *mddev = mddev_find(dev);
1527         struct gendisk *disk;
1528         int partitioned = (MAJOR(dev) != MD_MAJOR);
1529         int shift = partitioned ? MdpMinorShift : 0;
1530         int unit = MINOR(dev) >> shift;
1531
1532         if (!mddev)
1533                 return NULL;
1534
1535         down(&disks_sem);
1536         if (mddev->gendisk) {
1537                 up(&disks_sem);
1538                 mddev_put(mddev);
1539                 return NULL;
1540         }
1541         disk = alloc_disk(1 << shift);
1542         if (!disk) {
1543                 up(&disks_sem);
1544                 mddev_put(mddev);
1545                 return NULL;
1546         }
1547         disk->major = MAJOR(dev);
1548         disk->first_minor = unit << shift;
1549         if (partitioned) {
1550                 sprintf(disk->disk_name, "md_d%d", unit);
1551                 sprintf(disk->devfs_name, "md/d%d", unit);
1552         } else {
1553                 sprintf(disk->disk_name, "md%d", unit);
1554                 sprintf(disk->devfs_name, "md/%d", unit);
1555         }
1556         disk->fops = &md_fops;
1557         disk->private_data = mddev;
1558         disk->queue = mddev->queue;
1559         add_disk(disk);
1560         mddev->gendisk = disk;
1561         up(&disks_sem);
1562         return NULL;
1563 }
1564
1565 void md_wakeup_thread(mdk_thread_t *thread);
1566
1567 static void md_safemode_timeout(unsigned long data)
1568 {
1569         mddev_t *mddev = (mddev_t *) data;
1570
1571         mddev->safemode = 1;
1572         md_wakeup_thread(mddev->thread);
1573 }
1574
1575
1576 static int do_md_run(mddev_t * mddev)
1577 {
1578         int pnum, err;
1579         int chunk_size;
1580         struct list_head *tmp;
1581         mdk_rdev_t *rdev;
1582         struct gendisk *disk;
1583         char b[BDEVNAME_SIZE];
1584
1585         if (list_empty(&mddev->disks))
1586                 /* cannot run an array with no devices.. */
1587                 return -EINVAL;
1588
1589         if (mddev->pers)
1590                 return -EBUSY;
1591
1592         /*
1593          * Analyze all RAID superblock(s)
1594          */
1595         if (!mddev->raid_disks)
1596                 analyze_sbs(mddev);
1597
1598         chunk_size = mddev->chunk_size;
1599         pnum = level_to_pers(mddev->level);
1600
1601         if ((pnum != MULTIPATH) && (pnum != RAID1)) {
1602                 if (!chunk_size) {
1603                         /*
1604                          * 'default chunksize' in the old md code used to
1605                          * be PAGE_SIZE, baaad.
1606                          * we abort here to be on the safe side. We don't
1607                          * want to continue the bad practice.
1608                          */
1609                         printk(KERN_ERR
1610                                 "no chunksize specified, see 'man raidtab'\n");
1611                         return -EINVAL;
1612                 }
1613                 if (chunk_size > MAX_CHUNK_SIZE) {
1614                         printk(KERN_ERR "too big chunk_size: %d > %d\n",
1615                                 chunk_size, MAX_CHUNK_SIZE);
1616                         return -EINVAL;
1617                 }
1618                 /*
1619                  * chunk-size has to be a power of 2 and multiples of PAGE_SIZE
1620                  */
1621                 if ( (1 << ffz(~chunk_size)) != chunk_size) {
1622                         printk(KERN_ERR "chunk_size of %d not valid\n", chunk_size);
1623                         return -EINVAL;
1624                 }
1625                 if (chunk_size < PAGE_SIZE) {
1626                         printk(KERN_ERR "too small chunk_size: %d < %ld\n",
1627                                 chunk_size, PAGE_SIZE);
1628                         return -EINVAL;
1629                 }
1630
1631                 /* devices must have minimum size of one chunk */
1632                 ITERATE_RDEV(mddev,rdev,tmp) {
1633                         if (rdev->faulty)
1634                                 continue;
1635                         if (rdev->size < chunk_size / 1024) {
1636                                 printk(KERN_WARNING
1637                                         "md: Dev %s smaller than chunk_size:"
1638                                         " %lluk < %dk\n",
1639                                         bdevname(rdev->bdev,b),
1640                                         (unsigned long long)rdev->size,
1641                                         chunk_size / 1024);
1642                                 return -EINVAL;
1643                         }
1644                 }
1645         }
1646
1647 #ifdef CONFIG_KMOD
1648         if (!pers[pnum])
1649         {
1650                 request_module("md-personality-%d", pnum);
1651         }
1652 #endif
1653
1654         /*
1655          * Drop all container device buffers, from now on
1656          * the only valid external interface is through the md
1657          * device.
1658          * Also find largest hardsector size
1659          */
1660         ITERATE_RDEV(mddev,rdev,tmp) {
1661                 if (rdev->faulty)
1662                         continue;
1663                 sync_blockdev(rdev->bdev);
1664                 invalidate_bdev(rdev->bdev, 0);
1665         }
1666
1667         md_probe(mddev->unit, NULL, NULL);
1668         disk = mddev->gendisk;
1669         if (!disk)
1670                 return -ENOMEM;
1671
1672         spin_lock(&pers_lock);
1673         if (!pers[pnum] || !try_module_get(pers[pnum]->owner)) {
1674                 spin_unlock(&pers_lock);
1675                 printk(KERN_WARNING "md: personality %d is not loaded!\n",
1676                        pnum);
1677                 return -EINVAL;
1678         }
1679
1680         mddev->pers = pers[pnum];
1681         spin_unlock(&pers_lock);
1682
1683         mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */
1684
1685         /* before we start the array running, initialise the bitmap */
1686         err = bitmap_create(mddev);
1687         if (err)
1688                 printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
1689                         mdname(mddev), err);
1690         else
1691                 err = mddev->pers->run(mddev);
1692         if (err) {
1693                 printk(KERN_ERR "md: pers->run() failed ...\n");
1694                 module_put(mddev->pers->owner);
1695                 mddev->pers = NULL;
1696                 bitmap_destroy(mddev);
1697                 return err;
1698         }
1699         atomic_set(&mddev->writes_pending,0);
1700         mddev->safemode = 0;
1701         mddev->safemode_timer.function = md_safemode_timeout;
1702         mddev->safemode_timer.data = (unsigned long) mddev;
1703         mddev->safemode_delay = (20 * HZ)/1000 +1; /* 20 msec delay */
1704         mddev->in_sync = 1;
1705
1706         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
1707
1708         if (mddev->sb_dirty)
1709                 md_update_sb(mddev);
1710
1711         set_capacity(disk, mddev->array_size<<1);
1712
1713         /* If we call blk_queue_make_request here, it will
1714          * re-initialise max_sectors etc which may have been
1715          * refined inside -> run.  So just set the bits we need to set.
1716          * Most initialisation happended when we called
1717          * blk_queue_make_request(..., md_fail_request)
1718          * earlier.
1719          */
1720         mddev->queue->queuedata = mddev;
1721         mddev->queue->make_request_fn = mddev->pers->make_request;
1722
1723         mddev->changed = 1;
1724         return 0;
1725 }
1726
1727 static int restart_array(mddev_t *mddev)
1728 {
1729         struct gendisk *disk = mddev->gendisk;
1730         int err;
1731
1732         /*
1733          * Complain if it has no devices
1734          */
1735         err = -ENXIO;
1736         if (list_empty(&mddev->disks))
1737                 goto out;
1738
1739         if (mddev->pers) {
1740                 err = -EBUSY;
1741                 if (!mddev->ro)
1742                         goto out;
1743
1744                 mddev->safemode = 0;
1745                 mddev->ro = 0;
1746                 set_disk_ro(disk, 0);
1747
1748                 printk(KERN_INFO "md: %s switched to read-write mode.\n",
1749                         mdname(mddev));
1750                 /*
1751                  * Kick recovery or resync if necessary
1752                  */
1753                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
1754                 md_wakeup_thread(mddev->thread);
1755                 err = 0;
1756         } else {
1757                 printk(KERN_ERR "md: %s has no personality assigned.\n",
1758                         mdname(mddev));
1759                 err = -EINVAL;
1760         }
1761
1762 out:
1763         return err;
1764 }
1765
1766 static int do_md_stop(mddev_t * mddev, int ro)
1767 {
1768         int err = 0;
1769         struct gendisk *disk = mddev->gendisk;
1770
1771         if (mddev->pers) {
1772                 if (atomic_read(&mddev->active)>2) {
1773                         printk("md: %s still in use.\n",mdname(mddev));
1774                         return -EBUSY;
1775                 }
1776
1777                 if (mddev->sync_thread) {
1778                         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
1779                         md_unregister_thread(mddev->sync_thread);
1780                         mddev->sync_thread = NULL;
1781                 }
1782
1783                 del_timer_sync(&mddev->safemode_timer);
1784
1785                 invalidate_partition(disk, 0);
1786
1787                 if (ro) {
1788                         err  = -ENXIO;
1789                         if (mddev->ro)
1790                                 goto out;
1791                         mddev->ro = 1;
1792                 } else {
1793                         if (mddev->ro)
1794                                 set_disk_ro(disk, 0);
1795                         blk_queue_make_request(mddev->queue, md_fail_request);
1796                         mddev->pers->stop(mddev);
1797                         module_put(mddev->pers->owner);
1798                         mddev->pers = NULL;
1799                         if (mddev->ro)
1800                                 mddev->ro = 0;
1801                 }
1802                 if (!mddev->in_sync) {
1803                         /* mark array as shutdown cleanly */
1804                         mddev->in_sync = 1;
1805                         md_update_sb(mddev);
1806                 }
1807                 if (ro)
1808                         set_disk_ro(disk, 1);
1809         }
1810
1811         bitmap_destroy(mddev);
1812         if (mddev->bitmap_file) {
1813                 atomic_set(&mddev->bitmap_file->f_dentry->d_inode->i_writecount, 1);
1814                 fput(mddev->bitmap_file);
1815                 mddev->bitmap_file = NULL;
1816         }
1817
1818         /*
1819          * Free resources if final stop
1820          */
1821         if (!ro) {
1822                 struct gendisk *disk;
1823                 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
1824
1825                 export_array(mddev);
1826
1827                 mddev->array_size = 0;
1828                 disk = mddev->gendisk;
1829                 if (disk)
1830                         set_capacity(disk, 0);
1831                 mddev->changed = 1;
1832         } else
1833                 printk(KERN_INFO "md: %s switched to read-only mode.\n",
1834                         mdname(mddev));
1835         err = 0;
1836 out:
1837         return err;
1838 }
1839
1840 static void autorun_array(mddev_t *mddev)
1841 {
1842         mdk_rdev_t *rdev;
1843         struct list_head *tmp;
1844         int err;
1845
1846         if (list_empty(&mddev->disks))
1847                 return;
1848
1849         printk(KERN_INFO "md: running: ");
1850
1851         ITERATE_RDEV(mddev,rdev,tmp) {
1852                 char b[BDEVNAME_SIZE];
1853                 printk("<%s>", bdevname(rdev->bdev,b));
1854         }
1855         printk("\n");
1856
1857         err = do_md_run (mddev);
1858         if (err) {
1859                 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
1860                 do_md_stop (mddev, 0);
1861         }
1862 }
1863
1864 /*
1865  * lets try to run arrays based on all disks that have arrived
1866  * until now. (those are in pending_raid_disks)
1867  *
1868  * the method: pick the first pending disk, collect all disks with
1869  * the same UUID, remove all from the pending list and put them into
1870  * the 'same_array' list. Then order this list based on superblock
1871  * update time (freshest comes first), kick out 'old' disks and
1872  * compare superblocks. If everything's fine then run it.
1873  *
1874  * If "unit" is allocated, then bump its reference count
1875  */
1876 static void autorun_devices(int part)
1877 {
1878         struct list_head candidates;
1879         struct list_head *tmp;
1880         mdk_rdev_t *rdev0, *rdev;
1881         mddev_t *mddev;
1882         char b[BDEVNAME_SIZE];
1883
1884         printk(KERN_INFO "md: autorun ...\n");
1885         while (!list_empty(&pending_raid_disks)) {
1886                 dev_t dev;
1887                 rdev0 = list_entry(pending_raid_disks.next,
1888                                          mdk_rdev_t, same_set);
1889
1890                 printk(KERN_INFO "md: considering %s ...\n",
1891                         bdevname(rdev0->bdev,b));
1892                 INIT_LIST_HEAD(&candidates);
1893                 ITERATE_RDEV_PENDING(rdev,tmp)
1894                         if (super_90_load(rdev, rdev0, 0) >= 0) {
1895                                 printk(KERN_INFO "md:  adding %s ...\n",
1896                                         bdevname(rdev->bdev,b));
1897                                 list_move(&rdev->same_set, &candidates);
1898                         }
1899                 /*
1900                  * now we have a set of devices, with all of them having
1901                  * mostly sane superblocks. It's time to allocate the
1902                  * mddev.
1903                  */
1904                 if (rdev0->preferred_minor < 0 || rdev0->preferred_minor >= MAX_MD_DEVS) {
1905                         printk(KERN_INFO "md: unit number in %s is bad: %d\n",
1906                                bdevname(rdev0->bdev, b), rdev0->preferred_minor);
1907                         break;
1908                 }
1909                 if (part)
1910                         dev = MKDEV(mdp_major,
1911                                     rdev0->preferred_minor << MdpMinorShift);
1912                 else
1913                         dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
1914
1915                 md_probe(dev, NULL, NULL);
1916                 mddev = mddev_find(dev);
1917                 if (!mddev) {
1918                         printk(KERN_ERR
1919                                 "md: cannot allocate memory for md drive.\n");
1920                         break;
1921                 }
1922                 if (mddev_lock(mddev))
1923                         printk(KERN_WARNING "md: %s locked, cannot run\n",
1924                                mdname(mddev));
1925                 else if (mddev->raid_disks || mddev->major_version
1926                          || !list_empty(&mddev->disks)) {
1927                         printk(KERN_WARNING
1928                                 "md: %s already running, cannot run %s\n",
1929                                 mdname(mddev), bdevname(rdev0->bdev,b));
1930                         mddev_unlock(mddev);
1931                 } else {
1932                         printk(KERN_INFO "md: created %s\n", mdname(mddev));
1933                         ITERATE_RDEV_GENERIC(candidates,rdev,tmp) {
1934                                 list_del_init(&rdev->same_set);
1935                                 if (bind_rdev_to_array(rdev, mddev))
1936                                         export_rdev(rdev);
1937                         }
1938                         autorun_array(mddev);
1939                         mddev_unlock(mddev);
1940                 }
1941                 /* on success, candidates will be empty, on error
1942                  * it won't...
1943                  */
1944                 ITERATE_RDEV_GENERIC(candidates,rdev,tmp)
1945                         export_rdev(rdev);
1946                 mddev_put(mddev);
1947         }
1948         printk(KERN_INFO "md: ... autorun DONE.\n");
1949 }
1950
1951 /*
1952  * import RAID devices based on one partition
1953  * if possible, the array gets run as well.
1954  */
1955
1956 static int autostart_array(dev_t startdev)
1957 {
1958         char b[BDEVNAME_SIZE];
1959         int err = -EINVAL, i;
1960         mdp_super_t *sb = NULL;
1961         mdk_rdev_t *start_rdev = NULL, *rdev;
1962
1963         start_rdev = md_import_device(startdev, 0, 0);
1964         if (IS_ERR(start_rdev))
1965                 return err;
1966
1967
1968         /* NOTE: this can only work for 0.90.0 superblocks */
1969         sb = (mdp_super_t*)page_address(start_rdev->sb_page);
1970         if (sb->major_version != 0 ||
1971             sb->minor_version != 90 ) {
1972                 printk(KERN_WARNING "md: can only autostart 0.90.0 arrays\n");
1973                 export_rdev(start_rdev);
1974                 return err;
1975         }
1976
1977         if (start_rdev->faulty) {
1978                 printk(KERN_WARNING
1979                         "md: can not autostart based on faulty %s!\n",
1980                         bdevname(start_rdev->bdev,b));
1981                 export_rdev(start_rdev);
1982                 return err;
1983         }
1984         list_add(&start_rdev->same_set, &pending_raid_disks);
1985
1986         for (i = 0; i < MD_SB_DISKS; i++) {
1987                 mdp_disk_t *desc = sb->disks + i;
1988                 dev_t dev = MKDEV(desc->major, desc->minor);
1989
1990                 if (!dev)
1991                         continue;
1992                 if (dev == startdev)
1993                         continue;
1994                 if (MAJOR(dev) != desc->major || MINOR(dev) != desc->minor)
1995                         continue;
1996                 rdev = md_import_device(dev, 0, 0);
1997                 if (IS_ERR(rdev))
1998                         continue;
1999
2000                 list_add(&rdev->same_set, &pending_raid_disks);
2001         }
2002
2003         /*
2004          * possibly return codes
2005          */
2006         autorun_devices(0);
2007         return 0;
2008
2009 }
2010
2011
2012 static int get_version(void __user * arg)
2013 {
2014         mdu_version_t ver;
2015
2016         ver.major = MD_MAJOR_VERSION;
2017         ver.minor = MD_MINOR_VERSION;
2018         ver.patchlevel = MD_PATCHLEVEL_VERSION;
2019
2020         if (copy_to_user(arg, &ver, sizeof(ver)))
2021                 return -EFAULT;
2022
2023         return 0;
2024 }
2025
2026 static int get_array_info(mddev_t * mddev, void __user * arg)
2027 {
2028         mdu_array_info_t info;
2029         int nr,working,active,failed,spare;
2030         mdk_rdev_t *rdev;
2031         struct list_head *tmp;
2032
2033         nr=working=active=failed=spare=0;
2034         ITERATE_RDEV(mddev,rdev,tmp) {
2035                 nr++;
2036                 if (rdev->faulty)
2037                         failed++;
2038                 else {
2039                         working++;
2040                         if (rdev->in_sync)
2041                                 active++;
2042                         else
2043                                 spare++;
2044                 }
2045         }
2046
2047         info.major_version = mddev->major_version;
2048         info.minor_version = mddev->minor_version;
2049         info.patch_version = MD_PATCHLEVEL_VERSION;
2050         info.ctime         = mddev->ctime;
2051         info.level         = mddev->level;
2052         info.size          = mddev->size;
2053         info.nr_disks      = nr;
2054         info.raid_disks    = mddev->raid_disks;
2055         info.md_minor      = mddev->md_minor;
2056         info.not_persistent= !mddev->persistent;
2057
2058         info.utime         = mddev->utime;
2059         info.state         = 0;
2060         if (mddev->in_sync)
2061                 info.state = (1<<MD_SB_CLEAN);
2062         info.active_disks  = active;
2063         info.working_disks = working;
2064         info.failed_disks  = failed;
2065         info.spare_disks   = spare;
2066
2067         info.layout        = mddev->layout;
2068         info.chunk_size    = mddev->chunk_size;
2069
2070         if (copy_to_user(arg, &info, sizeof(info)))
2071                 return -EFAULT;
2072
2073         return 0;
2074 }
2075
2076 static int get_bitmap_file(mddev_t * mddev, void * arg)
2077 {
2078         mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
2079         char *ptr, *buf = NULL;
2080         int err = -ENOMEM;
2081
2082         file = kmalloc(sizeof(*file), GFP_KERNEL);
2083         if (!file)
2084                 goto out;
2085
2086         /* bitmap disabled, zero the first byte and copy out */
2087         if (!mddev->bitmap || !mddev->bitmap->file) {
2088                 file->pathname[0] = '\0';
2089                 goto copy_out;
2090         }
2091
2092         buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
2093         if (!buf)
2094                 goto out;
2095
2096         ptr = file_path(mddev->bitmap->file, buf, sizeof(file->pathname));
2097         if (!ptr)
2098                 goto out;
2099
2100         strcpy(file->pathname, ptr);
2101
2102 copy_out:
2103         err = 0;
2104         if (copy_to_user(arg, file, sizeof(*file)))
2105                 err = -EFAULT;
2106 out:
2107         kfree(buf);
2108         kfree(file);
2109         return err;
2110 }
2111
2112 static int get_disk_info(mddev_t * mddev, void __user * arg)
2113 {
2114         mdu_disk_info_t info;
2115         unsigned int nr;
2116         mdk_rdev_t *rdev;
2117
2118         if (copy_from_user(&info, arg, sizeof(info)))
2119                 return -EFAULT;
2120
2121         nr = info.number;
2122
2123         rdev = find_rdev_nr(mddev, nr);
2124         if (rdev) {
2125                 info.major = MAJOR(rdev->bdev->bd_dev);
2126                 info.minor = MINOR(rdev->bdev->bd_dev);
2127                 info.raid_disk = rdev->raid_disk;
2128                 info.state = 0;
2129                 if (rdev->faulty)
2130                         info.state |= (1<<MD_DISK_FAULTY);
2131                 else if (rdev->in_sync) {
2132                         info.state |= (1<<MD_DISK_ACTIVE);
2133                         info.state |= (1<<MD_DISK_SYNC);
2134                 }
2135         } else {
2136                 info.major = info.minor = 0;
2137                 info.raid_disk = -1;
2138                 info.state = (1<<MD_DISK_REMOVED);
2139         }
2140
2141         if (copy_to_user(arg, &info, sizeof(info)))
2142                 return -EFAULT;
2143
2144         return 0;
2145 }
2146
2147 static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
2148 {
2149         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
2150         mdk_rdev_t *rdev;
2151         dev_t dev = MKDEV(info->major,info->minor);
2152
2153         if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
2154                 return -EOVERFLOW;
2155
2156         if (!mddev->raid_disks) {
2157                 int err;
2158                 /* expecting a device which has a superblock */
2159                 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
2160                 if (IS_ERR(rdev)) {
2161                         printk(KERN_WARNING
2162                                 "md: md_import_device returned %ld\n",
2163                                 PTR_ERR(rdev));
2164                         return PTR_ERR(rdev);
2165                 }
2166                 if (!list_empty(&mddev->disks)) {
2167                         mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
2168                                                         mdk_rdev_t, same_set);
2169                         int err = super_types[mddev->major_version]
2170                                 .load_super(rdev, rdev0, mddev->minor_version);
2171                         if (err < 0) {
2172                                 printk(KERN_WARNING
2173                                         "md: %s has different UUID to %s\n",
2174                                         bdevname(rdev->bdev,b),
2175                                         bdevname(rdev0->bdev,b2));
2176                                 export_rdev(rdev);
2177                                 return -EINVAL;
2178                         }
2179                 }
2180                 err = bind_rdev_to_array(rdev, mddev);
2181                 if (err)
2182                         export_rdev(rdev);
2183                 return err;
2184         }
2185
2186         /*
2187          * add_new_disk can be used once the array is assembled
2188          * to add "hot spares".  They must already have a superblock
2189          * written
2190          */
2191         if (mddev->pers) {
2192                 int err;
2193                 if (!mddev->pers->hot_add_disk) {
2194                         printk(KERN_WARNING
2195                                 "%s: personality does not support diskops!\n",
2196                                mdname(mddev));
2197                         return -EINVAL;
2198                 }
2199                 rdev = md_import_device(dev, mddev->major_version,
2200                                         mddev->minor_version);
2201                 if (IS_ERR(rdev)) {
2202                         printk(KERN_WARNING
2203                                 "md: md_import_device returned %ld\n",
2204                                 PTR_ERR(rdev));
2205                         return PTR_ERR(rdev);
2206                 }
2207                 /* set save_raid_disk if appropriate */
2208                 if (!mddev->persistent) {
2209                         if (info->state & (1<<MD_DISK_SYNC)  &&
2210                             info->raid_disk < mddev->raid_disks)
2211                                 rdev->raid_disk = info->raid_disk;
2212                         else
2213                                 rdev->raid_disk = -1;
2214                 } else
2215                         super_types[mddev->major_version].
2216                                 validate_super(mddev, rdev);
2217                 rdev->saved_raid_disk = rdev->raid_disk;
2218
2219                 rdev->in_sync = 0; /* just to be sure */
2220                 rdev->raid_disk = -1;
2221                 err = bind_rdev_to_array(rdev, mddev);
2222                 if (err)
2223                         export_rdev(rdev);
2224
2225                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2226                 if (mddev->thread)
2227                         md_wakeup_thread(mddev->thread);
2228                 return err;
2229         }
2230
2231         /* otherwise, add_new_disk is only allowed
2232          * for major_version==0 superblocks
2233          */
2234         if (mddev->major_version != 0) {
2235                 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
2236                        mdname(mddev));
2237                 return -EINVAL;
2238         }
2239
2240         if (!(info->state & (1<<MD_DISK_FAULTY))) {
2241                 int err;
2242                 rdev = md_import_device (dev, -1, 0);
2243                 if (IS_ERR(rdev)) {
2244                         printk(KERN_WARNING
2245                                 "md: error, md_import_device() returned %ld\n",
2246                                 PTR_ERR(rdev));
2247                         return PTR_ERR(rdev);
2248                 }
2249                 rdev->desc_nr = info->number;
2250                 if (info->raid_disk < mddev->raid_disks)
2251                         rdev->raid_disk = info->raid_disk;
2252                 else
2253                         rdev->raid_disk = -1;
2254
2255                 rdev->faulty = 0;
2256                 if (rdev->raid_disk < mddev->raid_disks)
2257                         rdev->in_sync = (info->state & (1<<MD_DISK_SYNC));
2258                 else
2259                         rdev->in_sync = 0;
2260
2261                 err = bind_rdev_to_array(rdev, mddev);
2262                 if (err) {
2263                         export_rdev(rdev);
2264                         return err;
2265                 }
2266
2267                 if (!mddev->persistent) {
2268                         printk(KERN_INFO "md: nonpersistent superblock ...\n");
2269                         rdev->sb_offset = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
2270                 } else
2271                         rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
2272                 rdev->size = calc_dev_size(rdev, mddev->chunk_size);
2273
2274                 if (!mddev->size || (mddev->size > rdev->size))
2275                         mddev->size = rdev->size;
2276         }
2277
2278         return 0;
2279 }
2280
2281 static int hot_remove_disk(mddev_t * mddev, dev_t dev)
2282 {
2283         char b[BDEVNAME_SIZE];
2284         mdk_rdev_t *rdev;
2285
2286         if (!mddev->pers)
2287                 return -ENODEV;
2288
2289         rdev = find_rdev(mddev, dev);
2290         if (!rdev)
2291                 return -ENXIO;
2292
2293         if (rdev->raid_disk >= 0)
2294                 goto busy;
2295
2296         kick_rdev_from_array(rdev);
2297         md_update_sb(mddev);
2298
2299         return 0;
2300 busy:
2301         printk(KERN_WARNING "md: cannot remove active disk %s from %s ... \n",
2302                 bdevname(rdev->bdev,b), mdname(mddev));
2303         return -EBUSY;
2304 }
2305
2306 static int hot_add_disk(mddev_t * mddev, dev_t dev)
2307 {
2308         char b[BDEVNAME_SIZE];
2309         int err;
2310         unsigned int size;
2311         mdk_rdev_t *rdev;
2312
2313         if (!mddev->pers)
2314                 return -ENODEV;
2315
2316         if (mddev->major_version != 0) {
2317                 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
2318                         " version-0 superblocks.\n",
2319                         mdname(mddev));
2320                 return -EINVAL;
2321         }
2322         if (!mddev->pers->hot_add_disk) {
2323                 printk(KERN_WARNING
2324                         "%s: personality does not support diskops!\n",
2325                         mdname(mddev));
2326                 return -EINVAL;
2327         }
2328
2329         rdev = md_import_device (dev, -1, 0);
2330         if (IS_ERR(rdev)) {
2331                 printk(KERN_WARNING
2332                         "md: error, md_import_device() returned %ld\n",
2333                         PTR_ERR(rdev));
2334                 return -EINVAL;
2335         }
2336
2337         if (mddev->persistent)
2338                 rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
2339         else
2340                 rdev->sb_offset =
2341                         rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
2342
2343         size = calc_dev_size(rdev, mddev->chunk_size);
2344         rdev->size = size;
2345
2346         if (size < mddev->size) {
2347                 printk(KERN_WARNING
2348                         "%s: disk size %llu blocks < array size %llu\n",
2349                         mdname(mddev), (unsigned long long)size,
2350                         (unsigned long long)mddev->size);
2351                 err = -ENOSPC;
2352                 goto abort_export;
2353         }
2354
2355         if (rdev->faulty) {
2356                 printk(KERN_WARNING
2357                         "md: can not hot-add faulty %s disk to %s!\n",
2358                         bdevname(rdev->bdev,b), mdname(mddev));
2359                 err = -EINVAL;
2360                 goto abort_export;
2361         }
2362         rdev->in_sync = 0;
2363         rdev->desc_nr = -1;
2364         bind_rdev_to_array(rdev, mddev);
2365
2366         /*
2367          * The rest should better be atomic, we can have disk failures
2368          * noticed in interrupt contexts ...
2369          */
2370
2371         if (rdev->desc_nr == mddev->max_disks) {
2372                 printk(KERN_WARNING "%s: can not hot-add to full array!\n",
2373                         mdname(mddev));
2374                 err = -EBUSY;
2375                 goto abort_unbind_export;
2376         }
2377
2378         rdev->raid_disk = -1;
2379
2380         md_update_sb(mddev);
2381
2382         /*
2383          * Kick recovery, maybe this spare has to be added to the
2384          * array immediately.
2385          */
2386         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2387         md_wakeup_thread(mddev->thread);
2388
2389         return 0;
2390
2391 abort_unbind_export:
2392         unbind_rdev_from_array(rdev);
2393
2394 abort_export:
2395         export_rdev(rdev);
2396         return err;
2397 }
2398
2399 /* similar to deny_write_access, but accounts for our holding a reference
2400  * to the file ourselves */
2401 static int deny_bitmap_write_access(struct file * file)
2402 {
2403         struct inode *inode = file->f_mapping->host;
2404
2405         spin_lock(&inode->i_lock);
2406         if (atomic_read(&inode->i_writecount) > 1) {
2407                 spin_unlock(&inode->i_lock);
2408                 return -ETXTBSY;
2409         }
2410         atomic_set(&inode->i_writecount, -1);
2411         spin_unlock(&inode->i_lock);
2412
2413         return 0;
2414 }
2415
2416 static int set_bitmap_file(mddev_t *mddev, int fd)
2417 {
2418         int err;
2419
2420         if (mddev->pers)
2421                 return -EBUSY;
2422
2423         mddev->bitmap_file = fget(fd);
2424
2425         if (mddev->bitmap_file == NULL) {
2426                 printk(KERN_ERR "%s: error: failed to get bitmap file\n",
2427                         mdname(mddev));
2428                 return -EBADF;
2429         }
2430
2431         err = deny_bitmap_write_access(mddev->bitmap_file);
2432         if (err) {
2433                 printk(KERN_ERR "%s: error: bitmap file is already in use\n",
2434                         mdname(mddev));
2435                 fput(mddev->bitmap_file);
2436                 mddev->bitmap_file = NULL;
2437         } else
2438                 mddev->bitmap_offset = 0; /* file overrides offset */
2439         return err;
2440 }
2441
2442 /*
2443  * set_array_info is used two different ways
2444  * The original usage is when creating a new array.
2445  * In this usage, raid_disks is > 0 and it together with
2446  *  level, size, not_persistent,layout,chunksize determine the
2447  *  shape of the array.
2448  *  This will always create an array with a type-0.90.0 superblock.
2449  * The newer usage is when assembling an array.
2450  *  In this case raid_disks will be 0, and the major_version field is
2451  *  use to determine which style super-blocks are to be found on the devices.
2452  *  The minor and patch _version numbers are also kept incase the
2453  *  super_block handler wishes to interpret them.
2454  */
2455 static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
2456 {
2457
2458         if (info->raid_disks == 0) {
2459                 /* just setting version number for superblock loading */
2460                 if (info->major_version < 0 ||
2461                     info->major_version >= sizeof(super_types)/sizeof(super_types[0]) ||
2462                     super_types[info->major_version].name == NULL) {
2463                         /* maybe try to auto-load a module? */
2464                         printk(KERN_INFO
2465                                 "md: superblock version %d not known\n",
2466                                 info->major_version);
2467                         return -EINVAL;
2468                 }
2469                 mddev->major_version = info->major_version;
2470                 mddev->minor_version = info->minor_version;
2471                 mddev->patch_version = info->patch_version;
2472                 return 0;
2473         }
2474         mddev->major_version = MD_MAJOR_VERSION;
2475         mddev->minor_version = MD_MINOR_VERSION;
2476         mddev->patch_version = MD_PATCHLEVEL_VERSION;
2477         mddev->ctime         = get_seconds();
2478
2479         mddev->level         = info->level;
2480         mddev->size          = info->size;
2481         mddev->raid_disks    = info->raid_disks;
2482         /* don't set md_minor, it is determined by which /dev/md* was
2483          * openned
2484          */
2485         if (info->state & (1<<MD_SB_CLEAN))
2486                 mddev->recovery_cp = MaxSector;
2487         else
2488                 mddev->recovery_cp = 0;
2489         mddev->persistent    = ! info->not_persistent;
2490
2491         mddev->layout        = info->layout;
2492         mddev->chunk_size    = info->chunk_size;
2493
2494         mddev->max_disks     = MD_SB_DISKS;
2495
2496         mddev->sb_dirty      = 1;
2497
2498         /*
2499          * Generate a 128 bit UUID
2500          */
2501         get_random_bytes(mddev->uuid, 16);
2502
2503         return 0;
2504 }
2505
2506 /*
2507  * update_array_info is used to change the configuration of an
2508  * on-line array.
2509  * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
2510  * fields in the info are checked against the array.
2511  * Any differences that cannot be handled will cause an error.
2512  * Normally, only one change can be managed at a time.
2513  */
2514 static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
2515 {
2516         int rv = 0;
2517         int cnt = 0;
2518
2519         if (mddev->major_version != info->major_version ||
2520             mddev->minor_version != info->minor_version ||
2521 /*          mddev->patch_version != info->patch_version || */
2522             mddev->ctime         != info->ctime         ||
2523             mddev->level         != info->level         ||
2524 /*          mddev->layout        != info->layout        || */
2525             !mddev->persistent   != info->not_persistent||
2526             mddev->chunk_size    != info->chunk_size    )
2527                 return -EINVAL;
2528         /* Check there is only one change */
2529         if (mddev->size != info->size) cnt++;
2530         if (mddev->raid_disks != info->raid_disks) cnt++;
2531         if (mddev->layout != info->layout) cnt++;
2532         if (cnt == 0) return 0;
2533         if (cnt > 1) return -EINVAL;
2534
2535         if (mddev->layout != info->layout) {
2536                 /* Change layout
2537                  * we don't need to do anything at the md level, the
2538                  * personality will take care of it all.
2539                  */
2540                 if (mddev->pers->reconfig == NULL)
2541                         return -EINVAL;
2542                 else
2543                         return mddev->pers->reconfig(mddev, info->layout, -1);
2544         }
2545         if (mddev->size != info->size) {
2546                 mdk_rdev_t * rdev;
2547                 struct list_head *tmp;
2548                 if (mddev->pers->resize == NULL)
2549                         return -EINVAL;
2550                 /* The "size" is the amount of each device that is used.
2551                  * This can only make sense for arrays with redundancy.
2552                  * linear and raid0 always use whatever space is available
2553                  * We can only consider changing the size if no resync
2554                  * or reconstruction is happening, and if the new size
2555                  * is acceptable. It must fit before the sb_offset or,
2556                  * if that is <data_offset, it must fit before the
2557                  * size of each device.
2558                  * If size is zero, we find the largest size that fits.
2559                  */
2560                 if (mddev->sync_thread)
2561                         return -EBUSY;
2562                 ITERATE_RDEV(mddev,rdev,tmp) {
2563                         sector_t avail;
2564                         int fit = (info->size == 0);
2565                         if (rdev->sb_offset > rdev->data_offset)
2566                                 avail = (rdev->sb_offset*2) - rdev->data_offset;
2567                         else
2568                                 avail = get_capacity(rdev->bdev->bd_disk)
2569                                         - rdev->data_offset;
2570                         if (fit && (info->size == 0 || info->size > avail/2))
2571                                 info->size = avail/2;
2572                         if (avail < ((sector_t)info->size << 1))
2573                                 return -ENOSPC;
2574                 }
2575                 rv = mddev->pers->resize(mddev, (sector_t)info->size *2);
2576                 if (!rv) {
2577                         struct block_device *bdev;
2578
2579                         bdev = bdget_disk(mddev->gendisk, 0);
2580                         if (bdev) {
2581                                 down(&bdev->bd_inode->i_sem);
2582                                 i_size_write(bdev->bd_inode, mddev->array_size << 10);
2583                                 up(&bdev->bd_inode->i_sem);
2584                                 bdput(bdev);
2585                         }
2586                 }
2587         }
2588         if (mddev->raid_disks    != info->raid_disks) {
2589                 /* change the number of raid disks */
2590                 if (mddev->pers->reshape == NULL)
2591                         return -EINVAL;
2592                 if (info->raid_disks <= 0 ||
2593                     info->raid_disks >= mddev->max_disks)
2594                         return -EINVAL;
2595                 if (mddev->sync_thread)
2596                         return -EBUSY;
2597                 rv = mddev->pers->reshape(mddev, info->raid_disks);
2598                 if (!rv) {
2599                         struct block_device *bdev;
2600
2601                         bdev = bdget_disk(mddev->gendisk, 0);
2602                         if (bdev) {
2603                                 down(&bdev->bd_inode->i_sem);
2604                                 i_size_write(bdev->bd_inode, mddev->array_size << 10);
2605                                 up(&bdev->bd_inode->i_sem);
2606                                 bdput(bdev);
2607                         }
2608                 }
2609         }
2610         md_update_sb(mddev);
2611         return rv;
2612 }
2613
2614 static int set_disk_faulty(mddev_t *mddev, dev_t dev)
2615 {
2616         mdk_rdev_t *rdev;
2617
2618         if (mddev->pers == NULL)
2619                 return -ENODEV;
2620
2621         rdev = find_rdev(mddev, dev);
2622         if (!rdev)
2623                 return -ENODEV;
2624
2625         md_error(mddev, rdev);
2626         return 0;
2627 }
2628
2629 static int md_ioctl(struct inode *inode, struct file *file,
2630                         unsigned int cmd, unsigned long arg)
2631 {
2632         int err = 0;
2633         void __user *argp = (void __user *)arg;
2634         struct hd_geometry __user *loc = argp;
2635         mddev_t *mddev = NULL;
2636
2637         if (!capable(CAP_SYS_ADMIN))
2638                 return -EACCES;
2639
2640         /*
2641          * Commands dealing with the RAID driver but not any
2642          * particular array:
2643          */
2644         switch (cmd)
2645         {
2646                 case RAID_VERSION:
2647                         err = get_version(argp);
2648                         goto done;
2649
2650                 case PRINT_RAID_DEBUG:
2651                         err = 0;
2652                         md_print_devices();
2653                         goto done;
2654
2655 #ifndef MODULE
2656                 case RAID_AUTORUN:
2657                         err = 0;
2658                         autostart_arrays(arg);
2659                         goto done;
2660 #endif
2661                 default:;
2662         }
2663
2664         /*
2665          * Commands creating/starting a new array:
2666          */
2667
2668         mddev = inode->i_bdev->bd_disk->private_data;
2669
2670         if (!mddev) {
2671                 BUG();
2672                 goto abort;
2673         }
2674
2675
2676         if (cmd == START_ARRAY) {
2677                 /* START_ARRAY doesn't need to lock the array as autostart_array
2678                  * does the locking, and it could even be a different array
2679                  */
2680                 static int cnt = 3;
2681                 if (cnt > 0 ) {
2682                         printk(KERN_WARNING
2683                                "md: %s(pid %d) used deprecated START_ARRAY ioctl. "
2684                                "This will not be supported beyond 2.6\n",
2685                                current->comm, current->pid);
2686                         cnt--;
2687                 }
2688                 err = autostart_array(new_decode_dev(arg));
2689                 if (err) {
2690                         printk(KERN_WARNING "md: autostart failed!\n");
2691                         goto abort;
2692                 }
2693                 goto done;
2694         }
2695
2696         err = mddev_lock(mddev);
2697         if (err) {
2698                 printk(KERN_INFO
2699                         "md: ioctl lock interrupted, reason %d, cmd %d\n",
2700                         err, cmd);
2701                 goto abort;
2702         }
2703
2704         switch (cmd)
2705         {
2706                 case SET_ARRAY_INFO:
2707                         {
2708                                 mdu_array_info_t info;
2709                                 if (!arg)
2710                                         memset(&info, 0, sizeof(info));
2711                                 else if (copy_from_user(&info, argp, sizeof(info))) {
2712                                         err = -EFAULT;
2713                                         goto abort_unlock;
2714                                 }
2715                                 if (mddev->pers) {
2716                                         err = update_array_info(mddev, &info);
2717                                         if (err) {
2718                                                 printk(KERN_WARNING "md: couldn't update"
2719                                                        " array info. %d\n", err);
2720                                                 goto abort_unlock;
2721                                         }
2722                                         goto done_unlock;
2723                                 }
2724                                 if (!list_empty(&mddev->disks)) {
2725                                         printk(KERN_WARNING
2726                                                "md: array %s already has disks!\n",
2727                                                mdname(mddev));
2728                                         err = -EBUSY;
2729                                         goto abort_unlock;
2730                                 }
2731                                 if (mddev->raid_disks) {
2732                                         printk(KERN_WARNING
2733                                                "md: array %s already initialised!\n",
2734                                                mdname(mddev));
2735                                         err = -EBUSY;
2736                                         goto abort_unlock;
2737                                 }
2738                                 err = set_array_info(mddev, &info);
2739                                 if (err) {
2740                                         printk(KERN_WARNING "md: couldn't set"
2741                                                " array info. %d\n", err);
2742                                         goto abort_unlock;
2743                                 }
2744                         }
2745                         goto done_unlock;
2746
2747                 default:;
2748         }
2749
2750         /*
2751          * Commands querying/configuring an existing array:
2752          */
2753         /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
2754          * RUN_ARRAY, and SET_BITMAP_FILE are allowed */
2755         if (!mddev->raid_disks && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
2756                         && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE) {
2757                 err = -ENODEV;
2758                 goto abort_unlock;
2759         }
2760
2761         /*
2762          * Commands even a read-only array can execute:
2763          */
2764         switch (cmd)
2765         {
2766                 case GET_ARRAY_INFO:
2767                         err = get_array_info(mddev, argp);
2768                         goto done_unlock;
2769
2770                 case GET_BITMAP_FILE:
2771                         err = get_bitmap_file(mddev, (void *)arg);
2772                         goto done_unlock;
2773
2774                 case GET_DISK_INFO:
2775                         err = get_disk_info(mddev, argp);
2776                         goto done_unlock;
2777
2778                 case RESTART_ARRAY_RW:
2779                         err = restart_array(mddev);
2780                         goto done_unlock;
2781
2782                 case STOP_ARRAY:
2783                         err = do_md_stop (mddev, 0);
2784                         goto done_unlock;
2785
2786                 case STOP_ARRAY_RO:
2787                         err = do_md_stop (mddev, 1);
2788                         goto done_unlock;
2789
2790         /*
2791          * We have a problem here : there is no easy way to give a CHS
2792          * virtual geometry. We currently pretend that we have a 2 heads
2793          * 4 sectors (with a BIG number of cylinders...). This drives
2794          * dosfs just mad... ;-)
2795          */
2796                 case HDIO_GETGEO:
2797                         if (!loc) {
2798                                 err = -EINVAL;
2799                                 goto abort_unlock;
2800                         }
2801                         err = put_user (2, (char __user *) &loc->heads);
2802                         if (err)
2803                                 goto abort_unlock;
2804                         err = put_user (4, (char __user *) &loc->sectors);
2805                         if (err)
2806                                 goto abort_unlock;
2807                         err = put_user(get_capacity(mddev->gendisk)/8,
2808                                         (short __user *) &loc->cylinders);
2809                         if (err)
2810                                 goto abort_unlock;
2811                         err = put_user (get_start_sect(inode->i_bdev),
2812                                                 (long __user *) &loc->start);
2813                         goto done_unlock;
2814         }
2815
2816         /*
2817          * The remaining ioctls are changing the state of the
2818          * superblock, so we do not allow read-only arrays
2819          * here:
2820          */
2821         if (mddev->ro) {
2822                 err = -EROFS;
2823                 goto abort_unlock;
2824         }
2825
2826         switch (cmd)
2827         {
2828                 case ADD_NEW_DISK:
2829                 {
2830                         mdu_disk_info_t info;
2831                         if (copy_from_user(&info, argp, sizeof(info)))
2832                                 err = -EFAULT;
2833                         else
2834                                 err = add_new_disk(mddev, &info);
2835                         goto done_unlock;
2836                 }
2837
2838                 case HOT_REMOVE_DISK:
2839                         err = hot_remove_disk(mddev, new_decode_dev(arg));
2840                         goto done_unlock;
2841
2842                 case HOT_ADD_DISK:
2843                         err = hot_add_disk(mddev, new_decode_dev(arg));
2844                         goto done_unlock;
2845
2846                 case SET_DISK_FAULTY:
2847                         err = set_disk_faulty(mddev, new_decode_dev(arg));
2848                         goto done_unlock;
2849
2850                 case RUN_ARRAY:
2851                         err = do_md_run (mddev);
2852                         goto done_unlock;
2853
2854                 case SET_BITMAP_FILE:
2855                         err = set_bitmap_file(mddev, (int)arg);
2856                         goto done_unlock;
2857
2858                 default:
2859                         if (_IOC_TYPE(cmd) == MD_MAJOR)
2860                                 printk(KERN_WARNING "md: %s(pid %d) used"
2861                                         " obsolete MD ioctl, upgrade your"
2862                                         " software to use new ictls.\n",
2863                                         current->comm, current->pid);
2864                         err = -EINVAL;
2865                         goto abort_unlock;
2866         }
2867
2868 done_unlock:
2869 abort_unlock:
2870         mddev_unlock(mddev);
2871
2872         return err;
2873 done:
2874         if (err)
2875                 MD_BUG();
2876 abort:
2877         return err;
2878 }
2879
2880 static int md_open(struct inode *inode, struct file *file)
2881 {
2882         /*
2883          * Succeed if we can lock the mddev, which confirms that
2884          * it isn't being stopped right now.
2885          */
2886         mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
2887         int err;
2888
2889         if ((err = mddev_lock(mddev)))
2890                 goto out;
2891
2892         err = 0;
2893         mddev_get(mddev);
2894         mddev_unlock(mddev);
2895
2896         check_disk_change(inode->i_bdev);
2897  out:
2898         return err;
2899 }
2900
2901 static int md_release(struct inode *inode, struct file * file)
2902 {
2903         mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
2904
2905         if (!mddev)
2906                 BUG();
2907         mddev_put(mddev);
2908
2909         return 0;
2910 }
2911
2912 static int md_media_changed(struct gendisk *disk)
2913 {
2914         mddev_t *mddev = disk->private_data;
2915
2916         return mddev->changed;
2917 }
2918
2919 static int md_revalidate(struct gendisk *disk)
2920 {
2921         mddev_t *mddev = disk->private_data;
2922
2923         mddev->changed = 0;
2924         return 0;
2925 }
2926 static struct block_device_operations md_fops =
2927 {
2928         .owner          = THIS_MODULE,
2929         .open           = md_open,
2930         .release        = md_release,
2931         .ioctl          = md_ioctl,
2932         .media_changed  = md_media_changed,
2933         .revalidate_disk= md_revalidate,
2934 };
2935
2936 static int md_thread(void * arg)
2937 {
2938         mdk_thread_t *thread = arg;
2939
2940         lock_kernel();
2941
2942         /*
2943          * Detach thread
2944          */
2945
2946         daemonize(thread->name, mdname(thread->mddev));
2947
2948         current->exit_signal = SIGCHLD;
2949         allow_signal(SIGKILL);
2950         thread->tsk = current;
2951
2952         /*
2953          * md_thread is a 'system-thread', it's priority should be very
2954          * high. We avoid resource deadlocks individually in each
2955          * raid personality. (RAID5 does preallocation) We also use RR and
2956          * the very same RT priority as kswapd, thus we will never get
2957          * into a priority inversion deadlock.
2958          *
2959          * we definitely have to have equal or higher priority than
2960          * bdflush, otherwise bdflush will deadlock if there are too
2961          * many dirty RAID5 blocks.
2962          */
2963         unlock_kernel();
2964
2965         complete(thread->event);
2966         while (thread->run) {
2967                 void (*run)(mddev_t *);
2968
2969                 wait_event_interruptible_timeout(thread->wqueue,
2970                                                  test_bit(THREAD_WAKEUP, &thread->flags),
2971                                                  thread->timeout);
2972                 if (current->flags & PF_FREEZE)
2973                         refrigerator(PF_FREEZE);
2974
2975                 clear_bit(THREAD_WAKEUP, &thread->flags);
2976
2977                 run = thread->run;
2978                 if (run)
2979                         run(thread->mddev);
2980
2981                 if (signal_pending(current))
2982                         flush_signals(current);
2983         }
2984         complete(thread->event);
2985         return 0;
2986 }
2987
2988 void md_wakeup_thread(mdk_thread_t *thread)
2989 {
2990         if (thread) {
2991                 dprintk("md: waking up MD thread %s.\n", thread->tsk->comm);
2992                 set_bit(THREAD_WAKEUP, &thread->flags);
2993                 wake_up(&thread->wqueue);
2994         }
2995 }
2996
2997 mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
2998                                  const char *name)
2999 {
3000         mdk_thread_t *thread;
3001         int ret;
3002         struct completion event;
3003
3004         thread = (mdk_thread_t *) kmalloc
3005                                 (sizeof(mdk_thread_t), GFP_KERNEL);
3006         if (!thread)
3007                 return NULL;
3008
3009         memset(thread, 0, sizeof(mdk_thread_t));
3010         init_waitqueue_head(&thread->wqueue);
3011
3012         init_completion(&event);
3013         thread->event = &event;
3014         thread->run = run;
3015         thread->mddev = mddev;
3016         thread->name = name;
3017         thread->timeout = MAX_SCHEDULE_TIMEOUT;
3018         ret = kernel_thread(md_thread, thread, 0);
3019         if (ret < 0) {
3020                 kfree(thread);
3021                 return NULL;
3022         }
3023         wait_for_completion(&event);
3024         return thread;
3025 }
3026
3027 void md_unregister_thread(mdk_thread_t *thread)
3028 {
3029         struct completion event;
3030
3031         init_completion(&event);
3032
3033         thread->event = &event;
3034
3035         /* As soon as ->run is set to NULL, the task could disappear,
3036          * so we need to hold tasklist_lock until we have sent the signal
3037          */
3038         dprintk("interrupting MD-thread pid %d\n", thread->tsk->pid);
3039         read_lock(&tasklist_lock);
3040         thread->run = NULL;
3041         send_sig(SIGKILL, thread->tsk, 1);
3042         read_unlock(&tasklist_lock);
3043         wait_for_completion(&event);
3044         kfree(thread);
3045 }
3046
3047 void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
3048 {
3049         if (!mddev) {
3050                 MD_BUG();
3051                 return;
3052         }
3053
3054         if (!rdev || rdev->faulty)
3055                 return;
3056 /*
3057         dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",
3058                 mdname(mddev),
3059                 MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev),
3060                 __builtin_return_address(0),__builtin_return_address(1),
3061                 __builtin_return_address(2),__builtin_return_address(3));
3062 */
3063         if (!mddev->pers->error_handler)
3064                 return;
3065         mddev->pers->error_handler(mddev,rdev);
3066         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
3067         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3068         md_wakeup_thread(mddev->thread);
3069 }
3070
3071 /* seq_file implementation /proc/mdstat */
3072
3073 static void status_unused(struct seq_file *seq)
3074 {
3075         int i = 0;
3076         mdk_rdev_t *rdev;
3077         struct list_head *tmp;
3078
3079         seq_printf(seq, "unused devices: ");
3080
3081         ITERATE_RDEV_PENDING(rdev,tmp) {
3082                 char b[BDEVNAME_SIZE];
3083                 i++;
3084                 seq_printf(seq, "%s ",
3085                               bdevname(rdev->bdev,b));
3086         }
3087         if (!i)
3088                 seq_printf(seq, "<none>");
3089
3090         seq_printf(seq, "\n");
3091 }
3092
3093
3094 static void status_resync(struct seq_file *seq, mddev_t * mddev)
3095 {
3096         unsigned long max_blocks, resync, res, dt, db, rt;
3097
3098         resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
3099
3100         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
3101                 max_blocks = mddev->resync_max_sectors >> 1;
3102         else
3103                 max_blocks = mddev->size;
3104
3105         /*
3106          * Should not happen.
3107          */
3108         if (!max_blocks) {
3109                 MD_BUG();
3110                 return;
3111         }
3112         res = (resync/1024)*1000/(max_blocks/1024 + 1);
3113         {
3114                 int i, x = res/50, y = 20-x;
3115                 seq_printf(seq, "[");
3116                 for (i = 0; i < x; i++)
3117                         seq_printf(seq, "=");
3118                 seq_printf(seq, ">");
3119                 for (i = 0; i < y; i++)
3120                         seq_printf(seq, ".");
3121                 seq_printf(seq, "] ");
3122         }
3123         seq_printf(seq, " %s =%3lu.%lu%% (%lu/%lu)",
3124                       (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
3125                        "resync" : "recovery"),
3126                       res/10, res % 10, resync, max_blocks);
3127
3128         /*
3129          * We do not want to overflow, so the order of operands and
3130          * the * 100 / 100 trick are important. We do a +1 to be
3131          * safe against division by zero. We only estimate anyway.
3132          *
3133          * dt: time from mark until now
3134          * db: blocks written from mark until now
3135          * rt: remaining time
3136          */
3137         dt = ((jiffies - mddev->resync_mark) / HZ);
3138         if (!dt) dt++;
3139         db = resync - (mddev->resync_mark_cnt/2);
3140         rt = (dt * ((max_blocks-resync) / (db/100+1)))/100;
3141
3142         seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
3143
3144         seq_printf(seq, " speed=%ldK/sec", db/dt);
3145 }
3146
3147 static void *md_seq_start(struct seq_file *seq, loff_t *pos)
3148 {
3149         struct list_head *tmp;
3150         loff_t l = *pos;
3151         mddev_t *mddev;
3152
3153         if (l >= 0x10000)
3154                 return NULL;
3155         if (!l--)
3156                 /* header */
3157                 return (void*)1;
3158
3159         spin_lock(&all_mddevs_lock);
3160         list_for_each(tmp,&all_mddevs)
3161                 if (!l--) {
3162                         mddev = list_entry(tmp, mddev_t, all_mddevs);
3163                         mddev_get(mddev);
3164                         spin_unlock(&all_mddevs_lock);
3165                         return mddev;
3166                 }
3167         spin_unlock(&all_mddevs_lock);
3168         if (!l--)
3169                 return (void*)2;/* tail */
3170         return NULL;
3171 }
3172
3173 static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3174 {
3175         struct list_head *tmp;
3176         mddev_t *next_mddev, *mddev = v;
3177
3178         ++*pos;
3179         if (v == (void*)2)
3180                 return NULL;
3181
3182         spin_lock(&all_mddevs_lock);
3183         if (v == (void*)1)
3184                 tmp = all_mddevs.next;
3185         else
3186                 tmp = mddev->all_mddevs.next;
3187         if (tmp != &all_mddevs)
3188                 next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
3189         else {
3190                 next_mddev = (void*)2;
3191                 *pos = 0x10000;
3192         }
3193         spin_unlock(&all_mddevs_lock);
3194
3195         if (v != (void*)1)
3196                 mddev_put(mddev);
3197         return next_mddev;
3198
3199 }
3200
3201 static void md_seq_stop(struct seq_file *seq, void *v)
3202 {
3203         mddev_t *mddev = v;
3204
3205         if (mddev && v != (void*)1 && v != (void*)2)
3206                 mddev_put(mddev);
3207 }
3208
3209 static int md_seq_show(struct seq_file *seq, void *v)
3210 {
3211         mddev_t *mddev = v;
3212         sector_t size;
3213         struct list_head *tmp2;
3214         mdk_rdev_t *rdev;
3215         int i;
3216         struct bitmap *bitmap;
3217
3218         if (v == (void*)1) {
3219                 seq_printf(seq, "Personalities : ");
3220                 spin_lock(&pers_lock);
3221                 for (i = 0; i < MAX_PERSONALITY; i++)
3222                         if (pers[i])
3223                                 seq_printf(seq, "[%s] ", pers[i]->name);
3224
3225                 spin_unlock(&pers_lock);
3226                 seq_printf(seq, "\n");
3227                 return 0;
3228         }
3229         if (v == (void*)2) {
3230                 status_unused(seq);
3231                 return 0;
3232         }
3233
3234         if (mddev_lock(mddev)!=0)
3235                 return -EINTR;
3236         if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
3237                 seq_printf(seq, "%s : %sactive", mdname(mddev),
3238                                                 mddev->pers ? "" : "in");
3239                 if (mddev->pers) {
3240                         if (mddev->ro)
3241                                 seq_printf(seq, " (read-only)");
3242                         seq_printf(seq, " %s", mddev->pers->name);
3243                 }
3244
3245                 size = 0;
3246                 ITERATE_RDEV(mddev,rdev,tmp2) {
3247                         char b[BDEVNAME_SIZE];
3248                         seq_printf(seq, " %s[%d]",
3249                                 bdevname(rdev->bdev,b), rdev->desc_nr);
3250                         if (rdev->faulty) {
3251                                 seq_printf(seq, "(F)");
3252                                 continue;
3253                         }
3254                         size += rdev->size;
3255                 }
3256
3257                 if (!list_empty(&mddev->disks)) {
3258                         if (mddev->pers)
3259                                 seq_printf(seq, "\n      %llu blocks",
3260                                         (unsigned long long)mddev->array_size);
3261                         else
3262                                 seq_printf(seq, "\n      %llu blocks",
3263                                         (unsigned long long)size);
3264                 }
3265
3266                 if (mddev->pers) {
3267                         mddev->pers->status (seq, mddev);
3268                         seq_printf(seq, "\n      ");
3269                         if (mddev->curr_resync > 2) {
3270                                 status_resync (seq, mddev);
3271                                 seq_printf(seq, "\n      ");
3272                         } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
3273                                 seq_printf(seq, "       resync=DELAYED\n      ");
3274                 } else
3275                         seq_printf(seq, "\n       ");
3276
3277                 if ((bitmap = mddev->bitmap)) {
3278                         unsigned long chunk_kb;
3279                         unsigned long flags;
3280                         spin_lock_irqsave(&bitmap->lock, flags);
3281                         chunk_kb = bitmap->chunksize >> 10;
3282                         seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
3283                                 "%lu%s chunk",
3284                                 bitmap->pages - bitmap->missing_pages,
3285                                 bitmap->pages,
3286                                 (bitmap->pages - bitmap->missing_pages)
3287                                         << (PAGE_SHIFT - 10),
3288                                 chunk_kb ? chunk_kb : bitmap->chunksize,
3289                                 chunk_kb ? "KB" : "B");
3290                         if (bitmap->file) {
3291                                 seq_printf(seq, ", file: ");
3292                                 seq_path(seq, bitmap->file->f_vfsmnt,
3293                                          bitmap->file->f_dentry," \t\n");
3294                         }
3295
3296                         seq_printf(seq, "\n");
3297                         spin_unlock_irqrestore(&bitmap->lock, flags);
3298                 }
3299
3300                 seq_printf(seq, "\n");
3301         }
3302         mddev_unlock(mddev);
3303
3304         return 0;
3305 }
3306
3307 static struct seq_operations md_seq_ops = {
3308         .start  = md_seq_start,
3309         .next   = md_seq_next,
3310         .stop   = md_seq_stop,
3311         .show   = md_seq_show,
3312 };
3313
3314 static int md_seq_open(struct inode *inode, struct file *file)
3315 {
3316         int error;
3317
3318         error = seq_open(file, &md_seq_ops);
3319         return error;
3320 }
3321
3322 static struct file_operations md_seq_fops = {
3323         .open           = md_seq_open,
3324         .read           = seq_read,
3325         .llseek         = seq_lseek,
3326         .release        = seq_release,
3327 };
3328
3329 int register_md_personality(int pnum, mdk_personality_t *p)
3330 {
3331         if (pnum >= MAX_PERSONALITY) {
3332                 printk(KERN_ERR
3333                        "md: tried to install personality %s as nr %d, but max is %lu\n",
3334                        p->name, pnum, MAX_PERSONALITY-1);
3335                 return -EINVAL;
3336         }
3337
3338         spin_lock(&pers_lock);
3339         if (pers[pnum]) {
3340                 spin_unlock(&pers_lock);
3341                 return -EBUSY;
3342         }
3343
3344         pers[pnum] = p;
3345         printk(KERN_INFO "md: %s personality registered as nr %d\n", p->name, pnum);
3346         spin_unlock(&pers_lock);
3347         return 0;
3348 }
3349
3350 int unregister_md_personality(int pnum)
3351 {
3352         if (pnum >= MAX_PERSONALITY)
3353                 return -EINVAL;
3354
3355         printk(KERN_INFO "md: %s personality unregistered\n", pers[pnum]->name);
3356         spin_lock(&pers_lock);
3357         pers[pnum] = NULL;
3358         spin_unlock(&pers_lock);
3359         return 0;
3360 }
3361
3362 static int is_mddev_idle(mddev_t *mddev)
3363 {
3364         mdk_rdev_t * rdev;
3365         struct list_head *tmp;
3366         int idle;
3367         unsigned long curr_events;
3368
3369         idle = 1;
3370         ITERATE_RDEV(mddev,rdev,tmp) {
3371                 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
3372                 curr_events = disk_stat_read(disk, read_sectors) +
3373                                 disk_stat_read(disk, write_sectors) -
3374                                 atomic_read(&disk->sync_io);
3375                 /* Allow some slack between valud of curr_events and last_events,
3376                  * as there are some uninteresting races.
3377                  * Note: the following is an unsigned comparison.
3378                  */
3379                 if ((curr_events - rdev->last_events + 32) > 64) {
3380                         rdev->last_events = curr_events;
3381                         idle = 0;
3382                 }
3383         }
3384         return idle;
3385 }
3386
3387 void md_done_sync(mddev_t *mddev, int blocks, int ok)
3388 {
3389         /* another "blocks" (512byte) blocks have been synced */
3390         atomic_sub(blocks, &mddev->recovery_active);
3391         wake_up(&mddev->recovery_wait);
3392         if (!ok) {
3393                 set_bit(MD_RECOVERY_ERR, &mddev->recovery);
3394                 md_wakeup_thread(mddev->thread);
3395                 // stop recovery, signal do_sync ....
3396         }
3397 }
3398
3399
3400 /* md_write_start(mddev, bi)
3401  * If we need to update some array metadata (e.g. 'active' flag
3402  * in superblock) before writing, schedule a superblock update
3403  * and wait for it to complete.
3404  */
3405 void md_write_start(mddev_t *mddev, struct bio *bi)
3406 {
3407         DEFINE_WAIT(w);
3408         if (bio_data_dir(bi) != WRITE)
3409                 return;
3410
3411         atomic_inc(&mddev->writes_pending);
3412         if (mddev->in_sync) {
3413                 spin_lock(&mddev->write_lock);
3414                 if (mddev->in_sync) {
3415                         mddev->in_sync = 0;
3416                         mddev->sb_dirty = 1;
3417                         md_wakeup_thread(mddev->thread);
3418                 }
3419                 spin_unlock(&mddev->write_lock);
3420         }
3421         wait_event(mddev->sb_wait, mddev->sb_dirty==0);
3422 }
3423
3424 void md_write_end(mddev_t *mddev)
3425 {
3426         if (atomic_dec_and_test(&mddev->writes_pending)) {
3427                 if (mddev->safemode == 2)
3428                         md_wakeup_thread(mddev->thread);
3429                 else
3430                         mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
3431         }
3432 }
3433
3434 static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
3435
3436 #define SYNC_MARKS      10
3437 #define SYNC_MARK_STEP  (3*HZ)
3438 static void md_do_sync(mddev_t *mddev)
3439 {
3440         mddev_t *mddev2;
3441         unsigned int currspeed = 0,
3442                  window;
3443         sector_t max_sectors,j, io_sectors;
3444         unsigned long mark[SYNC_MARKS];
3445         sector_t mark_cnt[SYNC_MARKS];
3446         int last_mark,m;
3447         struct list_head *tmp;
3448         sector_t last_check;
3449         int skipped = 0;
3450
3451         /* just incase thread restarts... */
3452         if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
3453                 return;
3454
3455         /* we overload curr_resync somewhat here.
3456          * 0 == not engaged in resync at all
3457          * 2 == checking that there is no conflict with another sync
3458          * 1 == like 2, but have yielded to allow conflicting resync to
3459          *              commense
3460          * other == active in resync - this many blocks
3461          *
3462          * Before starting a resync we must have set curr_resync to
3463          * 2, and then checked that every "conflicting" array has curr_resync
3464          * less than ours.  When we find one that is the same or higher
3465          * we wait on resync_wait.  To avoid deadlock, we reduce curr_resync
3466          * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
3467          * This will mean we have to start checking from the beginning again.
3468          *
3469          */
3470
3471         do {
3472                 mddev->curr_resync = 2;
3473
3474         try_again:
3475                 if (signal_pending(current)) {
3476                         flush_signals(current);
3477                         goto skip;
3478                 }
3479                 ITERATE_MDDEV(mddev2,tmp) {
3480                         printk(".");
3481                         if (mddev2 == mddev)
3482                                 continue;
3483                         if (mddev2->curr_resync &&
3484                             match_mddev_units(mddev,mddev2)) {
3485                                 DEFINE_WAIT(wq);
3486                                 if (mddev < mddev2 && mddev->curr_resync == 2) {
3487                                         /* arbitrarily yield */
3488                                         mddev->curr_resync = 1;
3489                                         wake_up(&resync_wait);
3490                                 }
3491                                 if (mddev > mddev2 && mddev->curr_resync == 1)
3492                                         /* no need to wait here, we can wait the next
3493                                          * time 'round when curr_resync == 2
3494                                          */
3495                                         continue;
3496                                 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
3497                                 if (!signal_pending(current)
3498                                     && mddev2->curr_resync >= mddev->curr_resync) {
3499                                         printk(KERN_INFO "md: delaying resync of %s"
3500                                                " until %s has finished resync (they"
3501                                                " share one or more physical units)\n",
3502                                                mdname(mddev), mdname(mddev2));
3503                                         mddev_put(mddev2);
3504                                         schedule();
3505                                         finish_wait(&resync_wait, &wq);
3506                                         goto try_again;
3507                                 }
3508                                 finish_wait(&resync_wait, &wq);
3509                         }
3510                 }
3511         } while (mddev->curr_resync < 2);
3512
3513         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
3514                 /* resync follows the size requested by the personality,
3515                  * which defaults to physical size, but can be virtual size
3516                  */
3517                 max_sectors = mddev->resync_max_sectors;
3518         else
3519                 /* recovery follows the physical size of devices */
3520                 max_sectors = mddev->size << 1;
3521
3522         printk(KERN_INFO "md: syncing RAID array %s\n", mdname(mddev));
3523         printk(KERN_INFO "md: minimum _guaranteed_ reconstruction speed:"
3524                 " %d KB/sec/disc.\n", sysctl_speed_limit_min);
3525         printk(KERN_INFO "md: using maximum available idle IO bandwith "
3526                "(but not more than %d KB/sec) for reconstruction.\n",
3527                sysctl_speed_limit_max);
3528
3529         is_mddev_idle(mddev); /* this also initializes IO event counters */
3530         /* we don't use the checkpoint if there's a bitmap */
3531         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) && !mddev->bitmap)
3532                 j = mddev->recovery_cp;
3533         else
3534                 j = 0;
3535         io_sectors = 0;
3536         for (m = 0; m < SYNC_MARKS; m++) {
3537                 mark[m] = jiffies;
3538                 mark_cnt[m] = io_sectors;
3539         }
3540         last_mark = 0;
3541         mddev->resync_mark = mark[last_mark];
3542         mddev->resync_mark_cnt = mark_cnt[last_mark];
3543
3544         /*
3545          * Tune reconstruction:
3546          */
3547         window = 32*(PAGE_SIZE/512);
3548         printk(KERN_INFO "md: using %dk window, over a total of %llu blocks.\n",
3549                 window/2,(unsigned long long) max_sectors/2);
3550
3551         atomic_set(&mddev->recovery_active, 0);
3552         init_waitqueue_head(&mddev->recovery_wait);
3553         last_check = 0;
3554
3555         if (j>2) {
3556                 printk(KERN_INFO
3557                         "md: resuming recovery of %s from checkpoint.\n",
3558                         mdname(mddev));
3559                 mddev->curr_resync = j;
3560         }
3561
3562         while (j < max_sectors) {
3563                 sector_t sectors;
3564
3565                 skipped = 0;
3566                 sectors = mddev->pers->sync_request(mddev, j, &skipped,
3567                                             currspeed < sysctl_speed_limit_min);
3568                 if (sectors == 0) {
3569                         set_bit(MD_RECOVERY_ERR, &mddev->recovery);
3570                         goto out;
3571                 }
3572
3573                 if (!skipped) { /* actual IO requested */
3574                         io_sectors += sectors;
3575                         atomic_add(sectors, &mddev->recovery_active);
3576                 }
3577
3578                 j += sectors;
3579                 if (j>1) mddev->curr_resync = j;
3580
3581
3582                 if (last_check + window > io_sectors || j == max_sectors)
3583                         continue;
3584
3585                 last_check = io_sectors;
3586
3587                 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery) ||
3588                     test_bit(MD_RECOVERY_ERR, &mddev->recovery))
3589                         break;
3590
3591         repeat:
3592                 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
3593                         /* step marks */
3594                         int next = (last_mark+1) % SYNC_MARKS;
3595
3596                         mddev->resync_mark = mark[next];
3597                         mddev->resync_mark_cnt = mark_cnt[next];
3598                         mark[next] = jiffies;
3599                         mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
3600                         last_mark = next;
3601                 }
3602
3603
3604                 if (signal_pending(current)) {
3605                         /*
3606                          * got a signal, exit.
3607                          */
3608                         printk(KERN_INFO
3609                                 "md: md_do_sync() got signal ... exiting\n");
3610                         flush_signals(current);
3611                         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
3612                         goto out;
3613                 }
3614
3615                 /*
3616                  * this loop exits only if either when we are slower than
3617                  * the 'hard' speed limit, or the system was IO-idle for
3618                  * a jiffy.
3619                  * the system might be non-idle CPU-wise, but we only care
3620                  * about not overloading the IO subsystem. (things like an
3621                  * e2fsck being done on the RAID array should execute fast)
3622                  */
3623                 mddev->queue->unplug_fn(mddev->queue);
3624                 cond_resched();
3625
3626                 currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
3627                         /((jiffies-mddev->resync_mark)/HZ +1) +1;
3628
3629                 if (currspeed > sysctl_speed_limit_min) {
3630                         if ((currspeed > sysctl_speed_limit_max) ||
3631                                         !is_mddev_idle(mddev)) {
3632                                 msleep_interruptible(250);
3633                                 goto repeat;
3634                         }
3635                 }
3636         }
3637         printk(KERN_INFO "md: %s: sync done.\n",mdname(mddev));
3638         /*
3639          * this also signals 'finished resyncing' to md_stop
3640          */
3641  out:
3642         mddev->queue->unplug_fn(mddev->queue);
3643
3644         wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
3645
3646         /* tell personality that we are finished */
3647         mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
3648
3649         if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
3650             mddev->curr_resync > 2 &&
3651             mddev->curr_resync >= mddev->recovery_cp) {
3652                 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
3653                         printk(KERN_INFO
3654                                 "md: checkpointing recovery of %s.\n",
3655                                 mdname(mddev));
3656                         mddev->recovery_cp = mddev->curr_resync;
3657                 } else
3658                         mddev->recovery_cp = MaxSector;
3659         }
3660
3661  skip:
3662         mddev->curr_resync = 0;
3663         wake_up(&resync_wait);
3664         set_bit(MD_RECOVERY_DONE, &mddev->recovery);
3665         md_wakeup_thread(mddev->thread);
3666 }
3667
3668
3669 /*
3670  * This routine is regularly called by all per-raid-array threads to
3671  * deal with generic issues like resync and super-block update.
3672  * Raid personalities that don't have a thread (linear/raid0) do not
3673  * need this as they never do any recovery or update the superblock.
3674  *
3675  * It does not do any resync itself, but rather "forks" off other threads
3676  * to do that as needed.
3677  * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
3678  * "->recovery" and create a thread at ->sync_thread.
3679  * When the thread finishes it sets MD_RECOVERY_DONE (and might set MD_RECOVERY_ERR)
3680  * and wakeups up this thread which will reap the thread and finish up.
3681  * This thread also removes any faulty devices (with nr_pending == 0).
3682  *
3683  * The overall approach is:
3684  *  1/ if the superblock needs updating, update it.
3685  *  2/ If a recovery thread is running, don't do anything else.
3686  *  3/ If recovery has finished, clean up, possibly marking spares active.
3687  *  4/ If there are any faulty devices, remove them.
3688  *  5/ If array is degraded, try to add spares devices
3689  *  6/ If array has spares or is not in-sync, start a resync thread.
3690  */
3691 void md_check_recovery(mddev_t *mddev)
3692 {
3693         mdk_rdev_t *rdev;
3694         struct list_head *rtmp;
3695
3696
3697         if (mddev->bitmap)
3698                 bitmap_daemon_work(mddev->bitmap);
3699
3700         if (mddev->ro)
3701                 return;
3702
3703         if (signal_pending(current)) {
3704                 if (mddev->pers->sync_request) {
3705                         printk(KERN_INFO "md: %s in immediate safe mode\n",
3706                                mdname(mddev));
3707                         mddev->safemode = 2;
3708                 }
3709                 flush_signals(current);
3710         }
3711
3712         if ( ! (
3713                 mddev->sb_dirty ||
3714                 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
3715                 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
3716                 (mddev->safemode == 1) ||
3717                 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
3718                  && !mddev->in_sync && mddev->recovery_cp == MaxSector)
3719                 ))
3720                 return;
3721
3722         if (mddev_trylock(mddev)==0) {
3723                 int spares =0;
3724
3725                 spin_lock(&mddev->write_lock);
3726                 if (mddev->safemode && !atomic_read(&mddev->writes_pending) &&
3727                     !mddev->in_sync && mddev->recovery_cp == MaxSector) {
3728                         mddev->in_sync = 1;
3729                         mddev->sb_dirty = 1;
3730                 }
3731                 if (mddev->safemode == 1)
3732                         mddev->safemode = 0;
3733                 spin_unlock(&mddev->write_lock);
3734
3735                 if (mddev->sb_dirty)
3736                         md_update_sb(mddev);
3737
3738
3739                 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
3740                     !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
3741                         /* resync/recovery still happening */
3742                         clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3743                         goto unlock;
3744                 }
3745                 if (mddev->sync_thread) {
3746                         /* resync has finished, collect result */
3747                         md_unregister_thread(mddev->sync_thread);
3748                         mddev->sync_thread = NULL;
3749                         if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
3750                             !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
3751                                 /* success...*/
3752                                 /* activate any spares */
3753                                 mddev->pers->spare_active(mddev);
3754                         }
3755                         md_update_sb(mddev);
3756
3757                         /* if array is no-longer degraded, then any saved_raid_disk
3758                          * information must be scrapped
3759                          */
3760                         if (!mddev->degraded)
3761                                 ITERATE_RDEV(mddev,rdev,rtmp)
3762                                         rdev->saved_raid_disk = -1;
3763
3764                         mddev->recovery = 0;
3765                         /* flag recovery needed just to double check */
3766                         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3767                         goto unlock;
3768                 }
3769                 if (mddev->recovery)
3770                         /* probably just the RECOVERY_NEEDED flag */
3771                         mddev->recovery = 0;
3772
3773                 /* no recovery is running.
3774                  * remove any failed drives, then
3775                  * add spares if possible.
3776                  * Spare are also removed and re-added, to allow
3777                  * the personality to fail the re-add.
3778                  */
3779                 ITERATE_RDEV(mddev,rdev,rtmp)
3780                         if (rdev->raid_disk >= 0 &&
3781                             (rdev->faulty || ! rdev->in_sync) &&
3782                             atomic_read(&rdev->nr_pending)==0) {
3783                                 if (mddev->pers->hot_remove_disk(mddev, rdev->raid_disk)==0)
3784                                         rdev->raid_disk = -1;
3785                         }
3786
3787                 if (mddev->degraded) {
3788                         ITERATE_RDEV(mddev,rdev,rtmp)
3789                                 if (rdev->raid_disk < 0
3790                                     && !rdev->faulty) {
3791                                         if (mddev->pers->hot_add_disk(mddev,rdev))
3792                                                 spares++;
3793                                         else
3794                                                 break;
3795                                 }
3796                 }
3797
3798                 if (!spares && (mddev->recovery_cp == MaxSector )) {
3799                         /* nothing we can do ... */
3800                         goto unlock;
3801                 }
3802                 if (mddev->pers->sync_request) {
3803                         set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
3804                         if (!spares)
3805                                 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
3806                         if (spares && mddev->bitmap && ! mddev->bitmap->file) {
3807                                 /* We are adding a device or devices to an array
3808                                  * which has the bitmap stored on all devices.
3809                                  * So make sure all bitmap pages get written
3810                                  */
3811                                 bitmap_write_all(mddev->bitmap);
3812                         }
3813                         mddev->sync_thread = md_register_thread(md_do_sync,
3814                                                                 mddev,
3815                                                                 "%s_resync");
3816                         if (!mddev->sync_thread) {
3817                                 printk(KERN_ERR "%s: could not start resync"
3818                                         " thread...\n",
3819                                         mdname(mddev));
3820                                 /* leave the spares where they are, it shouldn't hurt */
3821                                 mddev->recovery = 0;
3822                         } else {
3823                                 md_wakeup_thread(mddev->sync_thread);
3824                         }
3825                 }
3826         unlock:
3827                 mddev_unlock(mddev);
3828         }
3829 }
3830
3831 static int md_notify_reboot(struct notifier_block *this,
3832                             unsigned long code, void *x)
3833 {
3834         struct list_head *tmp;
3835         mddev_t *mddev;
3836
3837         if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) {
3838
3839                 printk(KERN_INFO "md: stopping all md devices.\n");
3840
3841                 ITERATE_MDDEV(mddev,tmp)
3842                         if (mddev_trylock(mddev)==0)
3843                                 do_md_stop (mddev, 1);
3844                 /*
3845                  * certain more exotic SCSI devices are known to be
3846                  * volatile wrt too early system reboots. While the
3847                  * right place to handle this issue is the given
3848                  * driver, we do want to have a safe RAID driver ...
3849                  */
3850                 mdelay(1000*1);
3851         }
3852         return NOTIFY_DONE;
3853 }
3854
3855 static struct notifier_block md_notifier = {
3856         .notifier_call  = md_notify_reboot,
3857         .next           = NULL,
3858         .priority       = INT_MAX, /* before any real devices */
3859 };
3860
3861 static void md_geninit(void)
3862 {
3863         struct proc_dir_entry *p;
3864
3865         dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
3866
3867         p = create_proc_entry("mdstat", S_IRUGO, NULL);
3868         if (p)
3869                 p->proc_fops = &md_seq_fops;
3870 }
3871
3872 static int __init md_init(void)
3873 {
3874         int minor;
3875
3876         printk(KERN_INFO "md: md driver %d.%d.%d MAX_MD_DEVS=%d,"
3877                         " MD_SB_DISKS=%d\n",
3878                         MD_MAJOR_VERSION, MD_MINOR_VERSION,
3879                         MD_PATCHLEVEL_VERSION, MAX_MD_DEVS, MD_SB_DISKS);
3880         printk(KERN_INFO "md: bitmap version %d.%d\n", BITMAP_MAJOR,
3881                         BITMAP_MINOR);
3882
3883         if (register_blkdev(MAJOR_NR, "md"))
3884                 return -1;
3885         if ((mdp_major=register_blkdev(0, "mdp"))<=0) {
3886                 unregister_blkdev(MAJOR_NR, "md");
3887                 return -1;
3888         }
3889         devfs_mk_dir("md");
3890         blk_register_region(MKDEV(MAJOR_NR, 0), MAX_MD_DEVS, THIS_MODULE,
3891                                 md_probe, NULL, NULL);
3892         blk_register_region(MKDEV(mdp_major, 0), MAX_MD_DEVS<<MdpMinorShift, THIS_MODULE,
3893                             md_probe, NULL, NULL);
3894
3895         for (minor=0; minor < MAX_MD_DEVS; ++minor)
3896                 devfs_mk_bdev(MKDEV(MAJOR_NR, minor),
3897                                 S_IFBLK|S_IRUSR|S_IWUSR,
3898                                 "md/%d", minor);
3899
3900         for (minor=0; minor < MAX_MD_DEVS; ++minor)
3901                 devfs_mk_bdev(MKDEV(mdp_major, minor<<MdpMinorShift),
3902                               S_IFBLK|S_IRUSR|S_IWUSR,
3903                               "md/mdp%d", minor);
3904
3905
3906         register_reboot_notifier(&md_notifier);
3907         raid_table_header = register_sysctl_table(raid_root_table, 1);
3908
3909         md_geninit();
3910         return (0);
3911 }
3912
3913
3914 #ifndef MODULE
3915
3916 /*
3917  * Searches all registered partitions for autorun RAID arrays
3918  * at boot time.
3919  */
3920 static dev_t detected_devices[128];
3921 static int dev_cnt;
3922
3923 void md_autodetect_dev(dev_t dev)
3924 {
3925         if (dev_cnt >= 0 && dev_cnt < 127)
3926                 detected_devices[dev_cnt++] = dev;
3927 }
3928
3929
3930 static void autostart_arrays(int part)
3931 {
3932         mdk_rdev_t *rdev;
3933         int i;
3934
3935         printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
3936
3937         for (i = 0; i < dev_cnt; i++) {
3938                 dev_t dev = detected_devices[i];
3939
3940                 rdev = md_import_device(dev,0, 0);
3941                 if (IS_ERR(rdev))
3942                         continue;
3943
3944                 if (rdev->faulty) {
3945                         MD_BUG();
3946                         continue;
3947                 }
3948                 list_add(&rdev->same_set, &pending_raid_disks);
3949         }
3950         dev_cnt = 0;
3951
3952         autorun_devices(part);
3953 }
3954
3955 #endif
3956
3957 static __exit void md_exit(void)
3958 {
3959         mddev_t *mddev;
3960         struct list_head *tmp;
3961         int i;
3962         blk_unregister_region(MKDEV(MAJOR_NR,0), MAX_MD_DEVS);
3963         blk_unregister_region(MKDEV(mdp_major,0), MAX_MD_DEVS << MdpMinorShift);
3964         for (i=0; i < MAX_MD_DEVS; i++)
3965                 devfs_remove("md/%d", i);
3966         for (i=0; i < MAX_MD_DEVS; i++)
3967                 devfs_remove("md/d%d", i);
3968
3969         devfs_remove("md");
3970
3971         unregister_blkdev(MAJOR_NR,"md");
3972         unregister_blkdev(mdp_major, "mdp");
3973         unregister_reboot_notifier(&md_notifier);
3974         unregister_sysctl_table(raid_table_header);
3975         remove_proc_entry("mdstat", NULL);
3976         ITERATE_MDDEV(mddev,tmp) {
3977                 struct gendisk *disk = mddev->gendisk;
3978                 if (!disk)
3979                         continue;
3980                 export_array(mddev);
3981                 del_gendisk(disk);
3982                 put_disk(disk);
3983                 mddev->gendisk = NULL;
3984                 mddev_put(mddev);
3985         }
3986 }
3987
3988 module_init(md_init)
3989 module_exit(md_exit)
3990
3991 EXPORT_SYMBOL(register_md_personality);
3992 EXPORT_SYMBOL(unregister_md_personality);
3993 EXPORT_SYMBOL(md_error);
3994 EXPORT_SYMBOL(md_done_sync);
3995 EXPORT_SYMBOL(md_write_start);
3996 EXPORT_SYMBOL(md_write_end);
3997 EXPORT_SYMBOL(md_register_thread);
3998 EXPORT_SYMBOL(md_unregister_thread);
3999 EXPORT_SYMBOL(md_wakeup_thread);
4000 EXPORT_SYMBOL(md_print_devices);
4001 EXPORT_SYMBOL(md_check_recovery);
4002 MODULE_LICENSE("GPL");