Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/drivers/md/md.c

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