drivers/md/md.c

   1 /*
   2    md.c : Multiple Devices driver for Linux
   3      Copyright (C) 1998, 1999, 2000 Ingo Molnar
   4
   5      completely rewritten, based on the MD driver code from Marc Zyngier
   6
   7    Changes:
   8
   9    - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
  10    - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
  11    - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
  12    - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
  13    - kmod support by: Cyrus Durgin
  14    - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
  15    - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
  16
  17    - lots of fixes and improvements to the RAID1/RAID5 and generic
  18      RAID code (such as request based resynchronization):
  19
  20      Neil Brown <neilb@cse.unsw.edu.au>.
  21
  22    - persistent bitmap code
  23      Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
  24
  25    This program is free software; you can redistribute it and/or modify
  26    it under the terms of the GNU General Public License as published by
  27    the Free Software Foundation; either version 2, or (at your option)
  28    any later version.
  29
  30    You should have received a copy of the GNU General Public License
  31    (for example /usr/src/linux/COPYING); if not, write to the Free
  32    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  33 */
  34
  35 #include <linux/kthread.h>
  36 #include <linux/blkdev.h>
  37 #include <linux/badblocks.h>
  38 #include <linux/sysctl.h>
  39 #include <linux/seq_file.h>
  40 #include <linux/fs.h>
  41 #include <linux/poll.h>
  42 #include <linux/ctype.h>
  43 #include <linux/string.h>
  44 #include <linux/hdreg.h>
  45 #include <linux/proc_fs.h>
  46 #include <linux/random.h>
  47 #include <linux/module.h>
  48 #include <linux/reboot.h>
  49 #include <linux/file.h>
  50 #include <linux/compat.h>
  51 #include <linux/delay.h>
  52 #include <linux/raid/md_p.h>
  53 #include <linux/raid/md_u.h>
  54 #include <linux/slab.h>
  55 #include "md.h"
  56 #include "bitmap.h"
  57 #include "md-cluster.h"
  58
  59 #ifndef MODULE
  60 static void autostart_arrays(int part);
  61 #endif
  62
  63 /* pers_list is a list of registered personalities protected
  64  * by pers_lock.
  65  * pers_lock does extra service to protect accesses to
  66  * mddev->thread when the mutex cannot be held.
  67  */
  68 static LIST_HEAD(pers_list);
  69 static DEFINE_SPINLOCK(pers_lock);
  70
  71 struct md_cluster_operations *md_cluster_ops;
  72 EXPORT_SYMBOL(md_cluster_ops);
  73 struct module *md_cluster_mod;
  74 EXPORT_SYMBOL(md_cluster_mod);
  75
  76 static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
  77 static struct workqueue_struct *md_wq;
  78 static struct workqueue_struct *md_misc_wq;
  79
  80 static int remove_and_add_spares(struct mddev *mddev,
  81                                  struct md_rdev *this);
  82 static void mddev_detach(struct mddev *mddev);
  83
  84 /*
  85  * Default number of read corrections we'll attempt on an rdev
  86  * before ejecting it from the array. We divide the read error
  87  * count by 2 for every hour elapsed between read errors.
  88  */
  89 #define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
  90 /*
  91  * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
  92  * is 1000 KB/sec, so the extra system load does not show up that much.
  93  * Increase it if you want to have more _guaranteed_ speed. Note that
  94  * the RAID driver will use the maximum available bandwidth if the IO
  95  * subsystem is idle. There is also an 'absolute maximum' reconstruction
  96  * speed limit - in case reconstruction slows down your system despite
  97  * idle IO detection.
  98  *
  99  * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
 100  * or /sys/block/mdX/md/sync_speed_{min,max}
 101  */
 102
 103 static int sysctl_speed_limit_min = 1000;
 104 static int sysctl_speed_limit_max = 200000;
 105 static inline int speed_min(struct mddev *mddev)
 106 {
 107         return mddev->sync_speed_min ?
 108                 mddev->sync_speed_min : sysctl_speed_limit_min;
 109 }
 110
 111 static inline int speed_max(struct mddev *mddev)
 112 {
 113         return mddev->sync_speed_max ?
 114                 mddev->sync_speed_max : sysctl_speed_limit_max;
 115 }
 116
 117 static struct ctl_table_header *raid_table_header;
 118
 119 static struct ctl_table raid_table[] = {
 120         {
 121                 .procname       = "speed_limit_min",
 122                 .data           = &sysctl_speed_limit_min,
 123                 .maxlen         = sizeof(int),
 124                 .mode           = S_IRUGO|S_IWUSR,
 125                 .proc_handler   = proc_dointvec,
 126         },
 127         {
 128                 .procname       = "speed_limit_max",
 129                 .data           = &sysctl_speed_limit_max,
 130                 .maxlen         = sizeof(int),
 131                 .mode           = S_IRUGO|S_IWUSR,
 132                 .proc_handler   = proc_dointvec,
 133         },
 134         { }
 135 };
 136
 137 static struct ctl_table raid_dir_table[] = {
 138         {
 139                 .procname       = "raid",
 140                 .maxlen         = 0,
 141                 .mode           = S_IRUGO|S_IXUGO,
 142                 .child          = raid_table,
 143         },
 144         { }
 145 };
 146
 147 static struct ctl_table raid_root_table[] = {
 148         {
 149                 .procname       = "dev",
 150                 .maxlen         = 0,
 151                 .mode           = 0555,
 152                 .child          = raid_dir_table,
 153         },
 154         {  }
 155 };
 156
 157 static const struct block_device_operations md_fops;
 158
 159 static int start_readonly;
 160
 161 /* bio_clone_mddev
 162  * like bio_clone, but with a local bio set
 163  */
 164
 165 struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
 166                             struct mddev *mddev)
 167 {
 168         struct bio *b;
 169
 170         if (!mddev || !mddev->bio_set)
 171                 return bio_alloc(gfp_mask, nr_iovecs);
 172
 173         b = bio_alloc_bioset(gfp_mask, nr_iovecs, mddev->bio_set);
 174         if (!b)
 175                 return NULL;
 176         return b;
 177 }
 178 EXPORT_SYMBOL_GPL(bio_alloc_mddev);
 179
 180 struct bio *bio_clone_mddev(struct bio *bio, gfp_t gfp_mask,
 181                             struct mddev *mddev)
 182 {
 183         if (!mddev || !mddev->bio_set)
 184                 return bio_clone(bio, gfp_mask);
 185
 186         return bio_clone_bioset(bio, gfp_mask, mddev->bio_set);
 187 }
 188 EXPORT_SYMBOL_GPL(bio_clone_mddev);
 189
 190 /*
 191  * We have a system wide 'event count' that is incremented
 192  * on any 'interesting' event, and readers of /proc/mdstat
 193  * can use 'poll' or 'select' to find out when the event
 194  * count increases.
 195  *
 196  * Events are:
 197  *  start array, stop array, error, add device, remove device,
 198  *  start build, activate spare
 199  */
 200 static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
 201 static atomic_t md_event_count;
 202 void md_new_event(struct mddev *mddev)
 203 {
 204         atomic_inc(&md_event_count);
 205         wake_up(&md_event_waiters);
 206 }
 207 EXPORT_SYMBOL_GPL(md_new_event);
 208
 209 /*
 210  * Enables to iterate over all existing md arrays
 211  * all_mddevs_lock protects this list.
 212  */
 213 static LIST_HEAD(all_mddevs);
 214 static DEFINE_SPINLOCK(all_mddevs_lock);
 215
 216 /*
 217  * iterates through all used mddevs in the system.
 218  * We take care to grab the all_mddevs_lock whenever navigating
 219  * the list, and to always hold a refcount when unlocked.
 220  * Any code which breaks out of this loop while own
 221  * a reference to the current mddev and must mddev_put it.
 222  */
 223 #define for_each_mddev(_mddev,_tmp)                                     \
 224                                                                         \
 225         for (({ spin_lock(&all_mddevs_lock);                            \
 226                 _tmp = all_mddevs.next;                                 \
 227                 _mddev = NULL;});                                       \
 228              ({ if (_tmp != &all_mddevs)                                \
 229                         mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\
 230                 spin_unlock(&all_mddevs_lock);                          \
 231                 if (_mddev) mddev_put(_mddev);                          \
 232                 _mddev = list_entry(_tmp, struct mddev, all_mddevs);    \
 233                 _tmp != &all_mddevs;});                                 \
 234              ({ spin_lock(&all_mddevs_lock);                            \
 235                 _tmp = _tmp->next;})                                    \
 236                 )
 237
 238 /* Rather than calling directly into the personality make_request function,
 239  * IO requests come here first so that we can check if the device is
 240  * being suspended pending a reconfiguration.
 241  * We hold a refcount over the call to ->make_request.  By the time that
 242  * call has finished, the bio has been linked into some internal structure
 243  * and so is visible to ->quiesce(), so we don't need the refcount any more.
 244  */
 245 static blk_qc_t md_make_request(struct request_queue *q, struct bio *bio)
 246 {
 247         const int rw = bio_data_dir(bio);
 248         struct mddev *mddev = q->queuedata;
 249         unsigned int sectors;
 250         int cpu;
 251
 252         blk_queue_split(q, &bio, q->bio_split);
 253
 254         if (mddev == NULL || mddev->pers == NULL) {
 255                 bio_io_error(bio);
 256                 return BLK_QC_T_NONE;
 257         }
 258         if (mddev->ro == 1 && unlikely(rw == WRITE)) {
 259                 if (bio_sectors(bio) != 0)
 260                         bio->bi_error = -EROFS;
 261                 bio_endio(bio);
 262                 return BLK_QC_T_NONE;
 263         }
 264         smp_rmb(); /* Ensure implications of  'active' are visible */
 265         rcu_read_lock();
 266         if (mddev->suspended) {
 267                 DEFINE_WAIT(__wait);
 268                 for (;;) {
 269                         prepare_to_wait(&mddev->sb_wait, &__wait,
 270                                         TASK_UNINTERRUPTIBLE);
 271                         if (!mddev->suspended)
 272                                 break;
 273                         rcu_read_unlock();
 274                         schedule();
 275                         rcu_read_lock();
 276                 }
 277                 finish_wait(&mddev->sb_wait, &__wait);
 278         }
 279         atomic_inc(&mddev->active_io);
 280         rcu_read_unlock();
 281
 282         /*
 283          * save the sectors now since our bio can
 284          * go away inside make_request
 285          */
 286         sectors = bio_sectors(bio);
 287         /* bio could be mergeable after passing to underlayer */
 288         bio->bi_rw &= ~REQ_NOMERGE;
 289         mddev->pers->make_request(mddev, bio);
 290
 291         cpu = part_stat_lock();
 292         part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
 293         part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors);
 294         part_stat_unlock();
 295
 296         if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
 297                 wake_up(&mddev->sb_wait);
 298
 299         return BLK_QC_T_NONE;
 300 }
 301
 302 /* mddev_suspend makes sure no new requests are submitted
 303  * to the device, and that any requests that have been submitted
 304  * are completely handled.
 305  * Once mddev_detach() is called and completes, the module will be
 306  * completely unused.
 307  */
 308 void mddev_suspend(struct mddev *mddev)
 309 {
 310         WARN_ON_ONCE(mddev->thread && current == mddev->thread->tsk);
 311         if (mddev->suspended++)
 312                 return;
 313         synchronize_rcu();
 314         wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
 315         mddev->pers->quiesce(mddev, 1);
 316
 317         del_timer_sync(&mddev->safemode_timer);
 318 }
 319 EXPORT_SYMBOL_GPL(mddev_suspend);
 320
 321 void mddev_resume(struct mddev *mddev)
 322 {
 323         if (--mddev->suspended)
 324                 return;
 325         wake_up(&mddev->sb_wait);
 326         mddev->pers->quiesce(mddev, 0);
 327
 328         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
 329         md_wakeup_thread(mddev->thread);
 330         md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
 331 }
 332 EXPORT_SYMBOL_GPL(mddev_resume);
 333
 334 int mddev_congested(struct mddev *mddev, int bits)
 335 {
 336         struct md_personality *pers = mddev->pers;
 337         int ret = 0;
 338
 339         rcu_read_lock();
 340         if (mddev->suspended)
 341                 ret = 1;
 342         else if (pers && pers->congested)
 343                 ret = pers->congested(mddev, bits);
 344         rcu_read_unlock();
 345         return ret;
 346 }
 347 EXPORT_SYMBOL_GPL(mddev_congested);
 348 static int md_congested(void *data, int bits)
 349 {
 350         struct mddev *mddev = data;
 351         return mddev_congested(mddev, bits);
 352 }
 353
 354 /*
 355  * Generic flush handling for md
 356  */
 357
 358 static void md_end_flush(struct bio *bio)
 359 {
 360         struct md_rdev *rdev = bio->bi_private;
 361         struct mddev *mddev = rdev->mddev;
 362
 363         rdev_dec_pending(rdev, mddev);
 364
 365         if (atomic_dec_and_test(&mddev->flush_pending)) {
 366                 /* The pre-request flush has finished */
 367                 queue_work(md_wq, &mddev->flush_work);
 368         }
 369         bio_put(bio);
 370 }
 371
 372 static void md_submit_flush_data(struct work_struct *ws);
 373
 374 static void submit_flushes(struct work_struct *ws)
 375 {
 376         struct mddev *mddev = container_of(ws, struct mddev, flush_work);
 377         struct md_rdev *rdev;
 378
 379         INIT_WORK(&mddev->flush_work, md_submit_flush_data);
 380         atomic_set(&mddev->flush_pending, 1);
 381         rcu_read_lock();
 382         rdev_for_each_rcu(rdev, mddev)
 383                 if (rdev->raid_disk >= 0 &&
 384                     !test_bit(Faulty, &rdev->flags)) {
 385                         /* Take two references, one is dropped
 386                          * when request finishes, one after
 387                          * we reclaim rcu_read_lock
 388                          */
 389                         struct bio *bi;
 390                         atomic_inc(&rdev->nr_pending);
 391                         atomic_inc(&rdev->nr_pending);
 392                         rcu_read_unlock();
 393                         bi = bio_alloc_mddev(GFP_NOIO, 0, mddev);
 394                         bi->bi_end_io = md_end_flush;
 395                         bi->bi_private = rdev;
 396                         bi->bi_bdev = rdev->bdev;
 397                         bio_set_op_attrs(bi, REQ_OP_WRITE, WRITE_FLUSH);
 398                         atomic_inc(&mddev->flush_pending);
 399                         submit_bio(bi);
 400                         rcu_read_lock();
 401                         rdev_dec_pending(rdev, mddev);
 402                 }
 403         rcu_read_unlock();
 404         if (atomic_dec_and_test(&mddev->flush_pending))
 405                 queue_work(md_wq, &mddev->flush_work);
 406 }
 407
 408 static void md_submit_flush_data(struct work_struct *ws)
 409 {
 410         struct mddev *mddev = container_of(ws, struct mddev, flush_work);
 411         struct bio *bio = mddev->flush_bio;
 412
 413         if (bio->bi_iter.bi_size == 0)
 414                 /* an empty barrier - all done */
 415                 bio_endio(bio);
 416         else {
 417                 bio->bi_rw &= ~REQ_PREFLUSH;
 418                 mddev->pers->make_request(mddev, bio);
 419         }
 420
 421         mddev->flush_bio = NULL;
 422         wake_up(&mddev->sb_wait);
 423 }
 424
 425 void md_flush_request(struct mddev *mddev, struct bio *bio)
 426 {
 427         spin_lock_irq(&mddev->lock);
 428         wait_event_lock_irq(mddev->sb_wait,
 429                             !mddev->flush_bio,
 430                             mddev->lock);
 431         mddev->flush_bio = bio;
 432         spin_unlock_irq(&mddev->lock);
 433
 434         INIT_WORK(&mddev->flush_work, submit_flushes);
 435         queue_work(md_wq, &mddev->flush_work);
 436 }
 437 EXPORT_SYMBOL(md_flush_request);
 438
 439 void md_unplug(struct blk_plug_cb *cb, bool from_schedule)
 440 {
 441         struct mddev *mddev = cb->data;
 442         md_wakeup_thread(mddev->thread);
 443         kfree(cb);
 444 }
 445 EXPORT_SYMBOL(md_unplug);
 446
 447 static inline struct mddev *mddev_get(struct mddev *mddev)
 448 {
 449         atomic_inc(&mddev->active);
 450         return mddev;
 451 }
 452
 453 static void mddev_delayed_delete(struct work_struct *ws);
 454
 455 static void mddev_put(struct mddev *mddev)
 456 {
 457         struct bio_set *bs = NULL;
 458
 459         if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
 460                 return;
 461         if (!mddev->raid_disks && list_empty(&mddev->disks) &&
 462             mddev->ctime == 0 && !mddev->hold_active) {
 463                 /* Array is not configured at all, and not held active,
 464                  * so destroy it */
 465                 list_del_init(&mddev->all_mddevs);
 466                 bs = mddev->bio_set;
 467                 mddev->bio_set = NULL;
 468                 if (mddev->gendisk) {
 469                         /* We did a probe so need to clean up.  Call
 470                          * queue_work inside the spinlock so that
 471                          * flush_workqueue() after mddev_find will
 472                          * succeed in waiting for the work to be done.
 473                          */
 474                         INIT_WORK(&mddev->del_work, mddev_delayed_delete);
 475                         queue_work(md_misc_wq, &mddev->del_work);
 476                 } else
 477                         kfree(mddev);
 478         }
 479         spin_unlock(&all_mddevs_lock);
 480         if (bs)
 481                 bioset_free(bs);
 482 }
 483
 484 static void md_safemode_timeout(unsigned long data);
 485
 486 void mddev_init(struct mddev *mddev)
 487 {
 488         mutex_init(&mddev->open_mutex);
 489         mutex_init(&mddev->reconfig_mutex);
 490         mutex_init(&mddev->bitmap_info.mutex);
 491         INIT_LIST_HEAD(&mddev->disks);
 492         INIT_LIST_HEAD(&mddev->all_mddevs);
 493         setup_timer(&mddev->safemode_timer, md_safemode_timeout,
 494                     (unsigned long) mddev);
 495         atomic_set(&mddev->active, 1);
 496         atomic_set(&mddev->openers, 0);
 497         atomic_set(&mddev->active_io, 0);
 498         spin_lock_init(&mddev->lock);
 499         atomic_set(&mddev->flush_pending, 0);
 500         init_waitqueue_head(&mddev->sb_wait);
 501         init_waitqueue_head(&mddev->recovery_wait);
 502         mddev->reshape_position = MaxSector;
 503         mddev->reshape_backwards = 0;
 504         mddev->last_sync_action = "none";
 505         mddev->resync_min = 0;
 506         mddev->resync_max = MaxSector;
 507         mddev->level = LEVEL_NONE;
 508 }
 509 EXPORT_SYMBOL_GPL(mddev_init);
 510
 511 static struct mddev *mddev_find(dev_t unit)
 512 {
 513         struct mddev *mddev, *new = NULL;
 514
 515         if (unit && MAJOR(unit) != MD_MAJOR)
 516                 unit &= ~((1<<MdpMinorShift)-1);
 517
 518  retry:
 519         spin_lock(&all_mddevs_lock);
 520
 521         if (unit) {
 522                 list_for_each_entry(mddev, &all_mddevs, all_mddevs)
 523                         if (mddev->unit == unit) {
 524                                 mddev_get(mddev);
 525                                 spin_unlock(&all_mddevs_lock);
 526                                 kfree(new);
 527                                 return mddev;
 528                         }
 529
 530                 if (new) {
 531                         list_add(&new->all_mddevs, &all_mddevs);
 532                         spin_unlock(&all_mddevs_lock);
 533                         new->hold_active = UNTIL_IOCTL;
 534                         return new;
 535                 }
 536         } else if (new) {
 537                 /* find an unused unit number */
 538                 static int next_minor = 512;
 539                 int start = next_minor;
 540                 int is_free = 0;
 541                 int dev = 0;
 542                 while (!is_free) {
 543                         dev = MKDEV(MD_MAJOR, next_minor);
 544                         next_minor++;
 545                         if (next_minor > MINORMASK)
 546                                 next_minor = 0;
 547                         if (next_minor == start) {
 548                                 /* Oh dear, all in use. */
 549                                 spin_unlock(&all_mddevs_lock);
 550                                 kfree(new);
 551                                 return NULL;
 552                         }
 553
 554                         is_free = 1;
 555                         list_for_each_entry(mddev, &all_mddevs, all_mddevs)
 556                                 if (mddev->unit == dev) {
 557                                         is_free = 0;
 558                                         break;
 559                                 }
 560                 }
 561                 new->unit = dev;
 562                 new->md_minor = MINOR(dev);
 563                 new->hold_active = UNTIL_STOP;
 564                 list_add(&new->all_mddevs, &all_mddevs);
 565                 spin_unlock(&all_mddevs_lock);
 566                 return new;
 567         }
 568         spin_unlock(&all_mddevs_lock);
 569
 570         new = kzalloc(sizeof(*new), GFP_KERNEL);
 571         if (!new)
 572                 return NULL;
 573
 574         new->unit = unit;
 575         if (MAJOR(unit) == MD_MAJOR)
 576                 new->md_minor = MINOR(unit);
 577         else
 578                 new->md_minor = MINOR(unit) >> MdpMinorShift;
 579
 580         mddev_init(new);
 581
 582         goto retry;
 583 }
 584
 585 static struct attribute_group md_redundancy_group;
 586
 587 void mddev_unlock(struct mddev *mddev)
 588 {
 589         if (mddev->to_remove) {
 590                 /* These cannot be removed under reconfig_mutex as
 591                  * an access to the files will try to take reconfig_mutex
 592                  * while holding the file unremovable, which leads to
 593                  * a deadlock.
 594                  * So hold set sysfs_active while the remove in happeing,
 595                  * and anything else which might set ->to_remove or my
 596                  * otherwise change the sysfs namespace will fail with
 597                  * -EBUSY if sysfs_active is still set.
 598                  * We set sysfs_active under reconfig_mutex and elsewhere
 599                  * test it under the same mutex to ensure its correct value
 600                  * is seen.
 601                  */
 602                 struct attribute_group *to_remove = mddev->to_remove;
 603                 mddev->to_remove = NULL;
 604                 mddev->sysfs_active = 1;
 605                 mutex_unlock(&mddev->reconfig_mutex);
 606
 607                 if (mddev->kobj.sd) {
 608                         if (to_remove != &md_redundancy_group)
 609                                 sysfs_remove_group(&mddev->kobj, to_remove);
 610                         if (mddev->pers == NULL ||
 611                             mddev->pers->sync_request == NULL) {
 612                                 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
 613                                 if (mddev->sysfs_action)
 614                                         sysfs_put(mddev->sysfs_action);
 615                                 mddev->sysfs_action = NULL;
 616                         }
 617                 }
 618                 mddev->sysfs_active = 0;
 619         } else
 620                 mutex_unlock(&mddev->reconfig_mutex);
 621
 622         /* As we've dropped the mutex we need a spinlock to
 623          * make sure the thread doesn't disappear
 624          */
 625         spin_lock(&pers_lock);
 626         md_wakeup_thread(mddev->thread);
 627         spin_unlock(&pers_lock);
 628 }
 629 EXPORT_SYMBOL_GPL(mddev_unlock);
 630
 631 struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)
 632 {
 633         struct md_rdev *rdev;
 634
 635         rdev_for_each_rcu(rdev, mddev)
 636                 if (rdev->desc_nr == nr)
 637                         return rdev;
 638
 639         return NULL;
 640 }
 641 EXPORT_SYMBOL_GPL(md_find_rdev_nr_rcu);
 642
 643 static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)
 644 {
 645         struct md_rdev *rdev;
 646
 647         rdev_for_each(rdev, mddev)
 648                 if (rdev->bdev->bd_dev == dev)
 649                         return rdev;
 650
 651         return NULL;
 652 }
 653
 654 static struct md_rdev *find_rdev_rcu(struct mddev *mddev, dev_t dev)
 655 {
 656         struct md_rdev *rdev;
 657
 658         rdev_for_each_rcu(rdev, mddev)
 659                 if (rdev->bdev->bd_dev == dev)
 660                         return rdev;
 661
 662         return NULL;
 663 }
 664
 665 static struct md_personality *find_pers(int level, char *clevel)
 666 {
 667         struct md_personality *pers;
 668         list_for_each_entry(pers, &pers_list, list) {
 669                 if (level != LEVEL_NONE && pers->level == level)
 670                         return pers;
 671                 if (strcmp(pers->name, clevel)==0)
 672                         return pers;
 673         }
 674         return NULL;
 675 }
 676
 677 /* return the offset of the super block in 512byte sectors */
 678 static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
 679 {
 680         sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
 681         return MD_NEW_SIZE_SECTORS(num_sectors);
 682 }
 683
 684 static int alloc_disk_sb(struct md_rdev *rdev)
 685 {
 686         rdev->sb_page = alloc_page(GFP_KERNEL);
 687         if (!rdev->sb_page) {
 688                 printk(KERN_ALERT "md: out of memory.\n");
 689                 return -ENOMEM;
 690         }
 691
 692         return 0;
 693 }
 694
 695 void md_rdev_clear(struct md_rdev *rdev)
 696 {
 697         if (rdev->sb_page) {
 698                 put_page(rdev->sb_page);
 699                 rdev->sb_loaded = 0;
 700                 rdev->sb_page = NULL;
 701                 rdev->sb_start = 0;
 702                 rdev->sectors = 0;
 703         }
 704         if (rdev->bb_page) {
 705                 put_page(rdev->bb_page);
 706                 rdev->bb_page = NULL;
 707         }
 708         badblocks_exit(&rdev->badblocks);
 709 }
 710 EXPORT_SYMBOL_GPL(md_rdev_clear);
 711
 712 static void super_written(struct bio *bio)
 713 {
 714         struct md_rdev *rdev = bio->bi_private;
 715         struct mddev *mddev = rdev->mddev;
 716
 717         if (bio->bi_error) {
 718                 printk("md: super_written gets error=%d\n", bio->bi_error);
 719                 md_error(mddev, rdev);
 720         }
 721
 722         if (atomic_dec_and_test(&mddev->pending_writes))
 723                 wake_up(&mddev->sb_wait);
 724         rdev_dec_pending(rdev, mddev);
 725         bio_put(bio);
 726 }
 727
 728 void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
 729                    sector_t sector, int size, struct page *page)
 730 {
 731         /* write first size bytes of page to sector of rdev
 732          * Increment mddev->pending_writes before returning
 733          * and decrement it on completion, waking up sb_wait
 734          * if zero is reached.
 735          * If an error occurred, call md_error
 736          */
 737         struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);
 738
 739         atomic_inc(&rdev->nr_pending);
 740
 741         bio->bi_bdev = rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev;
 742         bio->bi_iter.bi_sector = sector;
 743         bio_add_page(bio, page, size, 0);
 744         bio->bi_private = rdev;
 745         bio->bi_end_io = super_written;
 746         bio_set_op_attrs(bio, REQ_OP_WRITE, WRITE_FLUSH_FUA);
 747
 748         atomic_inc(&mddev->pending_writes);
 749         submit_bio(bio);
 750 }
 751
 752 void md_super_wait(struct mddev *mddev)
 753 {
 754         /* wait for all superblock writes that were scheduled to complete */
 755         wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
 756 }
 757
 758 int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
 759                  struct page *page, int op, int op_flags, bool metadata_op)
 760 {
 761         struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, rdev->mddev);
 762         int ret;
 763
 764         bio->bi_bdev = (metadata_op && rdev->meta_bdev) ?
 765                 rdev->meta_bdev : rdev->bdev;
 766         bio_set_op_attrs(bio, op, op_flags);
 767         if (metadata_op)
 768                 bio->bi_iter.bi_sector = sector + rdev->sb_start;
 769         else if (rdev->mddev->reshape_position != MaxSector &&
 770                  (rdev->mddev->reshape_backwards ==
 771                   (sector >= rdev->mddev->reshape_position)))
 772                 bio->bi_iter.bi_sector = sector + rdev->new_data_offset;
 773         else
 774                 bio->bi_iter.bi_sector = sector + rdev->data_offset;
 775         bio_add_page(bio, page, size, 0);
 776
 777         submit_bio_wait(bio);
 778
 779         ret = !bio->bi_error;
 780         bio_put(bio);
 781         return ret;
 782 }
 783 EXPORT_SYMBOL_GPL(sync_page_io);
 784
 785 static int read_disk_sb(struct md_rdev *rdev, int size)
 786 {
 787         char b[BDEVNAME_SIZE];
 788
 789         if (rdev->sb_loaded)
 790                 return 0;
 791
 792         if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, 0, true))
 793                 goto fail;
 794         rdev->sb_loaded = 1;
 795         return 0;
 796
 797 fail:
 798         printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
 799                 bdevname(rdev->bdev,b));
 800         return -EINVAL;
 801 }
 802
 803 static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
 804 {
 805         return  sb1->set_uuid0 == sb2->set_uuid0 &&
 806                 sb1->set_uuid1 == sb2->set_uuid1 &&
 807                 sb1->set_uuid2 == sb2->set_uuid2 &&
 808                 sb1->set_uuid3 == sb2->set_uuid3;
 809 }
 810
 811 static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
 812 {
 813         int ret;
 814         mdp_super_t *tmp1, *tmp2;
 815
 816         tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
 817         tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
 818
 819         if (!tmp1 || !tmp2) {
 820                 ret = 0;
 821                 printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
 822                 goto abort;
 823         }
 824
 825         *tmp1 = *sb1;
 826         *tmp2 = *sb2;
 827
 828         /*
 829          * nr_disks is not constant
 830          */
 831         tmp1->nr_disks = 0;
 832         tmp2->nr_disks = 0;
 833
 834         ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
 835 abort:
 836         kfree(tmp1);
 837         kfree(tmp2);
 838         return ret;
 839 }
 840
 841 static u32 md_csum_fold(u32 csum)
 842 {
 843         csum = (csum & 0xffff) + (csum >> 16);
 844         return (csum & 0xffff) + (csum >> 16);
 845 }
 846
 847 static unsigned int calc_sb_csum(mdp_super_t *sb)
 848 {
 849         u64 newcsum = 0;
 850         u32 *sb32 = (u32*)sb;
 851         int i;
 852         unsigned int disk_csum, csum;
 853
 854         disk_csum = sb->sb_csum;
 855         sb->sb_csum = 0;
 856
 857         for (i = 0; i < MD_SB_BYTES/4 ; i++)
 858                 newcsum += sb32[i];
 859         csum = (newcsum & 0xffffffff) + (newcsum>>32);
 860
 861 #ifdef CONFIG_ALPHA
 862         /* This used to use csum_partial, which was wrong for several
 863          * reasons including that different results are returned on
 864          * different architectures.  It isn't critical that we get exactly
 865          * the same return value as before (we always csum_fold before
 866          * testing, and that removes any differences).  However as we
 867          * know that csum_partial always returned a 16bit value on
 868          * alphas, do a fold to maximise conformity to previous behaviour.
 869          */
 870         sb->sb_csum = md_csum_fold(disk_csum);
 871 #else
 872         sb->sb_csum = disk_csum;
 873 #endif
 874         return csum;
 875 }
 876
 877 /*
 878  * Handle superblock details.
 879  * We want to be able to handle multiple superblock formats
 880  * so we have a common interface to them all, and an array of
 881  * different handlers.
 882  * We rely on user-space to write the initial superblock, and support
 883  * reading and updating of superblocks.
 884  * Interface methods are:
 885  *   int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
 886  *      loads and validates a superblock on dev.
 887  *      if refdev != NULL, compare superblocks on both devices
 888  *    Return:
 889  *      0 - dev has a superblock that is compatible with refdev
 890  *      1 - dev has a superblock that is compatible and newer than refdev
 891  *          so dev should be used as the refdev in future
 892  *     -EINVAL superblock incompatible or invalid
 893  *     -othererror e.g. -EIO
 894  *
 895  *   int validate_super(struct mddev *mddev, struct md_rdev *dev)
 896  *      Verify that dev is acceptable into mddev.
 897  *       The first time, mddev->raid_disks will be 0, and data from
 898  *       dev should be merged in.  Subsequent calls check that dev
 899  *       is new enough.  Return 0 or -EINVAL
 900  *
 901  *   void sync_super(struct mddev *mddev, struct md_rdev *dev)
 902  *     Update the superblock for rdev with data in mddev
 903  *     This does not write to disc.
 904  *
 905  */
 906
 907 struct super_type  {
 908         char                *name;
 909         struct module       *owner;
 910         int                 (*load_super)(struct md_rdev *rdev,
 911                                           struct md_rdev *refdev,
 912                                           int minor_version);
 913         int                 (*validate_super)(struct mddev *mddev,
 914                                               struct md_rdev *rdev);
 915         void                (*sync_super)(struct mddev *mddev,
 916                                           struct md_rdev *rdev);
 917         unsigned long long  (*rdev_size_change)(struct md_rdev *rdev,
 918                                                 sector_t num_sectors);
 919         int                 (*allow_new_offset)(struct md_rdev *rdev,
 920                                                 unsigned long long new_offset);
 921 };
 922
 923 /*
 924  * Check that the given mddev has no bitmap.
 925  *
 926  * This function is called from the run method of all personalities that do not
 927  * support bitmaps. It prints an error message and returns non-zero if mddev
 928  * has a bitmap. Otherwise, it returns 0.
 929  *
 930  */
 931 int md_check_no_bitmap(struct mddev *mddev)
 932 {
 933         if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
 934                 return 0;
 935         printk(KERN_ERR "%s: bitmaps are not supported for %s\n",
 936                 mdname(mddev), mddev->pers->name);
 937         return 1;
 938 }
 939 EXPORT_SYMBOL(md_check_no_bitmap);
 940
 941 /*
 942  * load_super for 0.90.0
 943  */
 944 static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
 945 {
 946         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
 947         mdp_super_t *sb;
 948         int ret;
 949
 950         /*
 951          * Calculate the position of the superblock (512byte sectors),
 952          * it's at the end of the disk.
 953          *
 954          * It also happens to be a multiple of 4Kb.
 955          */
 956         rdev->sb_start = calc_dev_sboffset(rdev);
 957
 958         ret = read_disk_sb(rdev, MD_SB_BYTES);
 959         if (ret) return ret;
 960
 961         ret = -EINVAL;
 962
 963         bdevname(rdev->bdev, b);
 964         sb = page_address(rdev->sb_page);
 965
 966         if (sb->md_magic != MD_SB_MAGIC) {
 967                 printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
 968                        b);
 969                 goto abort;
 970         }
 971
 972         if (sb->major_version != 0 ||
 973             sb->minor_version < 90 ||
 974             sb->minor_version > 91) {
 975                 printk(KERN_WARNING "Bad version number %d.%d on %s\n",
 976                         sb->major_version, sb->minor_version,
 977                         b);
 978                 goto abort;
 979         }
 980
 981         if (sb->raid_disks <= 0)
 982                 goto abort;
 983
 984         if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
 985                 printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
 986                         b);
 987                 goto abort;
 988         }
 989
 990         rdev->preferred_minor = sb->md_minor;
 991         rdev->data_offset = 0;
 992         rdev->new_data_offset = 0;
 993         rdev->sb_size = MD_SB_BYTES;
 994         rdev->badblocks.shift = -1;
 995
 996         if (sb->level == LEVEL_MULTIPATH)
 997                 rdev->desc_nr = -1;
 998         else
 999                 rdev->desc_nr = sb->this_disk.number;
