drivers/md/md.c

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