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