1000
1001         if (!refdev) {
1002                 ret = 1;
1003         } else {
1004                 __u64 ev1, ev2;
1005                 mdp_super_t *refsb = page_address(refdev->sb_page);
1006                 if (!uuid_equal(refsb, sb)) {
1007                         printk(KERN_WARNING "md: %s has different UUID to %s\n",
1008                                 b, bdevname(refdev->bdev,b2));
1009                         goto abort;
1010                 }
1011                 if (!sb_equal(refsb, sb)) {
1012                         printk(KERN_WARNING "md: %s has same UUID"
1013                                " but different superblock to %s\n",
1014                                b, bdevname(refdev->bdev, b2));
1015                         goto abort;
1016                 }
1017                 ev1 = md_event(sb);
1018                 ev2 = md_event(refsb);
1019                 if (ev1 > ev2)
1020                         ret = 1;
1021                 else
1022                         ret = 0;
1023         }
1024         rdev->sectors = rdev->sb_start;
1025         /* Limit to 4TB as metadata cannot record more than that.
1026          * (not needed for Linear and RAID0 as metadata doesn't
1027          * record this size)
1028          */
1029         if (IS_ENABLED(CONFIG_LBDAF) && (u64)rdev->sectors >= (2ULL << 32) &&
1030             sb->level >= 1)
1031                 rdev->sectors = (sector_t)(2ULL << 32) - 2;
1032
1033         if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
1034                 /* "this cannot possibly happen" ... */
1035                 ret = -EINVAL;
1036
1037  abort:
1038         return ret;
1039 }
1040
1041 /*
1042  * validate_super for 0.90.0
1043  */
1044 static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
1045 {
1046         mdp_disk_t *desc;
1047         mdp_super_t *sb = page_address(rdev->sb_page);
1048         __u64 ev1 = md_event(sb);
1049
1050         rdev->raid_disk = -1;
1051         clear_bit(Faulty, &rdev->flags);
1052         clear_bit(In_sync, &rdev->flags);
1053         clear_bit(Bitmap_sync, &rdev->flags);
1054         clear_bit(WriteMostly, &rdev->flags);
1055
1056         if (mddev->raid_disks == 0) {
1057                 mddev->major_version = 0;
1058                 mddev->minor_version = sb->minor_version;
1059                 mddev->patch_version = sb->patch_version;
1060                 mddev->external = 0;
1061                 mddev->chunk_sectors = sb->chunk_size >> 9;
1062                 mddev->ctime = sb->ctime;
1063                 mddev->utime = sb->utime;
1064                 mddev->level = sb->level;
1065                 mddev->clevel[0] = 0;
1066                 mddev->layout = sb->layout;
1067                 mddev->raid_disks = sb->raid_disks;
1068                 mddev->dev_sectors = ((sector_t)sb->size) * 2;
1069                 mddev->events = ev1;
1070                 mddev->bitmap_info.offset = 0;
1071                 mddev->bitmap_info.space = 0;
1072                 /* bitmap can use 60 K after the 4K superblocks */
1073                 mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
1074                 mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
1075                 mddev->reshape_backwards = 0;
1076
1077                 if (mddev->minor_version >= 91) {
1078                         mddev->reshape_position = sb->reshape_position;
1079                         mddev->delta_disks = sb->delta_disks;
1080                         mddev->new_level = sb->new_level;
1081                         mddev->new_layout = sb->new_layout;
1082                         mddev->new_chunk_sectors = sb->new_chunk >> 9;
1083                         if (mddev->delta_disks < 0)
1084                                 mddev->reshape_backwards = 1;
1085                 } else {
1086                         mddev->reshape_position = MaxSector;
1087                         mddev->delta_disks = 0;
1088                         mddev->new_level = mddev->level;
1089                         mddev->new_layout = mddev->layout;
1090                         mddev->new_chunk_sectors = mddev->chunk_sectors;
1091                 }
1092
1093                 if (sb->state & (1<<MD_SB_CLEAN))
1094                         mddev->recovery_cp = MaxSector;
1095                 else {
1096                         if (sb->events_hi == sb->cp_events_hi &&
1097                                 sb->events_lo == sb->cp_events_lo) {
1098                                 mddev->recovery_cp = sb->recovery_cp;
1099                         } else
1100                                 mddev->recovery_cp = 0;
1101                 }
1102
1103                 memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
1104                 memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
1105                 memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
1106                 memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
1107
1108                 mddev->max_disks = MD_SB_DISKS;
1109
1110                 if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
1111                     mddev->bitmap_info.file == NULL) {
1112                         mddev->bitmap_info.offset =
1113                                 mddev->bitmap_info.default_offset;
1114                         mddev->bitmap_info.space =
1115                                 mddev->bitmap_info.default_space;
1116                 }
1117
1118         } else if (mddev->pers == NULL) {
1119                 /* Insist on good event counter while assembling, except
1120                  * for spares (which don't need an event count) */
1121                 ++ev1;
1122                 if (sb->disks[rdev->desc_nr].state & (
1123                             (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
1124                         if (ev1 < mddev->events)
1125                                 return -EINVAL;
1126         } else if (mddev->bitmap) {
1127                 /* if adding to array with a bitmap, then we can accept an
1128                  * older device ... but not too old.
1129                  */
1130                 if (ev1 < mddev->bitmap->events_cleared)
1131                         return 0;
1132                 if (ev1 < mddev->events)
1133                         set_bit(Bitmap_sync, &rdev->flags);
1134         } else {
1135                 if (ev1 < mddev->events)
1136                         /* just a hot-add of a new device, leave raid_disk at -1 */
1137                         return 0;
1138         }
1139
1140         if (mddev->level != LEVEL_MULTIPATH) {
1141                 desc = sb->disks + rdev->desc_nr;
1142
1143                 if (desc->state & (1<<MD_DISK_FAULTY))
1144                         set_bit(Faulty, &rdev->flags);
1145                 else if (desc->state & (1<<MD_DISK_SYNC) /* &&
1146                             desc->raid_disk < mddev->raid_disks */) {
1147                         set_bit(In_sync, &rdev->flags);
1148                         rdev->raid_disk = desc->raid_disk;
1149                         rdev->saved_raid_disk = desc->raid_disk;
1150                 } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
1151                         /* active but not in sync implies recovery up to
1152                          * reshape position.  We don't know exactly where
1153                          * that is, so set to zero for now */
1154                         if (mddev->minor_version >= 91) {
1155                                 rdev->recovery_offset = 0;
1156                                 rdev->raid_disk = desc->raid_disk;
1157                         }
1158                 }
1159                 if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
1160                         set_bit(WriteMostly, &rdev->flags);
1161         } else /* MULTIPATH are always insync */
1162                 set_bit(In_sync, &rdev->flags);
1163         return 0;
1164 }
1165
1166 /*
1167  * sync_super for 0.90.0
1168  */
1169 static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
1170 {
1171         mdp_super_t *sb;
1172         struct md_rdev *rdev2;
1173         int next_spare = mddev->raid_disks;
1174
1175         /* make rdev->sb match mddev data..
1176          *
1177          * 1/ zero out disks
1178          * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
1179          * 3/ any empty disks < next_spare become removed
1180          *
1181          * disks[0] gets initialised to REMOVED because
1182          * we cannot be sure from other fields if it has
1183          * been initialised or not.
1184          */
1185         int i;
1186         int active=0, working=0,failed=0,spare=0,nr_disks=0;
1187
1188         rdev->sb_size = MD_SB_BYTES;
1189
1190         sb = page_address(rdev->sb_page);
1191
1192         memset(sb, 0, sizeof(*sb));
1193
1194         sb->md_magic = MD_SB_MAGIC;
1195         sb->major_version = mddev->major_version;
1196         sb->patch_version = mddev->patch_version;
1197         sb->gvalid_words  = 0; /* ignored */
1198         memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
1199         memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
1200         memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
1201         memcpy(&sb->set_uuid3, mddev->uuid+12,4);
1202
1203         sb->ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
1204         sb->level = mddev->level;
1205         sb->size = mddev->dev_sectors / 2;
1206         sb->raid_disks = mddev->raid_disks;
1207         sb->md_minor = mddev->md_minor;
1208         sb->not_persistent = 0;
1209         sb->utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
1210         sb->state = 0;
1211         sb->events_hi = (mddev->events>>32);
1212         sb->events_lo = (u32)mddev->events;
1213
1214         if (mddev->reshape_position == MaxSector)
1215                 sb->minor_version = 90;
1216         else {
1217                 sb->minor_version = 91;
1218                 sb->reshape_position = mddev->reshape_position;
1219                 sb->new_level = mddev->new_level;
1220                 sb->delta_disks = mddev->delta_disks;
1221                 sb->new_layout = mddev->new_layout;
1222                 sb->new_chunk = mddev->new_chunk_sectors << 9;
1223         }
1224         mddev->minor_version = sb->minor_version;
1225         if (mddev->in_sync)
1226         {
1227                 sb->recovery_cp = mddev->recovery_cp;
1228                 sb->cp_events_hi = (mddev->events>>32);
1229                 sb->cp_events_lo = (u32)mddev->events;
1230                 if (mddev->recovery_cp == MaxSector)
1231                         sb->state = (1<< MD_SB_CLEAN);
1232         } else
1233                 sb->recovery_cp = 0;
1234
1235         sb->layout = mddev->layout;
1236         sb->chunk_size = mddev->chunk_sectors << 9;
1237
1238         if (mddev->bitmap && mddev->bitmap_info.file == NULL)
1239                 sb->state |= (1<<MD_SB_BITMAP_PRESENT);
1240
1241         sb->disks[0].state = (1<<MD_DISK_REMOVED);
1242         rdev_for_each(rdev2, mddev) {
1243                 mdp_disk_t *d;
1244                 int desc_nr;
1245                 int is_active = test_bit(In_sync, &rdev2->flags);
1246
1247                 if (rdev2->raid_disk >= 0 &&
1248                     sb->minor_version >= 91)
1249                         /* we have nowhere to store the recovery_offset,
1250                          * but if it is not below the reshape_position,
1251                          * we can piggy-back on that.
1252                          */
1253                         is_active = 1;
1254                 if (rdev2->raid_disk < 0 ||
1255                     test_bit(Faulty, &rdev2->flags))
1256                         is_active = 0;
1257                 if (is_active)
1258                         desc_nr = rdev2->raid_disk;
1259                 else
1260                         desc_nr = next_spare++;
1261                 rdev2->desc_nr = desc_nr;
1262                 d = &sb->disks[rdev2->desc_nr];
1263                 nr_disks++;
1264                 d->number = rdev2->desc_nr;
1265                 d->major = MAJOR(rdev2->bdev->bd_dev);
1266                 d->minor = MINOR(rdev2->bdev->bd_dev);
1267                 if (is_active)
1268                         d->raid_disk = rdev2->raid_disk;
1269                 else
1270                         d->raid_disk = rdev2->desc_nr; /* compatibility */
1271                 if (test_bit(Faulty, &rdev2->flags))
1272                         d->state = (1<<MD_DISK_FAULTY);
1273                 else if (is_active) {
1274                         d->state = (1<<MD_DISK_ACTIVE);
1275                         if (test_bit(In_sync, &rdev2->flags))
1276                                 d->state |= (1<<MD_DISK_SYNC);
1277                         active++;
1278                         working++;
1279                 } else {
1280                         d->state = 0;
1281                         spare++;
1282                         working++;
1283                 }
1284                 if (test_bit(WriteMostly, &rdev2->flags))
1285                         d->state |= (1<<MD_DISK_WRITEMOSTLY);
1286         }
1287         /* now set the "removed" and "faulty" bits on any missing devices */
1288         for (i=0 ; i < mddev->raid_disks ; i++) {
1289                 mdp_disk_t *d = &sb->disks[i];
1290                 if (d->state == 0 && d->number == 0) {
1291                         d->number = i;
1292                         d->raid_disk = i;
1293                         d->state = (1<<MD_DISK_REMOVED);
1294                         d->state |= (1<<MD_DISK_FAULTY);
1295                         failed++;
1296                 }
1297         }
1298         sb->nr_disks = nr_disks;
1299         sb->active_disks = active;
1300         sb->working_disks = working;
1301         sb->failed_disks = failed;
1302         sb->spare_disks = spare;
1303
1304         sb->this_disk = sb->disks[rdev->desc_nr];
1305         sb->sb_csum = calc_sb_csum(sb);
1306 }
1307
1308 /*
1309  * rdev_size_change for 0.90.0
1310  */
1311 static unsigned long long
1312 super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1313 {
1314         if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1315                 return 0; /* component must fit device */
1316         if (rdev->mddev->bitmap_info.offset)
1317                 return 0; /* can't move bitmap */
1318         rdev->sb_start = calc_dev_sboffset(rdev);
1319         if (!num_sectors || num_sectors > rdev->sb_start)
1320                 num_sectors = rdev->sb_start;
1321         /* Limit to 4TB as metadata cannot record more than that.
1322          * 4TB == 2^32 KB, or 2*2^32 sectors.
1323          */
1324         if (IS_ENABLED(CONFIG_LBDAF) && (u64)num_sectors >= (2ULL << 32) &&
1325             rdev->mddev->level >= 1)
1326                 num_sectors = (sector_t)(2ULL << 32) - 2;
1327         md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1328                        rdev->sb_page);
1329         md_super_wait(rdev->mddev);
1330         return num_sectors;
1331 }
1332
1333 static int
1334 super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
1335 {
1336         /* non-zero offset changes not possible with v0.90 */
1337         return new_offset == 0;
1338 }
1339
1340 /*
1341  * version 1 superblock
1342  */
1343
1344 static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb)
1345 {
1346         __le32 disk_csum;
1347         u32 csum;
1348         unsigned long long newcsum;
1349         int size = 256 + le32_to_cpu(sb->max_dev)*2;
1350         __le32 *isuper = (__le32*)sb;
1351
1352         disk_csum = sb->sb_csum;
1353         sb->sb_csum = 0;
1354         newcsum = 0;
1355         for (; size >= 4; size -= 4)
1356                 newcsum += le32_to_cpu(*isuper++);
1357
1358         if (size == 2)
1359                 newcsum += le16_to_cpu(*(__le16*) isuper);
1360
1361         csum = (newcsum & 0xffffffff) + (newcsum >> 32);
1362         sb->sb_csum = disk_csum;
1363         return cpu_to_le32(csum);
1364 }
1365
1366 static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
1367 {
1368         struct mdp_superblock_1 *sb;
1369         int ret;
1370         sector_t sb_start;
1371         sector_t sectors;
1372         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
1373         int bmask;
1374
1375         /*
1376          * Calculate the position of the superblock in 512byte sectors.
1377          * It is always aligned to a 4K boundary and
1378          * depeding on minor_version, it can be:
1379          * 0: At least 8K, but less than 12K, from end of device
1380          * 1: At start of device
1381          * 2: 4K from start of device.
1382          */
1383         switch(minor_version) {
1384         case 0:
1385                 sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
1386                 sb_start -= 8*2;
1387                 sb_start &= ~(sector_t)(4*2-1);
1388                 break;
1389         case 1:
1390                 sb_start = 0;
1391                 break;
1392         case 2:
1393                 sb_start = 8;
1394                 break;
1395         default:
1396                 return -EINVAL;
1397         }
1398         rdev->sb_start = sb_start;
1399
1400         /* superblock is rarely larger than 1K, but it can be larger,
1401          * and it is safe to read 4k, so we do that
1402          */
1403         ret = read_disk_sb(rdev, 4096);
1404         if (ret) return ret;
1405
1406         sb = page_address(rdev->sb_page);
1407
1408         if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
1409             sb->major_version != cpu_to_le32(1) ||
1410             le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
1411             le64_to_cpu(sb->super_offset) != rdev->sb_start ||
1412             (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
1413                 return -EINVAL;
1414
1415         if (calc_sb_1_csum(sb) != sb->sb_csum) {
1416                 printk("md: invalid superblock checksum on %s\n",
1417                         bdevname(rdev->bdev,b));
1418                 return -EINVAL;
1419         }
1420         if (le64_to_cpu(sb->data_size) < 10) {
1421                 printk("md: data_size too small on %s\n",
1422                        bdevname(rdev->bdev,b));
1423                 return -EINVAL;
1424         }
1425         if (sb->pad0 ||
1426             sb->pad3[0] ||
1427             memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
1428                 /* Some padding is non-zero, might be a new feature */
1429                 return -EINVAL;
1430
1431         rdev->preferred_minor = 0xffff;
1432         rdev->data_offset = le64_to_cpu(sb->data_offset);
1433         rdev->new_data_offset = rdev->data_offset;
1434         if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
1435             (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
1436                 rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
1437         atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
1438
1439         rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
1440         bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1441         if (rdev->sb_size & bmask)
1442                 rdev->sb_size = (rdev->sb_size | bmask) + 1;
1443
1444         if (minor_version
1445             && rdev->data_offset < sb_start + (rdev->sb_size/512))
1446                 return -EINVAL;
1447         if (minor_version
1448             && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
1449                 return -EINVAL;
1450
1451         if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
1452                 rdev->desc_nr = -1;
1453         else
1454                 rdev->desc_nr = le32_to_cpu(sb->dev_number);
1455
1456         if (!rdev->bb_page) {
1457                 rdev->bb_page = alloc_page(GFP_KERNEL);
1458                 if (!rdev->bb_page)
1459                         return -ENOMEM;
1460         }
1461         if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
1462             rdev->badblocks.count == 0) {
1463                 /* need to load the bad block list.
1464                  * Currently we limit it to one page.
1465                  */
1466                 s32 offset;
1467                 sector_t bb_sector;
1468                 u64 *bbp;
1469                 int i;
1470                 int sectors = le16_to_cpu(sb->bblog_size);
1471                 if (sectors > (PAGE_SIZE / 512))
1472                         return -EINVAL;
1473                 offset = le32_to_cpu(sb->bblog_offset);
1474                 if (offset == 0)
1475                         return -EINVAL;
1476                 bb_sector = (long long)offset;
1477                 if (!sync_page_io(rdev, bb_sector, sectors << 9,
1478                                   rdev->bb_page, REQ_OP_READ, 0, true))
1479                         return -EIO;
1480                 bbp = (u64 *)page_address(rdev->bb_page);
1481                 rdev->badblocks.shift = sb->bblog_shift;
1482                 for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
1483                         u64 bb = le64_to_cpu(*bbp);
1484                         int count = bb & (0x3ff);
1485                         u64 sector = bb >> 10;
1486                         sector <<= sb->bblog_shift;
1487                         count <<= sb->bblog_shift;
1488                         if (bb + 1 == 0)
1489                                 break;
1490                         if (badblocks_set(&rdev->badblocks, sector, count, 1))
1491                                 return -EINVAL;
1492                 }
1493         } else if (sb->bblog_offset != 0)
1494                 rdev->badblocks.shift = 0;
1495
1496         if (!refdev) {
1497                 ret = 1;
1498         } else {
1499                 __u64 ev1, ev2;
1500                 struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
1501
1502                 if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
1503                     sb->level != refsb->level ||
1504                     sb->layout != refsb->layout ||
1505                     sb->chunksize != refsb->chunksize) {
1506                         printk(KERN_WARNING "md: %s has strangely different"
1507                                 " superblock to %s\n",
1508                                 bdevname(rdev->bdev,b),
1509                                 bdevname(refdev->bdev,b2));
1510                         return -EINVAL;
1511                 }
1512                 ev1 = le64_to_cpu(sb->events);
1513                 ev2 = le64_to_cpu(refsb->events);
1514
1515                 if (ev1 > ev2)
1516                         ret = 1;
1517                 else
1518                         ret = 0;
1519         }
1520         if (minor_version) {
1521                 sectors = (i_size_read(rdev->bdev->bd_inode) >> 9);
1522                 sectors -= rdev->data_offset;
1523         } else
1524                 sectors = rdev->sb_start;
1525         if (sectors < le64_to_cpu(sb->data_size))
1526                 return -EINVAL;
1527         rdev->sectors = le64_to_cpu(sb->data_size);
1528         return ret;
1529 }
1530
1531 static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
1532 {
1533         struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
1534         __u64 ev1 = le64_to_cpu(sb->events);
1535
1536         rdev->raid_disk = -1;
1537         clear_bit(Faulty, &rdev->flags);
1538         clear_bit(In_sync, &rdev->flags);
1539         clear_bit(Bitmap_sync, &rdev->flags);
1540         clear_bit(WriteMostly, &rdev->flags);
1541
1542         if (mddev->raid_disks == 0) {
1543                 mddev->major_version = 1;
1544                 mddev->patch_version = 0;
1545                 mddev->external = 0;
1546                 mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
1547                 mddev->ctime = le64_to_cpu(sb->ctime);
1548                 mddev->utime = le64_to_cpu(sb->utime);
1549                 mddev->level = le32_to_cpu(sb->level);
1550                 mddev->clevel[0] = 0;
1551                 mddev->layout = le32_to_cpu(sb->layout);
1552                 mddev->raid_disks = le32_to_cpu(sb->raid_disks);
1553                 mddev->dev_sectors = le64_to_cpu(sb->size);
1554                 mddev->events = ev1;
1555                 mddev->bitmap_info.offset = 0;
1556                 mddev->bitmap_info.space = 0;
1557                 /* Default location for bitmap is 1K after superblock
1558                  * using 3K - total of 4K
1559                  */
1560                 mddev->bitmap_info.default_offset = 1024 >> 9;
1561                 mddev->bitmap_info.default_space = (4096-1024) >> 9;
1562                 mddev->reshape_backwards = 0;
1563
1564                 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
1565                 memcpy(mddev->uuid, sb->set_uuid, 16);
1566
1567                 mddev->max_disks =  (4096-256)/2;
1568
1569                 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
1570                     mddev->bitmap_info.file == NULL) {
1571                         mddev->bitmap_info.offset =
1572                                 (__s32)le32_to_cpu(sb->bitmap_offset);
1573                         /* Metadata doesn't record how much space is available.
1574                          * For 1.0, we assume we can use up to the superblock
1575                          * if before, else to 4K beyond superblock.
1576                          * For others, assume no change is possible.
1577                          */
1578                         if (mddev->minor_version > 0)
1579                                 mddev->bitmap_info.space = 0;
1580                         else if (mddev->bitmap_info.offset > 0)
1581                                 mddev->bitmap_info.space =
1582                                         8 - mddev->bitmap_info.offset;
1583                         else
1584                                 mddev->bitmap_info.space =
1585                                         -mddev->bitmap_info.offset;
1586                 }
1587
1588                 if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
1589                         mddev->reshape_position = le64_to_cpu(sb->reshape_position);
1590                         mddev->delta_disks = le32_to_cpu(sb->delta_disks);
1591                         mddev->new_level = le32_to_cpu(sb->new_level);
1592                         mddev->new_layout = le32_to_cpu(sb->new_layout);
1593                         mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
1594                         if (mddev->delta_disks < 0 ||
1595                             (mddev->delta_disks == 0 &&
1596                              (le32_to_cpu(sb->feature_map)
1597                               & MD_FEATURE_RESHAPE_BACKWARDS)))
1598                                 mddev->reshape_backwards = 1;
1599                 } else {
1600                         mddev->reshape_position = MaxSector;
1601                         mddev->delta_disks = 0;
1602                         mddev->new_level = mddev->level;
1603                         mddev->new_layout = mddev->layout;
1604                         mddev->new_chunk_sectors = mddev->chunk_sectors;
1605                 }
1606
1607                 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL) {
1608                         set_bit(MD_HAS_JOURNAL, &mddev->flags);
1609                         if (mddev->recovery_cp == MaxSector)
1610                                 set_bit(MD_JOURNAL_CLEAN, &mddev->flags);
1611                 }
1612         } else if (mddev->pers == NULL) {
1613                 /* Insist of good event counter while assembling, except for
1614                  * spares (which don't need an event count) */
1615                 ++ev1;
1616                 if (rdev->desc_nr >= 0 &&
1617                     rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
1618                     (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
1619                      le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL))
1620                         if (ev1 < mddev->events)
1621                                 return -EINVAL;
1622         } else if (mddev->bitmap) {
1623                 /* If adding to array with a bitmap, then we can accept an
1624                  * older device, but not too old.
1625                  */
1626                 if (ev1 < mddev->bitmap->events_cleared)
1627                         return 0;
1628                 if (ev1 < mddev->events)
1629                         set_bit(Bitmap_sync, &rdev->flags);
1630         } else {
1631                 if (ev1 < mddev->events)
1632                         /* just a hot-add of a new device, leave raid_disk at -1 */
1633                         return 0;
1634         }
1635         if (mddev->level != LEVEL_MULTIPATH) {
1636                 int role;
1637                 if (rdev->desc_nr < 0 ||
1638                     rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
1639                         role = MD_DISK_ROLE_SPARE;
1640                         rdev->desc_nr = -1;
1641                 } else
1642                         role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
1643                 switch(role) {
1644                 case MD_DISK_ROLE_SPARE: /* spare */
1645                         break;
1646                 case MD_DISK_ROLE_FAULTY: /* faulty */
1647                         set_bit(Faulty, &rdev->flags);
1648                         break;
1649                 case MD_DISK_ROLE_JOURNAL: /* journal device */
1650                         if (!(le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)) {
1651                                 /* journal device without journal feature */
1652                                 printk(KERN_WARNING
1653                                   "md: journal device provided without journal feature, ignoring the device\n");
1654                                 return -EINVAL;
1655                         }
1656                         set_bit(Journal, &rdev->flags);
1657                         rdev->journal_tail = le64_to_cpu(sb->journal_tail);
1658                         rdev->raid_disk = 0;
1659                         break;
1660                 default:
1661                         rdev->saved_raid_disk = role;
1662                         if ((le32_to_cpu(sb->feature_map) &
1663                              MD_FEATURE_RECOVERY_OFFSET)) {
1664                                 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
1665                                 if (!(le32_to_cpu(sb->feature_map) &
1666                                       MD_FEATURE_RECOVERY_BITMAP))
1667                                         rdev->saved_raid_disk = -1;
1668                         } else
1669                                 set_bit(In_sync, &rdev->flags);
1670                         rdev->raid_disk = role;
1671                         break;
1672                 }
1673                 if (sb->devflags & WriteMostly1)
1674                         set_bit(WriteMostly, &rdev->flags);
1675                 if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
1676                         set_bit(Replacement, &rdev->flags);
1677         } else /* MULTIPATH are always insync */
1678                 set_bit(In_sync, &rdev->flags);
1679
1680         return 0;
1681 }
1682
1683 static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
1684 {
1685         struct mdp_superblock_1 *sb;
1686         struct md_rdev *rdev2;
1687         int max_dev, i;
1688         /* make rdev->sb match mddev and rdev data. */
1689
1690         sb = page_address(rdev->sb_page);
1691
1692         sb->feature_map = 0;
1693         sb->pad0 = 0;
1694         sb->recovery_offset = cpu_to_le64(0);
1695         memset(sb->pad3, 0, sizeof(sb->pad3));
1696
1697         sb->utime = cpu_to_le64((__u64)mddev->utime);
1698         sb->events = cpu_to_le64(mddev->events);
1699         if (mddev->in_sync)
1700                 sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
1701         else if (test_bit(MD_JOURNAL_CLEAN, &mddev->flags))
1702                 sb->resync_offset = cpu_to_le64(MaxSector);
1703         else
1704                 sb->resync_offset = cpu_to_le64(0);
1705
1706         sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
1707
1708         sb->raid_disks = cpu_to_le32(mddev->raid_disks);
1709         sb->size = cpu_to_le64(mddev->dev_sectors);
1710         sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
1711         sb->level = cpu_to_le32(mddev->level);
1712         sb->layout = cpu_to_le32(mddev->layout);
1713
1714         if (test_bit(WriteMostly, &rdev->flags))
1715                 sb->devflags |= WriteMostly1;
1716         else
1717                 sb->devflags &= ~WriteMostly1;
1718         sb->data_offset = cpu_to_le64(rdev->data_offset);
1719         sb->data_size = cpu_to_le64(rdev->sectors);
1720
1721         if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
1722                 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
1723                 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
1724         }
1725
1726         if (rdev->raid_disk >= 0 && !test_bit(Journal, &rdev->flags) &&
1727             !test_bit(In_sync, &rdev->flags)) {
1728                 sb->feature_map |=
1729                         cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
1730                 sb->recovery_offset =
1731                         cpu_to_le64(rdev->recovery_offset);
1732                 if (rdev->saved_raid_disk >= 0 && mddev->bitmap)
1733                         sb->feature_map |=
1734                                 cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP);
1735         }
1736         /* Note: recovery_offset and journal_tail share space  */
1737         if (test_bit(Journal, &rdev->flags))
1738                 sb->journal_tail = cpu_to_le64(rdev->journal_tail);
1739         if (test_bit(Replacement, &rdev->flags))
1740                 sb->feature_map |=
1741                         cpu_to_le32(MD_FEATURE_REPLACEMENT);
1742
1743         if (mddev->reshape_position != MaxSector) {
1744                 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
1745                 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1746                 sb->new_layout = cpu_to_le32(mddev->new_layout);
1747                 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1748                 sb->new_level = cpu_to_le32(mddev->new_level);
1749                 sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
1750                 if (mddev->delta_disks == 0 &&
1751                     mddev->reshape_backwards)
1752                         sb->feature_map
1753                                 |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
1754                 if (rdev->new_data_offset != rdev->data_offset) {
1755                         sb->feature_map
1756                                 |= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
1757                         sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
1758                                                              - rdev->data_offset));
1759                 }
1760         }
1761
1762         if (mddev_is_clustered(mddev))
1763                 sb->feature_map |= cpu_to_le32(MD_FEATURE_CLUSTERED);
1764
1765         if (rdev->badblocks.count == 0)
1766                 /* Nothing to do for bad blocks*/ ;
1767         else if (sb->bblog_offset == 0)
1768                 /* Cannot record bad blocks on this device */
1769                 md_error(mddev, rdev);
1770         else {
1771                 struct badblocks *bb = &rdev->badblocks;
1772                 u64 *bbp = (u64 *)page_address(rdev->bb_page);
1773                 u64 *p = bb->page;
1774                 sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
1775                 if (bb->changed) {
1776                         unsigned seq;
1777
1778 retry:
1779                         seq = read_seqbegin(&bb->lock);
1780
1781                         memset(bbp, 0xff, PAGE_SIZE);
1782
1783                         for (i = 0 ; i < bb->count ; i++) {
1784                                 u64 internal_bb = p[i];
1785                                 u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
1786                                                 | BB_LEN(internal_bb));
1787                                 bbp[i] = cpu_to_le64(store_bb);
1788                         }
1789                         bb->changed = 0;
1790                         if (read_seqretry(&bb->lock, seq))
1791                                 goto retry;
1792
1793                         bb->sector = (rdev->sb_start +
1794                                       (int)le32_to_cpu(sb->bblog_offset));
1795                         bb->size = le16_to_cpu(sb->bblog_size);
1796                 }
1797         }
1798
1799         max_dev = 0;
1800         rdev_for_each(rdev2, mddev)
1801                 if (rdev2->desc_nr+1 > max_dev)
1802                         max_dev = rdev2->desc_nr+1;
1803
1804         if (max_dev > le32_to_cpu(sb->max_dev)) {
1805                 int bmask;
1806                 sb->max_dev = cpu_to_le32(max_dev);
1807                 rdev->sb_size = max_dev * 2 + 256;
1808                 bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
1809                 if (rdev->sb_size & bmask)
1810                         rdev->sb_size = (rdev->sb_size | bmask) + 1;
1811         } else
1812                 max_dev = le32_to_cpu(sb->max_dev);
1813
1814         for (i=0; i<max_dev;i++)
1815                 sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY);
1816
1817         if (test_bit(MD_HAS_JOURNAL, &mddev->flags))
1818                 sb->feature_map |= cpu_to_le32(MD_FEATURE_JOURNAL);
1819
1820         rdev_for_each(rdev2, mddev) {
1821                 i = rdev2->desc_nr;
1822                 if (test_bit(Faulty, &rdev2->flags))
1823                         sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY);
1824                 else if (test_bit(In_sync, &rdev2->flags))
1825                         sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1826                 else if (test_bit(Journal, &rdev2->flags))
1827                         sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_JOURNAL);
1828                 else if (rdev2->raid_disk >= 0)
1829                         sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1830                 else
1831                         sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
1832         }
1833
1834         sb->sb_csum = calc_sb_1_csum(sb);
1835 }
1836
1837 static unsigned long long
1838 super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
1839 {
1840         struct mdp_superblock_1 *sb;
1841         sector_t max_sectors;
1842         if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
1843                 return 0; /* component must fit device */
1844         if (rdev->data_offset != rdev->new_data_offset)
1845                 return 0; /* too confusing */
1846         if (rdev->sb_start < rdev->data_offset) {
1847                 /* minor versions 1 and 2; superblock before data */
1848                 max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
1849                 max_sectors -= rdev->data_offset;
1850                 if (!num_sectors || num_sectors > max_sectors)
1851                         num_sectors = max_sectors;
1852         } else if (rdev->mddev->bitmap_info.offset) {
1853                 /* minor version 0 with bitmap we can't move */
1854                 return 0;
1855         } else {
1856                 /* minor version 0; superblock after data */
1857                 sector_t sb_start;
1858                 sb_start = (i_size_read(rdev->bdev->bd_inode) >> 9) - 8*2;
1859                 sb_start &= ~(sector_t)(4*2 - 1);
1860                 max_sectors = rdev->sectors + sb_start - rdev->sb_start;
1861                 if (!num_sectors || num_sectors > max_sectors)
1862                         num_sectors = max_sectors;
1863                 rdev->sb_start = sb_start;
1864         }
1865         sb = page_address(rdev->sb_page);
1866         sb->data_size = cpu_to_le64(num_sectors);
1867         sb->super_offset = rdev->sb_start;
1868         sb->sb_csum = calc_sb_1_csum(sb);
1869         md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1870                        rdev->sb_page);
1871         md_super_wait(rdev->mddev);
1872         return num_sectors;
1873
1874 }
1875
1876 static int
1877 super_1_allow_new_offset(struct md_rdev *rdev,
1878                          unsigned long long new_offset)
1879 {
1880         /* All necessary checks on new >= old have been done */
1881         struct bitmap *bitmap;
1882         if (new_offset >= rdev->data_offset)
1883                 return 1;
1884
1885         /* with 1.0 metadata, there is no metadata to tread on
1886          * so we can always move back */
1887         if (rdev->mddev->minor_version == 0)
1888                 return 1;
1889
1890         /* otherwise we must be sure not to step on
1891          * any metadata, so stay:
1892          * 36K beyond start of superblock
1893          * beyond end of badblocks
1894          * beyond write-intent bitmap
1895          */
1896         if (rdev->sb_start + (32+4)*2 > new_offset)
1897                 return 0;
1898         bitmap = rdev->mddev->bitmap;
1899         if (bitmap && !rdev->mddev->bitmap_info.file &&
1900             rdev->sb_start + rdev->mddev->bitmap_info.offset +
1901             bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
1902                 return 0;
1903         if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
1904                 return 0;
1905
1906         return 1;
1907 }
1908
1909 static struct super_type super_types[] = {
1910         [0] = {
1911                 .name   = "0.90.0",
1912                 .owner  = THIS_MODULE,
1913                 .load_super         = super_90_load,
1914                 .validate_super     = super_90_validate,
1915                 .sync_super         = super_90_sync,
1916                 .rdev_size_change   = super_90_rdev_size_change,
1917                 .allow_new_offset   = super_90_allow_new_offset,
1918         },
1919         [1] = {
1920                 .name   = "md-1",
1921                 .owner  = THIS_MODULE,
1922                 .load_super         = super_1_load,
1923                 .validate_super     = super_1_validate,
1924                 .sync_super         = super_1_sync,
1925                 .rdev_size_change   = super_1_rdev_size_change,
1926                 .allow_new_offset   = super_1_allow_new_offset,
1927         },
1928 };
1929
1930 static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
1931 {
1932         if (mddev->sync_super) {
1933                 mddev->sync_super(mddev, rdev);
1934                 return;
1935         }
1936
1937         BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));
1938
1939         super_types[mddev->major_version].sync_super(mddev, rdev);
1940 }
1941
1942 static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
1943 {
1944         struct md_rdev *rdev, *rdev2;
1945
1946         rcu_read_lock();
1947         rdev_for_each_rcu(rdev, mddev1) {
1948                 if (test_bit(Faulty, &rdev->flags) ||
1949                     test_bit(Journal, &rdev->flags) ||
1950                     rdev->raid_disk == -1)
1951                         continue;
1952                 rdev_for_each_rcu(rdev2, mddev2) {
1953                         if (test_bit(Faulty, &rdev2->flags) ||
1954                             test_bit(Journal, &rdev2->flags) ||
1955                             rdev2->raid_disk == -1)
1956                                 continue;
1957                         if (rdev->bdev->bd_contains ==
1958                             rdev2->bdev->bd_contains) {
1959                                 rcu_read_unlock();
1960                                 return 1;
1961                         }
1962                 }
1963         }
1964         rcu_read_unlock();
1965         return 0;
1966 }
1967
1968 static LIST_HEAD(pending_raid_disks);
1969
1970 /*
1971  * Try to register data integrity profile for an mddev
1972  *
1973  * This is called when an array is started and after a disk has been kicked
1974  * from the array. It only succeeds if all working and active component devices
1975  * are integrity capable with matching profiles.
1976  */
1977 int md_integrity_register(struct mddev *mddev)
1978 {
1979         struct md_rdev *rdev, *reference = NULL;
1980
1981         if (list_empty(&mddev->disks))
1982                 return 0; /* nothing to do */
1983         if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
1984                 return 0; /* shouldn't register, or already is */
1985         rdev_for_each(rdev, mddev) {
1986                 /* skip spares and non-functional disks */
1987                 if (test_bit(Faulty, &rdev->flags))
1988                         continue;
1989                 if (rdev->raid_disk < 0)
1990                         continue;
1991                 if (!reference) {
1992                         /* Use the first rdev as the reference */
1993                         reference = rdev;
1994                         continue;
1995                 }
1996                 /* does this rdev's profile match the reference profile? */
1997                 if (blk_integrity_compare(reference->bdev->bd_disk,
1998                                 rdev->bdev->bd_disk) < 0)
1999                         return -EINVAL;
2000         }
2001         if (!reference || !bdev_get_integrity(reference->bdev))
2002                 return 0;
2003         /*
2004          * All component devices are integrity capable and have matching
2005          * profiles, register the common profile for the md device.
2006          */
2007         blk_integrity_register(mddev->gendisk,
2008                                bdev_get_integrity(reference->bdev));
2009
2010         printk(KERN_NOTICE "md: data integrity enabled on %s\n", mdname(mddev));
2011         if (bioset_integrity_create(mddev->bio_set, BIO_POOL_SIZE)) {
2012                 printk(KERN_ERR "md: failed to create integrity pool for %s\n",
2013                        mdname(mddev));
2014                 return -EINVAL;
2015         }
2016         return 0;
2017 }
2018 EXPORT_SYMBOL(md_integrity_register);
2019
2020 /*
2021  * Attempt to add an rdev, but only if it is consistent with the current
2022  * integrity profile
2023  */
2024 int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
2025 {
2026         struct blk_integrity *bi_rdev;
2027         struct blk_integrity *bi_mddev;
2028         char name[BDEVNAME_SIZE];
2029
2030         if (!mddev->gendisk)
2031                 return 0;
2032
2033         bi_rdev = bdev_get_integrity(rdev->bdev);
2034         bi_mddev = blk_get_integrity(mddev->gendisk);
2035
2036         if (!bi_mddev) /* nothing to do */
2037                 return 0;
2038
2039         if (blk_integrity_compare(mddev->gendisk, rdev->bdev->bd_disk) != 0) {
2040                 printk(KERN_NOTICE "%s: incompatible integrity profile for %s\n",
2041                                 mdname(mddev), bdevname(rdev->bdev, name));
2042                 return -ENXIO;
2043         }
2044
2045         return 0;
2046 }
2047 EXPORT_SYMBOL(md_integrity_add_rdev);
2048
2049 static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)
2050 {
2051         char b[BDEVNAME_SIZE];
2052         struct kobject *ko;
2053         int err;
2054
2055         /* prevent duplicates */
2056         if (find_rdev(mddev, rdev->bdev->bd_dev))
2057                 return -EEXIST;
2058
2059         /* make sure rdev->sectors exceeds mddev->dev_sectors */
2060         if (!test_bit(Journal, &rdev->flags) &&
2061             rdev->sectors &&
2062             (mddev->dev_sectors == 0 || rdev->sectors < mddev->dev_sectors)) {
2063                 if (mddev->pers) {
2064                         /* Cannot change size, so fail
2065                          * If mddev->level <= 0, then we don't care
2066                          * about aligning sizes (e.g. linear)
2067                          */
2068                         if (mddev->level > 0)
2069                                 return -ENOSPC;
2070                 } else
2071                         mddev->dev_sectors = rdev->sectors;
2072         }
2073
2074         /* Verify rdev->desc_nr is unique.
2075          * If it is -1, assign a free number, else
2076          * check number is not in use
2077          */
2078         rcu_read_lock();
2079         if (rdev->desc_nr < 0) {
2080                 int choice = 0;
2081                 if (mddev->pers)
2082                         choice = mddev->raid_disks;
2083                 while (md_find_rdev_nr_rcu(mddev, choice))
2084                         choice++;
2085                 rdev->desc_nr = choice;
2086         } else {
2087                 if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) {
2088                         rcu_read_unlock();
2089                         return -EBUSY;
2090                 }
2091         }
2092         rcu_read_unlock();
2093         if (!test_bit(Journal, &rdev->flags) &&
2094             mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
2095                 printk(KERN_WARNING "md: %s: array is limited to %d devices\n",
2096                        mdname(mddev), mddev->max_disks);
2097                 return -EBUSY;
2098         }
2099         bdevname(rdev->bdev,b);
2100         strreplace(b, '/', '!');
2101
2102         rdev->mddev = mddev;
2103         printk(KERN_INFO "md: bind<%s>\n", b);
2104
2105         if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
2106                 goto fail;
2107
2108         ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
2109         if (sysfs_create_link(&rdev->kobj, ko, "block"))
2110                 /* failure here is OK */;
2111         rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
2112
2113         list_add_rcu(&rdev->same_set, &mddev->disks);
2114         bd_link_disk_holder(rdev->bdev, mddev->gendisk);
2115
2116         /* May as well allow recovery to be retried once */
2117         mddev->recovery_disabled++;
2118
2119         return 0;
2120
2121  fail:
2122         printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
2123                b, mdname(mddev));
2124         return err;
2125 }
2126
2127 static void md_delayed_delete(struct work_struct *ws)
2128 {
2129         struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
2130         kobject_del(&rdev->kobj);
2131         kobject_put(&rdev->kobj);
2132 }
2133
2134 static void unbind_rdev_from_array(struct md_rdev *rdev)
2135 {
2136         char b[BDEVNAME_SIZE];
2137
2138         bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
2139         list_del_rcu(&rdev->same_set);
2140         printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
2141         rdev->mddev = NULL;
2142         sysfs_remove_link(&rdev->kobj, "block");
2143         sysfs_put(rdev->sysfs_state);
2144         rdev->sysfs_state = NULL;
2145         rdev->badblocks.count = 0;
2146         /* We need to delay this, otherwise we can deadlock when
2147          * writing to 'remove' to "dev/state".  We also need
2148          * to delay it due to rcu usage.
2149          */
2150         synchronize_rcu();
2151         INIT_WORK(&rdev->del_work, md_delayed_delete);
2152         kobject_get(&rdev->kobj);
2153         queue_work(md_misc_wq, &rdev->del_work);
2154 }
2155
2156 /*
2157  * prevent the device from being mounted, repartitioned or
2158  * otherwise reused by a RAID array (or any other kernel
2159  * subsystem), by bd_claiming the device.
2160  */
2161 static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
2162 {
2163         int err = 0;
2164         struct block_device *bdev;
2165         char b[BDEVNAME_SIZE];
2166
2167         bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
2168                                  shared ? (struct md_rdev *)lock_rdev : rdev);
2169         if (IS_ERR(bdev)) {
2170                 printk(KERN_ERR "md: could not open %s.\n",
2171                         __bdevname(dev, b));
2172                 return PTR_ERR(bdev);
2173         }
2174         rdev->bdev = bdev;
2175         return err;
2176 }
2177
2178 static void unlock_rdev(struct md_rdev *rdev)
2179 {
2180         struct block_device *bdev = rdev->bdev;
2181         rdev->bdev = NULL;
2182         blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
2183 }
2184
2185 void md_autodetect_dev(dev_t dev);
2186
2187 static void export_rdev(struct md_rdev *rdev)
2188 {
2189         char b[BDEVNAME_SIZE];
2190
2191         printk(KERN_INFO "md: export_rdev(%s)\n",
2192                 bdevname(rdev->bdev,b));
2193         md_rdev_clear(rdev);
2194 #ifndef MODULE
2195         if (test_bit(AutoDetected, &rdev->flags))
2196                 md_autodetect_dev(rdev->bdev->bd_dev);
2197 #endif
2198         unlock_rdev(rdev);
2199         kobject_put(&rdev->kobj);
2200 }
2201
2202 void md_kick_rdev_from_array(struct md_rdev *rdev)
2203 {
2204         unbind_rdev_from_array(rdev);
2205         export_rdev(rdev);
2206 }
2207 EXPORT_SYMBOL_GPL(md_kick_rdev_from_array);
2208
2209 static void export_array(struct mddev *mddev)
2210 {
2211         struct md_rdev *rdev;
2212
2213         while (!list_empty(&mddev->disks)) {
2214                 rdev = list_first_entry(&mddev->disks, struct md_rdev,
2215                                         same_set);
2216                 md_kick_rdev_from_array(rdev);
2217         }
2218         mddev->raid_disks = 0;
2219         mddev->major_version = 0;
2220 }
2221
2222 static void sync_sbs(struct mddev *mddev, int nospares)
2223 {
2224         /* Update each superblock (in-memory image), but
2225          * if we are allowed to, skip spares which already
2226          * have the right event counter, or have one earlier
2227          * (which would mean they aren't being marked as dirty
2228          * with the rest of the array)
2229          */
2230         struct md_rdev *rdev;
2231         rdev_for_each(rdev, mddev) {
2232                 if (rdev->sb_events == mddev->events ||
2233                     (nospares &&
2234                      rdev->raid_disk < 0 &&
2235                      rdev->sb_events+1 == mddev->events)) {
2236                         /* Don't update this superblock */
2237                         rdev->sb_loaded = 2;
2238                 } else {
2239                         sync_super(mddev, rdev);
2240                         rdev->sb_loaded = 1;
2241                 }
2242         }
2243 }
2244
2245 static bool does_sb_need_changing(struct mddev *mddev)
2246 {
2247         struct md_rdev *rdev;
2248         struct mdp_superblock_1 *sb;
2249         int role;
2250
2251         /* Find a good rdev */
2252         rdev_for_each(rdev, mddev)
2253                 if ((rdev->raid_disk >= 0) && !test_bit(Faulty, &rdev->flags))
2254                         break;
2255
2256         /* No good device found. */
2257         if (!rdev)
2258                 return false;
2259
2260         sb = page_address(rdev->sb_page);
2261         /* Check if a device has become faulty or a spare become active */
2262         rdev_for_each(rdev, mddev) {
2263                 role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
2264                 /* Device activated? */
2265                 if (role == 0xffff && rdev->raid_disk >=0 &&
2266                     !test_bit(Faulty, &rdev->flags))
2267                         return true;
2268                 /* Device turned faulty? */
2269                 if (test_bit(Faulty, &rdev->flags) && (role < 0xfffd))
2270                         return true;
2271         }
2272
2273         /* Check if any mddev parameters have changed */
2274         if ((mddev->dev_sectors != le64_to_cpu(sb->size)) ||
2275             (mddev->reshape_position != le64_to_cpu(sb->reshape_position)) ||
2276             (mddev->layout != le64_to_cpu(sb->layout)) ||
2277             (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) ||
2278             (mddev->chunk_sectors != le32_to_cpu(sb->chunksize)))
2279                 return true;
2280
2281         return false;
2282 }
2283
2284 void md_update_sb(struct mddev *mddev, int force_change)
2285 {
2286         struct md_rdev *rdev;
2287         int sync_req;
2288         int nospares = 0;
2289         int any_badblocks_changed = 0;
2290         int ret = -1;
2291
2292         if (mddev->ro) {
2293                 if (force_change)
2294                         set_bit(MD_CHANGE_DEVS, &mddev->flags);
2295                 return;
2296         }
2297
2298 repeat:
2299         if (mddev_is_clustered(mddev)) {
2300                 if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2301                         force_change = 1;
2302                 if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
2303                         nospares = 1;
2304                 ret = md_cluster_ops->metadata_update_start(mddev);
2305                 /* Has someone else has updated the sb */
2306                 if (!does_sb_need_changing(mddev)) {
2307                         if (ret == 0)
2308                                 md_cluster_ops->metadata_update_cancel(mddev);
2309                         bit_clear_unless(&mddev->flags, BIT(MD_CHANGE_PENDING),
2310                                                          BIT(MD_CHANGE_DEVS) |
2311                                                          BIT(MD_CHANGE_CLEAN));
2312                         return;
2313                 }
2314         }
2315
2316         /* First make sure individual recovery_offsets are correct */
2317         rdev_for_each(rdev, mddev) {
2318                 if (rdev->raid_disk >= 0 &&
2319                     mddev->delta_disks >= 0 &&
2320                     !test_bit(Journal, &rdev->flags) &&
2321                     !test_bit(In_sync, &rdev->flags) &&
2322                     mddev->curr_resync_completed > rdev->recovery_offset)
2323                                 rdev->recovery_offset = mddev->curr_resync_completed;
2324
2325         }
2326         if (!mddev->persistent) {
2327                 clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2328                 clear_bit(MD_CHANGE_DEVS, &mddev->flags);
2329                 if (!mddev->external) {
2330                         clear_bit(MD_CHANGE_PENDING, &mddev->flags);
2331                         rdev_for_each(rdev, mddev) {
2332                                 if (rdev->badblocks.changed) {
2333                                         rdev->badblocks.changed = 0;
2334                                         ack_all_badblocks(&rdev->badblocks);
2335                                         md_error(mddev, rdev);
2336                                 }
2337                                 clear_bit(Blocked, &rdev->flags);
2338                                 clear_bit(BlockedBadBlocks, &rdev->flags);
2339                                 wake_up(&rdev->blocked_wait);
2340                         }
2341                 }
2342                 wake_up(&mddev->sb_wait);
2343                 return;
2344         }
2345
2346         spin_lock(&mddev->lock);
2347
2348         mddev->utime = ktime_get_real_seconds();
2349
2350         if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
2351                 force_change = 1;
2352         if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
2353                 /* just a clean<-> dirty transition, possibly leave spares alone,
2354                  * though if events isn't the right even/odd, we will have to do
2355                  * spares after all
2356                  */
2357                 nospares = 1;
2358         if (force_change)
2359                 nospares = 0;
2360         if (mddev->degraded)
2361                 /* If the array is degraded, then skipping spares is both
2362                  * dangerous and fairly pointless.
2363                  * Dangerous because a device that was removed from the array
2364                  * might have a event_count that still looks up-to-date,
2365                  * so it can be re-added without a resync.
2366                  * Pointless because if there are any spares to skip,
2367                  * then a recovery will happen and soon that array won't
2368                  * be degraded any more and the spare can go back to sleep then.
2369                  */
2370                 nospares = 0;
2371
2372         sync_req = mddev->in_sync;
2373
2374         /* If this is just a dirty<->clean transition, and the array is clean
2375          * and 'events' is odd, we can roll back to the previous clean state */
2376         if (nospares
2377             && (mddev->in_sync && mddev->recovery_cp == MaxSector)
2378             && mddev->can_decrease_events
2379             && mddev->events != 1) {
2380                 mddev->events--;
2381                 mddev->can_decrease_events = 0;
2382         } else {
2383                 /* otherwise we have to go forward and ... */
2384                 mddev->events ++;
2385                 mddev->can_decrease_events = nospares;
2386         }
2387
2388         /*
2389          * This 64-bit counter should never wrap.
2390          * Either we are in around ~1 trillion A.C., assuming
2391          * 1 reboot per second, or we have a bug...
2392          */
2393         WARN_ON(mddev->events == 0);
2394
2395         rdev_for_each(rdev, mddev) {
2396                 if (rdev->badblocks.changed)
2397                         any_badblocks_changed++;
2398                 if (test_bit(Faulty, &rdev->flags))
2399                         set_bit(FaultRecorded, &rdev->flags);
2400         }
2401
2402         sync_sbs(mddev, nospares);
2403         spin_unlock(&mddev->lock);
2404
2405         pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
2406                  mdname(mddev), mddev->in_sync);
2407
2408         bitmap_update_sb(mddev->bitmap);
2409         rdev_for_each(rdev, mddev) {
2410                 char b[BDEVNAME_SIZE];
2411
2412                 if (rdev->sb_loaded != 1)
2413                         continue; /* no noise on spare devices */
2414
2415                 if (!test_bit(Faulty, &rdev->flags)) {
2416                         md_super_write(mddev,rdev,
2417                                        rdev->sb_start, rdev->sb_size,
2418                                        rdev->sb_page);
2419                         pr_debug("md: (write) %s's sb offset: %llu\n",
2420                                  bdevname(rdev->bdev, b),
2421                                  (unsigned long long)rdev->sb_start);
2422                         rdev->sb_events = mddev->events;
2423                         if (rdev->badblocks.size) {
2424                                 md_super_write(mddev, rdev,
2425                                                rdev->badblocks.sector,
2426                                                rdev->badblocks.size << 9,
2427                                                rdev->bb_page);
2428                                 rdev->badblocks.size = 0;
2429                         }
2430
2431                 } else
2432                         pr_debug("md: %s (skipping faulty)\n",
2433                                  bdevname(rdev->bdev, b));
2434
2435                 if (mddev->level == LEVEL_MULTIPATH)
2436                         /* only need to write one superblock... */
2437                         break;
2438         }
2439         md_super_wait(mddev);
2440         /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
2441
2442         if (mddev_is_clustered(mddev) && ret == 0)
2443                 md_cluster_ops->metadata_update_finish(mddev);
2444
2445         if (mddev->in_sync != sync_req ||
2446             !bit_clear_unless(&mddev->flags, BIT(MD_CHANGE_PENDING),
2447                                BIT(MD_CHANGE_DEVS) | BIT(MD_CHANGE_CLEAN)))
2448                 /* have to write it out again */
2449                 goto repeat;
2450         wake_up(&mddev->sb_wait);
2451         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
2452                 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
2453
2454         rdev_for_each(rdev, mddev) {
2455                 if (test_and_clear_bit(FaultRecorded, &rdev->flags))
2456                         clear_bit(Blocked, &rdev->flags);
2457
2458                 if (any_badblocks_changed)
2459                         ack_all_badblocks(&rdev->badblocks);
2460                 clear_bit(BlockedBadBlocks, &rdev->flags);
2461                 wake_up(&rdev->blocked_wait);
2462         }
2463 }
2464 EXPORT_SYMBOL(md_update_sb);
2465
2466 static int add_bound_rdev(struct md_rdev *rdev)
2467 {
2468         struct mddev *mddev = rdev->mddev;
2469         int err = 0;
2470         bool add_journal = test_bit(Journal, &rdev->flags);
2471
2472         if (!mddev->pers->hot_remove_disk || add_journal) {
2473                 /* If there is hot_add_disk but no hot_remove_disk
2474                  * then added disks for geometry changes,
2475                  * and should be added immediately.
2476                  */
2477                 super_types[mddev->major_version].
2478                         validate_super(mddev, rdev);
2479                 if (add_journal)
2480                         mddev_suspend(mddev);
2481                 err = mddev->pers->hot_add_disk(mddev, rdev);
2482                 if (add_journal)
2483                         mddev_resume(mddev);
2484                 if (err) {
2485                         unbind_rdev_from_array(rdev);
2486                         export_rdev(rdev);
2487                         return err;
2488                 }
2489         }
2490         sysfs_notify_dirent_safe(rdev->sysfs_state);
2491
2492         set_bit(MD_CHANGE_DEVS, &mddev->flags);
2493         if (mddev->degraded)
2494                 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
2495         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
2496         md_new_event(mddev);
2497         md_wakeup_thread(mddev->thread);
2498         return 0;
2499 }
2500
2501 /* words written to sysfs files may, or may not, be \n terminated.
2502  * We want to accept with case. For this we use cmd_match.
2503  */
2504 static int cmd_match(const char *cmd, const char *str)
2505 {
2506         /* See if cmd, written into a sysfs file, matches
2507          * str.  They must either be the same, or cmd can
2508          * have a trailing newline
2509          */
2510         while (*cmd && *str && *cmd == *str) {
2511                 cmd++;
2512                 str++;
2513         }
2514         if (*cmd == '\n')
2515                 cmd++;
2516         if (*str || *cmd)
2517                 return 0;
2518         return 1;
2519 }
2520
2521 struct rdev_sysfs_entry {
2522         struct attribute attr;
2523         ssize_t (*show)(struct md_rdev *, char *);
2524         ssize_t (*store)(struct md_rdev *, const char *, size_t);
2525 };
2526
2527 static ssize_t
2528 state_show(struct md_rdev *rdev, char *page)
2529 {
2530         char *sep = "";
2531         size_t len = 0;
2532         unsigned long flags = ACCESS_ONCE(rdev->flags);
2533
2534         if (test_bit(Faulty, &flags) ||
2535             rdev->badblocks.unacked_exist) {
2536                 len+= sprintf(page+len, "%sfaulty",sep);
2537                 sep = ",";
2538         }
2539         if (test_bit(In_sync, &flags)) {
2540                 len += sprintf(page+len, "%sin_sync",sep);
2541                 sep = ",";
2542         }
2543         if (test_bit(Journal, &flags)) {
2544                 len += sprintf(page+len, "%sjournal",sep);
2545                 sep = ",";
2546         }
2547         if (test_bit(WriteMostly, &flags)) {
2548                 len += sprintf(page+len, "%swrite_mostly",sep);
2549                 sep = ",";
2550         }
2551         if (test_bit(Blocked, &flags) ||
2552             (rdev->badblocks.unacked_exist
2553              && !test_bit(Faulty, &flags))) {
2554                 len += sprintf(page+len, "%sblocked", sep);
2555                 sep = ",";
2556         }
2557         if (!test_bit(Faulty, &flags) &&
2558             !test_bit(Journal, &flags) &&
2559             !test_bit(In_sync, &flags)) {
2560                 len += sprintf(page+len, "%sspare", sep);
2561                 sep = ",";
2562         }
2563         if (test_bit(WriteErrorSeen, &flags)) {
2564                 len += sprintf(page+len, "%swrite_error", sep);
2565                 sep = ",";
2566         }
2567         if (test_bit(WantReplacement, &flags)) {
2568                 len += sprintf(page+len, "%swant_replacement", sep);
2569                 sep = ",";
2570         }
2571         if (test_bit(Replacement, &flags)) {
2572                 len += sprintf(page+len, "%sreplacement", sep);
2573                 sep = ",";
2574         }
2575
2576         return len+sprintf(page+len, "\n");
2577 }
2578
2579 static ssize_t
2580 state_store(struct md_rdev *rdev, const char *buf, size_t len)
2581 {
2582         /* can write
2583          *  faulty  - simulates an error
2584          *  remove  - disconnects the device
2585          *  writemostly - sets write_mostly
2586          *  -writemostly - clears write_mostly
2587          *  blocked - sets the Blocked flags
2588          *  -blocked - clears the Blocked and possibly simulates an error
2589          *  insync - sets Insync providing device isn't active
2590          *  -insync - clear Insync for a device with a slot assigned,
2591          *            so that it gets rebuilt based on bitmap
2592          *  write_error - sets WriteErrorSeen
2593          *  -write_error - clears WriteErrorSeen
2594          */
2595         int err = -EINVAL;
2596         if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2597                 md_error(rdev->mddev, rdev);
2598                 if (test_bit(Faulty, &rdev->flags))
2599                         err = 0;
2600                 else
2601                         err = -EBUSY;
2602         } else if (cmd_match(buf, "remove")) {
2603                 if (rdev->raid_disk >= 0)
2604                         err = -EBUSY;
2605                 else {
2606                         struct mddev *mddev = rdev->mddev;
2607                         err = 0;
2608                         if (mddev_is_clustered(mddev))
2609                                 err = md_cluster_ops->remove_disk(mddev, rdev);
2610
2611                         if (err == 0) {
2612                                 md_kick_rdev_from_array(rdev);
2613                                 if (mddev->pers)
2614                                         md_update_sb(mddev, 1);
2615                                 md_new_event(mddev);
2616                         }
2617                 }
2618         } else if (cmd_match(buf, "writemostly")) {
2619                 set_bit(WriteMostly, &rdev->flags);
2620                 err = 0;
2621         } else if (cmd_match(buf, "-writemostly")) {
2622                 clear_bit(WriteMostly, &rdev->flags);
2623                 err = 0;
2624         } else if (cmd_match(buf, "blocked")) {
2625                 set_bit(Blocked, &rdev->flags);
2626                 err = 0;
2627         } else if (cmd_match(buf, "-blocked")) {
2628                 if (!test_bit(Faulty, &rdev->flags) &&
2629                     rdev->badblocks.unacked_exist) {
2630                         /* metadata handler doesn't understand badblocks,
2631                          * so we need to fail the device
2632                          */
2633                         md_error(rdev->mddev, rdev);
2634                 }
2635                 clear_bit(Blocked, &rdev->flags);
2636                 clear_bit(BlockedBadBlocks, &rdev->flags);
2637                 wake_up(&rdev->blocked_wait);
2638                 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2639                 md_wakeup_thread(rdev->mddev->thread);
2640
2641                 err = 0;
2642         } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
2643                 set_bit(In_sync, &rdev->flags);
2644                 err = 0;
2645         } else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0 &&
2646                    !test_bit(Journal, &rdev->flags)) {
2647                 if (rdev->mddev->pers == NULL) {
2648                         clear_bit(In_sync, &rdev->flags);
2649                         rdev->saved_raid_disk = rdev->raid_disk;
2650                         rdev->raid_disk = -1;
2651                         err = 0;
2652                 }
2653         } else if (cmd_match(buf, "write_error")) {
2654                 set_bit(WriteErrorSeen, &rdev->flags);
2655                 err = 0;
2656         } else if (cmd_match(buf, "-write_error")) {
2657                 clear_bit(WriteErrorSeen, &rdev->flags);
2658                 err = 0;
2659         } else if (cmd_match(buf, "want_replacement")) {
2660                 /* Any non-spare device that is not a replacement can
2661                  * become want_replacement at any time, but we then need to
2662                  * check if recovery is needed.
2663                  */
2664                 if (rdev->raid_disk >= 0 &&
2665                     !test_bit(Journal, &rdev->flags) &&
2666                     !test_bit(Replacement, &rdev->flags))
2667                         set_bit(WantReplacement, &rdev->flags);
2668                 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2669                 md_wakeup_thread(rdev->mddev->thread);
2670                 err = 0;
2671         } else if (cmd_match(buf, "-want_replacement")) {
2672                 /* Clearing 'want_replacement' is always allowed.
2673                  * Once replacements starts it is too late though.
2674                  */
2675                 err = 0;
2676                 clear_bit(WantReplacement, &rdev->flags);
2677         } else if (cmd_match(buf, "replacement")) {
2678                 /* Can only set a device as a replacement when array has not
2679                  * yet been started.  Once running, replacement is automatic
2680                  * from spares, or by assigning 'slot'.
2681                  */
2682                 if (rdev->mddev->pers)
2683                         err = -EBUSY;
2684                 else {
2685                         set_bit(Replacement, &rdev->flags);
2686                         err = 0;
2687                 }
2688         } else if (cmd_match(buf, "-replacement")) {
2689                 /* Similarly, can only clear Replacement before start */
2690                 if (rdev->mddev->pers)
2691                         err = -EBUSY;
2692                 else {
2693                         clear_bit(Replacement, &rdev->flags);
2694                         err = 0;
2695                 }
2696         } else if (cmd_match(buf, "re-add")) {
2697                 if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1)) {
2698                         /* clear_bit is performed _after_ all the devices
2699                          * have their local Faulty bit cleared. If any writes
2700                          * happen in the meantime in the local node, they
2701                          * will land in the local bitmap, which will be synced
2702                          * by this node eventually
2703                          */
2704                         if (!mddev_is_clustered(rdev->mddev) ||
2705                             (err = md_cluster_ops->gather_bitmaps(rdev)) == 0) {
2706                                 clear_bit(Faulty, &rdev->flags);
2707                                 err = add_bound_rdev(rdev);
2708                         }
2709                 } else
2710                         err = -EBUSY;
2711         }
2712         if (!err)
2713                 sysfs_notify_dirent_safe(rdev->sysfs_state);
2714         return err ? err : len;
2715 }
2716 static struct rdev_sysfs_entry rdev_state =
2717 __ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store);
2718
2719 static ssize_t
2720 errors_show(struct md_rdev *rdev, char *page)
2721 {
2722         return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
2723 }
2724
2725 static ssize_t
2726 errors_store(struct md_rdev *rdev, const char *buf, size_t len)
2727 {
2728         unsigned int n;
2729         int rv;
2730
2731         rv = kstrtouint(buf, 10, &n);
2732         if (rv < 0)
2733                 return rv;
2734         atomic_set(&rdev->corrected_errors, n);
2735         return len;
2736 }
2737 static struct rdev_sysfs_entry rdev_errors =
2738 __ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
2739
2740 static ssize_t
2741 slot_show(struct md_rdev *rdev, char *page)
2742 {
2743         if (test_bit(Journal, &rdev->flags))
2744                 return sprintf(page, "journal\n");
2745         else if (rdev->raid_disk < 0)
2746                 return sprintf(page, "none\n");
2747         else
2748                 return sprintf(page, "%d\n", rdev->raid_disk);
2749 }
2750
2751 static ssize_t
2752 slot_store(struct md_rdev *rdev, const char *buf, size_t len)
2753 {
2754         int slot;
2755         int err;
2756
2757         if (test_bit(Journal, &rdev->flags))
2758                 return -EBUSY;
2759         if (strncmp(buf, "none", 4)==0)
2760                 slot = -1;
2761         else {
2762                 err = kstrtouint(buf, 10, (unsigned int *)&slot);
2763                 if (err < 0)
2764                         return err;
2765         }
2766         if (rdev->mddev->pers && slot == -1) {
2767                 /* Setting 'slot' on an active array requires also
2768                  * updating the 'rd%d' link, and communicating
2769                  * with the personality with ->hot_*_disk.
2770                  * For now we only support removing
2771                  * failed/spare devices.  This normally happens automatically,
2772                  * but not when the metadata is externally managed.
2773                  */
2774                 if (rdev->raid_disk == -1)
2775                         return -EEXIST;
2776                 /* personality does all needed checks */
2777                 if (rdev->mddev->pers->hot_remove_disk == NULL)
2778                         return -EINVAL;
2779                 clear_bit(Blocked, &rdev->flags);
2780                 remove_and_add_spares(rdev->mddev, rdev);
2781                 if (rdev->raid_disk >= 0)
2782                         return -EBUSY;
2783                 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2784                 md_wakeup_thread(rdev->mddev->thread);
2785         } else if (rdev->mddev->pers) {
2786                 /* Activating a spare .. or possibly reactivating
2787                  * if we ever get bitmaps working here.
2788                  */
2789                 int err;
2790
2791                 if (rdev->raid_disk != -1)
2792                         return -EBUSY;
2793
2794                 if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
2795                         return -EBUSY;
2796
2797                 if (rdev->mddev->pers->hot_add_disk == NULL)
2798                         return -EINVAL;
2799
2800                 if (slot >= rdev->mddev->raid_disks &&
2801                     slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
2802                         return -ENOSPC;
2803
2804                 rdev->raid_disk = slot;
2805                 if (test_bit(In_sync, &rdev->flags))
2806                         rdev->saved_raid_disk = slot;
2807                 else
2808                         rdev->saved_raid_disk = -1;
2809                 clear_bit(In_sync, &rdev->flags);
2810                 clear_bit(Bitmap_sync, &rdev->flags);
2811                 err = rdev->mddev->pers->
2812                         hot_add_disk(rdev->mddev, rdev);
2813                 if (err) {
2814                         rdev->raid_disk = -1;
2815                         return err;
2816                 } else
2817                         sysfs_notify_dirent_safe(rdev->sysfs_state);
2818                 if (sysfs_link_rdev(rdev->mddev, rdev))
2819                         /* failure here is OK */;
2820                 /* don't wakeup anyone, leave that to userspace. */
2821         } else {
2822                 if (slot >= rdev->mddev->raid_disks &&
2823                     slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
2824                         return -ENOSPC;
2825                 rdev->raid_disk = slot;
2826                 /* assume it is working */
2827                 clear_bit(Faulty, &rdev->flags);
2828                 clear_bit(WriteMostly, &rdev->flags);
2829                 set_bit(In_sync, &rdev->flags);
2830                 sysfs_notify_dirent_safe(rdev->sysfs_state);
2831         }
2832         return len;
2833 }
2834
2835 static struct rdev_sysfs_entry rdev_slot =
2836 __ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
2837
2838 static ssize_t
2839 offset_show(struct md_rdev *rdev, char *page)
2840 {
2841         return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
2842 }
2843
2844 static ssize_t
2845 offset_store(struct md_rdev *rdev, const char *buf, size_t len)
2846 {
2847         unsigned long long offset;
2848         if (kstrtoull(buf, 10, &offset) < 0)
2849                 return -EINVAL;
2850         if (rdev->mddev->pers && rdev->raid_disk >= 0)
2851                 return -EBUSY;
2852         if (rdev->sectors && rdev->mddev->external)
2853                 /* Must set offset before size, so overlap checks
2854                  * can be sane */
2855                 return -EBUSY;
2856         rdev->data_offset = offset;
2857         rdev->new_data_offset = offset;
2858         return len;
2859 }
2860
2861 static struct rdev_sysfs_entry rdev_offset =
2862 __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
2863
2864 static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
2865 {
2866         return sprintf(page, "%llu\n",
2867                        (unsigned long long)rdev->new_data_offset);
2868 }
2869
2870 static ssize_t new_offset_store(struct md_rdev *rdev,
2871                                 const char *buf, size_t len)
2872 {
2873         unsigned long long new_offset;
2874         struct mddev *mddev = rdev->mddev;
2875
2876         if (kstrtoull(buf, 10, &new_offset) < 0)
2877                 return -EINVAL;
2878
2879         if (mddev->sync_thread ||
2880             test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
2881                 return -EBUSY;
2882         if (new_offset == rdev->data_offset)
2883                 /* reset is always permitted */
2884                 ;
2885         else if (new_offset > rdev->data_offset) {
2886                 /* must not push array size beyond rdev_sectors */
2887                 if (new_offset - rdev->data_offset
2888                     + mddev->dev_sectors > rdev->sectors)
2889                                 return -E2BIG;
2890         }
2891         /* Metadata worries about other space details. */
2892
2893         /* decreasing the offset is inconsistent with a backwards
2894          * reshape.
2895          */
2896         if (new_offset < rdev->data_offset &&
2897             mddev->reshape_backwards)
2898                 return -EINVAL;
2899         /* Increasing offset is inconsistent with forwards
2900          * reshape.  reshape_direction should be set to
2901          * 'backwards' first.
2902          */
2903         if (new_offset > rdev->data_offset &&
2904             !mddev->reshape_backwards)
2905                 return -EINVAL;
2906
2907         if (mddev->pers && mddev->persistent &&
2908             !super_types[mddev->major_version]
2909             .allow_new_offset(rdev, new_offset))
2910                 return -E2BIG;
2911         rdev->new_data_offset = new_offset;
2912         if (new_offset > rdev->data_offset)
2913                 mddev->reshape_backwards = 1;
2914         else if (new_offset < rdev->data_offset)
2915                 mddev->reshape_backwards = 0;
2916
2917         return len;
2918 }
2919 static struct rdev_sysfs_entry rdev_new_offset =
2920 __ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);
2921
2922 static ssize_t
2923 rdev_size_show(struct md_rdev *rdev, char *page)
2924 {
2925         return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
2926 }
2927
2928 static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
2929 {
2930         /* check if two start/length pairs overlap */
2931         if (s1+l1 <= s2)
2932                 return 0;
2933         if (s2+l2 <= s1)
2934                 return 0;
2935         return 1;
2936 }
2937
2938 static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
2939 {
2940         unsigned long long blocks;
2941         sector_t new;
2942
2943         if (kstrtoull(buf, 10, &blocks) < 0)
2944                 return -EINVAL;
2945
2946         if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
2947                 return -EINVAL; /* sector conversion overflow */
2948
2949         new = blocks * 2;
2950         if (new != blocks * 2)
2951                 return -EINVAL; /* unsigned long long to sector_t overflow */
2952
2953         *sectors = new;
2954         return 0;
2955 }
2956
2957 static ssize_t
2958 rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
2959 {
2960         struct mddev *my_mddev = rdev->mddev;
2961         sector_t oldsectors = rdev->sectors;
2962         sector_t sectors;
2963
2964         if (test_bit(Journal, &rdev->flags))
2965                 return -EBUSY;
2966         if (strict_blocks_to_sectors(buf, &sectors) < 0)
2967                 return -EINVAL;
2968         if (rdev->data_offset != rdev->new_data_offset)
2969                 return -EINVAL; /* too confusing */
2970         if (my_mddev->pers && rdev->raid_disk >= 0) {
2971                 if (my_mddev->persistent) {
2972                         sectors = super_types[my_mddev->major_version].
2973                                 rdev_size_change(rdev, sectors);
2974                         if (!sectors)
2975                                 return -EBUSY;
2976                 } else if (!sectors)
2977                         sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
2978                                 rdev->data_offset;
2979                 if (!my_mddev->pers->resize)
2980                         /* Cannot change size for RAID0 or Linear etc */
2981                         return -EINVAL;
2982         }
2983         if (sectors < my_mddev->dev_sectors)
2984                 return -EINVAL; /* component must fit device */
2985
2986         rdev->sectors = sectors;
2987         if (sectors > oldsectors && my_mddev->external) {
2988                 /* Need to check that all other rdevs with the same
2989                  * ->bdev do not overlap.  'rcu' is sufficient to walk
2990                  * the rdev lists safely.
2991                  * This check does not provide a hard guarantee, it
2992                  * just helps avoid dangerous mistakes.
2993                  */
2994                 struct mddev *mddev;
2995                 int overlap = 0;
2996                 struct list_head *tmp;
2997
2998                 rcu_read_lock();
2999                 for_each_mddev(mddev, tmp) {
3000                         struct md_rdev *rdev2;
3001
3002                         rdev_for_each(rdev2, mddev)
3003                                 if (rdev->bdev == rdev2->bdev &&
3004                                     rdev != rdev2 &&
3005                                     overlaps(rdev->data_offset, rdev->sectors,
3006                                              rdev2->data_offset,
3007                                              rdev2->sectors)) {
3008                                         overlap = 1;
3009                                         break;
3010                                 }
3011                         if (overlap) {
3012                                 mddev_put(mddev);
3013                                 break;
3014                         }
3015                 }
3016                 rcu_read_unlock();
3017                 if (overlap) {
3018                         /* Someone else could have slipped in a size
3019                          * change here, but doing so is just silly.
3020                          * We put oldsectors back because we *know* it is
3021                          * safe, and trust userspace not to race with
3022                          * itself
3023                          */
3024                         rdev->sectors = oldsectors;
3025                         return -EBUSY;
3026                 }
3027         }
3028         return len;
3029 }
3030
3031 static struct rdev_sysfs_entry rdev_size =
3032 __ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
3033
3034 static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
3035 {
3036         unsigned long long recovery_start = rdev->recovery_offset;
3037
3038         if (test_bit(In_sync, &rdev->flags) ||
3039             recovery_start == MaxSector)
3040                 return sprintf(page, "none\n");
3041
3042         return sprintf(page, "%llu\n", recovery_start);
3043 }
3044
3045 static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
3046 {
3047         unsigned long long recovery_start;
3048
3049         if (cmd_match(buf, "none"))
3050                 recovery_start = MaxSector;
3051         else if (kstrtoull(buf, 10, &recovery_start))
3052                 return -EINVAL;
3053
3054         if (rdev->mddev->pers &&
3055             rdev->raid_disk >= 0)
3056                 return -EBUSY;
3057
3058         rdev->recovery_offset = recovery_start;
3059         if (recovery_start == MaxSector)
3060                 set_bit(In_sync, &rdev->flags);
3061         else
3062                 clear_bit(In_sync, &rdev->flags);
3063         return len;
3064 }
3065
3066 static struct rdev_sysfs_entry rdev_recovery_start =
3067 __ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
3068
3069 /* sysfs access to bad-blocks list.
3070  * We present two files.
3071  * 'bad-blocks' lists sector numbers and lengths of ranges that
3072  *    are recorded as bad.  The list is truncated to fit within
3073  *    the one-page limit of sysfs.
3074  *    Writing "sector length" to this file adds an acknowledged
3075  *    bad block list.
3076  * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
3077  *    been acknowledged.  Writing to this file adds bad blocks
3078  *    without acknowledging them.  This is largely for testing.
3079  */
3080 static ssize_t bb_show(struct md_rdev *rdev, char *page)
3081 {
3082         return badblocks_show(&rdev->badblocks, page, 0);
3083 }
3084 static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
3085 {
3086         int rv = badblocks_store(&rdev->badblocks, page, len, 0);
3087         /* Maybe that ack was all we needed */
3088         if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
3089                 wake_up(&rdev->blocked_wait);
3090         return rv;
3091 }
3092 static struct rdev_sysfs_entry rdev_bad_blocks =
3093 __ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
3094
3095 static ssize_t ubb_show(struct md_rdev *rdev, char *page)
3096 {
3097         return badblocks_show(&rdev->badblocks, page, 1);
3098 }
3099 static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
3100 {
3101         return badblocks_store(&rdev->badblocks, page, len, 1);
3102 }
3103 static struct rdev_sysfs_entry rdev_unack_bad_blocks =
3104 __ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);
3105
3106 static struct attribute *rdev_default_attrs[] = {
3107         &rdev_state.attr,
3108         &rdev_errors.attr,
3109         &rdev_slot.attr,
3110         &rdev_offset.attr,
3111         &rdev_new_offset.attr,
3112         &rdev_size.attr,
3113         &rdev_recovery_start.attr,
3114         &rdev_bad_blocks.attr,
3115         &rdev_unack_bad_blocks.attr,
3116         NULL,
3117 };
3118 static ssize_t
3119 rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
3120 {
3121         struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3122         struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3123
3124         if (!entry->show)
3125                 return -EIO;
3126         if (!rdev->mddev)
3127                 return -EBUSY;
3128         return entry->show(rdev, page);
3129 }
3130
3131 static ssize_t
3132 rdev_attr_store(struct kobject *kobj, struct attribute *attr,
3133               const char *page, size_t length)
3134 {
3135         struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
3136         struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
3137         ssize_t rv;
3138         struct mddev *mddev = rdev->mddev;
3139
3140         if (!entry->store)
3141                 return -EIO;
3142         if (!capable(CAP_SYS_ADMIN))
3143                 return -EACCES;
3144         rv = mddev ? mddev_lock(mddev): -EBUSY;
3145         if (!rv) {
3146                 if (rdev->mddev == NULL)
3147                         rv = -EBUSY;
3148                 else
3149                         rv = entry->store(rdev, page, length);
3150                 mddev_unlock(mddev);
3151         }
3152         return rv;
3153 }
3154
3155 static void rdev_free(struct kobject *ko)
3156 {
3157         struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
3158         kfree(rdev);
3159 }
3160 static const struct sysfs_ops rdev_sysfs_ops = {
3161         .show           = rdev_attr_show,
3162         .store          = rdev_attr_store,
3163 };
3164 static struct kobj_type rdev_ktype = {
3165         .release        = rdev_free,
3166         .sysfs_ops      = &rdev_sysfs_ops,
3167         .default_attrs  = rdev_default_attrs,
3168 };
3169
3170 int md_rdev_init(struct md_rdev *rdev)
3171 {
3172         rdev->desc_nr = -1;
3173         rdev->saved_raid_disk = -1;
3174         rdev->raid_disk = -1;
3175         rdev->flags = 0;
3176         rdev->data_offset = 0;
3177         rdev->new_data_offset = 0;
3178         rdev->sb_events = 0;
3179         rdev->last_read_error.tv_sec  = 0;
3180         rdev->last_read_error.tv_nsec = 0;
3181         rdev->sb_loaded = 0;
3182         rdev->bb_page = NULL;
3183         atomic_set(&rdev->nr_pending, 0);
3184         atomic_set(&rdev->read_errors, 0);
3185         atomic_set(&rdev->corrected_errors, 0);
3186
3187         INIT_LIST_HEAD(&rdev->same_set);
3188         init_waitqueue_head(&rdev->blocked_wait);
3189
3190         /* Add space to store bad block list.
3191          * This reserves the space even on arrays where it cannot
3192          * be used - I wonder if that matters
3193          */
3194         return badblocks_init(&rdev->badblocks, 0);
3195 }
3196 EXPORT_SYMBOL_GPL(md_rdev_init);
3197 /*
3198  * Import a device. If 'super_format' >= 0, then sanity check the superblock
3199  *
3200  * mark the device faulty if:
3201  *
3202  *   - the device is nonexistent (zero size)
3203  *   - the device has no valid superblock
3204  *
3205  * a faulty rdev _never_ has rdev->sb set.
3206  */
3207 static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
3208 {
3209         char b[BDEVNAME_SIZE];
3210         int err;
3211         struct md_rdev *rdev;
3212         sector_t size;
3213
3214         rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
3215         if (!rdev) {
3216                 printk(KERN_ERR "md: could not alloc mem for new device!\n");
3217                 return ERR_PTR(-ENOMEM);
3218         }
3219
3220         err = md_rdev_init(rdev);
3221         if (err)
3222                 goto abort_free;
3223         err = alloc_disk_sb(rdev);
3224         if (err)
3225                 goto abort_free;
3226
3227         err = lock_rdev(rdev, newdev, super_format == -2);
3228         if (err)
3229                 goto abort_free;
3230
3231         kobject_init(&rdev->kobj, &rdev_ktype);
3232
3233         size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
3234         if (!size) {
3235                 printk(KERN_WARNING
3236                         "md: %s has zero or unknown size, marking faulty!\n",
3237                         bdevname(rdev->bdev,b));
3238                 err = -EINVAL;
3239                 goto abort_free;
3240         }
3241
3242         if (super_format >= 0) {
3243                 err = super_types[super_format].
3244                         load_super(rdev, NULL, super_minor);
3245                 if (err == -EINVAL) {
3246                         printk(KERN_WARNING
3247                                 "md: %s does not have a valid v%d.%d "
3248                                "superblock, not importing!\n",
3249                                 bdevname(rdev->bdev,b),
3250                                super_format, super_minor);
3251                         goto abort_free;
3252                 }
3253                 if (err < 0) {
3254                         printk(KERN_WARNING
3255                                 "md: could not read %s's sb, not importing!\n",
3256                                 bdevname(rdev->bdev,b));
3257                         goto abort_free;
3258                 }
3259         }
3260
3261         return rdev;
3262
3263 abort_free:
3264         if (rdev->bdev)
3265                 unlock_rdev(rdev);
3266         md_rdev_clear(rdev);
3267         kfree(rdev);
3268         return ERR_PTR(err);
3269 }
3270
3271 /*
3272  * Check a full RAID array for plausibility
3273  */
3274
3275 static void analyze_sbs(struct mddev *mddev)
3276 {
3277         int i;
3278         struct md_rdev *rdev, *freshest, *tmp;
3279         char b[BDEVNAME_SIZE];
3280
3281         freshest = NULL;
3282         rdev_for_each_safe(rdev, tmp, mddev)
3283                 switch (super_types[mddev->major_version].
3284                         load_super(rdev, freshest, mddev->minor_version)) {
3285                 case 1:
3286                         freshest = rdev;
3287                         break;
3288                 case 0:
3289                         break;
3290                 default:
3291                         printk( KERN_ERR \
3292                                 "md: fatal superblock inconsistency in %s"
3293                                 " -- removing from array\n",
3294                                 bdevname(rdev->bdev,b));
3295                         md_kick_rdev_from_array(rdev);
3296                 }
3297
3298         super_types[mddev->major_version].
3299                 validate_super(mddev, freshest);
3300
3301         i = 0;
3302         rdev_for_each_safe(rdev, tmp, mddev) {
3303                 if (mddev->max_disks &&
3304                     (rdev->desc_nr >= mddev->max_disks ||
3305                      i > mddev->max_disks)) {
3306                         printk(KERN_WARNING
3307                                "md: %s: %s: only %d devices permitted\n",
3308                                mdname(mddev), bdevname(rdev->bdev, b),
3309                                mddev->max_disks);
3310                         md_kick_rdev_from_array(rdev);
3311                         continue;
3312                 }
3313                 if (rdev != freshest) {
3314                         if (super_types[mddev->major_version].
3315                             validate_super(mddev, rdev)) {
3316                                 printk(KERN_WARNING "md: kicking non-fresh %s"
3317                                         " from array!\n",
3318                                         bdevname(rdev->bdev,b));
3319                                 md_kick_rdev_from_array(rdev);
3320                                 continue;
3321                         }
3322                 }
3323                 if (mddev->level == LEVEL_MULTIPATH) {
3324                         rdev->desc_nr = i++;
3325                         rdev->raid_disk = rdev->desc_nr;
3326                         set_bit(In_sync, &rdev->flags);
3327                 } else if (rdev->raid_disk >=
3328                             (mddev->raid_disks - min(0, mddev->delta_disks)) &&
3329                            !test_bit(Journal, &rdev->flags)) {
3330                         rdev->raid_disk = -1;
3331                         clear_bit(In_sync, &rdev->flags);
3332                 }
3333         }
3334 }
3335
3336 /* Read a fixed-point number.
3337  * Numbers in sysfs attributes should be in "standard" units where
3338  * possible, so time should be in seconds.
3339  * However we internally use a a much smaller unit such as
3340  * milliseconds or jiffies.
3341  * This function takes a decimal number with a possible fractional
3342  * component, and produces an integer which is the result of
3343  * multiplying that number by 10^'scale'.
3344  * all without any floating-point arithmetic.
3345  */
3346 int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
3347 {
3348         unsigned long result = 0;
3349         long decimals = -1;
3350         while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
3351                 if (*cp == '.')
3352                         decimals = 0;
3353                 else if (decimals < scale) {
3354                         unsigned int value;
3355                         value = *cp - '0';
3356                         result = result * 10 + value;
3357                         if (decimals >= 0)
3358                                 decimals++;
3359                 }
3360                 cp++;
3361         }
3362         if (*cp == '\n')
3363                 cp++;
3364         if (*cp)
3365                 return -EINVAL;
3366         if (decimals < 0)
3367                 decimals = 0;
3368         while (decimals < scale) {
3369                 result *= 10;
3370                 decimals ++;
3371         }
3372         *res = result;
3373         return 0;
3374 }
3375
3376 static ssize_t
3377 safe_delay_show(struct mddev *mddev, char *page)
3378 {
3379         int msec = (mddev->safemode_delay*1000)/HZ;
3380         return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
3381 }
3382 static ssize_t
3383 safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
3384 {
3385         unsigned long msec;
3386
3387         if (mddev_is_clustered(mddev)) {
3388                 pr_info("md: Safemode is disabled for clustered mode\n");
3389                 return -EINVAL;
3390         }
3391
3392         if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
3393                 return -EINVAL;
3394         if (msec == 0)
3395                 mddev->safemode_delay = 0;
3396         else {
3397                 unsigned long old_delay = mddev->safemode_delay;
3398                 unsigned long new_delay = (msec*HZ)/1000;
3399
3400                 if (new_delay == 0)
3401                         new_delay = 1;
3402                 mddev->safemode_delay = new_delay;
3403                 if (new_delay < old_delay || old_delay == 0)
3404                         mod_timer(&mddev->safemode_timer, jiffies+1);
3405         }
3406         return len;
3407 }
3408 static struct md_sysfs_entry md_safe_delay =
3409 __ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
3410
3411 static ssize_t
3412 level_show(struct mddev *mddev, char *page)
3413 {
3414         struct md_personality *p;
3415         int ret;
3416         spin_lock(&mddev->lock);
3417         p = mddev->pers;
3418         if (p)
3419                 ret = sprintf(page, "%s\n", p->name);
3420         else if (mddev->clevel[0])
3421                 ret = sprintf(page, "%s\n", mddev->clevel);
3422         else if (mddev->level != LEVEL_NONE)
3423                 ret = sprintf(page, "%d\n", mddev->level);
3424         else
3425                 ret = 0;
3426         spin_unlock(&mddev->lock);
3427         return ret;
3428 }
3429
3430 static ssize_t
3431 level_store(struct mddev *mddev, const char *buf, size_t len)
3432 {
3433         char clevel[16];
3434         ssize_t rv;
3435         size_t slen = len;
3436         struct md_personality *pers, *oldpers;
3437         long level;
3438         void *priv, *oldpriv;
3439         struct md_rdev *rdev;
3440
3441         if (slen == 0 || slen >= sizeof(clevel))
3442                 return -EINVAL;
3443
3444         rv = mddev_lock(mddev);
3445         if (rv)
3446                 return rv;
3447
3448         if (mddev->pers == NULL) {
3449                 strncpy(mddev->clevel, buf, slen);
3450                 if (mddev->clevel[slen-1] == '\n')
3451                         slen--;
3452                 mddev->clevel[slen] = 0;
3453                 mddev->level = LEVEL_NONE;
3454                 rv = len;
3455                 goto out_unlock;
3456         }
3457         rv = -EROFS;
3458         if (mddev->ro)
3459                 goto out_unlock;
3460
3461         /* request to change the personality.  Need to ensure:
3462          *  - array is not engaged in resync/recovery/reshape
3463          *  - old personality can be suspended
3464          *  - new personality will access other array.
3465          */
3466
3467         rv = -EBUSY;
3468         if (mddev->sync_thread ||
3469             test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3470             mddev->reshape_position != MaxSector ||
3471             mddev->sysfs_active)
3472                 goto out_unlock;
3473
3474         rv = -EINVAL;
3475         if (!mddev->pers->quiesce) {
3476                 printk(KERN_WARNING "md: %s: %s does not support online personality change\n",
3477                        mdname(mddev), mddev->pers->name);
3478                 goto out_unlock;
3479         }
3480
3481         /* Now find the new personality */
3482         strncpy(clevel, buf, slen);
3483         if (clevel[slen-1] == '\n')
3484                 slen--;
3485         clevel[slen] = 0;
3486         if (kstrtol(clevel, 10, &level))
3487                 level = LEVEL_NONE;
3488
3489         if (request_module("md-%s", clevel) != 0)
3490                 request_module("md-level-%s", clevel);
3491         spin_lock(&pers_lock);
3492         pers = find_pers(level, clevel);
3493         if (!pers || !try_module_get(pers->owner)) {
3494                 spin_unlock(&pers_lock);
3495                 printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
3496                 rv = -EINVAL;
3497                 goto out_unlock;
3498         }
3499         spin_unlock(&pers_lock);
3500
3501         if (pers == mddev->pers) {
3502                 /* Nothing to do! */
3503                 module_put(pers->owner);
3504                 rv = len;
3505                 goto out_unlock;
3506         }
3507         if (!pers->takeover) {
3508                 module_put(pers->owner);
3509                 printk(KERN_WARNING "md: %s: %s does not support personality takeover\n",
3510                        mdname(mddev), clevel);
3511                 rv = -EINVAL;
3512                 goto out_unlock;
3513         }
3514
3515         rdev_for_each(rdev, mddev)
3516                 rdev->new_raid_disk = rdev->raid_disk;
3517
3518         /* ->takeover must set new_* and/or delta_disks
3519          * if it succeeds, and may set them when it fails.
3520          */
3521         priv = pers->takeover(mddev);
3522         if (IS_ERR(priv)) {
3523                 mddev->new_level = mddev->level;
3524                 mddev->new_layout = mddev->layout;
3525                 mddev->new_chunk_sectors = mddev->chunk_sectors;
3526                 mddev->raid_disks -= mddev->delta_disks;
3527                 mddev->delta_disks = 0;
3528                 mddev->reshape_backwards = 0;
3529                 module_put(pers->owner);
3530                 printk(KERN_WARNING "md: %s: %s would not accept array\n",
3531                        mdname(mddev), clevel);
3532                 rv = PTR_ERR(priv);
3533                 goto out_unlock;
3534         }
3535
3536         /* Looks like we have a winner */
3537         mddev_suspend(mddev);
3538         mddev_detach(mddev);
3539
3540         spin_lock(&mddev->lock);
3541         oldpers = mddev->pers;
3542         oldpriv = mddev->private;
3543         mddev->pers = pers;
3544         mddev->private = priv;
3545         strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3546         mddev->level = mddev->new_level;
3547         mddev->layout = mddev->new_layout;
3548         mddev->chunk_sectors = mddev->new_chunk_sectors;
3549         mddev->delta_disks = 0;
3550         mddev->reshape_backwards = 0;
3551         mddev->degraded = 0;
3552         spin_unlock(&mddev->lock);
3553
3554         if (oldpers->sync_request == NULL &&
3555             mddev->external) {
3556                 /* We are converting from a no-redundancy array
3557                  * to a redundancy array and metadata is managed
3558                  * externally so we need to be sure that writes
3559                  * won't block due to a need to transition
3560                  *      clean->dirty
3561                  * until external management is started.
3562                  */
3563                 mddev->in_sync = 0;
3564                 mddev->safemode_delay = 0;
3565                 mddev->safemode = 0;
3566         }
3567
3568         oldpers->free(mddev, oldpriv);
3569
3570         if (oldpers->sync_request == NULL &&
3571             pers->sync_request != NULL) {
3572                 /* need to add the md_redundancy_group */
3573                 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
3574                         printk(KERN_WARNING
3575                                "md: cannot register extra attributes for %s\n",
3576                                mdname(mddev));
3577                 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
3578         }
3579         if (oldpers->sync_request != NULL &&
3580             pers->sync_request == NULL) {
3581                 /* need to remove the md_redundancy_group */
3582                 if (mddev->to_remove == NULL)
3583                         mddev->to_remove = &md_redundancy_group;
3584         }
3585
3586         rdev_for_each(rdev, mddev) {
3587                 if (rdev->raid_disk < 0)
3588                         continue;
3589                 if (rdev->new_raid_disk >= mddev->raid_disks)
3590                         rdev->new_raid_disk = -1;
3591                 if (rdev->new_raid_disk == rdev->raid_disk)
3592                         continue;
3593                 sysfs_unlink_rdev(mddev, rdev);
3594         }
3595         rdev_for_each(rdev, mddev) {
3596                 if (rdev->raid_disk < 0)
3597                         continue;
3598                 if (rdev->new_raid_disk == rdev->raid_disk)
3599                         continue;
3600                 rdev->raid_disk = rdev->new_raid_disk;
3601                 if (rdev->raid_disk < 0)
3602                         clear_bit(In_sync, &rdev->flags);
3603                 else {
3604                         if (sysfs_link_rdev(mddev, rdev))
3605                                 printk(KERN_WARNING "md: cannot register rd%d"
3606                                        " for %s after level change\n",
3607                                        rdev->raid_disk, mdname(mddev));
3608                 }
3609         }
3610
3611         if (pers->sync_request == NULL) {
3612                 /* this is now an array without redundancy, so
3613                  * it must always be in_sync
3614                  */
3615                 mddev->in_sync = 1;
3616                 del_timer_sync(&mddev->safemode_timer);
3617         }
3618         blk_set_stacking_limits(&mddev->queue->limits);
3619         pers->run(mddev);
3620         set_bit(MD_CHANGE_DEVS, &mddev->flags);
3621         mddev_resume(mddev);
3622         if (!mddev->thread)
3623                 md_update_sb(mddev, 1);
3624         sysfs_notify(&mddev->kobj, NULL, "level");
3625         md_new_event(mddev);
3626         rv = len;
3627 out_unlock:
3628         mddev_unlock(mddev);
3629         return rv;
3630 }
3631
3632 static struct md_sysfs_entry md_level =
3633 __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
3634
3635 static ssize_t
3636 layout_show(struct mddev *mddev, char *page)
3637 {
3638         /* just a number, not meaningful for all levels */
3639         if (mddev->reshape_position != MaxSector &&
3640             mddev->layout != mddev->new_layout)
3641                 return sprintf(page, "%d (%d)\n",
3642                                mddev->new_layout, mddev->layout);
3643         return sprintf(page, "%d\n", mddev->layout);
3644 }
3645
3646 static ssize_t
3647 layout_store(struct mddev *mddev, const char *buf, size_t len)
3648 {
3649         unsigned int n;
3650         int err;
3651
3652         err = kstrtouint(buf, 10, &n);
3653         if (err < 0)
3654                 return err;
3655         err = mddev_lock(mddev);
3656         if (err)
3657                 return err;
3658
3659         if (mddev->pers) {
3660                 if (mddev->pers->check_reshape == NULL)
3661                         err = -EBUSY;
3662                 else if (mddev->ro)
3663                         err = -EROFS;
3664                 else {
3665                         mddev->new_layout = n;
3666                         err = mddev->pers->check_reshape(mddev);
3667                         if (err)
3668                                 mddev->new_layout = mddev->layout;
3669                 }
3670         } else {
3671                 mddev->new_layout = n;
3672                 if (mddev->reshape_position == MaxSector)
3673                         mddev->layout = n;
3674         }
3675         mddev_unlock(mddev);
3676         return err ?: len;
3677 }
3678 static struct md_sysfs_entry md_layout =
3679 __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
3680
3681 static ssize_t
3682 raid_disks_show(struct mddev *mddev, char *page)
3683 {
3684         if (mddev->raid_disks == 0)
3685                 return 0;
3686         if (mddev->reshape_position != MaxSector &&
3687             mddev->delta_disks != 0)
3688                 return sprintf(page, "%d (%d)\n", mddev->raid_disks,
3689                                mddev->raid_disks - mddev->delta_disks);
3690         return sprintf(page, "%d\n", mddev->raid_disks);
3691 }
3692
3693 static int update_raid_disks(struct mddev *mddev, int raid_disks);
3694
3695 static ssize_t
3696 raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
3697 {
3698         unsigned int n;
3699         int err;
3700
3701         err = kstrtouint(buf, 10, &n);
3702         if (err < 0)
3703                 return err;
3704
3705         err = mddev_lock(mddev);
3706         if (err)
3707                 return err;
3708         if (mddev->pers)
3709                 err = update_raid_disks(mddev, n);
3710         else if (mddev->reshape_position != MaxSector) {
3711                 struct md_rdev *rdev;
3712                 int olddisks = mddev->raid_disks - mddev->delta_disks;
3713
3714                 err = -EINVAL;
3715                 rdev_for_each(rdev, mddev) {
3716                         if (olddisks < n &&
3717                             rdev->data_offset < rdev->new_data_offset)
3718                                 goto out_unlock;
3719                         if (olddisks > n &&
3720                             rdev->data_offset > rdev->new_data_offset)
3721                                 goto out_unlock;
3722                 }
3723                 err = 0;
3724                 mddev->delta_disks = n - olddisks;
3725                 mddev->raid_disks = n;
3726                 mddev->reshape_backwards = (mddev->delta_disks < 0);
3727         } else
3728                 mddev->raid_disks = n;
3729 out_unlock:
3730         mddev_unlock(mddev);
3731         return err ? err : len;
3732 }
3733 static struct md_sysfs_entry md_raid_disks =
3734 __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
3735
3736 static ssize_t
3737 chunk_size_show(struct mddev *mddev, char *page)
3738 {
3739         if (mddev->reshape_position != MaxSector &&
3740             mddev->chunk_sectors != mddev->new_chunk_sectors)
3741                 return sprintf(page, "%d (%d)\n",
3742                                mddev->new_chunk_sectors << 9,
3743                                mddev->chunk_sectors << 9);
3744         return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
3745 }
3746
3747 static ssize_t
3748 chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
3749 {
3750         unsigned long n;
3751         int err;
3752
3753         err = kstrtoul(buf, 10, &n);
3754         if (err < 0)
3755                 return err;
3756
3757         err = mddev_lock(mddev);
3758         if (err)
3759                 return err;
3760         if (mddev->pers) {
3761                 if (mddev->pers->check_reshape == NULL)
3762                         err = -EBUSY;
3763                 else if (mddev->ro)
3764                         err = -EROFS;
3765                 else {
3766                         mddev->new_chunk_sectors = n >> 9;
3767                         err = mddev->pers->check_reshape(mddev);
3768                         if (err)
3769                                 mddev->new_chunk_sectors = mddev->chunk_sectors;
3770                 }
3771         } else {
3772                 mddev->new_chunk_sectors = n >> 9;
3773                 if (mddev->reshape_position == MaxSector)
3774                         mddev->chunk_sectors = n >> 9;
3775         }
3776         mddev_unlock(mddev);
3777         return err ?: len;
3778 }
3779 static struct md_sysfs_entry md_chunk_size =
3780 __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
3781
3782 static ssize_t
3783 resync_start_show(struct mddev *mddev, char *page)
3784 {
3785         if (mddev->recovery_cp == MaxSector)
3786                 return sprintf(page, "none\n");
3787         return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
3788 }
3789
3790 static ssize_t
3791 resync_start_store(struct mddev *mddev, const char *buf, size_t len)
3792 {
3793         unsigned long long n;
3794         int err;
3795
3796         if (cmd_match(buf, "none"))
3797                 n = MaxSector;
3798         else {
3799                 err = kstrtoull(buf, 10, &n);
3800                 if (err < 0)
3801                         return err;
3802                 if (n != (sector_t)n)
3803                         return -EINVAL;
3804         }
3805
3806         err = mddev_lock(mddev);
3807         if (err)
3808                 return err;
3809         if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
3810                 err = -EBUSY;
3811
3812         if (!err) {
3813                 mddev->recovery_cp = n;
3814                 if (mddev->pers)
3815                         set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3816         }
3817         mddev_unlock(mddev);
3818         return err ?: len;
3819 }
3820 static struct md_sysfs_entry md_resync_start =
3821 __ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR,
3822                 resync_start_show, resync_start_store);
3823
3824 /*
3825  * The array state can be:
3826  *
3827  * clear
3828  *     No devices, no size, no level
3829  *     Equivalent to STOP_ARRAY ioctl
3830  * inactive
3831  *     May have some settings, but array is not active
3832  *        all IO results in error
3833  *     When written, doesn't tear down array, but just stops it
3834  * suspended (not supported yet)
3835  *     All IO requests will block. The array can be reconfigured.
3836  *     Writing this, if accepted, will block until array is quiescent
3837  * readonly
3838  *     no resync can happen.  no superblocks get written.
3839  *     write requests fail
3840  * read-auto
3841  *     like readonly, but behaves like 'clean' on a write request.
3842  *
3843  * clean - no pending writes, but otherwise active.
3844  *     When written to inactive array, starts without resync
3845  *     If a write request arrives then
3846  *       if metadata is known, mark 'dirty' and switch to 'active'.
3847  *       if not known, block and switch to write-pending
3848  *     If written to an active array that has pending writes, then fails.
3849  * active
3850  *     fully active: IO and resync can be happening.
3851  *     When written to inactive array, starts with resync
3852  *
3853  * write-pending
3854  *     clean, but writes are blocked waiting for 'active' to be written.
3855  *
3856  * active-idle
3857  *     like active, but no writes have been seen for a while (100msec).
3858  *
3859  */
3860 enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
3861                    write_pending, active_idle, bad_word};
3862 static char *array_states[] = {
3863         "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
3864         "write-pending", "active-idle", NULL };
3865
3866 static int match_word(const char *word, char **list)
3867 {
3868         int n;
3869         for (n=0; list[n]; n++)
3870                 if (cmd_match(word, list[n]))
3871                         break;
3872         return n;
3873 }
3874
3875 static ssize_t
3876 array_state_show(struct mddev *mddev, char *page)
3877 {
3878         enum array_state st = inactive;
3879
3880         if (mddev->pers)
3881                 switch(mddev->ro) {
3882                 case 1:
3883                         st = readonly;
3884                         break;
3885                 case 2:
3886                         st = read_auto;
3887                         break;
3888                 case 0:
3889                         if (mddev->in_sync)
3890                                 st = clean;
3891                         else if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
3892                                 st = write_pending;
3893                         else if (mddev->safemode)
3894                                 st = active_idle;
3895                         else
3896                                 st = active;
3897                 }
3898         else {
3899                 if (list_empty(&mddev->disks) &&
3900                     mddev->raid_disks == 0 &&
3901                     mddev->dev_sectors == 0)
3902                         st = clear;
3903                 else
3904                         st = inactive;
3905         }
3906         return sprintf(page, "%s\n", array_states[st]);
3907 }
3908
3909 static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev);
3910 static int md_set_readonly(struct mddev *mddev, struct block_device *bdev);
3911 static int do_md_run(struct mddev *mddev);
3912 static int restart_array(struct mddev *mddev);
3913
3914 static ssize_t
3915 array_state_store(struct mddev *mddev, const char *buf, size_t len)
3916 {
3917         int err;
3918         enum array_state st = match_word(buf, array_states);
3919
3920         if (mddev->pers && (st == active || st == clean) && mddev->ro != 1) {
3921                 /* don't take reconfig_mutex when toggling between
3922                  * clean and active
3923                  */
3924                 spin_lock(&mddev->lock);
3925                 if (st == active) {
3926                         restart_array(mddev);
3927                         clear_bit(MD_CHANGE_PENDING, &mddev->flags);
3928                         wake_up(&mddev->sb_wait);
3929                         err = 0;
3930                 } else /* st == clean */ {
3931                         restart_array(mddev);
3932                         if (atomic_read(&mddev->writes_pending) == 0) {
3933                                 if (mddev->in_sync == 0) {
3934                                         mddev->in_sync = 1;
3935                                         if (mddev->safemode == 1)
3936                                                 mddev->safemode = 0;
3937                                         set_bit(MD_CHANGE_CLEAN, &mddev->flags);
3938                                 }
3939                                 err = 0;
3940                         } else
3941                                 err = -EBUSY;
3942                 }
3943                 spin_unlock(&mddev->lock);
3944                 return err ?: len;
3945         }
3946         err = mddev_lock(mddev);
3947         if (err)
3948                 return err;
3949         err = -EINVAL;
3950         switch(st) {
3951         case bad_word:
3952                 break;
3953         case clear:
3954                 /* stopping an active array */
3955                 err = do_md_stop(mddev, 0, NULL);
3956                 break;
3957         case inactive:
3958                 /* stopping an active array */
3959                 if (mddev->pers)
3960                         err = do_md_stop(mddev, 2, NULL);
3961                 else
3962                         err = 0; /* already inactive */
3963                 break;
3964         case suspended:
3965                 break; /* not supported yet */
3966         case readonly:
3967                 if (mddev->pers)
3968                         err = md_set_readonly(mddev, NULL);
3969                 else {
3970                         mddev->ro = 1;
3971                         set_disk_ro(mddev->gendisk, 1);
3972                         err = do_md_run(mddev);
3973                 }
3974                 break;
3975         case read_auto:
3976                 if (mddev->pers) {
3977                         if (mddev->ro == 0)
3978                                 err = md_set_readonly(mddev, NULL);
3979                         else if (mddev->ro == 1)
3980                                 err = restart_array(mddev);
3981                         if (err == 0) {
3982                                 mddev->ro = 2;
3983                                 set_disk_ro(mddev->gendisk, 0);
3984                         }
3985                 } else {
3986                         mddev->ro = 2;
3987                         err = do_md_run(mddev);
3988                 }
3989                 break;
3990         case clean:
3991                 if (mddev->pers) {
3992                         err = restart_array(mddev);
3993                         if (err)
3994                                 break;
3995                         spin_lock(&mddev->lock);
3996                         if (atomic_read(&mddev->writes_pending) == 0) {
3997                                 if (mddev->in_sync == 0) {
3998                                         mddev->in_sync = 1;
3999                                         if (mddev->safemode == 1)
4000                                                 mddev->safemode = 0;
4001                                         set_bit(MD_CHANGE_CLEAN, &mddev->flags);
4002                                 }
4003                                 err = 0;
4004                         } else
4005                                 err = -EBUSY;
4006                         spin_unlock(&mddev->lock);
4007                 } else
4008                         err = -EINVAL;
4009                 break;
4010         case active:
4011                 if (mddev->pers) {
4012                         err = restart_array(mddev);
4013                         if (err)
4014                                 break;
4015                         clear_bit(MD_CHANGE_PENDING, &mddev->flags);
4016                         wake_up(&mddev->sb_wait);
4017                         err = 0;
4018                 } else {
4019                         mddev->ro = 0;
4020                         set_disk_ro(mddev->gendisk, 0);
4021                         err = do_md_run(mddev);
4022                 }
4023                 break;
4024         case write_pending:
4025         case active_idle:
4026                 /* these cannot be set */
4027                 break;
4028         }
4029
4030         if (!err) {
4031                 if (mddev->hold_active == UNTIL_IOCTL)
4032                         mddev->hold_active = 0;
4033                 sysfs_notify_dirent_safe(mddev->sysfs_state);
4034         }
4035         mddev_unlock(mddev);
4036         return err ?: len;
4037 }
4038 static struct md_sysfs_entry md_array_state =
4039 __ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
4040
4041 static ssize_t
4042 max_corrected_read_errors_show(struct mddev *mddev, char *page) {
4043         return sprintf(page, "%d\n",
4044                        atomic_read(&mddev->max_corr_read_errors));
4045 }
4046
4047 static ssize_t
4048 max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
4049 {
4050         unsigned int n;
4051         int rv;
4052
4053         rv = kstrtouint(buf, 10, &n);
4054         if (rv < 0)
4055                 return rv;
4056         atomic_set(&mddev->max_corr_read_errors, n);
4057         return len;
4058 }
4059
4060 static struct md_sysfs_entry max_corr_read_errors =
4061 __ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
4062         max_corrected_read_errors_store);
4063
4064 static ssize_t
4065 null_show(struct mddev *mddev, char *page)
4066 {
4067         return -EINVAL;
4068 }
4069
4070 static ssize_t
4071 new_dev_store(struct mddev *mddev, const char *buf, size_t len)
4072 {
4073         /* buf must be %d:%d\n? giving major and minor numbers */
4074         /* The new device is added to the array.
4075          * If the array has a persistent superblock, we read the
4076          * superblock to initialise info and check validity.
4077          * Otherwise, only checking done is that in bind_rdev_to_array,
4078          * which mainly checks size.
4079          */
4080         char *e;
4081         int major = simple_strtoul(buf, &e, 10);
4082         int minor;
4083         dev_t dev;
4084         struct md_rdev *rdev;
4085         int err;
4086
4087         if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
4088                 return -EINVAL;
4089         minor = simple_strtoul(e+1, &e, 10);
4090         if (*e && *e != '\n')
4091                 return -EINVAL;
4092         dev = MKDEV(major, minor);
4093         if (major != MAJOR(dev) ||
4094             minor != MINOR(dev))
4095                 return -EOVERFLOW;
4096
4097         flush_workqueue(md_misc_wq);
4098
4099         err = mddev_lock(mddev);
4100         if (err)
4101                 return err;
4102         if (mddev->persistent) {
4103                 rdev = md_import_device(dev, mddev->major_version,
4104                                         mddev->minor_version);
4105                 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
4106                         struct md_rdev *rdev0
4107                                 = list_entry(mddev->disks.next,
4108                                              struct md_rdev, same_set);
4109                         err = super_types[mddev->major_version]
4110                                 .load_super(rdev, rdev0, mddev->minor_version);
4111                         if (err < 0)
4112                                 goto out;
4113                 }
4114         } else if (mddev->external)
4115                 rdev = md_import_device(dev, -2, -1);
4116         else
4117                 rdev = md_import_device(dev, -1, -1);
4118
4119         if (IS_ERR(rdev)) {
4120                 mddev_unlock(mddev);
4121                 return PTR_ERR(rdev);
4122         }
4123         err = bind_rdev_to_array(rdev, mddev);
4124  out:
4125         if (err)
4126                 export_rdev(rdev);
4127         mddev_unlock(mddev);
4128         return err ? err : len;
4129 }
4130
4131 static struct md_sysfs_entry md_new_device =
4132 __ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
4133
4134 static ssize_t
4135 bitmap_store(struct mddev *mddev, const char *buf, size_t len)
4136 {
4137         char *end;
4138         unsigned long chunk, end_chunk;
4139         int err;
4140
4141         err = mddev_lock(mddev);
4142         if (err)
4143                 return err;
4144         if (!mddev->bitmap)
4145                 goto out;
4146         /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
4147         while (*buf) {
4148                 chunk = end_chunk = simple_strtoul(buf, &end, 0);
4149                 if (buf == end) break;
4150                 if (*end == '-') { /* range */
4151                         buf = end + 1;
4152                         end_chunk = simple_strtoul(buf, &end, 0);
4153                         if (buf == end) break;
4154                 }
4155                 if (*end && !isspace(*end)) break;
4156                 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
4157                 buf = skip_spaces(end);
4158         }
4159         bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
4160 out:
4161         mddev_unlock(mddev);
4162         return len;
4163 }
4164
4165 static struct md_sysfs_entry md_bitmap =
4166 __ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
4167
4168 static ssize_t
4169 size_show(struct mddev *mddev, char *page)
4170 {
4171         return sprintf(page, "%llu\n",
4172                 (unsigned long long)mddev->dev_sectors / 2);
4173 }
4174
4175 static int update_size(struct mddev *mddev, sector_t num_sectors);
4176
4177 static ssize_t
4178 size_store(struct mddev *mddev, const char *buf, size_t len)
4179 {
4180         /* If array is inactive, we can reduce the component size, but
4181          * not increase it (except from 0).
4182          * If array is active, we can try an on-line resize
4183          */
4184         sector_t sectors;
4185         int err = strict_blocks_to_sectors(buf, &sectors);
4186
4187         if (err < 0)
4188                 return err;
4189         err = mddev_lock(mddev);
4190         if (err)
4191                 return err;
4192         if (mddev->pers) {
4193                 err = update_size(mddev, sectors);
4194                 md_update_sb(mddev, 1);
4195         } else {
4196                 if (mddev->dev_sectors == 0 ||
4197                     mddev->dev_sectors > sectors)
4198                         mddev->dev_sectors = sectors;
4199                 else
4200                         err = -ENOSPC;
4201         }
4202         mddev_unlock(mddev);
4203         return err ? err : len;
4204 }
4205
4206 static struct md_sysfs_entry md_size =
4207 __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
4208
4209 /* Metadata version.
4210  * This is one of
4211  *   'none' for arrays with no metadata (good luck...)
4212  *   'external' for arrays with externally managed metadata,
4213  * or N.M for internally known formats
4214  */
4215 static ssize_t
4216 metadata_show(struct mddev *mddev, char *page)
4217 {
4218         if (mddev->persistent)
4219                 return sprintf(page, "%d.%d\n",
4220                                mddev->major_version, mddev->minor_version);
4221         else if (mddev->external)
4222                 return sprintf(page, "external:%s\n", mddev->metadata_type);
4223         else
4224                 return sprintf(page, "none\n");
4225 }
4226
4227 static ssize_t
4228 metadata_store(struct mddev *mddev, const char *buf, size_t len)
4229 {
4230         int major, minor;
4231         char *e;
4232         int err;
4233         /* Changing the details of 'external' metadata is
4234          * always permitted.  Otherwise there must be
4235          * no devices attached to the array.
4236          */
4237
4238         err = mddev_lock(mddev);
4239         if (err)
4240                 return err;
4241         err = -EBUSY;
4242         if (mddev->external && strncmp(buf, "external:", 9) == 0)
4243                 ;
4244         else if (!list_empty(&mddev->disks))
4245                 goto out_unlock;
4246
4247         err = 0;
4248         if (cmd_match(buf, "none")) {
4249                 mddev->persistent = 0;
4250                 mddev->external = 0;
4251                 mddev->major_version = 0;
4252                 mddev->minor_version = 90;
4253                 goto out_unlock;
4254         }
4255         if (strncmp(buf, "external:", 9) == 0) {
4256                 size_t namelen = len-9;
4257                 if (namelen >= sizeof(mddev->metadata_type))
4258                         namelen = sizeof(mddev->metadata_type)-1;
4259                 strncpy(mddev->metadata_type, buf+9, namelen);
4260                 mddev->metadata_type[namelen] = 0;
4261                 if (namelen && mddev->metadata_type[namelen-1] == '\n')
4262                         mddev->metadata_type[--namelen] = 0;
4263                 mddev->persistent = 0;
4264                 mddev->external = 1;
4265                 mddev->major_version = 0;
4266                 mddev->minor_version = 90;
4267                 goto out_unlock;
4268         }
4269         major = simple_strtoul(buf, &e, 10);
4270         err = -EINVAL;
4271         if (e==buf || *e != '.')
4272                 goto out_unlock;
4273         buf = e+1;
4274         minor = simple_strtoul(buf, &e, 10);
4275         if (e==buf || (*e && *e != '\n') )
4276                 goto out_unlock;
4277         err = -ENOENT;
4278         if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
4279                 goto out_unlock;
4280         mddev->major_version = major;
4281         mddev->minor_version = minor;
4282         mddev->persistent = 1;
4283         mddev->external = 0;
4284         err = 0;
4285 out_unlock:
4286         mddev_unlock(mddev);
4287         return err ?: len;
4288 }
4289
4290 static struct md_sysfs_entry md_metadata =
4291 __ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
4292
4293 static ssize_t
4294 action_show(struct mddev *mddev, char *page)
4295 {
4296         char *type = "idle";
4297         unsigned long recovery = mddev->recovery;
4298         if (test_bit(MD_RECOVERY_FROZEN, &recovery))
4299                 type = "frozen";
4300         else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
4301             (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
4302                 if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
4303                         type = "reshape";
4304                 else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
4305                         if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
4306                                 type = "resync";
4307                         else if (test_bit(MD_RECOVERY_CHECK, &recovery))
4308                                 type = "check";
4309                         else
4310                                 type = "repair";
4311                 } else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
4312                         type = "recover";
4313                 else if (mddev->reshape_position != MaxSector)
4314                         type = "reshape";
4315         }
4316         return sprintf(page, "%s\n", type);
4317 }
4318
4319 static ssize_t
4320 action_store(struct mddev *mddev, const char *page, size_t len)
4321 {
4322         if (!mddev->pers || !mddev->pers->sync_request)
4323                 return -EINVAL;
4324
4325
4326         if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
4327                 if (cmd_match(page, "frozen"))
4328                         set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4329                 else
4330                         clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4331                 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
4332                     mddev_lock(mddev) == 0) {
4333                         flush_workqueue(md_misc_wq);
4334                         if (mddev->sync_thread) {
4335                                 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4336                                 md_reap_sync_thread(mddev);
4337                         }
4338                         mddev_unlock(mddev);
4339                 }
4340         } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4341                 return -EBUSY;
4342         else if (cmd_match(page, "resync"))
4343                 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4344         else if (cmd_match(page, "recover")) {
4345                 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4346                 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
4347         } else if (cmd_match(page, "reshape")) {
4348                 int err;
4349                 if (mddev->pers->start_reshape == NULL)
4350                         return -EINVAL;
4351                 err = mddev_lock(mddev);
4352                 if (!err) {
4353                         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4354                                 err =  -EBUSY;
4355                         else {
4356                                 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4357                                 err = mddev->pers->start_reshape(mddev);
4358                         }
4359                         mddev_unlock(mddev);
4360                 }
4361                 if (err)
4362                         return err;
4363                 sysfs_notify(&mddev->kobj, NULL, "degraded");
4364         } else {
4365                 if (cmd_match(page, "check"))
4366                         set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4367                 else if (!cmd_match(page, "repair"))
4368                         return -EINVAL;
4369                 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4370                 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
4371                 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4372         }
4373         if (mddev->ro == 2) {
4374                 /* A write to sync_action is enough to justify
4375                  * canceling read-auto mode
4376                  */
4377                 mddev->ro = 0;
4378                 md_wakeup_thread(mddev->sync_thread);
4379         }
4380         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4381         md_wakeup_thread(mddev->thread);
4382         sysfs_notify_dirent_safe(mddev->sysfs_action);
4383         return len;
4384 }
4385
4386 static struct md_sysfs_entry md_scan_mode =
4387 __ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
4388
4389 static ssize_t
4390 last_sync_action_show(struct mddev *mddev, char *page)
4391 {
4392         return sprintf(page, "%s\n", mddev->last_sync_action);
4393 }
4394
4395 static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action);
4396
4397 static ssize_t
4398 mismatch_cnt_show(struct mddev *mddev, char *page)
4399 {
4400         return sprintf(page, "%llu\n",
4401                        (unsigned long long)
4402                        atomic64_read(&mddev->resync_mismatches));
4403 }
4404
4405 static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
4406
4407 static ssize_t
4408 sync_min_show(struct mddev *mddev, char *page)
4409 {
4410         return sprintf(page, "%d (%s)\n", speed_min(mddev),
4411                        mddev->sync_speed_min ? "local": "system");
4412 }
4413
4414 static ssize_t
4415 sync_min_store(struct mddev *mddev, const char *buf, size_t len)
4416 {
4417         unsigned int min;
4418         int rv;
4419
4420         if (strncmp(buf, "system", 6)==0) {
4421                 min = 0;
4422         } else {
4423                 rv = kstrtouint(buf, 10, &min);
4424                 if (rv < 0)
4425                         return rv;
4426                 if (min == 0)
4427                         return -EINVAL;
4428         }
4429         mddev->sync_speed_min = min;
4430         return len;
4431 }
4432
4433 static struct md_sysfs_entry md_sync_min =
4434 __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
4435
4436 static ssize_t
4437 sync_max_show(struct mddev *mddev, char *page)
4438 {
4439         return sprintf(page, "%d (%s)\n", speed_max(mddev),
4440                        mddev->sync_speed_max ? "local": "system");
4441 }
4442
4443 static ssize_t
4444 sync_max_store(struct mddev *mddev, const char *buf, size_t len)
4445 {
4446         unsigned int max;
4447         int rv;
4448
4449         if (strncmp(buf, "system", 6)==0) {
4450                 max = 0;
4451         } else {
4452                 rv = kstrtouint(buf, 10, &max);
4453                 if (rv < 0)
4454                         return rv;
4455                 if (max == 0)
4456                         return -EINVAL;
4457         }
4458         mddev->sync_speed_max = max;
4459         return len;
4460 }
4461
4462 static struct md_sysfs_entry md_sync_max =
4463 __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
4464
4465 static ssize_t
4466 degraded_show(struct mddev *mddev, char *page)
4467 {
4468         return sprintf(page, "%d\n", mddev->degraded);
4469 }
4470 static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
4471
4472 static ssize_t
4473 sync_force_parallel_show(struct mddev *mddev, char *page)
4474 {
4475         return sprintf(page, "%d\n", mddev->parallel_resync);
4476 }
4477
4478 static ssize_t
4479 sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
4480 {
4481         long n;
4482
4483         if (kstrtol(buf, 10, &n))
4484                 return -EINVAL;
4485
4486         if (n != 0 && n != 1)
4487                 return -EINVAL;
4488
4489         mddev->parallel_resync = n;
4490
4491         if (mddev->sync_thread)
4492                 wake_up(&resync_wait);
4493
4494         return len;
4495 }
4496
4497 /* force parallel resync, even with shared block devices */
4498 static struct md_sysfs_entry md_sync_force_parallel =
4499 __ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
4500        sync_force_parallel_show, sync_force_parallel_store);
4501
4502 static ssize_t
4503 sync_speed_show(struct mddev *mddev, char *page)
4504 {
4505         unsigned long resync, dt, db;
4506         if (mddev->curr_resync == 0)
4507                 return sprintf(page, "none\n");
4508         resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
4509         dt = (jiffies - mddev->resync_mark) / HZ;
4510         if (!dt) dt++;
4511         db = resync - mddev->resync_mark_cnt;
4512         return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
4513 }
4514
4515 static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
4516
4517 static ssize_t
4518 sync_completed_show(struct mddev *mddev, char *page)
4519 {
4520         unsigned long long max_sectors, resync;
4521
4522         if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4523                 return sprintf(page, "none\n");
4524
4525         if (mddev->curr_resync == 1 ||
4526             mddev->curr_resync == 2)
4527                 return sprintf(page, "delayed\n");
4528
4529         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
4530             test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
4531                 max_sectors = mddev->resync_max_sectors;
4532         else
4533                 max_sectors = mddev->dev_sectors;
4534
4535         resync = mddev->curr_resync_completed;
4536         return sprintf(page, "%llu / %llu\n", resync, max_sectors);
4537 }
4538
4539 static struct md_sysfs_entry md_sync_completed =
4540         __ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL);
4541
4542 static ssize_t
4543 min_sync_show(struct mddev *mddev, char *page)
4544 {
4545         return sprintf(page, "%llu\n",
4546                        (unsigned long long)mddev->resync_min);
4547 }
4548 static ssize_t
4549 min_sync_store(struct mddev *mddev, const char *buf, size_t len)
4550 {
4551         unsigned long long min;
4552         int err;
4553
4554         if (kstrtoull(buf, 10, &min))
4555                 return -EINVAL;
4556
4557         spin_lock(&mddev->lock);
4558         err = -EINVAL;
4559         if (min > mddev->resync_max)
4560                 goto out_unlock;
4561
4562         err = -EBUSY;
4563         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4564                 goto out_unlock;
4565
4566         /* Round down to multiple of 4K for safety */
4567         mddev->resync_min = round_down(min, 8);
4568         err = 0;
4569
4570 out_unlock:
4571         spin_unlock(&mddev->lock);
4572         return err ?: len;
4573 }
4574
4575 static struct md_sysfs_entry md_min_sync =
4576 __ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
4577
4578 static ssize_t
4579 max_sync_show(struct mddev *mddev, char *page)
4580 {
4581         if (mddev->resync_max == MaxSector)
4582                 return sprintf(page, "max\n");
4583         else
4584                 return sprintf(page, "%llu\n",
4585                                (unsigned long long)mddev->resync_max);
4586 }
4587 static ssize_t
4588 max_sync_store(struct mddev *mddev, const char *buf, size_t len)
4589 {
4590         int err;
4591         spin_lock(&mddev->lock);
4592         if (strncmp(buf, "max", 3) == 0)
4593                 mddev->resync_max = MaxSector;
4594         else {
4595                 unsigned long long max;
4596                 int chunk;
4597
4598                 err = -EINVAL;
4599                 if (kstrtoull(buf, 10, &max))
4600                         goto out_unlock;
4601                 if (max < mddev->resync_min)
4602                         goto out_unlock;
4603
4604                 err = -EBUSY;
4605                 if (max < mddev->resync_max &&
4606                     mddev->ro == 0 &&
4607                     test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
4608                         goto out_unlock;
4609
4610                 /* Must be a multiple of chunk_size */
4611                 chunk = mddev->chunk_sectors;
4612                 if (chunk) {
4613                         sector_t temp = max;
4614
4615                         err = -EINVAL;
4616                         if (sector_div(temp, chunk))
4617                                 goto out_unlock;
4618                 }
4619                 mddev->resync_max = max;
4620         }
4621         wake_up(&mddev->recovery_wait);
4622         err = 0;
4623 out_unlock:
4624         spin_unlock(&mddev->lock);
4625         return err ?: len;
4626 }
4627
4628 static struct md_sysfs_entry md_max_sync =
4629 __ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
4630
4631 static ssize_t
4632 suspend_lo_show(struct mddev *mddev, char *page)
4633 {
4634         return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
4635 }
4636
4637 static ssize_t
4638 suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
4639 {
4640         unsigned long long old, new;
4641         int err;
4642
4643         err = kstrtoull(buf, 10, &new);
4644         if (err < 0)
4645                 return err;
4646         if (new != (sector_t)new)
4647                 return -EINVAL;
4648
4649         err = mddev_lock(mddev);
4650         if (err)
4651                 return err;
4652         err = -EINVAL;
4653         if (mddev->pers == NULL ||
4654             mddev->pers->quiesce == NULL)
4655                 goto unlock;
4656         old = mddev->suspend_lo;
4657         mddev->suspend_lo = new;
4658         if (new >= old)
4659                 /* Shrinking suspended region */
4660                 mddev->pers->quiesce(mddev, 2);
4661         else {
4662                 /* Expanding suspended region - need to wait */
4663                 mddev->pers->quiesce(mddev, 1);
4664                 mddev->pers->quiesce(mddev, 0);
4665         }
4666         err = 0;
4667 unlock:
4668         mddev_unlock(mddev);
4669         return err ?: len;
4670 }
4671 static struct md_sysfs_entry md_suspend_lo =
4672 __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
4673
4674 static ssize_t
4675 suspend_hi_show(struct mddev *mddev, char *page)
4676 {
4677         return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
4678 }
4679
4680 static ssize_t
4681 suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
4682 {
4683         unsigned long long old, new;
4684         int err;
4685
4686         err = kstrtoull(buf, 10, &new);
4687         if (err < 0)
4688                 return err;
4689         if (new != (sector_t)new)
4690                 return -EINVAL;
4691
4692         err = mddev_lock(mddev);
4693         if (err)
4694                 return err;
4695         err = -EINVAL;
4696         if (mddev->pers == NULL ||
4697             mddev->pers->quiesce == NULL)
4698                 goto unlock;
4699         old = mddev->suspend_hi;
4700         mddev->suspend_hi = new;
4701         if (new <= old)
4702                 /* Shrinking suspended region */
4703                 mddev->pers->quiesce(mddev, 2);
4704         else {
4705                 /* Expanding suspended region - need to wait */
4706                 mddev->pers->quiesce(mddev, 1);
4707                 mddev->pers->quiesce(mddev, 0);
4708         }
4709         err = 0;
4710 unlock:
4711         mddev_unlock(mddev);
4712         return err ?: len;
4713 }
4714 static struct md_sysfs_entry md_suspend_hi =
4715 __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
4716
4717 static ssize_t
4718 reshape_position_show(struct mddev *mddev, char *page)
4719 {
4720         if (mddev->reshape_position != MaxSector)
4721                 return sprintf(page, "%llu\n",
4722                                (unsigned long long)mddev->reshape_position);
4723         strcpy(page, "none\n");
4724         return 5;
4725 }
4726
4727 static ssize_t
4728 reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
4729 {
4730         struct md_rdev *rdev;
4731         unsigned long long new;
4732         int err;
4733
4734         err = kstrtoull(buf, 10, &new);
4735         if (err < 0)
4736                 return err;
4737         if (new != (sector_t)new)
4738                 return -EINVAL;
4739         err = mddev_lock(mddev);
4740         if (err)
4741                 return err;
4742         err = -EBUSY;
4743         if (mddev->pers)
4744                 goto unlock;
4745         mddev->reshape_position = new;
4746         mddev->delta_disks = 0;
4747         mddev->reshape_backwards = 0;
4748         mddev->new_level = mddev->level;
4749         mddev->new_layout = mddev->layout;
4750         mddev->new_chunk_sectors = mddev->chunk_sectors;
4751         rdev_for_each(rdev, mddev)
4752                 rdev->new_data_offset = rdev->data_offset;
4753         err = 0;
4754 unlock:
4755         mddev_unlock(mddev);
4756         return err ?: len;
4757 }
4758
4759 static struct md_sysfs_entry md_reshape_position =
4760 __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
4761        reshape_position_store);
4762
4763 static ssize_t
4764 reshape_direction_show(struct mddev *mddev, char *page)
4765 {
4766         return sprintf(page, "%s\n",
4767                        mddev->reshape_backwards ? "backwards" : "forwards");
4768 }
4769
4770 static ssize_t
4771 reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
4772 {
4773         int backwards = 0;
4774         int err;
4775
4776         if (cmd_match(buf, "forwards"))
4777                 backwards = 0;
4778         else if (cmd_match(buf, "backwards"))
4779                 backwards = 1;
4780         else
4781                 return -EINVAL;
4782         if (mddev->reshape_backwards == backwards)
4783                 return len;
4784
4785         err = mddev_lock(mddev);
4786         if (err)
4787                 return err;
4788         /* check if we are allowed to change */
4789         if (mddev->delta_disks)
4790                 err = -EBUSY;
4791         else if (mddev->persistent &&
4792             mddev->major_version == 0)
4793                 err =  -EINVAL;
4794         else
4795                 mddev->reshape_backwards = backwards;
4796         mddev_unlock(mddev);
4797         return err ?: len;
4798 }
4799
4800 static struct md_sysfs_entry md_reshape_direction =
4801 __ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
4802        reshape_direction_store);
4803
4804 static ssize_t
4805 array_size_show(struct mddev *mddev, char *page)
4806 {
4807         if (mddev->external_size)
4808                 return sprintf(page, "%llu\n",
4809                                (unsigned long long)mddev->array_sectors/2);
4810         else
4811                 return sprintf(page, "default\n");
4812 }
4813
4814 static ssize_t
4815 array_size_store(struct mddev *mddev, const char *buf, size_t len)
4816 {
4817         sector_t sectors;
4818         int err;
4819
4820         err = mddev_lock(mddev);
4821         if (err)
4822                 return err;
4823
4824         /* cluster raid doesn't support change array_sectors */
4825         if (mddev_is_clustered(mddev))
4826                 return -EINVAL;
4827
4828         if (strncmp(buf, "default", 7) == 0) {
4829                 if (mddev->pers)
4830                         sectors = mddev->pers->size(mddev, 0, 0);
4831                 else
4832                         sectors = mddev->array_sectors;
4833
4834                 mddev->external_size = 0;
4835         } else {
4836                 if (strict_blocks_to_sectors(buf, &sectors) < 0)
4837                         err = -EINVAL;
4838                 else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
4839                         err = -E2BIG;
4840                 else
4841                         mddev->external_size = 1;
4842         }
4843
4844         if (!err) {
4845                 mddev->array_sectors = sectors;
4846                 if (mddev->pers) {
4847                         set_capacity(mddev->gendisk, mddev->array_sectors);
4848                         revalidate_disk(mddev->gendisk);
4849                 }
4850         }
4851         mddev_unlock(mddev);
4852         return err ?: len;
4853 }
4854
4855 static struct md_sysfs_entry md_array_size =
4856 __ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
4857        array_size_store);
4858
4859 static struct attribute *md_default_attrs[] = {
4860         &md_level.attr,
4861         &md_layout.attr,
4862         &md_raid_disks.attr,
4863         &md_chunk_size.attr,
4864         &md_size.attr,
4865         &md_resync_start.attr,
4866         &md_metadata.attr,
4867         &md_new_device.attr,
4868         &md_safe_delay.attr,
4869         &md_array_state.attr,
4870         &md_reshape_position.attr,
4871         &md_reshape_direction.attr,
4872         &md_array_size.attr,
4873         &max_corr_read_errors.attr,
4874         NULL,
4875 };
4876
4877 static struct attribute *md_redundancy_attrs[] = {
4878         &md_scan_mode.attr,
4879         &md_last_scan_mode.attr,
4880         &md_mismatches.attr,
4881         &md_sync_min.attr,
4882         &md_sync_max.attr,
4883         &md_sync_speed.attr,
4884         &md_sync_force_parallel.attr,
4885         &md_sync_completed.attr,
4886         &md_min_sync.attr,
4887         &md_max_sync.attr,
4888         &md_suspend_lo.attr,
4889         &md_suspend_hi.attr,
4890         &md_bitmap.attr,
4891         &md_degraded.attr,
4892         NULL,
4893 };
4894 static struct attribute_group md_redundancy_group = {
4895         .name = NULL,
4896         .attrs = md_redundancy_attrs,
4897 };
4898
4899 static ssize_t
4900 md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
4901 {
4902         struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
4903         struct mddev *mddev = container_of(kobj, struct mddev, kobj);
4904         ssize_t rv;
4905
4906         if (!entry->show)
4907                 return -EIO;
4908         spin_lock(&all_mddevs_lock);
4909         if (list_empty(&mddev->all_mddevs)) {
4910                 spin_unlock(&all_mddevs_lock);
4911                 return -EBUSY;
4912         }
4913         mddev_get(mddev);
4914         spin_unlock(&all_mddevs_lock);
4915
4916         rv = entry->show(mddev, page);
4917         mddev_put(mddev);
4918         return rv;
4919 }
4920
4921 static ssize_t
4922 md_attr_store(struct kobject *kobj, struct attribute *attr,
4923               const char *page, size_t length)
4924 {
4925         struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
4926         struct mddev *mddev = container_of(kobj, struct mddev, kobj);
4927         ssize_t rv;
4928
4929         if (!entry->store)
4930                 return -EIO;
4931         if (!capable(CAP_SYS_ADMIN))
4932                 return -EACCES;
4933         spin_lock(&all_mddevs_lock);
4934         if (list_empty(&mddev->all_mddevs)) {
4935                 spin_unlock(&all_mddevs_lock);
4936                 return -EBUSY;
4937         }
4938         mddev_get(mddev);
4939         spin_unlock(&all_mddevs_lock);
4940         rv = entry->store(mddev, page, length);
4941         mddev_put(mddev);
4942         return rv;
4943 }
4944
4945 static void md_free(struct kobject *ko)
4946 {
4947         struct mddev *mddev = container_of(ko, struct mddev, kobj);
4948
4949         if (mddev->sysfs_state)
4950                 sysfs_put(mddev->sysfs_state);
4951
4952         if (mddev->queue)
4953                 blk_cleanup_queue(mddev->queue);
4954         if (mddev->gendisk) {
4955                 del_gendisk(mddev->gendisk);
4956                 put_disk(mddev->gendisk);
4957         }
4958
4959         kfree(mddev);
4960 }
4961
4962 static const struct sysfs_ops md_sysfs_ops = {
4963         .show   = md_attr_show,
4964         .store  = md_attr_store,
4965 };
4966 static struct kobj_type md_ktype = {
4967         .release        = md_free,
4968         .sysfs_ops      = &md_sysfs_ops,
4969         .default_attrs  = md_default_attrs,
4970 };
4971
4972 int mdp_major = 0;
4973
4974 static void mddev_delayed_delete(struct work_struct *ws)
4975 {
4976         struct mddev *mddev = container_of(ws, struct mddev, del_work);
4977
4978         sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
4979         kobject_del(&mddev->kobj);
4980         kobject_put(&mddev->kobj);
4981 }
4982
4983 static int md_alloc(dev_t dev, char *name)
4984 {
4985         static DEFINE_MUTEX(disks_mutex);
4986         struct mddev *mddev = mddev_find(dev);
4987         struct gendisk *disk;
4988         int partitioned;
4989         int shift;
4990         int unit;
4991         int error;
4992
4993         if (!mddev)
4994                 return -ENODEV;
4995
4996         partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
4997         shift = partitioned ? MdpMinorShift : 0;
4998         unit = MINOR(mddev->unit) >> shift;
4999
5000         /* wait for any previous instance of this device to be
5001          * completely removed (mddev_delayed_delete).
5002          */
5003         flush_workqueue(md_misc_wq);
5004
5005         mutex_lock(&disks_mutex);
5006         error = -EEXIST;
5007         if (mddev->gendisk)
5008                 goto abort;
5009
5010         if (name) {
5011                 /* Need to ensure that 'name' is not a duplicate.
5012                  */
5013                 struct mddev *mddev2;
5014                 spin_lock(&all_mddevs_lock);
5015
5016                 list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
5017                         if (mddev2->gendisk &&
5018                             strcmp(mddev2->gendisk->disk_name, name) == 0) {
5019                                 spin_unlock(&all_mddevs_lock);
5020                                 goto abort;
5021                         }
5022                 spin_unlock(&all_mddevs_lock);
5023         }
5024
5025         error = -ENOMEM;
5026         mddev->queue = blk_alloc_queue(GFP_KERNEL);
5027         if (!mddev->queue)
5028                 goto abort;
5029         mddev->queue->queuedata = mddev;
5030
5031         blk_queue_make_request(mddev->queue, md_make_request);
5032         blk_set_stacking_limits(&mddev->queue->limits);
5033
5034         disk = alloc_disk(1 << shift);
5035         if (!disk) {
5036                 blk_cleanup_queue(mddev->queue);
5037                 mddev->queue = NULL;
5038                 goto abort;
5039         }
5040         disk->major = MAJOR(mddev->unit);
5041         disk->first_minor = unit << shift;
5042         if (name)
5043                 strcpy(disk->disk_name, name);
5044         else if (partitioned)
5045                 sprintf(disk->disk_name, "md_d%d", unit);
5046         else
5047                 sprintf(disk->disk_name, "md%d", unit);
5048         disk->fops = &md_fops;
5049         disk->private_data = mddev;
5050         disk->queue = mddev->queue;
5051         blk_queue_write_cache(mddev->queue, true, true);
5052         /* Allow extended partitions.  This makes the
5053          * 'mdp' device redundant, but we can't really
5054          * remove it now.
5055          */
5056         disk->flags |= GENHD_FL_EXT_DEVT;
5057         mddev->gendisk = disk;
5058         /* As soon as we call add_disk(), another thread could get
5059          * through to md_open, so make sure it doesn't get too far
5060          */
5061         mutex_lock(&mddev->open_mutex);
5062         add_disk(disk);
5063
5064         error = kobject_init_and_add(&mddev->kobj, &md_ktype,
5065                                      &disk_to_dev(disk)->kobj, "%s", "md");
5066         if (error) {
5067                 /* This isn't possible, but as kobject_init_and_add is marked
5068                  * __must_check, we must do something with the result
5069                  */
5070                 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
5071                        disk->disk_name);
5072                 error = 0;
5073         }
5074         if (mddev->kobj.sd &&
5075             sysfs_create_group(&mddev->kobj, &md_bitmap_group))
5076                 printk(KERN_DEBUG "pointless warning\n");
5077         mutex_unlock(&mddev->open_mutex);
5078  abort:
5079         mutex_unlock(&disks_mutex);
5080         if (!error && mddev->kobj.sd) {
5081                 kobject_uevent(&mddev->kobj, KOBJ_ADD);
5082                 mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
5083         }
5084         mddev_put(mddev);
5085         return error;
5086 }
5087
5088 static struct kobject *md_probe(dev_t dev, int *part, void *data)
5089 {
5090         md_alloc(dev, NULL);
5091         return NULL;
5092 }
5093
5094 static int add_named_array(const char *val, struct kernel_param *kp)
5095 {
5096         /* val must be "md_*" where * is not all digits.
5097          * We allocate an array with a large free minor number, and
5098          * set the name to val.  val must not already be an active name.
5099          */
5100         int len = strlen(val);
5101         char buf[DISK_NAME_LEN];
5102
5103         while (len && val[len-1] == '\n')
5104                 len--;
5105         if (len >= DISK_NAME_LEN)
5106                 return -E2BIG;
5107         strlcpy(buf, val, len+1);
5108         if (strncmp(buf, "md_", 3) != 0)
5109                 return -EINVAL;
5110         return md_alloc(0, buf);
5111 }
5112
5113 static void md_safemode_timeout(unsigned long data)
5114 {
5115         struct mddev *mddev = (struct mddev *) data;
5116
5117         if (!atomic_read(&mddev->writes_pending)) {
5118                 mddev->safemode = 1;
5119                 if (mddev->external)
5120                         sysfs_notify_dirent_safe(mddev->sysfs_state);
5121         }
5122         md_wakeup_thread(mddev->thread);
5123 }
5124
5125 static int start_dirty_degraded;
5126
5127 int md_run(struct mddev *mddev)
5128 {
5129         int err;
5130         struct md_rdev *rdev;
5131         struct md_personality *pers;
5132
5133         if (list_empty(&mddev->disks))
5134                 /* cannot run an array with no devices.. */
5135                 return -EINVAL;
5136
5137         if (mddev->pers)
5138                 return -EBUSY;
5139         /* Cannot run until previous stop completes properly */
5140         if (mddev->sysfs_active)
5141                 return -EBUSY;
5142
5143         /*
5144          * Analyze all RAID superblock(s)
5145          */
5146         if (!mddev->raid_disks) {
5147                 if (!mddev->persistent)
5148                         return -EINVAL;
5149                 analyze_sbs(mddev);
5150         }
5151
5152         if (mddev->level != LEVEL_NONE)
5153                 request_module("md-level-%d", mddev->level);
5154         else if (mddev->clevel[0])
5155                 request_module("md-%s", mddev->clevel);
5156
5157         /*
5158          * Drop all container device buffers, from now on
5159          * the only valid external interface is through the md
5160          * device.
5161          */
5162         rdev_for_each(rdev, mddev) {
5163                 if (test_bit(Faulty, &rdev->flags))
5164                         continue;
5165                 sync_blockdev(rdev->bdev);
5166                 invalidate_bdev(rdev->bdev);
5167
5168                 /* perform some consistency tests on the device.
5169                  * We don't want the data to overlap the metadata,
5170                  * Internal Bitmap issues have been handled elsewhere.
5171                  */
5172                 if (rdev->meta_bdev) {
5173                         /* Nothing to check */;
5174                 } else if (rdev->data_offset < rdev->sb_start) {
5175                         if (mddev->dev_sectors &&
5176                             rdev->data_offset + mddev->dev_sectors
5177                             > rdev->sb_start) {
5178                                 printk("md: %s: data overlaps metadata\n",
5179                                        mdname(mddev));
5180                                 return -EINVAL;
5181                         }
5182                 } else {
5183                         if (rdev->sb_start + rdev->sb_size/512
5184                             > rdev->data_offset) {
5185                                 printk("md: %s: metadata overlaps data\n",
5186                                        mdname(mddev));
5187                                 return -EINVAL;
5188                         }
5189                 }
5190                 sysfs_notify_dirent_safe(rdev->sysfs_state);
5191         }
5192
5193         if (mddev->bio_set == NULL)
5194                 mddev->bio_set = bioset_create(BIO_POOL_SIZE, 0);
5195
5196         spin_lock(&pers_lock);
5197         pers = find_pers(mddev->level, mddev->clevel);
5198         if (!pers || !try_module_get(pers->owner)) {
5199                 spin_unlock(&pers_lock);
5200                 if (mddev->level != LEVEL_NONE)
5201                         printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
5202                                mddev->level);
5203                 else
5204                         printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
5205                                mddev->clevel);
5206                 return -EINVAL;
5207         }
5208         spin_unlock(&pers_lock);
5209         if (mddev->level != pers->level) {
5210                 mddev->level = pers->level;
5211                 mddev->new_level = pers->level;
5212         }
5213         strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
5214
5215         if (mddev->reshape_position != MaxSector &&
5216             pers->start_reshape == NULL) {
5217                 /* This personality cannot handle reshaping... */
5218                 module_put(pers->owner);
5219                 return -EINVAL;
5220         }
5221
5222         if (pers->sync_request) {
5223                 /* Warn if this is a potentially silly
5224                  * configuration.
5225                  */
5226                 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
5227                 struct md_rdev *rdev2;
5228                 int warned = 0;
5229
5230                 rdev_for_each(rdev, mddev)
5231                         rdev_for_each(rdev2, mddev) {
5232                                 if (rdev < rdev2 &&
5233                                     rdev->bdev->bd_contains ==
5234                                     rdev2->bdev->bd_contains) {
5235                                         printk(KERN_WARNING
5236                                                "%s: WARNING: %s appears to be"
5237                                                " on the same physical disk as"
5238                                                " %s.\n",
5239                                                mdname(mddev),
5240                                                bdevname(rdev->bdev,b),
5241                                                bdevname(rdev2->bdev,b2));
5242                                         warned = 1;
5243                                 }
5244                         }
5245
5246                 if (warned)
5247                         printk(KERN_WARNING
5248                                "True protection against single-disk"
5249                                " failure might be compromised.\n");
5250         }
5251
5252         mddev->recovery = 0;
5253         /* may be over-ridden by personality */
5254         mddev->resync_max_sectors = mddev->dev_sectors;
5255
5256         mddev->ok_start_degraded = start_dirty_degraded;
5257
5258         if (start_readonly && mddev->ro == 0)
5259                 mddev->ro = 2; /* read-only, but switch on first write */
5260
5261         err = pers->run(mddev);
5262         if (err)
5263                 printk(KERN_ERR "md: pers->run() failed ...\n");
5264         else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {
5265                 WARN_ONCE(!mddev->external_size, "%s: default size too small,"
5266                           " but 'external_size' not in effect?\n", __func__);
5267                 printk(KERN_ERR
5268                        "md: invalid array_size %llu > default size %llu\n",
5269                        (unsigned long long)mddev->array_sectors / 2,
5270                        (unsigned long long)pers->size(mddev, 0, 0) / 2);
5271                 err = -EINVAL;
5272         }
5273         if (err == 0 && pers->sync_request &&
5274             (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
5275                 struct bitmap *bitmap;
5276
5277                 bitmap = bitmap_create(mddev, -1);
5278                 if (IS_ERR(bitmap)) {
5279                         err = PTR_ERR(bitmap);
5280                         printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
5281                                mdname(mddev), err);
5282                 } else
5283                         mddev->bitmap = bitmap;
5284
5285         }
5286         if (err) {
5287                 mddev_detach(mddev);
5288                 if (mddev->private)
5289                         pers->free(mddev, mddev->private);
5290                 mddev->private = NULL;
5291                 module_put(pers->owner);
5292                 bitmap_destroy(mddev);
5293                 return err;
5294         }
5295         if (mddev->queue) {
5296                 mddev->queue->backing_dev_info.congested_data = mddev;
5297                 mddev->queue->backing_dev_info.congested_fn = md_congested;
5298         }
5299         if (pers->sync_request) {
5300                 if (mddev->kobj.sd &&
5301                     sysfs_create_group(&mddev->kobj, &md_redundancy_group))
5302                         printk(KERN_WARNING
5303                                "md: cannot register extra attributes for %s\n",
5304                                mdname(mddev));
5305                 mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
5306         } else if (mddev->ro == 2) /* auto-readonly not meaningful */
5307                 mddev->ro = 0;
5308
5309         atomic_set(&mddev->writes_pending,0);
5310         atomic_set(&mddev->max_corr_read_errors,
5311                    MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
5312         mddev->safemode = 0;
5313         if (mddev_is_clustered(mddev))
5314                 mddev->safemode_delay = 0;
5315         else
5316                 mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
5317         mddev->in_sync = 1;
5318         smp_wmb();
5319         spin_lock(&mddev->lock);
5320         mddev->pers = pers;
5321         spin_unlock(&mddev->lock);
5322         rdev_for_each(rdev, mddev)
5323                 if (rdev->raid_disk >= 0)
5324                         if (sysfs_link_rdev(mddev, rdev))
5325                                 /* failure here is OK */;
5326
5327         if (mddev->degraded && !mddev->ro)
5328                 /* This ensures that recovering status is reported immediately
5329                  * via sysfs - until a lack of spares is confirmed.
5330                  */
5331                 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5332         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5333
5334         if (mddev->flags & MD_UPDATE_SB_FLAGS)
5335                 md_update_sb(mddev, 0);
5336
5337         md_new_event(mddev);
5338         sysfs_notify_dirent_safe(mddev->sysfs_state);
5339         sysfs_notify_dirent_safe(mddev->sysfs_action);
5340         sysfs_notify(&mddev->kobj, NULL, "degraded");
5341         return 0;
5342 }
5343 EXPORT_SYMBOL_GPL(md_run);
5344
5345 static int do_md_run(struct mddev *mddev)
5346 {
5347         int err;
5348
5349         err = md_run(mddev);
5350         if (err)
5351                 goto out;
5352         err = bitmap_load(mddev);
5353         if (err) {
5354                 bitmap_destroy(mddev);
5355                 goto out;
5356         }
5357
5358         if (mddev_is_clustered(mddev))
5359                 md_allow_write(mddev);
5360
5361         md_wakeup_thread(mddev->thread);
5362         md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
5363
5364         set_capacity(mddev->gendisk, mddev->array_sectors);
5365         revalidate_disk(mddev->gendisk);
5366         mddev->changed = 1;
5367         kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
5368 out:
5369         return err;
5370 }
5371
5372 static int restart_array(struct mddev *mddev)
5373 {
5374         struct gendisk *disk = mddev->gendisk;
5375
5376         /* Complain if it has no devices */
5377         if (list_empty(&mddev->disks))
5378                 return -ENXIO;
5379         if (!mddev->pers)
5380                 return -EINVAL;
5381         if (!mddev->ro)
5382                 return -EBUSY;
5383         if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {
5384                 struct md_rdev *rdev;
5385                 bool has_journal = false;
5386
5387                 rcu_read_lock();
5388                 rdev_for_each_rcu(rdev, mddev) {
5389                         if (test_bit(Journal, &rdev->flags) &&
5390                             !test_bit(Faulty, &rdev->flags)) {
5391                                 has_journal = true;
5392                                 break;
5393                         }
5394                 }
5395                 rcu_read_unlock();
5396
5397                 /* Don't restart rw with journal missing/faulty */
5398                 if (!has_journal)
5399                         return -EINVAL;
5400         }
5401
5402         mddev->safemode = 0;
5403         mddev->ro = 0;
5404         set_disk_ro(disk, 0);
5405         printk(KERN_INFO "md: %s switched to read-write mode.\n",
5406                 mdname(mddev));
5407         /* Kick recovery or resync if necessary */
5408         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5409         md_wakeup_thread(mddev->thread);
5410         md_wakeup_thread(mddev->sync_thread);
5411         sysfs_notify_dirent_safe(mddev->sysfs_state);
5412         return 0;
5413 }
5414
5415 static void md_clean(struct mddev *mddev)
5416 {
5417         mddev->array_sectors = 0;
5418         mddev->external_size = 0;
5419         mddev->dev_sectors = 0;
5420         mddev->raid_disks = 0;
5421         mddev->recovery_cp = 0;
5422         mddev->resync_min = 0;
5423         mddev->resync_max = MaxSector;
5424         mddev->reshape_position = MaxSector;
5425         mddev->external = 0;
5426         mddev->persistent = 0;
5427         mddev->level = LEVEL_NONE;
5428         mddev->clevel[0] = 0;
5429         mddev->flags = 0;
5430         mddev->ro = 0;
5431         mddev->metadata_type[0] = 0;
5432         mddev->chunk_sectors = 0;
5433         mddev->ctime = mddev->utime = 0;
5434         mddev->layout = 0;
5435         mddev->max_disks = 0;
5436         mddev->events = 0;
5437         mddev->can_decrease_events = 0;
5438         mddev->delta_disks = 0;
5439         mddev->reshape_backwards = 0;
5440         mddev->new_level = LEVEL_NONE;
5441         mddev->new_layout = 0;
5442         mddev->new_chunk_sectors = 0;
5443         mddev->curr_resync = 0;
5444         atomic64_set(&mddev->resync_mismatches, 0);
5445         mddev->suspend_lo = mddev->suspend_hi = 0;
5446         mddev->sync_speed_min = mddev->sync_speed_max = 0;
5447         mddev->recovery = 0;
5448         mddev->in_sync = 0;
5449         mddev->changed = 0;
5450         mddev->degraded = 0;
5451         mddev->safemode = 0;
5452         mddev->private = NULL;
5453         mddev->bitmap_info.offset = 0;
5454         mddev->bitmap_info.default_offset = 0;
5455         mddev->bitmap_info.default_space = 0;
5456         mddev->bitmap_info.chunksize = 0;
5457         mddev->bitmap_info.daemon_sleep = 0;
5458         mddev->bitmap_info.max_write_behind = 0;
5459 }
5460
5461 static void __md_stop_writes(struct mddev *mddev)
5462 {
5463         set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5464         flush_workqueue(md_misc_wq);
5465         if (mddev->sync_thread) {
5466                 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5467                 md_reap_sync_thread(mddev);
5468         }
5469
5470         del_timer_sync(&mddev->safemode_timer);
5471
5472         bitmap_flush(mddev);
5473         md_super_wait(mddev);
5474
5475         if (mddev->ro == 0 &&
5476             ((!mddev->in_sync && !mddev_is_clustered(mddev)) ||
5477              (mddev->flags & MD_UPDATE_SB_FLAGS))) {
5478                 /* mark array as shutdown cleanly */
5479                 if (!mddev_is_clustered(mddev))
5480                         mddev->in_sync = 1;
5481                 md_update_sb(mddev, 1);
5482         }
5483 }
5484
5485 void md_stop_writes(struct mddev *mddev)
5486 {
5487         mddev_lock_nointr(mddev);
5488         __md_stop_writes(mddev);
5489         mddev_unlock(mddev);
5490 }
5491 EXPORT_SYMBOL_GPL(md_stop_writes);
5492
5493 static void mddev_detach(struct mddev *mddev)
5494 {
5495         struct bitmap *bitmap = mddev->bitmap;
5496         /* wait for behind writes to complete */
5497         if (bitmap && atomic_read(&bitmap->behind_writes) > 0) {
5498                 printk(KERN_INFO "md:%s: behind writes in progress - waiting to stop.\n",
5499                        mdname(mddev));
5500                 /* need to kick something here to make sure I/O goes? */
5501                 wait_event(bitmap->behind_wait,
5502                            atomic_read(&bitmap->behind_writes) == 0);
5503         }
5504         if (mddev->pers && mddev->pers->quiesce) {
5505                 mddev->pers->quiesce(mddev, 1);
5506                 mddev->pers->quiesce(mddev, 0);
5507         }
5508         md_unregister_thread(&mddev->thread);
5509         if (mddev->queue)
5510                 blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
5511 }
5512
5513 static void __md_stop(struct mddev *mddev)
5514 {
5515         struct md_personality *pers = mddev->pers;
5516         mddev_detach(mddev);
5517         /* Ensure ->event_work is done */
5518         flush_workqueue(md_misc_wq);
5519         spin_lock(&mddev->lock);
5520         mddev->pers = NULL;
5521         spin_unlock(&mddev->lock);
5522         pers->free(mddev, mddev->private);
5523         mddev->private = NULL;
5524         if (pers->sync_request && mddev->to_remove == NULL)
5525                 mddev->to_remove = &md_redundancy_group;
5526         module_put(pers->owner);
5527         clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5528 }
5529
5530 void md_stop(struct mddev *mddev)
5531 {
5532         /* stop the array and free an attached data structures.
5533          * This is called from dm-raid
5534          */
5535         __md_stop(mddev);
5536         bitmap_destroy(mddev);
5537         if (mddev->bio_set)
5538                 bioset_free(mddev->bio_set);
5539 }
5540
5541 EXPORT_SYMBOL_GPL(md_stop);
5542
5543 static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
5544 {
5545         int err = 0;
5546         int did_freeze = 0;
5547
5548         if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
5549                 did_freeze = 1;
5550                 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5551                 md_wakeup_thread(mddev->thread);
5552         }
5553         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5554                 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5555         if (mddev->sync_thread)
5556                 /* Thread might be blocked waiting for metadata update
5557                  * which will now never happen */
5558                 wake_up_process(mddev->sync_thread->tsk);
5559
5560         if (mddev->external && test_bit(MD_CHANGE_PENDING, &mddev->flags))
5561                 return -EBUSY;
5562         mddev_unlock(mddev);
5563         wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING,
5564                                           &mddev->recovery));
5565         wait_event(mddev->sb_wait,
5566                    !test_bit(MD_CHANGE_PENDING, &mddev->flags));
5567         mddev_lock_nointr(mddev);
5568
5569         mutex_lock(&mddev->open_mutex);
5570         if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
5571             mddev->sync_thread ||
5572             test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
5573             (bdev && !test_bit(MD_STILL_CLOSED, &mddev->flags))) {
5574                 printk("md: %s still in use.\n",mdname(mddev));
5575                 if (did_freeze) {
5576                         clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5577                         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5578                         md_wakeup_thread(mddev->thread);
5579                 }
5580                 err = -EBUSY;
5581                 goto out;
5582         }
5583         if (mddev->pers) {
5584                 __md_stop_writes(mddev);
5585
5586                 err  = -ENXIO;
5587                 if (mddev->ro==1)
5588                         goto out;
5589                 mddev->ro = 1;
5590                 set_disk_ro(mddev->gendisk, 1);
5591                 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5592                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5593                 md_wakeup_thread(mddev->thread);
5594                 sysfs_notify_dirent_safe(mddev->sysfs_state);
5595                 err = 0;
5596         }
5597 out:
5598         mutex_unlock(&mddev->open_mutex);
5599         return err;
5600 }
5601
5602 /* mode:
5603  *   0 - completely stop and dis-assemble array
5604  *   2 - stop but do not disassemble array
5605  */
5606 static int do_md_stop(struct mddev *mddev, int mode,
5607                       struct block_device *bdev)
5608 {
5609         struct gendisk *disk = mddev->gendisk;
5610         struct md_rdev *rdev;
5611         int did_freeze = 0;
5612
5613         if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
5614                 did_freeze = 1;
5615                 set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5616                 md_wakeup_thread(mddev->thread);
5617         }
5618         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
5619                 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5620         if (mddev->sync_thread)
5621                 /* Thread might be blocked waiting for metadata update
5622                  * which will now never happen */
5623                 wake_up_process(mddev->sync_thread->tsk);
5624
5625         mddev_unlock(mddev);
5626         wait_event(resync_wait, (mddev->sync_thread == NULL &&
5627                                  !test_bit(MD_RECOVERY_RUNNING,
5628                                            &mddev->recovery)));
5629         mddev_lock_nointr(mddev);
5630
5631         mutex_lock(&mddev->open_mutex);
5632         if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
5633             mddev->sysfs_active ||
5634             mddev->sync_thread ||
5635             test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
5636             (bdev && !test_bit(MD_STILL_CLOSED, &mddev->flags))) {
5637                 printk("md: %s still in use.\n",mdname(mddev));
5638                 mutex_unlock(&mddev->open_mutex);
5639                 if (did_freeze) {
5640                         clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5641                         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5642                         md_wakeup_thread(mddev->thread);
5643                 }
5644                 return -EBUSY;
5645         }
5646         if (mddev->pers) {
5647                 if (mddev->ro)
5648                         set_disk_ro(disk, 0);
5649
5650                 __md_stop_writes(mddev);
5651                 __md_stop(mddev);
5652                 mddev->queue->backing_dev_info.congested_fn = NULL;
5653
5654                 /* tell userspace to handle 'inactive' */
5655                 sysfs_notify_dirent_safe(mddev->sysfs_state);
5656
5657                 rdev_for_each(rdev, mddev)
5658                         if (rdev->raid_disk >= 0)
5659                                 sysfs_unlink_rdev(mddev, rdev);
5660
5661                 set_capacity(disk, 0);
5662                 mutex_unlock(&mddev->open_mutex);
5663                 mddev->changed = 1;
5664                 revalidate_disk(disk);
5665
5666                 if (mddev->ro)
5667                         mddev->ro = 0;
5668         } else
5669                 mutex_unlock(&mddev->open_mutex);
5670         /*
5671          * Free resources if final stop
5672          */
5673         if (mode == 0) {
5674                 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
5675
5676                 bitmap_destroy(mddev);
5677                 if (mddev->bitmap_info.file) {
5678                         struct file *f = mddev->bitmap_info.file;
5679                         spin_lock(&mddev->lock);
5680                         mddev->bitmap_info.file = NULL;
5681                         spin_unlock(&mddev->lock);
5682                         fput(f);
5683                 }
5684                 mddev->bitmap_info.offset = 0;
5685
5686                 export_array(mddev);
5687
5688                 md_clean(mddev);
5689                 if (mddev->hold_active == UNTIL_STOP)
5690                         mddev->hold_active = 0;
5691         }
5692         md_new_event(mddev);
5693         sysfs_notify_dirent_safe(mddev->sysfs_state);
5694         return 0;
5695 }
5696
5697 #ifndef MODULE
5698 static void autorun_array(struct mddev *mddev)
5699 {
5700         struct md_rdev *rdev;
5701         int err;
5702
5703         if (list_empty(&mddev->disks))
5704                 return;
5705
5706         printk(KERN_INFO "md: running: ");
5707
5708         rdev_for_each(rdev, mddev) {
5709                 char b[BDEVNAME_SIZE];
5710                 printk("<%s>", bdevname(rdev->bdev,b));
5711         }
5712         printk("\n");
5713
5714         err = do_md_run(mddev);
5715         if (err) {
5716                 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
5717                 do_md_stop(mddev, 0, NULL);
5718         }
5719 }
5720
5721 /*
5722  * lets try to run arrays based on all disks that have arrived
5723  * until now. (those are in pending_raid_disks)
5724  *
5725  * the method: pick the first pending disk, collect all disks with
5726  * the same UUID, remove all from the pending list and put them into
5727  * the 'same_array' list. Then order this list based on superblock
5728  * update time (freshest comes first), kick out 'old' disks and
5729  * compare superblocks. If everything's fine then run it.
5730  *
5731  * If "unit" is allocated, then bump its reference count
5732  */
5733 static void autorun_devices(int part)
5734 {
5735         struct md_rdev *rdev0, *rdev, *tmp;
5736         struct mddev *mddev;
5737         char b[BDEVNAME_SIZE];
5738
5739         printk(KERN_INFO "md: autorun ...\n");
5740         while (!list_empty(&pending_raid_disks)) {
5741                 int unit;
5742                 dev_t dev;
5743                 LIST_HEAD(candidates);
5744                 rdev0 = list_entry(pending_raid_disks.next,
5745                                          struct md_rdev, same_set);
5746
5747                 printk(KERN_INFO "md: considering %s ...\n",
5748                         bdevname(rdev0->bdev,b));
5749                 INIT_LIST_HEAD(&candidates);
5750                 rdev_for_each_list(rdev, tmp, &pending_raid_disks)
5751                         if (super_90_load(rdev, rdev0, 0) >= 0) {
5752                                 printk(KERN_INFO "md:  adding %s ...\n",
5753                                         bdevname(rdev->bdev,b));
5754                                 list_move(&rdev->same_set, &candidates);
5755                         }
5756                 /*
5757                  * now we have a set of devices, with all of them having
5758                  * mostly sane superblocks. It's time to allocate the
5759                  * mddev.
5760                  */
5761                 if (part) {
5762                         dev = MKDEV(mdp_major,
5763                                     rdev0->preferred_minor << MdpMinorShift);
5764                         unit = MINOR(dev) >> MdpMinorShift;
5765                 } else {
5766                         dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
5767                         unit = MINOR(dev);
5768                 }
5769                 if (rdev0->preferred_minor != unit) {
5770                         printk(KERN_INFO "md: unit number in %s is bad: %d\n",
5771                                bdevname(rdev0->bdev, b), rdev0->preferred_minor);
5772                         break;
5773                 }
5774
5775                 md_probe(dev, NULL, NULL);
5776                 mddev = mddev_find(dev);
5777                 if (!mddev || !mddev->gendisk) {
5778                         if (mddev)
5779                                 mddev_put(mddev);
5780                         printk(KERN_ERR
5781                                 "md: cannot allocate memory for md drive.\n");
5782                         break;
5783                 }
5784                 if (mddev_lock(mddev))
5785                         printk(KERN_WARNING "md: %s locked, cannot run\n",
5786                                mdname(mddev));
5787                 else if (mddev->raid_disks || mddev->major_version
5788                          || !list_empty(&mddev->disks)) {
5789                         printk(KERN_WARNING
5790                                 "md: %s already running, cannot run %s\n",
5791                                 mdname(mddev), bdevname(rdev0->bdev,b));
5792                         mddev_unlock(mddev);
5793                 } else {
5794                         printk(KERN_INFO "md: created %s\n", mdname(mddev));
5795                         mddev->persistent = 1;
5796                         rdev_for_each_list(rdev, tmp, &candidates) {
5797                                 list_del_init(&rdev->same_set);
5798                                 if (bind_rdev_to_array(rdev, mddev))
5799                                         export_rdev(rdev);
5800                         }
5801                         autorun_array(mddev);
5802                         mddev_unlock(mddev);
5803                 }
5804                 /* on success, candidates will be empty, on error
5805                  * it won't...
5806                  */
5807                 rdev_for_each_list(rdev, tmp, &candidates) {
5808                         list_del_init(&rdev->same_set);
5809                         export_rdev(rdev);
5810                 }
5811                 mddev_put(mddev);
5812         }
5813         printk(KERN_INFO "md: ... autorun DONE.\n");
5814 }
5815 #endif /* !MODULE */
5816
5817 static int get_version(void __user *arg)
5818 {
5819         mdu_version_t ver;
5820
5821         ver.major = MD_MAJOR_VERSION;
5822         ver.minor = MD_MINOR_VERSION;
5823         ver.patchlevel = MD_PATCHLEVEL_VERSION;
5824
5825         if (copy_to_user(arg, &ver, sizeof(ver)))
5826                 return -EFAULT;
5827
5828         return 0;
5829 }
5830
5831 static int get_array_info(struct mddev *mddev, void __user *arg)
5832 {
5833         mdu_array_info_t info;
5834         int nr,working,insync,failed,spare;
5835         struct md_rdev *rdev;
5836
5837         nr = working = insync = failed = spare = 0;
5838         rcu_read_lock();
5839         rdev_for_each_rcu(rdev, mddev) {
5840                 nr++;
5841                 if (test_bit(Faulty, &rdev->flags))
5842                         failed++;
5843                 else {
5844                         working++;
5845                         if (test_bit(In_sync, &rdev->flags))
5846                                 insync++;
5847                         else
5848                                 spare++;
5849                 }
5850         }
5851         rcu_read_unlock();
5852
5853         info.major_version = mddev->major_version;
5854         info.minor_version = mddev->minor_version;
5855         info.patch_version = MD_PATCHLEVEL_VERSION;
5856         info.ctime         = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
5857         info.level         = mddev->level;
5858         info.size          = mddev->dev_sectors / 2;
5859         if (info.size != mddev->dev_sectors / 2) /* overflow */
5860                 info.size = -1;
5861         info.nr_disks      = nr;
5862         info.raid_disks    = mddev->raid_disks;
5863         info.md_minor      = mddev->md_minor;
5864         info.not_persistent= !mddev->persistent;
5865
5866         info.utime         = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
5867         info.state         = 0;
5868         if (mddev->in_sync)
5869                 info.state = (1<<MD_SB_CLEAN);
5870         if (mddev->bitmap && mddev->bitmap_info.offset)
5871                 info.state |= (1<<MD_SB_BITMAP_PRESENT);
5872         if (mddev_is_clustered(mddev))
5873                 info.state |= (1<<MD_SB_CLUSTERED);
5874         info.active_disks  = insync;
5875         info.working_disks = working;
5876         info.failed_disks  = failed;
5877         info.spare_disks   = spare;
5878
5879         info.layout        = mddev->layout;
5880         info.chunk_size    = mddev->chunk_sectors << 9;
5881
5882         if (copy_to_user(arg, &info, sizeof(info)))
5883                 return -EFAULT;
5884
5885         return 0;
5886 }
5887
5888 static int get_bitmap_file(struct mddev *mddev, void __user * arg)
5889 {
5890         mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
5891         char *ptr;
5892         int err;
5893
5894         file = kzalloc(sizeof(*file), GFP_NOIO);
5895         if (!file)
5896                 return -ENOMEM;
5897
5898         err = 0;
5899         spin_lock(&mddev->lock);
5900         /* bitmap enabled */
5901         if (mddev->bitmap_info.file) {
5902                 ptr = file_path(mddev->bitmap_info.file, file->pathname,
5903                                 sizeof(file->pathname));
5904                 if (IS_ERR(ptr))
5905                         err = PTR_ERR(ptr);
5906                 else
5907                         memmove(file->pathname, ptr,
5908                                 sizeof(file->pathname)-(ptr-file->pathname));
5909         }
5910         spin_unlock(&mddev->lock);
5911
5912         if (err == 0 &&
5913             copy_to_user(arg, file, sizeof(*file)))
5914                 err = -EFAULT;
5915
5916         kfree(file);
5917         return err;
5918 }
5919
5920 static int get_disk_info(struct mddev *mddev, void __user * arg)
5921 {
5922         mdu_disk_info_t info;
5923         struct md_rdev *rdev;
5924
5925         if (copy_from_user(&info, arg, sizeof(info)))
5926                 return -EFAULT;
5927
5928         rcu_read_lock();
5929         rdev = md_find_rdev_nr_rcu(mddev, info.number);
5930         if (rdev) {
5931                 info.major = MAJOR(rdev->bdev->bd_dev);
5932                 info.minor = MINOR(rdev->bdev->bd_dev);
5933                 info.raid_disk = rdev->raid_disk;
5934                 info.state = 0;
5935                 if (test_bit(Faulty, &rdev->flags))
5936                         info.state |= (1<<MD_DISK_FAULTY);
5937                 else if (test_bit(In_sync, &rdev->flags)) {
5938                         info.state |= (1<<MD_DISK_ACTIVE);
5939                         info.state |= (1<<MD_DISK_SYNC);
5940                 }
5941                 if (test_bit(Journal, &rdev->flags))
5942                         info.state |= (1<<MD_DISK_JOURNAL);
5943                 if (test_bit(WriteMostly, &rdev->flags))
5944                         info.state |= (1<<MD_DISK_WRITEMOSTLY);
5945         } else {
5946                 info.major = info.minor = 0;
5947                 info.raid_disk = -1;
5948                 info.state = (1<<MD_DISK_REMOVED);
5949         }
5950         rcu_read_unlock();
5951
5952         if (copy_to_user(arg, &info, sizeof(info)))
5953                 return -EFAULT;
5954
5955         return 0;
5956 }
5957
5958 static int add_new_disk(struct mddev *mddev, mdu_disk_info_t *info)
5959 {
5960         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
5961         struct md_rdev *rdev;
5962         dev_t dev = MKDEV(info->major,info->minor);
5963
5964         if (mddev_is_clustered(mddev) &&
5965                 !(info->state & ((1 << MD_DISK_CLUSTER_ADD) | (1 << MD_DISK_CANDIDATE)))) {
5966                 pr_err("%s: Cannot add to clustered mddev.\n",
5967                                mdname(mddev));
5968                 return -EINVAL;
5969         }
5970
5971         if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
5972                 return -EOVERFLOW;
5973
5974         if (!mddev->raid_disks) {
5975                 int err;
5976                 /* expecting a device which has a superblock */
5977                 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
5978                 if (IS_ERR(rdev)) {
5979                         printk(KERN_WARNING
5980                                 "md: md_import_device returned %ld\n",
5981                                 PTR_ERR(rdev));
5982                         return PTR_ERR(rdev);
5983                 }
5984                 if (!list_empty(&mddev->disks)) {
5985                         struct md_rdev *rdev0
5986                                 = list_entry(mddev->disks.next,
5987                                              struct md_rdev, same_set);
5988                         err = super_types[mddev->major_version]
5989                                 .load_super(rdev, rdev0, mddev->minor_version);
5990                         if (err < 0) {
5991                                 printk(KERN_WARNING
5992                                         "md: %s has different UUID to %s\n",
5993                                         bdevname(rdev->bdev,b),
5994                                         bdevname(rdev0->bdev,b2));
5995                                 export_rdev(rdev);
5996                                 return -EINVAL;
5997                         }
5998                 }
5999                 err = bind_rdev_to_array(rdev, mddev);
6000                 if (err)
6001                         export_rdev(rdev);
6002                 return err;
6003         }
6004
6005         /*
6006          * add_new_disk can be used once the array is assembled
6007          * to add "hot spares".  They must already have a superblock
6008          * written
6009          */
6010         if (mddev->pers) {
6011                 int err;
6012                 if (!mddev->pers->hot_add_disk) {
6013                         printk(KERN_WARNING
6014                                 "%s: personality does not support diskops!\n",
6015                                mdname(mddev));
6016                         return -EINVAL;
6017                 }
6018                 if (mddev->persistent)
6019                         rdev = md_import_device(dev, mddev->major_version,
6020                                                 mddev->minor_version);
6021                 else
6022                         rdev = md_import_device(dev, -1, -1);
6023                 if (IS_ERR(rdev)) {
6024                         printk(KERN_WARNING
6025                                 "md: md_import_device returned %ld\n",
6026                                 PTR_ERR(rdev));
6027                         return PTR_ERR(rdev);
6028                 }
6029                 /* set saved_raid_disk if appropriate */
6030                 if (!mddev->persistent) {
6031                         if (info->state & (1<<MD_DISK_SYNC)  &&
6032                             info->raid_disk < mddev->raid_disks) {
6033                                 rdev->raid_disk = info->raid_disk;
6034                                 set_bit(In_sync, &rdev->flags);
6035                                 clear_bit(Bitmap_sync, &rdev->flags);
6036                         } else
6037                                 rdev->raid_disk = -1;
6038                         rdev->saved_raid_disk = rdev->raid_disk;
6039                 } else
6040                         super_types[mddev->major_version].
6041                                 validate_super(mddev, rdev);
6042                 if ((info->state & (1<<MD_DISK_SYNC)) &&
6043                      rdev->raid_disk != info->raid_disk) {
6044                         /* This was a hot-add request, but events doesn't
6045                          * match, so reject it.
6046                          */
6047                         export_rdev(rdev);
6048                         return -EINVAL;
6049                 }
6050
6051                 clear_bit(In_sync, &rdev->flags); /* just to be sure */
6052                 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6053                         set_bit(WriteMostly, &rdev->flags);
6054                 else
6055                         clear_bit(WriteMostly, &rdev->flags);
6056
6057                 if (info->state & (1<<MD_DISK_JOURNAL)) {
6058                         struct md_rdev *rdev2;
6059                         bool has_journal = false;
6060
6061                         /* make sure no existing journal disk */
6062                         rdev_for_each(rdev2, mddev) {
6063                                 if (test_bit(Journal, &rdev2->flags)) {
6064                                         has_journal = true;
6065                                         break;
6066                                 }
6067                         }
6068                         if (has_journal) {
6069                                 export_rdev(rdev);
6070                                 return -EBUSY;
6071                         }
6072                         set_bit(Journal, &rdev->flags);
6073                 }
6074                 /*
6075                  * check whether the device shows up in other nodes
6076                  */
6077                 if (mddev_is_clustered(mddev)) {
6078                         if (info->state & (1 << MD_DISK_CANDIDATE))
6079                                 set_bit(Candidate, &rdev->flags);
6080                         else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
6081                                 /* --add initiated by this node */
6082                                 err = md_cluster_ops->add_new_disk(mddev, rdev);
6083                                 if (err) {
6084                                         export_rdev(rdev);
6085                                         return err;
6086                                 }
6087                         }
6088                 }
6089
6090                 rdev->raid_disk = -1;
6091                 err = bind_rdev_to_array(rdev, mddev);
6092
6093                 if (err)
6094                         export_rdev(rdev);
6095
6096                 if (mddev_is_clustered(mddev)) {
6097                         if (info->state & (1 << MD_DISK_CANDIDATE))
6098                                 md_cluster_ops->new_disk_ack(mddev, (err == 0));
6099                         else {
6100                                 if (err)
6101                                         md_cluster_ops->add_new_disk_cancel(mddev);
6102                                 else
6103                                         err = add_bound_rdev(rdev);
6104                         }
6105
6106                 } else if (!err)
6107                         err = add_bound_rdev(rdev);
6108
6109                 return err;
6110         }
6111
6112         /* otherwise, add_new_disk is only allowed
6113          * for major_version==0 superblocks
6114          */
6115         if (mddev->major_version != 0) {
6116                 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
6117                        mdname(mddev));
6118                 return -EINVAL;
6119         }
6120
6121         if (!(info->state & (1<<MD_DISK_FAULTY))) {
6122                 int err;
6123                 rdev = md_import_device(dev, -1, 0);
6124                 if (IS_ERR(rdev)) {
6125                         printk(KERN_WARNING
6126                                 "md: error, md_import_device() returned %ld\n",
6127                                 PTR_ERR(rdev));
6128                         return PTR_ERR(rdev);
6129                 }
6130                 rdev->desc_nr = info->number;
6131                 if (info->raid_disk < mddev->raid_disks)
6132                         rdev->raid_disk = info->raid_disk;
6133                 else
6134                         rdev->raid_disk = -1;
6135
6136                 if (rdev->raid_disk < mddev->raid_disks)
6137                         if (info->state & (1<<MD_DISK_SYNC))
6138                                 set_bit(In_sync, &rdev->flags);
6139
6140                 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
6141                         set_bit(WriteMostly, &rdev->flags);
6142
6143                 if (!mddev->persistent) {
6144                         printk(KERN_INFO "md: nonpersistent superblock ...\n");
6145                         rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
6146                 } else
6147                         rdev->sb_start = calc_dev_sboffset(rdev);
6148                 rdev->sectors = rdev->sb_start;
6149
6150                 err = bind_rdev_to_array(rdev, mddev);
6151                 if (err) {
6152                         export_rdev(rdev);
6153                         return err;
6154                 }
6155         }
6156
6157         return 0;
6158 }
6159
6160 static int hot_remove_disk(struct mddev *mddev, dev_t dev)
6161 {
6162         char b[BDEVNAME_SIZE];
6163         struct md_rdev *rdev;
6164
6165         rdev = find_rdev(mddev, dev);
6166         if (!rdev)
6167                 return -ENXIO;
6168
6169         if (rdev->raid_disk < 0)
6170                 goto kick_rdev;
6171
6172         clear_bit(Blocked, &rdev->flags);
6173         remove_and_add_spares(mddev, rdev);
6174
6175         if (rdev->raid_disk >= 0)
6176                 goto busy;
6177
6178 kick_rdev:
6179         if (mddev_is_clustered(mddev))
6180                 md_cluster_ops->remove_disk(mddev, rdev);
6181
6182         md_kick_rdev_from_array(rdev);
6183         md_update_sb(mddev, 1);
6184         md_new_event(mddev);
6185
6186         return 0;
6187 busy:
6188         printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
6189                 bdevname(rdev->bdev,b), mdname(mddev));
6190         return -EBUSY;
6191 }
6192
6193 static int hot_add_disk(struct mddev *mddev, dev_t dev)
6194 {
6195         char b[BDEVNAME_SIZE];
6196         int err;
6197         struct md_rdev *rdev;
6198
6199         if (!mddev->pers)
6200                 return -ENODEV;
6201
6202         if (mddev->major_version != 0) {
6203                 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
6204                         " version-0 superblocks.\n",
6205                         mdname(mddev));
6206                 return -EINVAL;
6207         }
6208         if (!mddev->pers->hot_add_disk) {
6209                 printk(KERN_WARNING
6210                         "%s: personality does not support diskops!\n",
6211                         mdname(mddev));
6212                 return -EINVAL;
6213         }
6214
6215         rdev = md_import_device(dev, -1, 0);
6216         if (IS_ERR(rdev)) {
6217                 printk(KERN_WARNING
6218                         "md: error, md_import_device() returned %ld\n",
6219                         PTR_ERR(rdev));
6220                 return -EINVAL;
6221         }
6222
6223         if (mddev->persistent)
6224                 rdev->sb_start = calc_dev_sboffset(rdev);
6225         else
6226                 rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
6227
6228         rdev->sectors = rdev->sb_start;
6229
6230         if (test_bit(Faulty, &rdev->flags)) {
6231                 printk(KERN_WARNING
6232                         "md: can not hot-add faulty %s disk to %s!\n",
6233                         bdevname(rdev->bdev,b), mdname(mddev));
6234                 err = -EINVAL;
6235                 goto abort_export;
6236         }
6237
6238         clear_bit(In_sync, &rdev->flags);
6239         rdev->desc_nr = -1;
6240         rdev->saved_raid_disk = -1;
6241         err = bind_rdev_to_array(rdev, mddev);
6242         if (err)
6243                 goto abort_export;
6244
6245         /*
6246          * The rest should better be atomic, we can have disk failures
6247          * noticed in interrupt contexts ...
6248          */
6249
6250         rdev->raid_disk = -1;
6251
6252         md_update_sb(mddev, 1);
6253         /*
6254          * Kick recovery, maybe this spare has to be added to the
6255          * array immediately.
6256          */
6257         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6258         md_wakeup_thread(mddev->thread);
6259         md_new_event(mddev);
6260         return 0;
6261
6262 abort_export:
6263         export_rdev(rdev);
6264         return err;
6265 }
6266
6267 static int set_bitmap_file(struct mddev *mddev, int fd)
6268 {
6269         int err = 0;
6270
6271         if (mddev->pers) {
6272                 if (!mddev->pers->quiesce || !mddev->thread)
6273                         return -EBUSY;
6274                 if (mddev->recovery || mddev->sync_thread)
6275                         return -EBUSY;
6276                 /* we should be able to change the bitmap.. */
6277         }
6278
6279         if (fd >= 0) {
6280                 struct inode *inode;
6281                 struct file *f;
6282
6283                 if (mddev->bitmap || mddev->bitmap_info.file)
6284                         return -EEXIST; /* cannot add when bitmap is present */
6285                 f = fget(fd);
6286
6287                 if (f == NULL) {
6288                         printk(KERN_ERR "%s: error: failed to get bitmap file\n",
6289                                mdname(mddev));
6290                         return -EBADF;
6291                 }
6292
6293                 inode = f->f_mapping->host;
6294                 if (!S_ISREG(inode->i_mode)) {
6295                         printk(KERN_ERR "%s: error: bitmap file must be a regular file\n",
6296                                mdname(mddev));
6297                         err = -EBADF;
6298                 } else if (!(f->f_mode & FMODE_WRITE)) {
6299                         printk(KERN_ERR "%s: error: bitmap file must open for write\n",
6300                                mdname(mddev));
6301                         err = -EBADF;
6302                 } else if (atomic_read(&inode->i_writecount) != 1) {
6303                         printk(KERN_ERR "%s: error: bitmap file is already in use\n",
6304                                mdname(mddev));
6305                         err = -EBUSY;
6306                 }
6307                 if (err) {
6308                         fput(f);
6309                         return err;
6310                 }
6311                 mddev->bitmap_info.file = f;
6312                 mddev->bitmap_info.offset = 0; /* file overrides offset */
6313         } else if (mddev->bitmap == NULL)
6314                 return -ENOENT; /* cannot remove what isn't there */
6315         err = 0;
6316         if (mddev->pers) {
6317                 mddev->pers->quiesce(mddev, 1);
6318                 if (fd >= 0) {
6319                         struct bitmap *bitmap;
6320
6321                         bitmap = bitmap_create(mddev, -1);
6322                         if (!IS_ERR(bitmap)) {
6323                                 mddev->bitmap = bitmap;
6324                                 err = bitmap_load(mddev);
6325                         } else
6326                                 err = PTR_ERR(bitmap);
6327                 }
6328                 if (fd < 0 || err) {
6329                         bitmap_destroy(mddev);
6330                         fd = -1; /* make sure to put the file */
6331                 }
6332                 mddev->pers->quiesce(mddev, 0);
6333         }
6334         if (fd < 0) {
6335                 struct file *f = mddev->bitmap_info.file;
6336                 if (f) {
6337                         spin_lock(&mddev->lock);
6338                         mddev->bitmap_info.file = NULL;
6339                         spin_unlock(&mddev->lock);
6340                         fput(f);
6341                 }
6342         }
6343
6344         return err;
6345 }
6346
6347 /*
6348  * set_array_info is used two different ways
6349  * The original usage is when creating a new array.
6350  * In this usage, raid_disks is > 0 and it together with
6351  *  level, size, not_persistent,layout,chunksize determine the
6352  *  shape of the array.
6353  *  This will always create an array with a type-0.90.0 superblock.
6354  * The newer usage is when assembling an array.
6355  *  In this case raid_disks will be 0, and the major_version field is
6356  *  use to determine which style super-blocks are to be found on the devices.
6357  *  The minor and patch _version numbers are also kept incase the
6358  *  super_block handler wishes to interpret them.
6359  */
6360 static int set_array_info(struct mddev *mddev, mdu_array_info_t *info)
6361 {
6362
6363         if (info->raid_disks == 0) {
6364                 /* just setting version number for superblock loading */
6365                 if (info->major_version < 0 ||
6366                     info->major_version >= ARRAY_SIZE(super_types) ||
6367                     super_types[info->major_version].name == NULL) {
6368                         /* maybe try to auto-load a module? */
6369                         printk(KERN_INFO
6370                                 "md: superblock version %d not known\n",
6371                                 info->major_version);
6372                         return -EINVAL;
6373                 }
6374                 mddev->major_version = info->major_version;
6375                 mddev->minor_version = info->minor_version;
6376                 mddev->patch_version = info->patch_version;
6377                 mddev->persistent = !info->not_persistent;
6378                 /* ensure mddev_put doesn't delete this now that there
6379                  * is some minimal configuration.
6380                  */
6381                 mddev->ctime         = ktime_get_real_seconds();
6382                 return 0;
6383         }
6384         mddev->major_version = MD_MAJOR_VERSION;
6385         mddev->minor_version = MD_MINOR_VERSION;
6386         mddev->patch_version = MD_PATCHLEVEL_VERSION;
6387         mddev->ctime         = ktime_get_real_seconds();
6388
6389         mddev->level         = info->level;
6390         mddev->clevel[0]     = 0;
6391         mddev->dev_sectors   = 2 * (sector_t)info->size;
6392         mddev->raid_disks    = info->raid_disks;
6393         /* don't set md_minor, it is determined by which /dev/md* was
6394          * openned
6395          */
6396         if (info->state & (1<<MD_SB_CLEAN))
6397                 mddev->recovery_cp = MaxSector;
6398         else
6399                 mddev->recovery_cp = 0;
6400         mddev->persistent    = ! info->not_persistent;
6401         mddev->external      = 0;
6402
6403         mddev->layout        = info->layout;
6404         mddev->chunk_sectors = info->chunk_size >> 9;
6405
6406         mddev->max_disks     = MD_SB_DISKS;
6407
6408         if (mddev->persistent)
6409                 mddev->flags         = 0;
6410         set_bit(MD_CHANGE_DEVS, &mddev->flags);
6411
6412         mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
6413         mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
6414         mddev->bitmap_info.offset = 0;
6415
6416         mddev->reshape_position = MaxSector;
6417
6418         /*
6419          * Generate a 128 bit UUID
6420          */
6421         get_random_bytes(mddev->uuid, 16);
6422
6423         mddev->new_level = mddev->level;
6424         mddev->new_chunk_sectors = mddev->chunk_sectors;
6425         mddev->new_layout = mddev->layout;
6426         mddev->delta_disks = 0;
6427         mddev->reshape_backwards = 0;
6428
6429         return 0;
6430 }
6431
6432 void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
6433 {
6434         WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);
6435
6436         if (mddev->external_size)
6437                 return;
6438
6439         mddev->array_sectors = array_sectors;
6440 }
6441 EXPORT_SYMBOL(md_set_array_sectors);
6442
6443 static int update_size(struct mddev *mddev, sector_t num_sectors)
6444 {
6445         struct md_rdev *rdev;
6446         int rv;
6447         int fit = (num_sectors == 0);
6448
6449         /* cluster raid doesn't support update size */
6450         if (mddev_is_clustered(mddev))
6451                 return -EINVAL;
6452
6453         if (mddev->pers->resize == NULL)
6454                 return -EINVAL;
6455         /* The "num_sectors" is the number of sectors of each device that
6456          * is used.  This can only make sense for arrays with redundancy.
6457          * linear and raid0 always use whatever space is available. We can only
6458          * consider changing this number if no resync or reconstruction is
6459          * happening, and if the new size is acceptable. It must fit before the
6460          * sb_start or, if that is <data_offset, it must fit before the size
6461          * of each device.  If num_sectors is zero, we find the largest size
6462          * that fits.
6463          */
6464         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
6465             mddev->sync_thread)
6466                 return -EBUSY;
6467         if (mddev->ro)
6468                 return -EROFS;
6469
6470         rdev_for_each(rdev, mddev) {
6471                 sector_t avail = rdev->sectors;
6472
6473                 if (fit && (num_sectors == 0 || num_sectors > avail))
6474                         num_sectors = avail;
6475                 if (avail < num_sectors)
6476                         return -ENOSPC;
6477         }
6478         rv = mddev->pers->resize(mddev, num_sectors);
6479         if (!rv)
6480                 revalidate_disk(mddev->gendisk);
6481         return rv;
6482 }
6483
6484 static int update_raid_disks(struct mddev *mddev, int raid_disks)
6485 {
6486         int rv;
6487         struct md_rdev *rdev;
6488         /* change the number of raid disks */
6489         if (mddev->pers->check_reshape == NULL)
6490                 return -EINVAL;
6491         if (mddev->ro)
6492                 return -EROFS;
6493         if (raid_disks <= 0 ||
6494             (mddev->max_disks && raid_disks >= mddev->max_disks))
6495                 return -EINVAL;
6496         if (mddev->sync_thread ||
6497             test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
6498             mddev->reshape_position != MaxSector)
6499                 return -EBUSY;
6500
6501         rdev_for_each(rdev, mddev) {
6502                 if (mddev->raid_disks < raid_disks &&
6503                     rdev->data_offset < rdev->new_data_offset)
6504                         return -EINVAL;
6505                 if (mddev->raid_disks > raid_disks &&
6506                     rdev->data_offset > rdev->new_data_offset)
6507                         return -EINVAL;
6508         }
6509
6510         mddev->delta_disks = raid_disks - mddev->raid_disks;
6511         if (mddev->delta_disks < 0)
6512                 mddev->reshape_backwards = 1;
6513         else if (mddev->delta_disks > 0)
6514                 mddev->reshape_backwards = 0;
6515
6516         rv = mddev->pers->check_reshape(mddev);
6517         if (rv < 0) {
6518                 mddev->delta_disks = 0;
6519                 mddev->reshape_backwards = 0;
6520         }
6521         return rv;
6522 }
6523
6524 /*
6525  * update_array_info is used to change the configuration of an
6526  * on-line array.
6527  * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
6528  * fields in the info are checked against the array.
6529  * Any differences that cannot be handled will cause an error.
6530  * Normally, only one change can be managed at a time.
6531  */
6532 static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
6533 {
6534         int rv = 0;
6535         int cnt = 0;
6536         int state = 0;
6537
6538         /* calculate expected state,ignoring low bits */
6539         if (mddev->bitmap && mddev->bitmap_info.offset)
6540                 state |= (1 << MD_SB_BITMAP_PRESENT);
6541
6542         if (mddev->major_version != info->major_version ||
6543             mddev->minor_version != info->minor_version ||
6544 /*          mddev->patch_version != info->patch_version || */
6545             mddev->ctime         != info->ctime         ||
6546             mddev->level         != info->level         ||
6547 /*          mddev->layout        != info->layout        || */
6548             mddev->persistent    != !info->not_persistent ||
6549             mddev->chunk_sectors != info->chunk_size >> 9 ||
6550             /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
6551             ((state^info->state) & 0xfffffe00)
6552                 )
6553                 return -EINVAL;
6554         /* Check there is only one change */
6555         if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6556                 cnt++;
6557         if (mddev->raid_disks != info->raid_disks)
6558                 cnt++;
6559         if (mddev->layout != info->layout)
6560                 cnt++;
6561         if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
6562                 cnt++;
6563         if (cnt == 0)
6564                 return 0;
6565         if (cnt > 1)
6566                 return -EINVAL;
6567
6568         if (mddev->layout != info->layout) {
6569                 /* Change layout
6570                  * we don't need to do anything at the md level, the
6571                  * personality will take care of it all.
6572                  */
6573                 if (mddev->pers->check_reshape == NULL)
6574                         return -EINVAL;
6575                 else {
6576                         mddev->new_layout = info->layout;
6577                         rv = mddev->pers->check_reshape(mddev);
6578                         if (rv)
6579                                 mddev->new_layout = mddev->layout;
6580                         return rv;
6581                 }
6582         }
6583         if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
6584                 rv = update_size(mddev, (sector_t)info->size * 2);
6585
6586         if (mddev->raid_disks    != info->raid_disks)
6587                 rv = update_raid_disks(mddev, info->raid_disks);
6588
6589         if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
6590                 if (mddev->pers->quiesce == NULL || mddev->thread == NULL) {
6591                         rv = -EINVAL;
6592                         goto err;
6593                 }
6594                 if (mddev->recovery || mddev->sync_thread) {
6595                         rv = -EBUSY;
6596                         goto err;
6597                 }
6598                 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
6599                         struct bitmap *bitmap;
6600                         /* add the bitmap */
6601                         if (mddev->bitmap) {
6602                                 rv = -EEXIST;
6603                                 goto err;
6604                         }
6605                         if (mddev->bitmap_info.default_offset == 0) {
6606                                 rv = -EINVAL;
6607                                 goto err;
6608                         }
6609                         mddev->bitmap_info.offset =
6610                                 mddev->bitmap_info.default_offset;
6611                         mddev->bitmap_info.space =
6612                                 mddev->bitmap_info.default_space;
6613                         mddev->pers->quiesce(mddev, 1);
6614                         bitmap = bitmap_create(mddev, -1);
6615                         if (!IS_ERR(bitmap)) {
6616                                 mddev->bitmap = bitmap;
6617                                 rv = bitmap_load(mddev);
6618                         } else
6619                                 rv = PTR_ERR(bitmap);
6620                         if (rv)
6621                                 bitmap_destroy(mddev);
6622                         mddev->pers->quiesce(mddev, 0);
6623                 } else {
6624                         /* remove the bitmap */
6625                         if (!mddev->bitmap) {
6626                                 rv = -ENOENT;
6627                                 goto err;
6628                         }
6629                         if (mddev->bitmap->storage.file) {
6630                                 rv = -EINVAL;
6631                                 goto err;
6632                         }
6633                         if (mddev->bitmap_info.nodes) {
6634                                 /* hold PW on all the bitmap lock */
6635                                 if (md_cluster_ops->lock_all_bitmaps(mddev) <= 0) {
6636                                         printk("md: can't change bitmap to none since the"
6637                                                " array is in use by more than one node\n");
6638                                         rv = -EPERM;
6639                                         md_cluster_ops->unlock_all_bitmaps(mddev);
6640                                         goto err;
6641                                 }
6642
6643                                 mddev->bitmap_info.nodes = 0;
6644                                 md_cluster_ops->leave(mddev);
6645                         }
6646                         mddev->pers->quiesce(mddev, 1);
6647                         bitmap_destroy(mddev);
6648                         mddev->pers->quiesce(mddev, 0);
6649                         mddev->bitmap_info.offset = 0;
6650                 }
6651         }
6652         md_update_sb(mddev, 1);
6653         return rv;
6654 err:
6655         return rv;
6656 }
6657
6658 static int set_disk_faulty(struct mddev *mddev, dev_t dev)
6659 {
6660         struct md_rdev *rdev;
6661         int err = 0;
6662
6663         if (mddev->pers == NULL)
6664                 return -ENODEV;
6665
6666         rcu_read_lock();
6667         rdev = find_rdev_rcu(mddev, dev);
6668         if (!rdev)
6669                 err =  -ENODEV;
6670         else {
6671                 md_error(mddev, rdev);
6672                 if (!test_bit(Faulty, &rdev->flags))
6673                         err = -EBUSY;
6674         }
6675         rcu_read_unlock();
6676         return err;
6677 }
6678
6679 /*
6680  * We have a problem here : there is no easy way to give a CHS
6681  * virtual geometry. We currently pretend that we have a 2 heads
6682  * 4 sectors (with a BIG number of cylinders...). This drives
6683  * dosfs just mad... ;-)
6684  */
6685 static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
6686 {
6687         struct mddev *mddev = bdev->bd_disk->private_data;
6688
6689         geo->heads = 2;
6690         geo->sectors = 4;
6691         geo->cylinders = mddev->array_sectors / 8;
6692         return 0;
6693 }
6694
6695 static inline bool md_ioctl_valid(unsigned int cmd)
6696 {
6697         switch (cmd) {
6698         case ADD_NEW_DISK:
6699         case BLKROSET:
6700         case GET_ARRAY_INFO:
6701         case GET_BITMAP_FILE:
6702         case GET_DISK_INFO:
6703         case HOT_ADD_DISK:
6704         case HOT_REMOVE_DISK:
6705         case RAID_AUTORUN:
6706         case RAID_VERSION:
6707         case RESTART_ARRAY_RW:
6708         case RUN_ARRAY:
6709         case SET_ARRAY_INFO:
6710         case SET_BITMAP_FILE:
6711         case SET_DISK_FAULTY:
6712         case STOP_ARRAY:
6713         case STOP_ARRAY_RO:
6714         case CLUSTERED_DISK_NACK:
6715                 return true;
6716         default:
6717                 return false;
6718         }
6719 }
6720
6721 static int md_ioctl(struct block_device *bdev, fmode_t mode,
6722                         unsigned int cmd, unsigned long arg)
6723 {
6724         int err = 0;
6725         void __user *argp = (void __user *)arg;
6726         struct mddev *mddev = NULL;
6727         int ro;
6728
6729         if (!md_ioctl_valid(cmd))
6730                 return -ENOTTY;
6731
6732         switch (cmd) {
6733         case RAID_VERSION:
6734         case GET_ARRAY_INFO:
6735         case GET_DISK_INFO:
6736                 break;
6737         default:
6738                 if (!capable(CAP_SYS_ADMIN))
6739                         return -EACCES;
6740         }
6741
6742         /*
6743          * Commands dealing with the RAID driver but not any
6744          * particular array:
6745          */
6746         switch (cmd) {
6747         case RAID_VERSION:
6748                 err = get_version(argp);
6749                 goto out;
6750
6751 #ifndef MODULE
6752         case RAID_AUTORUN:
6753                 err = 0;
6754                 autostart_arrays(arg);
6755                 goto out;
6756 #endif
6757         default:;
6758         }
6759
6760         /*
6761          * Commands creating/starting a new array:
6762          */
6763
6764         mddev = bdev->bd_disk->private_data;
6765
6766         if (!mddev) {
6767                 BUG();
6768                 goto out;
6769         }
6770
6771         /* Some actions do not requires the mutex */
6772         switch (cmd) {
6773         case GET_ARRAY_INFO:
6774                 if (!mddev->raid_disks && !mddev->external)
6775                         err = -ENODEV;
6776                 else
6777                         err = get_array_info(mddev, argp);
6778                 goto out;
6779
6780         case GET_DISK_INFO:
6781                 if (!mddev->raid_disks && !mddev->external)
6782                         err = -ENODEV;
6783                 else
6784                         err = get_disk_info(mddev, argp);
6785                 goto out;
6786
6787         case SET_DISK_FAULTY:
6788                 err = set_disk_faulty(mddev, new_decode_dev(arg));
6789                 goto out;
6790
6791         case GET_BITMAP_FILE:
6792                 err = get_bitmap_file(mddev, argp);
6793                 goto out;
6794
6795         }
6796
6797         if (cmd == ADD_NEW_DISK)
6798                 /* need to ensure md_delayed_delete() has completed */
6799                 flush_workqueue(md_misc_wq);
6800
6801         if (cmd == HOT_REMOVE_DISK)
6802                 /* need to ensure recovery thread has run */
6803                 wait_event_interruptible_timeout(mddev->sb_wait,
6804                                                  !test_bit(MD_RECOVERY_NEEDED,
6805                                                            &mddev->flags),
6806                                                  msecs_to_jiffies(5000));
6807         if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) {
6808                 /* Need to flush page cache, and ensure no-one else opens
6809                  * and writes
6810                  */
6811                 mutex_lock(&mddev->open_mutex);
6812                 if (mddev->pers && atomic_read(&mddev->openers) > 1) {
6813                         mutex_unlock(&mddev->open_mutex);
6814                         err = -EBUSY;
6815                         goto out;
6816                 }
6817                 set_bit(MD_STILL_CLOSED, &mddev->flags);
6818                 mutex_unlock(&mddev->open_mutex);
6819                 sync_blockdev(bdev);
6820         }
6821         err = mddev_lock(mddev);
6822         if (err) {
6823                 printk(KERN_INFO
6824                         "md: ioctl lock interrupted, reason %d, cmd %d\n",
6825                         err, cmd);
6826                 goto out;
6827         }
6828
6829         if (cmd == SET_ARRAY_INFO) {
6830                 mdu_array_info_t info;
6831                 if (!arg)
6832                         memset(&info, 0, sizeof(info));
6833                 else if (copy_from_user(&info, argp, sizeof(info))) {
6834                         err = -EFAULT;
6835                         goto unlock;
6836                 }
6837                 if (mddev->pers) {
6838                         err = update_array_info(mddev, &info);
6839                         if (err) {
6840                                 printk(KERN_WARNING "md: couldn't update"
6841                                        " array info. %d\n", err);
6842                                 goto unlock;
6843                         }
6844                         goto unlock;
6845                 }
6846                 if (!list_empty(&mddev->disks)) {
6847                         printk(KERN_WARNING
6848                                "md: array %s already has disks!\n",
6849                                mdname(mddev));
6850                         err = -EBUSY;
6851                         goto unlock;
6852                 }
6853                 if (mddev->raid_disks) {
6854                         printk(KERN_WARNING
6855                                "md: array %s already initialised!\n",
6856                                mdname(mddev));
6857                         err = -EBUSY;
6858                         goto unlock;
6859                 }
6860                 err = set_array_info(mddev, &info);
6861                 if (err) {
6862                         printk(KERN_WARNING "md: couldn't set"
6863                                " array info. %d\n", err);
6864                         goto unlock;
6865                 }
6866                 goto unlock;
6867         }
6868
6869         /*
6870          * Commands querying/configuring an existing array:
6871          */
6872         /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
6873          * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
6874         if ((!mddev->raid_disks && !mddev->external)
6875             && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
6876             && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
6877             && cmd != GET_BITMAP_FILE) {
6878                 err = -ENODEV;
6879                 goto unlock;
6880         }
6881
6882         /*
6883          * Commands even a read-only array can execute:
6884          */
6885         switch (cmd) {
6886         case RESTART_ARRAY_RW:
6887                 err = restart_array(mddev);
6888                 goto unlock;
6889
6890         case STOP_ARRAY:
6891                 err = do_md_stop(mddev, 0, bdev);
6892                 goto unlock;
6893
6894         case STOP_ARRAY_RO:
6895                 err = md_set_readonly(mddev, bdev);
6896                 goto unlock;
6897
6898         case HOT_REMOVE_DISK:
6899                 err = hot_remove_disk(mddev, new_decode_dev(arg));
6900                 goto unlock;
6901
6902         case ADD_NEW_DISK:
6903                 /* We can support ADD_NEW_DISK on read-only arrays
6904                  * only if we are re-adding a preexisting device.
6905                  * So require mddev->pers and MD_DISK_SYNC.
6906                  */
6907                 if (mddev->pers) {
6908                         mdu_disk_info_t info;
6909                         if (copy_from_user(&info, argp, sizeof(info)))
6910                                 err = -EFAULT;
6911                         else if (!(info.state & (1<<MD_DISK_SYNC)))
6912                                 /* Need to clear read-only for this */
6913                                 break;
6914                         else
6915                                 err = add_new_disk(mddev, &info);
6916                         goto unlock;
6917                 }
6918                 break;
6919
6920         case BLKROSET:
6921                 if (get_user(ro, (int __user *)(arg))) {
6922                         err = -EFAULT;
6923                         goto unlock;
6924                 }
6925                 err = -EINVAL;
6926
6927                 /* if the bdev is going readonly the value of mddev->ro
6928                  * does not matter, no writes are coming
6929                  */
6930                 if (ro)
6931                         goto unlock;
6932
6933                 /* are we are already prepared for writes? */
6934                 if (mddev->ro != 1)
6935                         goto unlock;
6936
6937                 /* transitioning to readauto need only happen for
6938                  * arrays that call md_write_start
6939                  */
6940                 if (mddev->pers) {
6941                         err = restart_array(mddev);
6942                         if (err == 0) {
6943                                 mddev->ro = 2;
6944                                 set_disk_ro(mddev->gendisk, 0);
6945                         }
6946                 }
6947                 goto unlock;
6948         }
6949
6950         /*
6951          * The remaining ioctls are changing the state of the
6952          * superblock, so we do not allow them on read-only arrays.
6953          */
6954         if (mddev->ro && mddev->pers) {
6955                 if (mddev->ro == 2) {
6956                         mddev->ro = 0;
6957                         sysfs_notify_dirent_safe(mddev->sysfs_state);
6958                         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
6959                         /* mddev_unlock will wake thread */
6960                         /* If a device failed while we were read-only, we
6961                          * need to make sure the metadata is updated now.
6962                          */
6963                         if (test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
6964                                 mddev_unlock(mddev);
6965                                 wait_event(mddev->sb_wait,
6966                                            !test_bit(MD_CHANGE_DEVS, &mddev->flags) &&
6967                                            !test_bit(MD_CHANGE_PENDING, &mddev->flags));
6968                                 mddev_lock_nointr(mddev);
6969                         }
6970                 } else {
6971                         err = -EROFS;
6972                         goto unlock;
6973                 }
6974         }
6975
6976         switch (cmd) {
6977         case ADD_NEW_DISK:
6978         {
6979                 mdu_disk_info_t info;
6980                 if (copy_from_user(&info, argp, sizeof(info)))
6981                         err = -EFAULT;
6982                 else
6983                         err = add_new_disk(mddev, &info);
6984                 goto unlock;
6985         }
6986
6987         case CLUSTERED_DISK_NACK:
6988                 if (mddev_is_clustered(mddev))
6989                         md_cluster_ops->new_disk_ack(mddev, false);
6990                 else
6991                         err = -EINVAL;
6992                 goto unlock;
6993
6994         case HOT_ADD_DISK:
6995                 err = hot_add_disk(mddev, new_decode_dev(arg));
6996                 goto unlock;
6997
6998         case RUN_ARRAY:
6999                 err = do_md_run(mddev);
7000                 goto unlock;
7001
7002         case SET_BITMAP_FILE:
7003                 err = set_bitmap_file(mddev, (int)arg);
7004                 goto unlock;
7005
7006         default:
7007                 err = -EINVAL;
7008                 goto unlock;
7009         }
7010
7011 unlock:
7012         if (mddev->hold_active == UNTIL_IOCTL &&
7013             err != -EINVAL)
7014                 mddev->hold_active = 0;
7015         mddev_unlock(mddev);
7016 out:
7017         return err;
7018 }
7019 #ifdef CONFIG_COMPAT
7020 static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
7021                     unsigned int cmd, unsigned long arg)
7022 {
7023         switch (cmd) {
7024         case HOT_REMOVE_DISK:
7025         case HOT_ADD_DISK:
7026         case SET_DISK_FAULTY:
7027         case SET_BITMAP_FILE:
7028                 /* These take in integer arg, do not convert */
7029                 break;
7030         default:
7031                 arg = (unsigned long)compat_ptr(arg);
7032                 break;
7033         }
7034
7035         return md_ioctl(bdev, mode, cmd, arg);
7036 }
7037 #endif /* CONFIG_COMPAT */
7038
7039 static int md_open(struct block_device *bdev, fmode_t mode)
7040 {
7041         /*
7042          * Succeed if we can lock the mddev, which confirms that
7043          * it isn't being stopped right now.
7044          */
7045         struct mddev *mddev = mddev_find(bdev->bd_dev);
7046         int err;
7047
7048         if (!mddev)
7049                 return -ENODEV;
7050
7051         if (mddev->gendisk != bdev->bd_disk) {
7052                 /* we are racing with mddev_put which is discarding this
7053                  * bd_disk.
7054                  */
7055                 mddev_put(mddev);
7056                 /* Wait until bdev->bd_disk is definitely gone */
7057                 flush_workqueue(md_misc_wq);
7058                 /* Then retry the open from the top */
7059                 return -ERESTARTSYS;
7060         }
7061         BUG_ON(mddev != bdev->bd_disk->private_data);
7062
7063         if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
7064                 goto out;
7065
7066         err = 0;
7067         atomic_inc(&mddev->openers);
7068         clear_bit(MD_STILL_CLOSED, &mddev->flags);
7069         mutex_unlock(&mddev->open_mutex);
7070
7071         check_disk_change(bdev);
7072  out:
7073         return err;
7074 }
7075
7076 static void md_release(struct gendisk *disk, fmode_t mode)
7077 {
7078         struct mddev *mddev = disk->private_data;
7079
7080         BUG_ON(!mddev);
7081         atomic_dec(&mddev->openers);
7082         mddev_put(mddev);
7083 }
7084
7085 static int md_media_changed(struct gendisk *disk)
7086 {
7087         struct mddev *mddev = disk->private_data;
7088
7089         return mddev->changed;
7090 }
7091
7092 static int md_revalidate(struct gendisk *disk)
7093 {
7094         struct mddev *mddev = disk->private_data;
7095
7096         mddev->changed = 0;
7097         return 0;
7098 }
7099 static const struct block_device_operations md_fops =
7100 {
7101         .owner          = THIS_MODULE,
7102         .open           = md_open,
7103         .release        = md_release,
7104         .ioctl          = md_ioctl,
7105 #ifdef CONFIG_COMPAT
7106         .compat_ioctl   = md_compat_ioctl,
7107 #endif
7108         .getgeo         = md_getgeo,
7109         .media_changed  = md_media_changed,
7110         .revalidate_disk= md_revalidate,
7111 };
7112
7113 static int md_thread(void *arg)
7114 {
7115         struct md_thread *thread = arg;
7116
7117         /*
7118          * md_thread is a 'system-thread', it's priority should be very
7119          * high. We avoid resource deadlocks individually in each
7120          * raid personality. (RAID5 does preallocation) We also use RR and
7121          * the very same RT priority as kswapd, thus we will never get
7122          * into a priority inversion deadlock.
7123          *
7124          * we definitely have to have equal or higher priority than
7125          * bdflush, otherwise bdflush will deadlock if there are too
7126          * many dirty RAID5 blocks.
7127          */
7128
7129         allow_signal(SIGKILL);
7130         while (!kthread_should_stop()) {
7131
7132                 /* We need to wait INTERRUPTIBLE so that
7133                  * we don't add to the load-average.
7134                  * That means we need to be sure no signals are
7135                  * pending
7136                  */
7137                 if (signal_pending(current))
7138                         flush_signals(current);
7139
7140                 wait_event_interruptible_timeout
7141                         (thread->wqueue,
7142                          test_bit(THREAD_WAKEUP, &thread->flags)
7143                          || kthread_should_stop(),
7144                          thread->timeout);
7145
7146                 clear_bit(THREAD_WAKEUP, &thread->flags);
7147                 if (!kthread_should_stop())
7148                         thread->run(thread);
7149         }
7150
7151         return 0;
7152 }
7153
7154 void md_wakeup_thread(struct md_thread *thread)
7155 {
7156         if (thread) {
7157                 pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
7158                 set_bit(THREAD_WAKEUP, &thread->flags);
7159                 wake_up(&thread->wqueue);
7160         }
7161 }
7162 EXPORT_SYMBOL(md_wakeup_thread);
7163
7164 struct md_thread *md_register_thread(void (*run) (struct md_thread *),
7165                 struct mddev *mddev, const char *name)
7166 {
7167         struct md_thread *thread;
7168
7169         thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
7170         if (!thread)
7171                 return NULL;
7172
7173         init_waitqueue_head(&thread->wqueue);
7174
7175         thread->run = run;
7176         thread->mddev = mddev;
7177         thread->timeout = MAX_SCHEDULE_TIMEOUT;
7178         thread->tsk = kthread_run(md_thread, thread,
7179                                   "%s_%s",
7180                                   mdname(thread->mddev),
7181                                   name);
7182         if (IS_ERR(thread->tsk)) {
7183                 kfree(thread);
7184                 return NULL;
7185         }
7186         return thread;
7187 }
7188 EXPORT_SYMBOL(md_register_thread);
7189
7190 void md_unregister_thread(struct md_thread **threadp)
7191 {
7192         struct md_thread *thread = *threadp;
7193         if (!thread)
7194                 return;
7195         pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
7196         /* Locking ensures that mddev_unlock does not wake_up a
7197          * non-existent thread
7198          */
7199         spin_lock(&pers_lock);
7200         *threadp = NULL;
7201         spin_unlock(&pers_lock);
7202
7203         kthread_stop(thread->tsk);
7204         kfree(thread);
7205 }
7206 EXPORT_SYMBOL(md_unregister_thread);
7207
7208 void md_error(struct mddev *mddev, struct md_rdev *rdev)
7209 {
7210         if (!rdev || test_bit(Faulty, &rdev->flags))
7211                 return;
7212
7213         if (!mddev->pers || !mddev->pers->error_handler)
7214                 return;
7215         mddev->pers->error_handler(mddev,rdev);
7216         if (mddev->degraded)
7217                 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
7218         sysfs_notify_dirent_safe(rdev->sysfs_state);
7219         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7220         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7221         md_wakeup_thread(mddev->thread);
7222         if (mddev->event_work.func)
7223                 queue_work(md_misc_wq, &mddev->event_work);
7224         md_new_event(mddev);
7225 }
7226 EXPORT_SYMBOL(md_error);
7227
7228 /* seq_file implementation /proc/mdstat */
7229
7230 static void status_unused(struct seq_file *seq)
7231 {
7232         int i = 0;
7233         struct md_rdev *rdev;
7234
7235         seq_printf(seq, "unused devices: ");
7236
7237         list_for_each_entry(rdev, &pending_raid_disks, same_set) {
7238                 char b[BDEVNAME_SIZE];
7239                 i++;
7240                 seq_printf(seq, "%s ",
7241                               bdevname(rdev->bdev,b));
7242         }
7243         if (!i)
7244                 seq_printf(seq, "<none>");
7245
7246         seq_printf(seq, "\n");
7247 }
7248
7249 static int status_resync(struct seq_file *seq, struct mddev *mddev)
7250 {
7251         sector_t max_sectors, resync, res;
7252         unsigned long dt, db;
7253         sector_t rt;
7254         int scale;
7255         unsigned int per_milli;
7256
7257         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
7258             test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7259                 max_sectors = mddev->resync_max_sectors;
7260         else
7261                 max_sectors = mddev->dev_sectors;
7262
7263         resync = mddev->curr_resync;
7264         if (resync <= 3) {
7265                 if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7266                         /* Still cleaning up */
7267                         resync = max_sectors;
7268         } else
7269                 resync -= atomic_read(&mddev->recovery_active);
7270
7271         if (resync == 0) {
7272                 if (mddev->recovery_cp < MaxSector) {
7273                         seq_printf(seq, "\tresync=PENDING");
7274                         return 1;
7275                 }
7276                 return 0;
7277         }
7278         if (resync < 3) {
7279                 seq_printf(seq, "\tresync=DELAYED");
7280                 return 1;
7281         }
7282
7283         WARN_ON(max_sectors == 0);
7284         /* Pick 'scale' such that (resync>>scale)*1000 will fit
7285          * in a sector_t, and (max_sectors>>scale) will fit in a
7286          * u32, as those are the requirements for sector_div.
7287          * Thus 'scale' must be at least 10
7288          */
7289         scale = 10;
7290         if (sizeof(sector_t) > sizeof(unsigned long)) {
7291                 while ( max_sectors/2 > (1ULL<<(scale+32)))
7292                         scale++;
7293         }
7294         res = (resync>>scale)*1000;
7295         sector_div(res, (u32)((max_sectors>>scale)+1));
7296
7297         per_milli = res;
7298         {
7299                 int i, x = per_milli/50, y = 20-x;
7300                 seq_printf(seq, "[");
7301                 for (i = 0; i < x; i++)
7302                         seq_printf(seq, "=");
7303                 seq_printf(seq, ">");
7304                 for (i = 0; i < y; i++)
7305                         seq_printf(seq, ".");
7306                 seq_printf(seq, "] ");
7307         }
7308         seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
7309                    (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
7310                     "reshape" :
7311                     (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
7312                      "check" :
7313                      (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
7314                       "resync" : "recovery"))),
7315                    per_milli/10, per_milli % 10,
7316                    (unsigned long long) resync/2,
7317                    (unsigned long long) max_sectors/2);
7318
7319         /*
7320          * dt: time from mark until now
7321          * db: blocks written from mark until now
7322          * rt: remaining time
7323          *
7324          * rt is a sector_t, so could be 32bit or 64bit.
7325          * So we divide before multiply in case it is 32bit and close
7326          * to the limit.
7327          * We scale the divisor (db) by 32 to avoid losing precision
7328          * near the end of resync when the number of remaining sectors
7329          * is close to 'db'.
7330          * We then divide rt by 32 after multiplying by db to compensate.
7331          * The '+1' avoids division by zero if db is very small.
7332          */
7333         dt = ((jiffies - mddev->resync_mark) / HZ);
7334         if (!dt) dt++;
7335         db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
7336                 - mddev->resync_mark_cnt;
7337
7338         rt = max_sectors - resync;    /* number of remaining sectors */
7339         sector_div(rt, db/32+1);
7340         rt *= dt;
7341         rt >>= 5;
7342
7343         seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
7344                    ((unsigned long)rt % 60)/6);
7345
7346         seq_printf(seq, " speed=%ldK/sec", db/2/dt);
7347         return 1;
7348 }
7349
7350 static void *md_seq_start(struct seq_file *seq, loff_t *pos)
7351 {
7352         struct list_head *tmp;
7353         loff_t l = *pos;
7354         struct mddev *mddev;
7355
7356         if (l >= 0x10000)
7357                 return NULL;
7358         if (!l--)
7359                 /* header */
7360                 return (void*)1;
7361
7362         spin_lock(&all_mddevs_lock);
7363         list_for_each(tmp,&all_mddevs)
7364                 if (!l--) {
7365                         mddev = list_entry(tmp, struct mddev, all_mddevs);
7366                         mddev_get(mddev);
7367                         spin_unlock(&all_mddevs_lock);
7368                         return mddev;
7369                 }
7370         spin_unlock(&all_mddevs_lock);
7371         if (!l--)
7372                 return (void*)2;/* tail */
7373         return NULL;
7374 }
7375
7376 static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
7377 {
7378         struct list_head *tmp;
7379         struct mddev *next_mddev, *mddev = v;
7380
7381         ++*pos;
7382         if (v == (void*)2)
7383                 return NULL;
7384
7385         spin_lock(&all_mddevs_lock);
7386         if (v == (void*)1)
7387                 tmp = all_mddevs.next;
7388         else
7389                 tmp = mddev->all_mddevs.next;
7390         if (tmp != &all_mddevs)
7391                 next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
7392         else {
7393                 next_mddev = (void*)2;
7394                 *pos = 0x10000;
7395         }
7396         spin_unlock(&all_mddevs_lock);
7397
7398         if (v != (void*)1)
7399                 mddev_put(mddev);
7400         return next_mddev;
7401
7402 }
7403
7404 static void md_seq_stop(struct seq_file *seq, void *v)
7405 {
7406         struct mddev *mddev = v;
7407
7408         if (mddev && v != (void*)1 && v != (void*)2)
7409                 mddev_put(mddev);
7410 }
7411
7412 static int md_seq_show(struct seq_file *seq, void *v)
7413 {
7414         struct mddev *mddev = v;
7415         sector_t sectors;
7416         struct md_rdev *rdev;
7417
7418         if (v == (void*)1) {
7419                 struct md_personality *pers;
7420                 seq_printf(seq, "Personalities : ");
7421                 spin_lock(&pers_lock);
7422                 list_for_each_entry(pers, &pers_list, list)
7423                         seq_printf(seq, "[%s] ", pers->name);
7424
7425                 spin_unlock(&pers_lock);
7426                 seq_printf(seq, "\n");
7427                 seq->poll_event = atomic_read(&md_event_count);
7428                 return 0;
7429         }
7430         if (v == (void*)2) {
7431                 status_unused(seq);
7432                 return 0;
7433         }
7434
7435         spin_lock(&mddev->lock);
7436         if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
7437                 seq_printf(seq, "%s : %sactive", mdname(mddev),
7438                                                 mddev->pers ? "" : "in");
7439                 if (mddev->pers) {
7440                         if (mddev->ro==1)
7441                                 seq_printf(seq, " (read-only)");
7442                         if (mddev->ro==2)
7443                                 seq_printf(seq, " (auto-read-only)");
7444                         seq_printf(seq, " %s", mddev->pers->name);
7445                 }
7446
7447                 sectors = 0;
7448                 rcu_read_lock();
7449                 rdev_for_each_rcu(rdev, mddev) {
7450                         char b[BDEVNAME_SIZE];
7451                         seq_printf(seq, " %s[%d]",
7452                                 bdevname(rdev->bdev,b), rdev->desc_nr);
7453                         if (test_bit(WriteMostly, &rdev->flags))
7454                                 seq_printf(seq, "(W)");
7455                         if (test_bit(Journal, &rdev->flags))
7456                                 seq_printf(seq, "(J)");
7457                         if (test_bit(Faulty, &rdev->flags)) {
7458                                 seq_printf(seq, "(F)");
7459                                 continue;
7460                         }
7461                         if (rdev->raid_disk < 0)
7462                                 seq_printf(seq, "(S)"); /* spare */
7463                         if (test_bit(Replacement, &rdev->flags))
7464                                 seq_printf(seq, "(R)");
7465                         sectors += rdev->sectors;
7466                 }
7467                 rcu_read_unlock();
7468
7469                 if (!list_empty(&mddev->disks)) {
7470                         if (mddev->pers)
7471                                 seq_printf(seq, "\n      %llu blocks",
7472                                            (unsigned long long)
7473                                            mddev->array_sectors / 2);
7474                         else
7475                                 seq_printf(seq, "\n      %llu blocks",
7476                                            (unsigned long long)sectors / 2);
7477                 }
7478                 if (mddev->persistent) {
7479                         if (mddev->major_version != 0 ||
7480                             mddev->minor_version != 90) {
7481                                 seq_printf(seq," super %d.%d",
7482                                            mddev->major_version,
7483                                            mddev->minor_version);
7484                         }
7485                 } else if (mddev->external)
7486                         seq_printf(seq, " super external:%s",
7487                                    mddev->metadata_type);
7488                 else
7489                         seq_printf(seq, " super non-persistent");
7490
7491                 if (mddev->pers) {
7492                         mddev->pers->status(seq, mddev);
7493                         seq_printf(seq, "\n      ");
7494                         if (mddev->pers->sync_request) {
7495                                 if (status_resync(seq, mddev))
7496                                         seq_printf(seq, "\n      ");
7497                         }
7498                 } else
7499                         seq_printf(seq, "\n       ");
7500
7501                 bitmap_status(seq, mddev->bitmap);
7502
7503                 seq_printf(seq, "\n");
7504         }
7505         spin_unlock(&mddev->lock);
7506
7507         return 0;
7508 }
7509
7510 static const struct seq_operations md_seq_ops = {
7511         .start  = md_seq_start,
7512         .next   = md_seq_next,
7513         .stop   = md_seq_stop,
7514         .show   = md_seq_show,
7515 };
7516
7517 static int md_seq_open(struct inode *inode, struct file *file)
7518 {
7519         struct seq_file *seq;
7520         int error;
7521
7522         error = seq_open(file, &md_seq_ops);
7523         if (error)
7524                 return error;
7525
7526         seq = file->private_data;
7527         seq->poll_event = atomic_read(&md_event_count);
7528         return error;
7529 }
7530
7531 static int md_unloading;
7532 static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
7533 {
7534         struct seq_file *seq = filp->private_data;
7535         int mask;
7536
7537         if (md_unloading)
7538                 return POLLIN|POLLRDNORM|POLLERR|POLLPRI;
7539         poll_wait(filp, &md_event_waiters, wait);
7540
7541         /* always allow read */
7542         mask = POLLIN | POLLRDNORM;
7543
7544         if (seq->poll_event != atomic_read(&md_event_count))
7545                 mask |= POLLERR | POLLPRI;
7546         return mask;
7547 }
7548
7549 static const struct file_operations md_seq_fops = {
7550         .owner          = THIS_MODULE,
7551         .open           = md_seq_open,
7552         .read           = seq_read,
7553         .llseek         = seq_lseek,
7554         .release        = seq_release_private,
7555         .poll           = mdstat_poll,
7556 };
7557
7558 int register_md_personality(struct md_personality *p)
7559 {
7560         printk(KERN_INFO "md: %s personality registered for level %d\n",
7561                                                 p->name, p->level);
7562         spin_lock(&pers_lock);
7563         list_add_tail(&p->list, &pers_list);
7564         spin_unlock(&pers_lock);
7565         return 0;
7566 }
7567 EXPORT_SYMBOL(register_md_personality);
7568
7569 int unregister_md_personality(struct md_personality *p)
7570 {
7571         printk(KERN_INFO "md: %s personality unregistered\n", p->name);
7572         spin_lock(&pers_lock);
7573         list_del_init(&p->list);
7574         spin_unlock(&pers_lock);
7575         return 0;
7576 }
7577 EXPORT_SYMBOL(unregister_md_personality);
7578
7579 int register_md_cluster_operations(struct md_cluster_operations *ops,
7580                                    struct module *module)
7581 {
7582         int ret = 0;
7583         spin_lock(&pers_lock);
7584         if (md_cluster_ops != NULL)
7585                 ret = -EALREADY;
7586         else {
7587                 md_cluster_ops = ops;
7588                 md_cluster_mod = module;
7589         }
7590         spin_unlock(&pers_lock);
7591         return ret;
7592 }
7593 EXPORT_SYMBOL(register_md_cluster_operations);
7594
7595 int unregister_md_cluster_operations(void)
7596 {
7597         spin_lock(&pers_lock);
7598         md_cluster_ops = NULL;
7599         spin_unlock(&pers_lock);
7600         return 0;
7601 }
7602 EXPORT_SYMBOL(unregister_md_cluster_operations);
7603
7604 int md_setup_cluster(struct mddev *mddev, int nodes)
7605 {
7606         int err;
7607
7608         err = request_module("md-cluster");
7609         if (err) {
7610                 pr_err("md-cluster module not found.\n");
7611                 return -ENOENT;
7612         }
7613
7614         spin_lock(&pers_lock);
7615         if (!md_cluster_ops || !try_module_get(md_cluster_mod)) {
7616                 spin_unlock(&pers_lock);
7617                 return -ENOENT;
7618         }
7619         spin_unlock(&pers_lock);
7620
7621         return md_cluster_ops->join(mddev, nodes);
7622 }
7623
7624 void md_cluster_stop(struct mddev *mddev)
7625 {
7626         if (!md_cluster_ops)
7627                 return;
7628         md_cluster_ops->leave(mddev);
7629         module_put(md_cluster_mod);
7630 }
7631
7632 static int is_mddev_idle(struct mddev *mddev, int init)
7633 {
7634         struct md_rdev *rdev;
7635         int idle;
7636         int curr_events;
7637
7638         idle = 1;
7639         rcu_read_lock();
7640         rdev_for_each_rcu(rdev, mddev) {
7641                 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
7642                 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
7643                               (int)part_stat_read(&disk->part0, sectors[1]) -
7644                               atomic_read(&disk->sync_io);
7645                 /* sync IO will cause sync_io to increase before the disk_stats
7646                  * as sync_io is counted when a request starts, and
7647                  * disk_stats is counted when it completes.
7648                  * So resync activity will cause curr_events to be smaller than
7649                  * when there was no such activity.
7650                  * non-sync IO will cause disk_stat to increase without
7651                  * increasing sync_io so curr_events will (eventually)
7652                  * be larger than it was before.  Once it becomes
7653                  * substantially larger, the test below will cause
7654                  * the array to appear non-idle, and resync will slow
7655                  * down.
7656                  * If there is a lot of outstanding resync activity when
7657                  * we set last_event to curr_events, then all that activity
7658                  * completing might cause the array to appear non-idle
7659                  * and resync will be slowed down even though there might
7660                  * not have been non-resync activity.  This will only
7661                  * happen once though.  'last_events' will soon reflect
7662                  * the state where there is little or no outstanding
7663                  * resync requests, and further resync activity will
7664                  * always make curr_events less than last_events.
7665                  *
7666                  */
7667                 if (init || curr_events - rdev->last_events > 64) {
7668                         rdev->last_events = curr_events;
7669                         idle = 0;
7670                 }
7671         }
7672         rcu_read_unlock();
7673         return idle;
7674 }
7675
7676 void md_done_sync(struct mddev *mddev, int blocks, int ok)
7677 {
7678         /* another "blocks" (512byte) blocks have been synced */
7679         atomic_sub(blocks, &mddev->recovery_active);
7680         wake_up(&mddev->recovery_wait);
7681         if (!ok) {
7682                 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7683                 set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
7684                 md_wakeup_thread(mddev->thread);
7685                 // stop recovery, signal do_sync ....
7686         }
7687 }
7688 EXPORT_SYMBOL(md_done_sync);
7689
7690 /* md_write_start(mddev, bi)
7691  * If we need to update some array metadata (e.g. 'active' flag
7692  * in superblock) before writing, schedule a superblock update
7693  * and wait for it to complete.
7694  */
7695 void md_write_start(struct mddev *mddev, struct bio *bi)
7696 {
7697         int did_change = 0;
7698         if (bio_data_dir(bi) != WRITE)
7699                 return;
7700
7701         BUG_ON(mddev->ro == 1);
7702         if (mddev->ro == 2) {
7703                 /* need to switch to read/write */
7704                 mddev->ro = 0;
7705                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7706                 md_wakeup_thread(mddev->thread);
7707                 md_wakeup_thread(mddev->sync_thread);
7708                 did_change = 1;
7709         }
7710         atomic_inc(&mddev->writes_pending);
7711         if (mddev->safemode == 1)
7712                 mddev->safemode = 0;
7713         if (mddev->in_sync) {
7714                 spin_lock(&mddev->lock);
7715                 if (mddev->in_sync) {
7716                         mddev->in_sync = 0;
7717                         set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7718                         set_bit(MD_CHANGE_PENDING, &mddev->flags);
7719                         md_wakeup_thread(mddev->thread);
7720                         did_change = 1;
7721                 }
7722                 spin_unlock(&mddev->lock);
7723         }
7724         if (did_change)
7725                 sysfs_notify_dirent_safe(mddev->sysfs_state);
7726         wait_event(mddev->sb_wait,
7727                    !test_bit(MD_CHANGE_PENDING, &mddev->flags));
7728 }
7729 EXPORT_SYMBOL(md_write_start);
7730
7731 void md_write_end(struct mddev *mddev)
7732 {
7733         if (atomic_dec_and_test(&mddev->writes_pending)) {
7734                 if (mddev->safemode == 2)
7735                         md_wakeup_thread(mddev->thread);
7736                 else if (mddev->safemode_delay)
7737                         mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
7738         }
7739 }
7740 EXPORT_SYMBOL(md_write_end);
7741
7742 /* md_allow_write(mddev)
7743  * Calling this ensures that the array is marked 'active' so that writes
7744  * may proceed without blocking.  It is important to call this before
7745  * attempting a GFP_KERNEL allocation while holding the mddev lock.
7746  * Must be called with mddev_lock held.
7747  *
7748  * In the ->external case MD_CHANGE_PENDING can not be cleared until mddev->lock
7749  * is dropped, so return -EAGAIN after notifying userspace.
7750  */
7751 int md_allow_write(struct mddev *mddev)
7752 {
7753         if (!mddev->pers)
7754                 return 0;
7755         if (mddev->ro)
7756                 return 0;
7757         if (!mddev->pers->sync_request)
7758                 return 0;
7759
7760         spin_lock(&mddev->lock);
7761         if (mddev->in_sync) {
7762                 mddev->in_sync = 0;
7763                 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
7764                 set_bit(MD_CHANGE_PENDING, &mddev->flags);
7765                 if (mddev->safemode_delay &&
7766                     mddev->safemode == 0)
7767                         mddev->safemode = 1;
7768                 spin_unlock(&mddev->lock);
7769                 md_update_sb(mddev, 0);
7770                 sysfs_notify_dirent_safe(mddev->sysfs_state);
7771         } else
7772                 spin_unlock(&mddev->lock);
7773
7774         if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
7775                 return -EAGAIN;
7776         else
7777                 return 0;
7778 }
7779 EXPORT_SYMBOL_GPL(md_allow_write);
7780
7781 #define SYNC_MARKS      10
7782 #define SYNC_MARK_STEP  (3*HZ)
7783 #define UPDATE_FREQUENCY (5*60*HZ)
7784 void md_do_sync(struct md_thread *thread)
7785 {
7786         struct mddev *mddev = thread->mddev;
7787         struct mddev *mddev2;
7788         unsigned int currspeed = 0,
7789                  window;
7790         sector_t max_sectors,j, io_sectors, recovery_done;
7791         unsigned long mark[SYNC_MARKS];
7792         unsigned long update_time;
7793         sector_t mark_cnt[SYNC_MARKS];
7794         int last_mark,m;
7795         struct list_head *tmp;
7796         sector_t last_check;
7797         int skipped = 0;
7798         struct md_rdev *rdev;
7799         char *desc, *action = NULL;
7800         struct blk_plug plug;
7801         int ret;
7802
7803         /* just incase thread restarts... */
7804         if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
7805                 return;
7806         if (mddev->ro) {/* never try to sync a read-only array */
7807                 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
7808                 return;
7809         }
7810
7811         if (mddev_is_clustered(mddev)) {
7812                 ret = md_cluster_ops->resync_start(mddev);
7813                 if (ret)
7814                         goto skip;
7815
7816                 if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
7817                         test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ||
7818                         test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
7819                      && ((unsigned long long)mddev->curr_resync_completed
7820                          < (unsigned long long)mddev->resync_max_sectors))
7821                         goto skip;
7822         }
7823
7824         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7825                 if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
7826                         desc = "data-check";
7827                         action = "check";
7828                 } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
7829                         desc = "requested-resync";
7830                         action = "repair";
7831                 } else
7832                         desc = "resync";
7833         } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7834                 desc = "reshape";
7835         else
7836                 desc = "recovery";
7837
7838         mddev->last_sync_action = action ?: desc;
7839
7840         /* we overload curr_resync somewhat here.
7841          * 0 == not engaged in resync at all
7842          * 2 == checking that there is no conflict with another sync
7843          * 1 == like 2, but have yielded to allow conflicting resync to
7844          *              commense
7845          * other == active in resync - this many blocks
7846          *
7847          * Before starting a resync we must have set curr_resync to
7848          * 2, and then checked that every "conflicting" array has curr_resync
7849          * less than ours.  When we find one that is the same or higher
7850          * we wait on resync_wait.  To avoid deadlock, we reduce curr_resync
7851          * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
7852          * This will mean we have to start checking from the beginning again.
7853          *
7854          */
7855
7856         do {
7857                 mddev->curr_resync = 2;
7858
7859         try_again:
7860                 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
7861                         goto skip;
7862                 for_each_mddev(mddev2, tmp) {
7863                         if (mddev2 == mddev)
7864                                 continue;
7865                         if (!mddev->parallel_resync
7866                         &&  mddev2->curr_resync
7867                         &&  match_mddev_units(mddev, mddev2)) {
7868                                 DEFINE_WAIT(wq);
7869                                 if (mddev < mddev2 && mddev->curr_resync == 2) {
7870                                         /* arbitrarily yield */
7871                                         mddev->curr_resync = 1;
7872                                         wake_up(&resync_wait);
7873                                 }
7874                                 if (mddev > mddev2 && mddev->curr_resync == 1)
7875                                         /* no need to wait here, we can wait the next
7876                                          * time 'round when curr_resync == 2
7877                                          */
7878                                         continue;
7879                                 /* We need to wait 'interruptible' so as not to
7880                                  * contribute to the load average, and not to
7881                                  * be caught by 'softlockup'
7882                                  */
7883                                 prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
7884                                 if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
7885                                     mddev2->curr_resync >= mddev->curr_resync) {
7886                                         printk(KERN_INFO "md: delaying %s of %s"
7887                                                " until %s has finished (they"
7888                                                " share one or more physical units)\n",
7889                                                desc, mdname(mddev), mdname(mddev2));
7890                                         mddev_put(mddev2);
7891                                         if (signal_pending(current))
7892                                                 flush_signals(current);
7893                                         schedule();
7894                                         finish_wait(&resync_wait, &wq);
7895                                         goto try_again;
7896                                 }
7897                                 finish_wait(&resync_wait, &wq);
7898                         }
7899                 }
7900         } while (mddev->curr_resync < 2);
7901
7902         j = 0;
7903         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
7904                 /* resync follows the size requested by the personality,
7905                  * which defaults to physical size, but can be virtual size
7906                  */
7907                 max_sectors = mddev->resync_max_sectors;
7908                 atomic64_set(&mddev->resync_mismatches, 0);
7909                 /* we don't use the checkpoint if there's a bitmap */
7910                 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
7911                         j = mddev->resync_min;
7912                 else if (!mddev->bitmap)
7913                         j = mddev->recovery_cp;
7914
7915         } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
7916                 max_sectors = mddev->resync_max_sectors;
7917         else {
7918                 /* recovery follows the physical size of devices */
7919                 max_sectors = mddev->dev_sectors;
7920                 j = MaxSector;
7921                 rcu_read_lock();
7922                 rdev_for_each_rcu(rdev, mddev)
7923                         if (rdev->raid_disk >= 0 &&
7924                             !test_bit(Journal, &rdev->flags) &&
7925                             !test_bit(Faulty, &rdev->flags) &&
7926                             !test_bit(In_sync, &rdev->flags) &&
7927                             rdev->recovery_offset < j)
7928                                 j = rdev->recovery_offset;
7929                 rcu_read_unlock();
7930
7931                 /* If there is a bitmap, we need to make sure all
7932                  * writes that started before we added a spare
7933                  * complete before we start doing a recovery.
7934                  * Otherwise the write might complete and (via
7935                  * bitmap_endwrite) set a bit in the bitmap after the
7936                  * recovery has checked that bit and skipped that
7937                  * region.
7938                  */
7939                 if (mddev->bitmap) {
7940                         mddev->pers->quiesce(mddev, 1);
7941                         mddev->pers->quiesce(mddev, 0);
7942                 }
7943         }
7944
7945         printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
7946         printk(KERN_INFO "md: minimum _guaranteed_  speed:"
7947                 " %d KB/sec/disk.\n", speed_min(mddev));
7948         printk(KERN_INFO "md: using maximum available idle IO bandwidth "
7949                "(but not more than %d KB/sec) for %s.\n",
7950                speed_max(mddev), desc);
7951
7952         is_mddev_idle(mddev, 1); /* this initializes IO event counters */
7953
7954         io_sectors = 0;
7955         for (m = 0; m < SYNC_MARKS; m++) {
7956                 mark[m] = jiffies;
7957                 mark_cnt[m] = io_sectors;
7958         }
7959         last_mark = 0;
7960         mddev->resync_mark = mark[last_mark];
7961         mddev->resync_mark_cnt = mark_cnt[last_mark];
7962
7963         /*
7964          * Tune reconstruction:
7965          */
7966         window = 32*(PAGE_SIZE/512);
7967         printk(KERN_INFO "md: using %dk window, over a total of %lluk.\n",
7968                 window/2, (unsigned long long)max_sectors/2);
7969
7970         atomic_set(&mddev->recovery_active, 0);
7971         last_check = 0;
7972
7973         if (j>2) {
7974                 printk(KERN_INFO
7975                        "md: resuming %s of %s from checkpoint.\n",
7976                        desc, mdname(mddev));
7977                 mddev->curr_resync = j;
7978         } else
7979                 mddev->curr_resync = 3; /* no longer delayed */
7980         mddev->curr_resync_completed = j;
7981         sysfs_notify(&mddev->kobj, NULL, "sync_completed");
7982         md_new_event(mddev);
7983         update_time = jiffies;
7984
7985         blk_start_plug(&plug);
7986         while (j < max_sectors) {
7987                 sector_t sectors;
7988
7989                 skipped = 0;
7990
7991                 if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
7992                     ((mddev->curr_resync > mddev->curr_resync_completed &&
7993                       (mddev->curr_resync - mddev->curr_resync_completed)
7994                       > (max_sectors >> 4)) ||
7995                      time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) ||
7996                      (j - mddev->curr_resync_completed)*2
7997                      >= mddev->resync_max - mddev->curr_resync_completed ||
7998                      mddev->curr_resync_completed > mddev->resync_max
7999                             )) {
8000                         /* time to update curr_resync_completed */
8001                         wait_event(mddev->recovery_wait,
8002                                    atomic_read(&mddev->recovery_active) == 0);
8003                         mddev->curr_resync_completed = j;
8004                         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
8005                             j > mddev->recovery_cp)
8006                                 mddev->recovery_cp = j;
8007                         update_time = jiffies;
8008                         set_bit(MD_CHANGE_CLEAN, &mddev->flags);
8009                         sysfs_notify(&mddev->kobj, NULL, "sync_completed");
8010                 }
8011
8012                 while (j >= mddev->resync_max &&
8013                        !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8014                         /* As this condition is controlled by user-space,
8015                          * we can block indefinitely, so use '_interruptible'
8016                          * to avoid triggering warnings.
8017                          */
8018                         flush_signals(current); /* just in case */
8019                         wait_event_interruptible(mddev->recovery_wait,
8020                                                  mddev->resync_max > j
8021                                                  || test_bit(MD_RECOVERY_INTR,
8022                                                              &mddev->recovery));
8023                 }
8024
8025                 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8026                         break;
8027
8028                 sectors = mddev->pers->sync_request(mddev, j, &skipped);
8029                 if (sectors == 0) {
8030                         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8031                         break;
8032                 }
8033
8034                 if (!skipped) { /* actual IO requested */
8035                         io_sectors += sectors;
8036                         atomic_add(sectors, &mddev->recovery_active);
8037                 }
8038
8039                 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8040                         break;
8041
8042                 j += sectors;
8043                 if (j > max_sectors)
8044                         /* when skipping, extra large numbers can be returned. */
8045                         j = max_sectors;
8046                 if (j > 2)
8047                         mddev->curr_resync = j;
8048                 mddev->curr_mark_cnt = io_sectors;
8049                 if (last_check == 0)
8050                         /* this is the earliest that rebuild will be
8051                          * visible in /proc/mdstat
8052                          */
8053                         md_new_event(mddev);
8054
8055                 if (last_check + window > io_sectors || j == max_sectors)
8056                         continue;
8057
8058                 last_check = io_sectors;
8059         repeat:
8060                 if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
8061                         /* step marks */
8062                         int next = (last_mark+1) % SYNC_MARKS;
8063
8064                         mddev->resync_mark = mark[next];
8065                         mddev->resync_mark_cnt = mark_cnt[next];
8066                         mark[next] = jiffies;
8067                         mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
8068                         last_mark = next;
8069                 }
8070
8071                 if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8072                         break;
8073
8074                 /*
8075                  * this loop exits only if either when we are slower than
8076                  * the 'hard' speed limit, or the system was IO-idle for
8077                  * a jiffy.
8078                  * the system might be non-idle CPU-wise, but we only care
8079                  * about not overloading the IO subsystem. (things like an
8080                  * e2fsck being done on the RAID array should execute fast)
8081                  */
8082                 cond_resched();
8083
8084                 recovery_done = io_sectors - atomic_read(&mddev->recovery_active);
8085                 currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2
8086                         /((jiffies-mddev->resync_mark)/HZ +1) +1;
8087
8088                 if (currspeed > speed_min(mddev)) {
8089                         if (currspeed > speed_max(mddev)) {
8090                                 msleep(500);
8091                                 goto repeat;
8092                         }
8093                         if (!is_mddev_idle(mddev, 0)) {
8094                                 /*
8095                                  * Give other IO more of a chance.
8096                                  * The faster the devices, the less we wait.
8097                                  */
8098                                 wait_event(mddev->recovery_wait,
8099                                            !atomic_read(&mddev->recovery_active));
8100                         }
8101                 }
8102         }
8103         printk(KERN_INFO "md: %s: %s %s.\n",mdname(mddev), desc,
8104                test_bit(MD_RECOVERY_INTR, &mddev->recovery)
8105                ? "interrupted" : "done");
8106         /*
8107          * this also signals 'finished resyncing' to md_stop
8108          */
8109         blk_finish_plug(&plug);
8110         wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
8111
8112         if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8113             !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8114             mddev->curr_resync > 2) {
8115                 mddev->curr_resync_completed = mddev->curr_resync;
8116                 sysfs_notify(&mddev->kobj, NULL, "sync_completed");
8117         }
8118         mddev->pers->sync_request(mddev, max_sectors, &skipped);
8119
8120         if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
8121             mddev->curr_resync > 2) {
8122                 if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
8123                         if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8124                                 if (mddev->curr_resync >= mddev->recovery_cp) {
8125                                         printk(KERN_INFO
8126                                                "md: checkpointing %s of %s.\n",
8127                                                desc, mdname(mddev));
8128                                         if (test_bit(MD_RECOVERY_ERROR,
8129                                                 &mddev->recovery))
8130                                                 mddev->recovery_cp =
8131                                                         mddev->curr_resync_completed;
8132                                         else
8133                                                 mddev->recovery_cp =
8134                                                         mddev->curr_resync;
8135                                 }
8136                         } else
8137                                 mddev->recovery_cp = MaxSector;
8138                 } else {
8139                         if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8140                                 mddev->curr_resync = MaxSector;
8141                         rcu_read_lock();
8142                         rdev_for_each_rcu(rdev, mddev)
8143                                 if (rdev->raid_disk >= 0 &&
8144                                     mddev->delta_disks >= 0 &&
8145                                     !test_bit(Journal, &rdev->flags) &&
8146                                     !test_bit(Faulty, &rdev->flags) &&
8147                                     !test_bit(In_sync, &rdev->flags) &&
8148                                     rdev->recovery_offset < mddev->curr_resync)
8149                                         rdev->recovery_offset = mddev->curr_resync;
8150                         rcu_read_unlock();
8151                 }
8152         }
8153  skip:
8154         if (mddev_is_clustered(mddev) &&
8155             ret == 0) {
8156                 /* set CHANGE_PENDING here since maybe another
8157                  * update is needed, so other nodes are informed */
8158                 set_mask_bits(&mddev->flags, 0,
8159                               BIT(MD_CHANGE_PENDING) | BIT(MD_CHANGE_DEVS));
8160                 md_wakeup_thread(mddev->thread);
8161                 wait_event(mddev->sb_wait,
8162                            !test_bit(MD_CHANGE_PENDING, &mddev->flags));
8163                 md_cluster_ops->resync_finish(mddev);
8164         } else
8165                 set_bit(MD_CHANGE_DEVS, &mddev->flags);
8166
8167         spin_lock(&mddev->lock);
8168         if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
8169                 /* We completed so min/max setting can be forgotten if used. */
8170                 if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8171                         mddev->resync_min = 0;
8172                 mddev->resync_max = MaxSector;
8173         } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
8174                 mddev->resync_min = mddev->curr_resync_completed;
8175         set_bit(MD_RECOVERY_DONE, &mddev->recovery);
8176         mddev->curr_resync = 0;
8177         spin_unlock(&mddev->lock);
8178
8179         wake_up(&resync_wait);
8180         md_wakeup_thread(mddev->thread);
8181         return;
8182 }
8183 EXPORT_SYMBOL_GPL(md_do_sync);
8184
8185 static int remove_and_add_spares(struct mddev *mddev,
8186                                  struct md_rdev *this)
8187 {
8188         struct md_rdev *rdev;
8189         int spares = 0;
8190         int removed = 0;
8191
8192         rdev_for_each(rdev, mddev)
8193                 if ((this == NULL || rdev == this) &&
8194                     rdev->raid_disk >= 0 &&
8195                     !test_bit(Blocked, &rdev->flags) &&
8196                     (test_bit(Faulty, &rdev->flags) ||
8197                      (!test_bit(In_sync, &rdev->flags) &&
8198                       !test_bit(Journal, &rdev->flags))) &&
8199                     atomic_read(&rdev->nr_pending)==0) {
8200                         if (mddev->pers->hot_remove_disk(
8201                                     mddev, rdev) == 0) {
8202                                 sysfs_unlink_rdev(mddev, rdev);
8203                                 rdev->raid_disk = -1;
8204                                 removed++;
8205                         }
8206                 }
8207         if (removed && mddev->kobj.sd)
8208                 sysfs_notify(&mddev->kobj, NULL, "degraded");
8209
8210         if (this && removed)
8211                 goto no_add;
8212
8213         rdev_for_each(rdev, mddev) {
8214                 if (this && this != rdev)
8215                         continue;
8216                 if (test_bit(Candidate, &rdev->flags))
8217                         continue;
8218                 if (rdev->raid_disk >= 0 &&
8219                     !test_bit(In_sync, &rdev->flags) &&
8220                     !test_bit(Journal, &rdev->flags) &&
8221                     !test_bit(Faulty, &rdev->flags))
8222                         spares++;
8223                 if (rdev->raid_disk >= 0)
8224                         continue;
8225                 if (test_bit(Faulty, &rdev->flags))
8226                         continue;
8227                 if (!test_bit(Journal, &rdev->flags)) {
8228                         if (mddev->ro &&
8229                             ! (rdev->saved_raid_disk >= 0 &&
8230                                !test_bit(Bitmap_sync, &rdev->flags)))
8231                                 continue;
8232
8233                         rdev->recovery_offset = 0;
8234                 }
8235                 if (mddev->pers->
8236                     hot_add_disk(mddev, rdev) == 0) {
8237                         if (sysfs_link_rdev(mddev, rdev))
8238                                 /* failure here is OK */;
8239                         if (!test_bit(Journal, &rdev->flags))
8240                                 spares++;
8241                         md_new_event(mddev);
8242                         set_bit(MD_CHANGE_DEVS, &mddev->flags);
8243                 }
8244         }
8245 no_add:
8246         if (removed)
8247                 set_bit(MD_CHANGE_DEVS, &mddev->flags);
8248         return spares;
8249 }
8250
8251 static void md_start_sync(struct work_struct *ws)
8252 {
8253         struct mddev *mddev = container_of(ws, struct mddev, del_work);
8254         int ret = 0;
8255
8256         mddev->sync_thread = md_register_thread(md_do_sync,
8257                                                 mddev,
8258                                                 "resync");
8259         if (!mddev->sync_thread) {
8260                 if (!(mddev_is_clustered(mddev) && ret == -EAGAIN))
8261                         printk(KERN_ERR "%s: could not start resync"
8262                                " thread...\n",
8263                                mdname(mddev));
8264                 /* leave the spares where they are, it shouldn't hurt */
8265                 clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8266                 clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8267                 clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8268                 clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8269                 clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8270                 wake_up(&resync_wait);
8271                 if (test_and_clear_bit(MD_RECOVERY_RECOVER,
8272                                        &mddev->recovery))
8273                         if (mddev->sysfs_action)
8274                                 sysfs_notify_dirent_safe(mddev->sysfs_action);
8275         } else
8276                 md_wakeup_thread(mddev->sync_thread);
8277         sysfs_notify_dirent_safe(mddev->sysfs_action);
8278         md_new_event(mddev);
8279 }
8280
8281 /*
8282  * This routine is regularly called by all per-raid-array threads to
8283  * deal with generic issues like resync and super-block update.
8284  * Raid personalities that don't have a thread (linear/raid0) do not
8285  * need this as they never do any recovery or update the superblock.
8286  *
8287  * It does not do any resync itself, but rather "forks" off other threads
8288  * to do that as needed.
8289  * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
8290  * "->recovery" and create a thread at ->sync_thread.
8291  * When the thread finishes it sets MD_RECOVERY_DONE
8292  * and wakeups up this thread which will reap the thread and finish up.
8293  * This thread also removes any faulty devices (with nr_pending == 0).
8294  *
8295  * The overall approach is:
8296  *  1/ if the superblock needs updating, update it.
8297  *  2/ If a recovery thread is running, don't do anything else.
8298  *  3/ If recovery has finished, clean up, possibly marking spares active.
8299  *  4/ If there are any faulty devices, remove them.
8300  *  5/ If array is degraded, try to add spares devices
8301  *  6/ If array has spares or is not in-sync, start a resync thread.
8302  */
8303 void md_check_recovery(struct mddev *mddev)
8304 {
8305         if (mddev->suspended)
8306                 return;
8307
8308         if (mddev->bitmap)
8309                 bitmap_daemon_work(mddev);
8310
8311         if (signal_pending(current)) {
8312                 if (mddev->pers->sync_request && !mddev->external) {
8313                         printk(KERN_INFO "md: %s in immediate safe mode\n",
8314                                mdname(mddev));
8315                         mddev->safemode = 2;
8316                 }
8317                 flush_signals(current);
8318         }
8319
8320         if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
8321                 return;
8322         if ( ! (
8323                 (mddev->flags & MD_UPDATE_SB_FLAGS & ~ (1<<MD_CHANGE_PENDING)) ||
8324                 test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
8325                 test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
8326                 test_bit(MD_RELOAD_SB, &mddev->flags) ||
8327                 (mddev->external == 0 && mddev->safemode == 1) ||
8328                 (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
8329                  && !mddev->in_sync && mddev->recovery_cp == MaxSector)
8330                 ))
8331                 return;
8332
8333         if (mddev_trylock(mddev)) {
8334                 int spares = 0;
8335
8336                 if (mddev->ro) {
8337                         struct md_rdev *rdev;
8338                         if (!mddev->external && mddev->in_sync)
8339                                 /* 'Blocked' flag not needed as failed devices
8340                                  * will be recorded if array switched to read/write.
8341                                  * Leaving it set will prevent the device
8342                                  * from being removed.
8343                                  */
8344                                 rdev_for_each(rdev, mddev)
8345                                         clear_bit(Blocked, &rdev->flags);
8346                         /* On a read-only array we can:
8347                          * - remove failed devices
8348                          * - add already-in_sync devices if the array itself
8349                          *   is in-sync.
8350                          * As we only add devices that are already in-sync,
8351                          * we can activate the spares immediately.
8352                          */
8353                         remove_and_add_spares(mddev, NULL);
8354                         /* There is no thread, but we need to call
8355                          * ->spare_active and clear saved_raid_disk
8356                          */
8357                         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8358                         md_reap_sync_thread(mddev);
8359                         clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8360                         clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8361                         clear_bit(MD_CHANGE_PENDING, &mddev->flags);
8362                         goto unlock;
8363                 }
8364
8365                 if (mddev_is_clustered(mddev)) {
8366                         struct md_rdev *rdev;
8367                         /* kick the device if another node issued a
8368                          * remove disk.
8369                          */
8370                         rdev_for_each(rdev, mddev) {
8371                                 if (test_and_clear_bit(ClusterRemove, &rdev->flags) &&
8372                                                 rdev->raid_disk < 0)
8373                                         md_kick_rdev_from_array(rdev);
8374                         }
8375
8376                         if (test_and_clear_bit(MD_RELOAD_SB, &mddev->flags))
8377                                 md_reload_sb(mddev, mddev->good_device_nr);
8378                 }
8379
8380                 if (!mddev->external) {
8381                         int did_change = 0;
8382                         spin_lock(&mddev->lock);
8383                         if (mddev->safemode &&
8384                             !atomic_read(&mddev->writes_pending) &&
8385                             !mddev->in_sync &&
8386                             mddev->recovery_cp == MaxSector) {
8387                                 mddev->in_sync = 1;
8388                                 did_change = 1;
8389                                 set_bit(MD_CHANGE_CLEAN, &mddev->flags);
8390                         }
8391                         if (mddev->safemode == 1)
8392                                 mddev->safemode = 0;
8393                         spin_unlock(&mddev->lock);
8394                         if (did_change)
8395                                 sysfs_notify_dirent_safe(mddev->sysfs_state);
8396                 }
8397
8398                 if (mddev->flags & MD_UPDATE_SB_FLAGS)
8399                         md_update_sb(mddev, 0);
8400
8401                 if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
8402                     !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
8403                         /* resync/recovery still happening */
8404                         clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8405                         goto unlock;
8406                 }
8407                 if (mddev->sync_thread) {
8408                         md_reap_sync_thread(mddev);
8409                         goto unlock;
8410                 }
8411                 /* Set RUNNING before clearing NEEDED to avoid
8412                  * any transients in the value of "sync_action".
8413                  */
8414                 mddev->curr_resync_completed = 0;
8415                 spin_lock(&mddev->lock);
8416                 set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8417                 spin_unlock(&mddev->lock);
8418                 /* Clear some bits that don't mean anything, but
8419                  * might be left set
8420                  */
8421                 clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
8422                 clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
8423
8424                 if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
8425                     test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
8426                         goto not_running;
8427                 /* no recovery is running.
8428                  * remove any failed drives, then
8429                  * add spares if possible.
8430                  * Spares are also removed and re-added, to allow
8431                  * the personality to fail the re-add.
8432                  */
8433
8434                 if (mddev->reshape_position != MaxSector) {
8435                         if (mddev->pers->check_reshape == NULL ||
8436                             mddev->pers->check_reshape(mddev) != 0)
8437                                 /* Cannot proceed */
8438                                 goto not_running;
8439                         set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8440                         clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8441                 } else if ((spares = remove_and_add_spares(mddev, NULL))) {
8442                         clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8443                         clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8444                         clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8445                         set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8446                 } else if (mddev->recovery_cp < MaxSector) {
8447                         set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8448                         clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
8449                 } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
8450                         /* nothing to be done ... */
8451                         goto not_running;
8452
8453                 if (mddev->pers->sync_request) {
8454                         if (spares) {
8455                                 /* We are adding a device or devices to an array
8456                                  * which has the bitmap stored on all devices.
8457                                  * So make sure all bitmap pages get written
8458                                  */
8459                                 bitmap_write_all(mddev->bitmap);
8460                         }
8461                         INIT_WORK(&mddev->del_work, md_start_sync);
8462                         queue_work(md_misc_wq, &mddev->del_work);
8463                         goto unlock;
8464                 }
8465         not_running:
8466                 if (!mddev->sync_thread) {
8467                         clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8468                         wake_up(&resync_wait);
8469                         if (test_and_clear_bit(MD_RECOVERY_RECOVER,
8470                                                &mddev->recovery))
8471                                 if (mddev->sysfs_action)
8472                                         sysfs_notify_dirent_safe(mddev->sysfs_action);
8473                 }
8474         unlock:
8475                 wake_up(&mddev->sb_wait);
8476                 mddev_unlock(mddev);
8477         }
8478 }
8479 EXPORT_SYMBOL(md_check_recovery);
8480
8481 void md_reap_sync_thread(struct mddev *mddev)
8482 {
8483         struct md_rdev *rdev;
8484
8485         /* resync has finished, collect result */
8486         md_unregister_thread(&mddev->sync_thread);
8487         if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
8488             !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
8489                 /* success...*/
8490                 /* activate any spares */
8491                 if (mddev->pers->spare_active(mddev)) {
8492                         sysfs_notify(&mddev->kobj, NULL,
8493                                      "degraded");
8494                         set_bit(MD_CHANGE_DEVS, &mddev->flags);
8495                 }
8496         }
8497         if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
8498             mddev->pers->finish_reshape)
8499                 mddev->pers->finish_reshape(mddev);
8500
8501         /* If array is no-longer degraded, then any saved_raid_disk
8502          * information must be scrapped.
8503          */
8504         if (!mddev->degraded)
8505                 rdev_for_each(rdev, mddev)
8506                         rdev->saved_raid_disk = -1;
8507
8508         md_update_sb(mddev, 1);
8509         clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8510         clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
8511         clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
8512         clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8513         clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
8514         clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8515         wake_up(&resync_wait);
8516         /* flag recovery needed just to double check */
8517         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8518         sysfs_notify_dirent_safe(mddev->sysfs_action);
8519         md_new_event(mddev);
8520         if (mddev->event_work.func)
8521                 queue_work(md_misc_wq, &mddev->event_work);
8522 }
8523 EXPORT_SYMBOL(md_reap_sync_thread);
8524
8525 void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
8526 {
8527         sysfs_notify_dirent_safe(rdev->sysfs_state);
8528         wait_event_timeout(rdev->blocked_wait,
8529                            !test_bit(Blocked, &rdev->flags) &&
8530                            !test_bit(BlockedBadBlocks, &rdev->flags),
8531                            msecs_to_jiffies(5000));
8532         rdev_dec_pending(rdev, mddev);
8533 }
8534 EXPORT_SYMBOL(md_wait_for_blocked_rdev);
8535
8536 void md_finish_reshape(struct mddev *mddev)
8537 {
8538         /* called be personality module when reshape completes. */
8539         struct md_rdev *rdev;
8540
8541         rdev_for_each(rdev, mddev) {
8542                 if (rdev->data_offset > rdev->new_data_offset)
8543                         rdev->sectors += rdev->data_offset - rdev->new_data_offset;
8544                 else
8545                         rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
8546                 rdev->data_offset = rdev->new_data_offset;
8547         }
8548 }
8549 EXPORT_SYMBOL(md_finish_reshape);
8550
8551 /* Bad block management */
8552
8553 /* Returns 1 on success, 0 on failure */
8554 int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8555                        int is_new)
8556 {
8557         struct mddev *mddev = rdev->mddev;
8558         int rv;
8559         if (is_new)
8560                 s += rdev->new_data_offset;
8561         else
8562                 s += rdev->data_offset;
8563         rv = badblocks_set(&rdev->badblocks, s, sectors, 0);
8564         if (rv == 0) {
8565                 /* Make sure they get written out promptly */
8566                 sysfs_notify_dirent_safe(rdev->sysfs_state);
8567                 set_mask_bits(&mddev->flags, 0,
8568                               BIT(MD_CHANGE_CLEAN) | BIT(MD_CHANGE_PENDING));
8569                 md_wakeup_thread(rdev->mddev->thread);
8570                 return 1;
8571         } else
8572                 return 0;
8573 }
8574 EXPORT_SYMBOL_GPL(rdev_set_badblocks);
8575
8576 int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
8577                          int is_new)
8578 {
8579         if (is_new)
8580                 s += rdev->new_data_offset;
8581         else
8582                 s += rdev->data_offset;
8583         return badblocks_clear(&rdev->badblocks,
8584                                   s, sectors);
8585 }
8586 EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
8587
8588 static int md_notify_reboot(struct notifier_block *this,
8589                             unsigned long code, void *x)
8590 {
8591         struct list_head *tmp;
8592         struct mddev *mddev;
8593         int need_delay = 0;
8594
8595         for_each_mddev(mddev, tmp) {
8596                 if (mddev_trylock(mddev)) {
8597                         if (mddev->pers)
8598                                 __md_stop_writes(mddev);
8599                         if (mddev->persistent)
8600                                 mddev->safemode = 2;
8601                         mddev_unlock(mddev);
8602                 }
8603                 need_delay = 1;
8604         }
8605         /*
8606          * certain more exotic SCSI devices are known to be
8607          * volatile wrt too early system reboots. While the
8608          * right place to handle this issue is the given
8609          * driver, we do want to have a safe RAID driver ...
8610          */
8611         if (need_delay)
8612                 mdelay(1000*1);
8613
8614         return NOTIFY_DONE;
8615 }
8616
8617 static struct notifier_block md_notifier = {
8618         .notifier_call  = md_notify_reboot,
8619         .next           = NULL,
8620         .priority       = INT_MAX, /* before any real devices */
8621 };
8622
8623 static void md_geninit(void)
8624 {
8625         pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
8626
8627         proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
8628 }
8629
8630 static int __init md_init(void)
8631 {
8632         int ret = -ENOMEM;
8633
8634         md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
8635         if (!md_wq)
8636                 goto err_wq;
8637
8638         md_misc_wq = alloc_workqueue("md_misc", 0, 0);
8639         if (!md_misc_wq)
8640                 goto err_misc_wq;
8641
8642         if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
8643                 goto err_md;
8644
8645         if ((ret = register_blkdev(0, "mdp")) < 0)
8646                 goto err_mdp;
8647         mdp_major = ret;
8648
8649         blk_register_region(MKDEV(MD_MAJOR, 0), 512, THIS_MODULE,
8650                             md_probe, NULL, NULL);
8651         blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
8652                             md_probe, NULL, NULL);
8653
8654         register_reboot_notifier(&md_notifier);
8655         raid_table_header = register_sysctl_table(raid_root_table);
8656
8657         md_geninit();
8658         return 0;
8659
8660 err_mdp:
8661         unregister_blkdev(MD_MAJOR, "md");
8662 err_md:
8663         destroy_workqueue(md_misc_wq);
8664 err_misc_wq:
8665         destroy_workqueue(md_wq);
8666 err_wq:
8667         return ret;
8668 }
8669
8670 static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev)
8671 {
8672         struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
8673         struct md_rdev *rdev2;
8674         int role, ret;
8675         char b[BDEVNAME_SIZE];
8676
8677         /* Check for change of roles in the active devices */
8678         rdev_for_each(rdev2, mddev) {
8679                 if (test_bit(Faulty, &rdev2->flags))
8680                         continue;
8681
8682                 /* Check if the roles changed */
8683                 role = le16_to_cpu(sb->dev_roles[rdev2->desc_nr]);
8684
8685                 if (test_bit(Candidate, &rdev2->flags)) {
8686                         if (role == 0xfffe) {
8687                                 pr_info("md: Removing Candidate device %s because add failed\n", bdevname(rdev2->bdev,b));
8688                                 md_kick_rdev_from_array(rdev2);
8689                                 continue;
8690                         }
8691                         else
8692                                 clear_bit(Candidate, &rdev2->flags);
8693                 }
8694
8695                 if (role != rdev2->raid_disk) {
8696                         /* got activated */
8697                         if (rdev2->raid_disk == -1 && role != 0xffff) {
8698                                 rdev2->saved_raid_disk = role;
8699                                 ret = remove_and_add_spares(mddev, rdev2);
8700                                 pr_info("Activated spare: %s\n",
8701                                                 bdevname(rdev2->bdev,b));
8702                                 /* wakeup mddev->thread here, so array could
8703                                  * perform resync with the new activated disk */
8704                                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8705                                 md_wakeup_thread(mddev->thread);
8706
8707                         }
8708                         /* device faulty
8709                          * We just want to do the minimum to mark the disk
8710                          * as faulty. The recovery is performed by the
8711                          * one who initiated the error.
8712                          */
8713                         if ((role == 0xfffe) || (role == 0xfffd)) {
8714                                 md_error(mddev, rdev2);
8715                                 clear_bit(Blocked, &rdev2->flags);
8716                         }
8717                 }
8718         }
8719
8720         if (mddev->raid_disks != le32_to_cpu(sb->raid_disks))
8721                 update_raid_disks(mddev, le32_to_cpu(sb->raid_disks));
8722
8723         /* Finally set the event to be up to date */
8724         mddev->events = le64_to_cpu(sb->events);
8725 }
8726
8727 static int read_rdev(struct mddev *mddev, struct md_rdev *rdev)
8728 {
8729         int err;
8730         struct page *swapout = rdev->sb_page;
8731         struct mdp_superblock_1 *sb;
8732
8733         /* Store the sb page of the rdev in the swapout temporary
8734          * variable in case we err in the future
8735          */
8736         rdev->sb_page = NULL;
8737         alloc_disk_sb(rdev);
8738         ClearPageUptodate(rdev->sb_page);
8739         rdev->sb_loaded = 0;
8740         err = super_types[mddev->major_version].load_super(rdev, NULL, mddev->minor_version);
8741
8742         if (err < 0) {
8743                 pr_warn("%s: %d Could not reload rdev(%d) err: %d. Restoring old values\n",
8744                                 __func__, __LINE__, rdev->desc_nr, err);
8745                 put_page(rdev->sb_page);
8746                 rdev->sb_page = swapout;
8747                 rdev->sb_loaded = 1;
8748                 return err;
8749         }
8750
8751         sb = page_address(rdev->sb_page);
8752         /* Read the offset unconditionally, even if MD_FEATURE_RECOVERY_OFFSET
8753          * is not set
8754          */
8755
8756         if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET))
8757                 rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
8758
8759         /* The other node finished recovery, call spare_active to set
8760          * device In_sync and mddev->degraded
8761          */
8762         if (rdev->recovery_offset == MaxSector &&
8763             !test_bit(In_sync, &rdev->flags) &&
8764             mddev->pers->spare_active(mddev))
8765                 sysfs_notify(&mddev->kobj, NULL, "degraded");
8766
8767         put_page(swapout);
8768         return 0;
8769 }
8770
8771 void md_reload_sb(struct mddev *mddev, int nr)
8772 {
8773         struct md_rdev *rdev;
8774         int err;
8775
8776         /* Find the rdev */
8777         rdev_for_each_rcu(rdev, mddev) {
8778                 if (rdev->desc_nr == nr)
8779                         break;
8780         }
8781
8782         if (!rdev || rdev->desc_nr != nr) {
8783                 pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr);
8784                 return;
8785         }
8786
8787         err = read_rdev(mddev, rdev);
8788         if (err < 0)
8789                 return;
8790
8791         check_sb_changes(mddev, rdev);
8792
8793         /* Read all rdev's to update recovery_offset */
8794         rdev_for_each_rcu(rdev, mddev)
8795                 read_rdev(mddev, rdev);
8796 }
8797 EXPORT_SYMBOL(md_reload_sb);
8798
8799 #ifndef MODULE
8800
8801 /*
8802  * Searches all registered partitions for autorun RAID arrays
8803  * at boot time.
8804  */
8805
8806 static LIST_HEAD(all_detected_devices);
8807 struct detected_devices_node {
8808         struct list_head list;
8809         dev_t dev;
8810 };
8811
8812 void md_autodetect_dev(dev_t dev)
8813 {
8814         struct detected_devices_node *node_detected_dev;
8815
8816         node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
8817         if (node_detected_dev) {
8818                 node_detected_dev->dev = dev;
8819                 list_add_tail(&node_detected_dev->list, &all_detected_devices);
8820         } else {
8821                 printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed"
8822                         ", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev));
8823         }
8824 }
8825
8826 static void autostart_arrays(int part)
8827 {
8828         struct md_rdev *rdev;
8829         struct detected_devices_node *node_detected_dev;
8830         dev_t dev;
8831         int i_scanned, i_passed;
8832
8833         i_scanned = 0;
8834         i_passed = 0;
8835
8836         printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
8837
8838         while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
8839                 i_scanned++;
8840                 node_detected_dev = list_entry(all_detected_devices.next,
8841                                         struct detected_devices_node, list);
8842                 list_del(&node_detected_dev->list);
8843                 dev = node_detected_dev->dev;
8844                 kfree(node_detected_dev);
8845                 rdev = md_import_device(dev,0, 90);
8846                 if (IS_ERR(rdev))
8847                         continue;
8848
8849                 if (test_bit(Faulty, &rdev->flags))
8850                         continue;
8851
8852                 set_bit(AutoDetected, &rdev->flags);
8853                 list_add(&rdev->same_set, &pending_raid_disks);
8854                 i_passed++;
8855         }
8856
8857         printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
8858                                                 i_scanned, i_passed);
8859
8860         autorun_devices(part);
8861 }
8862
8863 #endif /* !MODULE */
8864
8865 static __exit void md_exit(void)
8866 {
8867         struct mddev *mddev;
8868         struct list_head *tmp;
8869         int delay = 1;
8870
8871         blk_unregister_region(MKDEV(MD_MAJOR,0), 512);
8872         blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
8873
8874         unregister_blkdev(MD_MAJOR,"md");
8875         unregister_blkdev(mdp_major, "mdp");
8876         unregister_reboot_notifier(&md_notifier);
8877         unregister_sysctl_table(raid_table_header);
8878
8879         /* We cannot unload the modules while some process is
8880          * waiting for us in select() or poll() - wake them up
8881          */
8882         md_unloading = 1;
8883         while (waitqueue_active(&md_event_waiters)) {
8884                 /* not safe to leave yet */
8885                 wake_up(&md_event_waiters);
8886                 msleep(delay);
8887                 delay += delay;
8888         }
8889         remove_proc_entry("mdstat", NULL);
8890
8891         for_each_mddev(mddev, tmp) {
8892                 export_array(mddev);
8893                 mddev->hold_active = 0;
8894         }
8895         destroy_workqueue(md_misc_wq);
8896         destroy_workqueue(md_wq);
8897 }
8898
8899 subsys_initcall(md_init);
8900 module_exit(md_exit)
8901
8902 static int get_ro(char *buffer, struct kernel_param *kp)
8903 {
8904         return sprintf(buffer, "%d", start_readonly);
8905 }
8906 static int set_ro(const char *val, struct kernel_param *kp)
8907 {
8908         return kstrtouint(val, 10, (unsigned int *)&start_readonly);
8909 }
8910
8911 module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
8912 module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
8913 module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
8914
8915 MODULE_LICENSE("GPL");
8916 MODULE_DESCRIPTION("MD RAID framework");
8917 MODULE_ALIAS("md");
8918 MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);