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