md: move lots of #include lines out of .h files and into .c
[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_k.h>
49 #include <linux/raid/md_p.h>
50 #include <linux/raid/md_u.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             rdev->recovery_offset > 0) {
1329                 sb->feature_map |= cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
1330                 sb->recovery_offset = cpu_to_le64(rdev->recovery_offset);
1331         }
1332
1333         if (mddev->reshape_position != MaxSector) {
1334                 sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
1335                 sb->reshape_position = cpu_to_le64(mddev->reshape_position);
1336                 sb->new_layout = cpu_to_le32(mddev->new_layout);
1337                 sb->delta_disks = cpu_to_le32(mddev->delta_disks);
1338                 sb->new_level = cpu_to_le32(mddev->new_level);
1339                 sb->new_chunk = cpu_to_le32(mddev->new_chunk>>9);
1340         }
1341
1342         max_dev = 0;
1343         list_for_each_entry(rdev2, &mddev->disks, same_set)
1344                 if (rdev2->desc_nr+1 > max_dev)
1345                         max_dev = rdev2->desc_nr+1;
1346
1347         if (max_dev > le32_to_cpu(sb->max_dev))
1348                 sb->max_dev = cpu_to_le32(max_dev);
1349         for (i=0; i<max_dev;i++)
1350                 sb->dev_roles[i] = cpu_to_le16(0xfffe);
1351         
1352         list_for_each_entry(rdev2, &mddev->disks, same_set) {
1353                 i = rdev2->desc_nr;
1354                 if (test_bit(Faulty, &rdev2->flags))
1355                         sb->dev_roles[i] = cpu_to_le16(0xfffe);
1356                 else if (test_bit(In_sync, &rdev2->flags))
1357                         sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1358                 else if (rdev2->raid_disk >= 0 && rdev2->recovery_offset > 0)
1359                         sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
1360                 else
1361                         sb->dev_roles[i] = cpu_to_le16(0xffff);
1362         }
1363
1364         sb->sb_csum = calc_sb_1_csum(sb);
1365 }
1366
1367 static unsigned long long
1368 super_1_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
1369 {
1370         struct mdp_superblock_1 *sb;
1371         sector_t max_sectors;
1372         if (num_sectors && num_sectors < rdev->mddev->size * 2)
1373                 return 0; /* component must fit device */
1374         if (rdev->sb_start < rdev->data_offset) {
1375                 /* minor versions 1 and 2; superblock before data */
1376                 max_sectors = rdev->bdev->bd_inode->i_size >> 9;
1377                 max_sectors -= rdev->data_offset;
1378                 if (!num_sectors || num_sectors > max_sectors)
1379                         num_sectors = max_sectors;
1380         } else if (rdev->mddev->bitmap_offset) {
1381                 /* minor version 0 with bitmap we can't move */
1382                 return 0;
1383         } else {
1384                 /* minor version 0; superblock after data */
1385                 sector_t sb_start;
1386                 sb_start = (rdev->bdev->bd_inode->i_size >> 9) - 8*2;
1387                 sb_start &= ~(sector_t)(4*2 - 1);
1388                 max_sectors = rdev->size * 2 + sb_start - rdev->sb_start;
1389                 if (!num_sectors || num_sectors > max_sectors)
1390                         num_sectors = max_sectors;
1391                 rdev->sb_start = sb_start;
1392         }
1393         sb = (struct mdp_superblock_1 *) page_address(rdev->sb_page);
1394         sb->data_size = cpu_to_le64(num_sectors);
1395         sb->super_offset = rdev->sb_start;
1396         sb->sb_csum = calc_sb_1_csum(sb);
1397         md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
1398                        rdev->sb_page);
1399         md_super_wait(rdev->mddev);
1400         return num_sectors / 2; /* kB for sysfs */
1401 }
1402
1403 static struct super_type super_types[] = {
1404         [0] = {
1405                 .name   = "0.90.0",
1406                 .owner  = THIS_MODULE,
1407                 .load_super         = super_90_load,
1408                 .validate_super     = super_90_validate,
1409                 .sync_super         = super_90_sync,
1410                 .rdev_size_change   = super_90_rdev_size_change,
1411         },
1412         [1] = {
1413                 .name   = "md-1",
1414                 .owner  = THIS_MODULE,
1415                 .load_super         = super_1_load,
1416                 .validate_super     = super_1_validate,
1417                 .sync_super         = super_1_sync,
1418                 .rdev_size_change   = super_1_rdev_size_change,
1419         },
1420 };
1421
1422 static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
1423 {
1424         mdk_rdev_t *rdev, *rdev2;
1425
1426         rcu_read_lock();
1427         rdev_for_each_rcu(rdev, mddev1)
1428                 rdev_for_each_rcu(rdev2, mddev2)
1429                         if (rdev->bdev->bd_contains ==
1430                             rdev2->bdev->bd_contains) {
1431                                 rcu_read_unlock();
1432                                 return 1;
1433                         }
1434         rcu_read_unlock();
1435         return 0;
1436 }
1437
1438 static LIST_HEAD(pending_raid_disks);
1439
1440 static void md_integrity_check(mdk_rdev_t *rdev, mddev_t *mddev)
1441 {
1442         struct mdk_personality *pers = mddev->pers;
1443         struct gendisk *disk = mddev->gendisk;
1444         struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev);
1445         struct blk_integrity *bi_mddev = blk_get_integrity(disk);
1446
1447         /* Data integrity passthrough not supported on RAID 4, 5 and 6 */
1448         if (pers && pers->level >= 4 && pers->level <= 6)
1449                 return;
1450
1451         /* If rdev is integrity capable, register profile for mddev */
1452         if (!bi_mddev && bi_rdev) {
1453                 if (blk_integrity_register(disk, bi_rdev))
1454                         printk(KERN_ERR "%s: %s Could not register integrity!\n",
1455                                __func__, disk->disk_name);
1456                 else
1457                         printk(KERN_NOTICE "Enabling data integrity on %s\n",
1458                                disk->disk_name);
1459                 return;
1460         }
1461
1462         /* Check that mddev and rdev have matching profiles */
1463         if (blk_integrity_compare(disk, rdev->bdev->bd_disk) < 0) {
1464                 printk(KERN_ERR "%s: %s/%s integrity mismatch!\n", __func__,
1465                        disk->disk_name, rdev->bdev->bd_disk->disk_name);
1466                 printk(KERN_NOTICE "Disabling data integrity on %s\n",
1467                        disk->disk_name);
1468                 blk_integrity_unregister(disk);
1469         }
1470 }
1471
1472 static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
1473 {
1474         char b[BDEVNAME_SIZE];
1475         struct kobject *ko;
1476         char *s;
1477         int err;
1478
1479         if (rdev->mddev) {
1480                 MD_BUG();
1481                 return -EINVAL;
1482         }
1483
1484         /* prevent duplicates */
1485         if (find_rdev(mddev, rdev->bdev->bd_dev))
1486                 return -EEXIST;
1487
1488         /* make sure rdev->size exceeds mddev->size */
1489         if (rdev->size && (mddev->size == 0 || rdev->size < mddev->size)) {
1490                 if (mddev->pers) {
1491                         /* Cannot change size, so fail
1492                          * If mddev->level <= 0, then we don't care
1493                          * about aligning sizes (e.g. linear)
1494                          */
1495                         if (mddev->level > 0)
1496                                 return -ENOSPC;
1497                 } else
1498                         mddev->size = rdev->size;
1499         }
1500
1501         /* Verify rdev->desc_nr is unique.
1502          * If it is -1, assign a free number, else
1503          * check number is not in use
1504          */
1505         if (rdev->desc_nr < 0) {
1506                 int choice = 0;
1507                 if (mddev->pers) choice = mddev->raid_disks;
1508                 while (find_rdev_nr(mddev, choice))
1509                         choice++;
1510                 rdev->desc_nr = choice;
1511         } else {
1512                 if (find_rdev_nr(mddev, rdev->desc_nr))
1513                         return -EBUSY;
1514         }
1515         if (mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
1516                 printk(KERN_WARNING "md: %s: array is limited to %d devices\n",
1517                        mdname(mddev), mddev->max_disks);
1518                 return -EBUSY;
1519         }
1520         bdevname(rdev->bdev,b);
1521         while ( (s=strchr(b, '/')) != NULL)
1522                 *s = '!';
1523
1524         rdev->mddev = mddev;
1525         printk(KERN_INFO "md: bind<%s>\n", b);
1526
1527         if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
1528                 goto fail;
1529
1530         ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
1531         if ((err = sysfs_create_link(&rdev->kobj, ko, "block"))) {
1532                 kobject_del(&rdev->kobj);
1533                 goto fail;
1534         }
1535         rdev->sysfs_state = sysfs_get_dirent(rdev->kobj.sd, "state");
1536
1537         list_add_rcu(&rdev->same_set, &mddev->disks);
1538         bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk);
1539
1540         /* May as well allow recovery to be retried once */
1541         mddev->recovery_disabled = 0;
1542
1543         md_integrity_check(rdev, mddev);
1544         return 0;
1545
1546  fail:
1547         printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
1548                b, mdname(mddev));
1549         return err;
1550 }
1551
1552 static void md_delayed_delete(struct work_struct *ws)
1553 {
1554         mdk_rdev_t *rdev = container_of(ws, mdk_rdev_t, del_work);
1555         kobject_del(&rdev->kobj);
1556         kobject_put(&rdev->kobj);
1557 }
1558
1559 static void unbind_rdev_from_array(mdk_rdev_t * rdev)
1560 {
1561         char b[BDEVNAME_SIZE];
1562         if (!rdev->mddev) {
1563                 MD_BUG();
1564                 return;
1565         }
1566         bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
1567         list_del_rcu(&rdev->same_set);
1568         printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
1569         rdev->mddev = NULL;
1570         sysfs_remove_link(&rdev->kobj, "block");
1571         sysfs_put(rdev->sysfs_state);
1572         rdev->sysfs_state = NULL;
1573         /* We need to delay this, otherwise we can deadlock when
1574          * writing to 'remove' to "dev/state".  We also need
1575          * to delay it due to rcu usage.
1576          */
1577         synchronize_rcu();
1578         INIT_WORK(&rdev->del_work, md_delayed_delete);
1579         kobject_get(&rdev->kobj);
1580         schedule_work(&rdev->del_work);
1581 }
1582
1583 /*
1584  * prevent the device from being mounted, repartitioned or
1585  * otherwise reused by a RAID array (or any other kernel
1586  * subsystem), by bd_claiming the device.
1587  */
1588 static int lock_rdev(mdk_rdev_t *rdev, dev_t dev, int shared)
1589 {
1590         int err = 0;
1591         struct block_device *bdev;
1592         char b[BDEVNAME_SIZE];
1593
1594         bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
1595         if (IS_ERR(bdev)) {
1596                 printk(KERN_ERR "md: could not open %s.\n",
1597                         __bdevname(dev, b));
1598                 return PTR_ERR(bdev);
1599         }
1600         err = bd_claim(bdev, shared ? (mdk_rdev_t *)lock_rdev : rdev);
1601         if (err) {
1602                 printk(KERN_ERR "md: could not bd_claim %s.\n",
1603                         bdevname(bdev, b));
1604                 blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
1605                 return err;
1606         }
1607         if (!shared)
1608                 set_bit(AllReserved, &rdev->flags);
1609         rdev->bdev = bdev;
1610         return err;
1611 }
1612
1613 static void unlock_rdev(mdk_rdev_t *rdev)
1614 {
1615         struct block_device *bdev = rdev->bdev;
1616         rdev->bdev = NULL;
1617         if (!bdev)
1618                 MD_BUG();
1619         bd_release(bdev);
1620         blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
1621 }
1622
1623 void md_autodetect_dev(dev_t dev);
1624
1625 static void export_rdev(mdk_rdev_t * rdev)
1626 {
1627         char b[BDEVNAME_SIZE];
1628         printk(KERN_INFO "md: export_rdev(%s)\n",
1629                 bdevname(rdev->bdev,b));
1630         if (rdev->mddev)
1631                 MD_BUG();
1632         free_disk_sb(rdev);
1633 #ifndef MODULE
1634         if (test_bit(AutoDetected, &rdev->flags))
1635                 md_autodetect_dev(rdev->bdev->bd_dev);
1636 #endif
1637         unlock_rdev(rdev);
1638         kobject_put(&rdev->kobj);
1639 }
1640
1641 static void kick_rdev_from_array(mdk_rdev_t * rdev)
1642 {
1643         unbind_rdev_from_array(rdev);
1644         export_rdev(rdev);
1645 }
1646
1647 static void export_array(mddev_t *mddev)
1648 {
1649         mdk_rdev_t *rdev, *tmp;
1650
1651         rdev_for_each(rdev, tmp, mddev) {
1652                 if (!rdev->mddev) {
1653                         MD_BUG();
1654                         continue;
1655                 }
1656                 kick_rdev_from_array(rdev);
1657         }
1658         if (!list_empty(&mddev->disks))
1659                 MD_BUG();
1660         mddev->raid_disks = 0;
1661         mddev->major_version = 0;
1662 }
1663
1664 static void print_desc(mdp_disk_t *desc)
1665 {
1666         printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number,
1667                 desc->major,desc->minor,desc->raid_disk,desc->state);
1668 }
1669
1670 static void print_sb_90(mdp_super_t *sb)
1671 {
1672         int i;
1673
1674         printk(KERN_INFO 
1675                 "md:  SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
1676                 sb->major_version, sb->minor_version, sb->patch_version,
1677                 sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
1678                 sb->ctime);
1679         printk(KERN_INFO "md:     L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n",
1680                 sb->level, sb->size, sb->nr_disks, sb->raid_disks,
1681                 sb->md_minor, sb->layout, sb->chunk_size);
1682         printk(KERN_INFO "md:     UT:%08x ST:%d AD:%d WD:%d"
1683                 " FD:%d SD:%d CSUM:%08x E:%08lx\n",
1684                 sb->utime, sb->state, sb->active_disks, sb->working_disks,
1685                 sb->failed_disks, sb->spare_disks,
1686                 sb->sb_csum, (unsigned long)sb->events_lo);
1687
1688         printk(KERN_INFO);
1689         for (i = 0; i < MD_SB_DISKS; i++) {
1690                 mdp_disk_t *desc;
1691
1692                 desc = sb->disks + i;
1693                 if (desc->number || desc->major || desc->minor ||
1694                     desc->raid_disk || (desc->state && (desc->state != 4))) {
1695                         printk("     D %2d: ", i);
1696                         print_desc(desc);
1697                 }
1698         }
1699         printk(KERN_INFO "md:     THIS: ");
1700         print_desc(&sb->this_disk);
1701 }
1702
1703 static void print_sb_1(struct mdp_superblock_1 *sb)
1704 {
1705         __u8 *uuid;
1706
1707         uuid = sb->set_uuid;
1708         printk(KERN_INFO "md:  SB: (V:%u) (F:0x%08x) Array-ID:<%02x%02x%02x%02x"
1709                         ":%02x%02x:%02x%02x:%02x%02x:%02x%02x%02x%02x%02x%02x>\n"
1710                KERN_INFO "md:    Name: \"%s\" CT:%llu\n",
1711                 le32_to_cpu(sb->major_version),
1712                 le32_to_cpu(sb->feature_map),
1713                 uuid[0], uuid[1], uuid[2], uuid[3],
1714                 uuid[4], uuid[5], uuid[6], uuid[7],
1715                 uuid[8], uuid[9], uuid[10], uuid[11],
1716                 uuid[12], uuid[13], uuid[14], uuid[15],
1717                 sb->set_name,
1718                 (unsigned long long)le64_to_cpu(sb->ctime)
1719                        & MD_SUPERBLOCK_1_TIME_SEC_MASK);
1720
1721         uuid = sb->device_uuid;
1722         printk(KERN_INFO "md:       L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu"
1723                         " RO:%llu\n"
1724                KERN_INFO "md:     Dev:%08x UUID: %02x%02x%02x%02x:%02x%02x:%02x%02x:%02x%02x"
1725                         ":%02x%02x%02x%02x%02x%02x\n"
1726                KERN_INFO "md:       (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
1727                KERN_INFO "md:         (MaxDev:%u) \n",
1728                 le32_to_cpu(sb->level),
1729                 (unsigned long long)le64_to_cpu(sb->size),
1730                 le32_to_cpu(sb->raid_disks),
1731                 le32_to_cpu(sb->layout),
1732                 le32_to_cpu(sb->chunksize),
1733                 (unsigned long long)le64_to_cpu(sb->data_offset),
1734                 (unsigned long long)le64_to_cpu(sb->data_size),
1735                 (unsigned long long)le64_to_cpu(sb->super_offset),
1736                 (unsigned long long)le64_to_cpu(sb->recovery_offset),
1737                 le32_to_cpu(sb->dev_number),
1738                 uuid[0], uuid[1], uuid[2], uuid[3],
1739                 uuid[4], uuid[5], uuid[6], uuid[7],
1740                 uuid[8], uuid[9], uuid[10], uuid[11],
1741                 uuid[12], uuid[13], uuid[14], uuid[15],
1742                 sb->devflags,
1743                 (unsigned long long)le64_to_cpu(sb->utime) & MD_SUPERBLOCK_1_TIME_SEC_MASK,
1744                 (unsigned long long)le64_to_cpu(sb->events),
1745                 (unsigned long long)le64_to_cpu(sb->resync_offset),
1746                 le32_to_cpu(sb->sb_csum),
1747                 le32_to_cpu(sb->max_dev)
1748                 );
1749 }
1750
1751 static void print_rdev(mdk_rdev_t *rdev, int major_version)
1752 {
1753         char b[BDEVNAME_SIZE];
1754         printk(KERN_INFO "md: rdev %s, SZ:%08llu F:%d S:%d DN:%u\n",
1755                 bdevname(rdev->bdev,b), (unsigned long long)rdev->size,
1756                 test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
1757                 rdev->desc_nr);
1758         if (rdev->sb_loaded) {
1759                 printk(KERN_INFO "md: rdev superblock (MJ:%d):\n", major_version);
1760                 switch (major_version) {
1761                 case 0:
1762                         print_sb_90((mdp_super_t*)page_address(rdev->sb_page));
1763                         break;
1764                 case 1:
1765                         print_sb_1((struct mdp_superblock_1 *)page_address(rdev->sb_page));
1766                         break;
1767                 }
1768         } else
1769                 printk(KERN_INFO "md: no rdev superblock!\n");
1770 }
1771
1772 static void md_print_devices(void)
1773 {
1774         struct list_head *tmp;
1775         mdk_rdev_t *rdev;
1776         mddev_t *mddev;
1777         char b[BDEVNAME_SIZE];
1778
1779         printk("\n");
1780         printk("md:     **********************************\n");
1781         printk("md:     * <COMPLETE RAID STATE PRINTOUT> *\n");
1782         printk("md:     **********************************\n");
1783         for_each_mddev(mddev, tmp) {
1784
1785                 if (mddev->bitmap)
1786                         bitmap_print_sb(mddev->bitmap);
1787                 else
1788                         printk("%s: ", mdname(mddev));
1789                 list_for_each_entry(rdev, &mddev->disks, same_set)
1790                         printk("<%s>", bdevname(rdev->bdev,b));
1791                 printk("\n");
1792
1793                 list_for_each_entry(rdev, &mddev->disks, same_set)
1794                         print_rdev(rdev, mddev->major_version);
1795         }
1796         printk("md:     **********************************\n");
1797         printk("\n");
1798 }
1799
1800
1801 static void sync_sbs(mddev_t * mddev, int nospares)
1802 {
1803         /* Update each superblock (in-memory image), but
1804          * if we are allowed to, skip spares which already
1805          * have the right event counter, or have one earlier
1806          * (which would mean they aren't being marked as dirty
1807          * with the rest of the array)
1808          */
1809         mdk_rdev_t *rdev;
1810
1811         list_for_each_entry(rdev, &mddev->disks, same_set) {
1812                 if (rdev->sb_events == mddev->events ||
1813                     (nospares &&
1814                      rdev->raid_disk < 0 &&
1815                      (rdev->sb_events&1)==0 &&
1816                      rdev->sb_events+1 == mddev->events)) {
1817                         /* Don't update this superblock */
1818                         rdev->sb_loaded = 2;
1819                 } else {
1820                         super_types[mddev->major_version].
1821                                 sync_super(mddev, rdev);
1822                         rdev->sb_loaded = 1;
1823                 }
1824         }
1825 }
1826
1827 static void md_update_sb(mddev_t * mddev, int force_change)
1828 {
1829         mdk_rdev_t *rdev;
1830         int sync_req;
1831         int nospares = 0;
1832
1833         if (mddev->external)
1834                 return;
1835 repeat:
1836         spin_lock_irq(&mddev->write_lock);
1837
1838         set_bit(MD_CHANGE_PENDING, &mddev->flags);
1839         if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
1840                 force_change = 1;
1841         if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
1842                 /* just a clean<-> dirty transition, possibly leave spares alone,
1843                  * though if events isn't the right even/odd, we will have to do
1844                  * spares after all
1845                  */
1846                 nospares = 1;
1847         if (force_change)
1848                 nospares = 0;
1849         if (mddev->degraded)
1850                 /* If the array is degraded, then skipping spares is both
1851                  * dangerous and fairly pointless.
1852                  * Dangerous because a device that was removed from the array
1853                  * might have a event_count that still looks up-to-date,
1854                  * so it can be re-added without a resync.
1855                  * Pointless because if there are any spares to skip,
1856                  * then a recovery will happen and soon that array won't
1857                  * be degraded any more and the spare can go back to sleep then.
1858                  */
1859                 nospares = 0;
1860
1861         sync_req = mddev->in_sync;
1862         mddev->utime = get_seconds();
1863
1864         /* If this is just a dirty<->clean transition, and the array is clean
1865          * and 'events' is odd, we can roll back to the previous clean state */
1866         if (nospares
1867             && (mddev->in_sync && mddev->recovery_cp == MaxSector)
1868             && (mddev->events & 1)
1869             && mddev->events != 1)
1870                 mddev->events--;
1871         else {
1872                 /* otherwise we have to go forward and ... */
1873                 mddev->events ++;
1874                 if (!mddev->in_sync || mddev->recovery_cp != MaxSector) { /* not clean */
1875                         /* .. if the array isn't clean, insist on an odd 'events' */
1876                         if ((mddev->events&1)==0) {
1877                                 mddev->events++;
1878                                 nospares = 0;
1879                         }
1880                 } else {
1881                         /* otherwise insist on an even 'events' (for clean states) */
1882                         if ((mddev->events&1)) {
1883                                 mddev->events++;
1884                                 nospares = 0;
1885                         }
1886                 }
1887         }
1888
1889         if (!mddev->events) {
1890                 /*
1891                  * oops, this 64-bit counter should never wrap.
1892                  * Either we are in around ~1 trillion A.C., assuming
1893                  * 1 reboot per second, or we have a bug:
1894                  */
1895                 MD_BUG();
1896                 mddev->events --;
1897         }
1898
1899         /*
1900          * do not write anything to disk if using
1901          * nonpersistent superblocks
1902          */
1903         if (!mddev->persistent) {
1904                 if (!mddev->external)
1905                         clear_bit(MD_CHANGE_PENDING, &mddev->flags);
1906
1907                 spin_unlock_irq(&mddev->write_lock);
1908                 wake_up(&mddev->sb_wait);
1909                 return;
1910         }
1911         sync_sbs(mddev, nospares);
1912         spin_unlock_irq(&mddev->write_lock);
1913
1914         dprintk(KERN_INFO 
1915                 "md: updating %s RAID superblock on device (in sync %d)\n",
1916                 mdname(mddev),mddev->in_sync);
1917
1918         bitmap_update_sb(mddev->bitmap);
1919         list_for_each_entry(rdev, &mddev->disks, same_set) {
1920                 char b[BDEVNAME_SIZE];
1921                 dprintk(KERN_INFO "md: ");
1922                 if (rdev->sb_loaded != 1)
1923                         continue; /* no noise on spare devices */
1924                 if (test_bit(Faulty, &rdev->flags))
1925                         dprintk("(skipping faulty ");
1926
1927                 dprintk("%s ", bdevname(rdev->bdev,b));
1928                 if (!test_bit(Faulty, &rdev->flags)) {
1929                         md_super_write(mddev,rdev,
1930                                        rdev->sb_start, rdev->sb_size,
1931                                        rdev->sb_page);
1932                         dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
1933                                 bdevname(rdev->bdev,b),
1934                                 (unsigned long long)rdev->sb_start);
1935                         rdev->sb_events = mddev->events;
1936
1937                 } else
1938                         dprintk(")\n");
1939                 if (mddev->level == LEVEL_MULTIPATH)
1940                         /* only need to write one superblock... */
1941                         break;
1942         }
1943         md_super_wait(mddev);
1944         /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
1945
1946         spin_lock_irq(&mddev->write_lock);
1947         if (mddev->in_sync != sync_req ||
1948             test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
1949                 /* have to write it out again */
1950                 spin_unlock_irq(&mddev->write_lock);
1951                 goto repeat;
1952         }
1953         clear_bit(MD_CHANGE_PENDING, &mddev->flags);
1954         spin_unlock_irq(&mddev->write_lock);
1955         wake_up(&mddev->sb_wait);
1956
1957 }
1958
1959 /* words written to sysfs files may, or may not, be \n terminated.
1960  * We want to accept with case. For this we use cmd_match.
1961  */
1962 static int cmd_match(const char *cmd, const char *str)
1963 {
1964         /* See if cmd, written into a sysfs file, matches
1965          * str.  They must either be the same, or cmd can
1966          * have a trailing newline
1967          */
1968         while (*cmd && *str && *cmd == *str) {
1969                 cmd++;
1970                 str++;
1971         }
1972         if (*cmd == '\n')
1973                 cmd++;
1974         if (*str || *cmd)
1975                 return 0;
1976         return 1;
1977 }
1978
1979 struct rdev_sysfs_entry {
1980         struct attribute attr;
1981         ssize_t (*show)(mdk_rdev_t *, char *);
1982         ssize_t (*store)(mdk_rdev_t *, const char *, size_t);
1983 };
1984
1985 static ssize_t
1986 state_show(mdk_rdev_t *rdev, char *page)
1987 {
1988         char *sep = "";
1989         size_t len = 0;
1990
1991         if (test_bit(Faulty, &rdev->flags)) {
1992                 len+= sprintf(page+len, "%sfaulty",sep);
1993                 sep = ",";
1994         }
1995         if (test_bit(In_sync, &rdev->flags)) {
1996                 len += sprintf(page+len, "%sin_sync",sep);
1997                 sep = ",";
1998         }
1999         if (test_bit(WriteMostly, &rdev->flags)) {
2000                 len += sprintf(page+len, "%swrite_mostly",sep);
2001                 sep = ",";
2002         }
2003         if (test_bit(Blocked, &rdev->flags)) {
2004                 len += sprintf(page+len, "%sblocked", sep);
2005                 sep = ",";
2006         }
2007         if (!test_bit(Faulty, &rdev->flags) &&
2008             !test_bit(In_sync, &rdev->flags)) {
2009                 len += sprintf(page+len, "%sspare", sep);
2010                 sep = ",";
2011         }
2012         return len+sprintf(page+len, "\n");
2013 }
2014
2015 static ssize_t
2016 state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
2017 {
2018         /* can write
2019          *  faulty  - simulates and error
2020          *  remove  - disconnects the device
2021          *  writemostly - sets write_mostly
2022          *  -writemostly - clears write_mostly
2023          *  blocked - sets the Blocked flag
2024          *  -blocked - clears the Blocked flag
2025          */
2026         int err = -EINVAL;
2027         if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
2028                 md_error(rdev->mddev, rdev);
2029                 err = 0;
2030         } else if (cmd_match(buf, "remove")) {
2031                 if (rdev->raid_disk >= 0)
2032                         err = -EBUSY;
2033                 else {
2034                         mddev_t *mddev = rdev->mddev;
2035                         kick_rdev_from_array(rdev);
2036                         if (mddev->pers)
2037                                 md_update_sb(mddev, 1);
2038                         md_new_event(mddev);
2039                         err = 0;
2040                 }
2041         } else if (cmd_match(buf, "writemostly")) {
2042                 set_bit(WriteMostly, &rdev->flags);
2043                 err = 0;
2044         } else if (cmd_match(buf, "-writemostly")) {
2045                 clear_bit(WriteMostly, &rdev->flags);
2046                 err = 0;
2047         } else if (cmd_match(buf, "blocked")) {
2048                 set_bit(Blocked, &rdev->flags);
2049                 err = 0;
2050         } else if (cmd_match(buf, "-blocked")) {
2051                 clear_bit(Blocked, &rdev->flags);
2052                 wake_up(&rdev->blocked_wait);
2053                 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2054                 md_wakeup_thread(rdev->mddev->thread);
2055
2056                 err = 0;
2057         }
2058         if (!err && rdev->sysfs_state)
2059                 sysfs_notify_dirent(rdev->sysfs_state);
2060         return err ? err : len;
2061 }
2062 static struct rdev_sysfs_entry rdev_state =
2063 __ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
2064
2065 static ssize_t
2066 errors_show(mdk_rdev_t *rdev, char *page)
2067 {
2068         return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
2069 }
2070
2071 static ssize_t
2072 errors_store(mdk_rdev_t *rdev, const char *buf, size_t len)
2073 {
2074         char *e;
2075         unsigned long n = simple_strtoul(buf, &e, 10);
2076         if (*buf && (*e == 0 || *e == '\n')) {
2077                 atomic_set(&rdev->corrected_errors, n);
2078                 return len;
2079         }
2080         return -EINVAL;
2081 }
2082 static struct rdev_sysfs_entry rdev_errors =
2083 __ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
2084
2085 static ssize_t
2086 slot_show(mdk_rdev_t *rdev, char *page)
2087 {
2088         if (rdev->raid_disk < 0)
2089                 return sprintf(page, "none\n");
2090         else
2091                 return sprintf(page, "%d\n", rdev->raid_disk);
2092 }
2093
2094 static ssize_t
2095 slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
2096 {
2097         char *e;
2098         int err;
2099         char nm[20];
2100         int slot = simple_strtoul(buf, &e, 10);
2101         if (strncmp(buf, "none", 4)==0)
2102                 slot = -1;
2103         else if (e==buf || (*e && *e!= '\n'))
2104                 return -EINVAL;
2105         if (rdev->mddev->pers && slot == -1) {
2106                 /* Setting 'slot' on an active array requires also
2107                  * updating the 'rd%d' link, and communicating
2108                  * with the personality with ->hot_*_disk.
2109                  * For now we only support removing
2110                  * failed/spare devices.  This normally happens automatically,
2111                  * but not when the metadata is externally managed.
2112                  */
2113                 if (rdev->raid_disk == -1)
2114                         return -EEXIST;
2115                 /* personality does all needed checks */
2116                 if (rdev->mddev->pers->hot_add_disk == NULL)
2117                         return -EINVAL;
2118                 err = rdev->mddev->pers->
2119                         hot_remove_disk(rdev->mddev, rdev->raid_disk);
2120                 if (err)
2121                         return err;
2122                 sprintf(nm, "rd%d", rdev->raid_disk);
2123                 sysfs_remove_link(&rdev->mddev->kobj, nm);
2124                 set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
2125                 md_wakeup_thread(rdev->mddev->thread);
2126         } else if (rdev->mddev->pers) {
2127                 mdk_rdev_t *rdev2;
2128                 /* Activating a spare .. or possibly reactivating
2129                  * if we every get bitmaps working here.
2130                  */
2131
2132                 if (rdev->raid_disk != -1)
2133                         return -EBUSY;
2134
2135                 if (rdev->mddev->pers->hot_add_disk == NULL)
2136                         return -EINVAL;
2137
2138                 list_for_each_entry(rdev2, &rdev->mddev->disks, same_set)
2139                         if (rdev2->raid_disk == slot)
2140                                 return -EEXIST;
2141
2142                 rdev->raid_disk = slot;
2143                 if (test_bit(In_sync, &rdev->flags))
2144                         rdev->saved_raid_disk = slot;
2145                 else
2146                         rdev->saved_raid_disk = -1;
2147                 err = rdev->mddev->pers->
2148                         hot_add_disk(rdev->mddev, rdev);
2149                 if (err) {
2150                         rdev->raid_disk = -1;
2151                         return err;
2152                 } else
2153                         sysfs_notify_dirent(rdev->sysfs_state);
2154                 sprintf(nm, "rd%d", rdev->raid_disk);
2155                 if (sysfs_create_link(&rdev->mddev->kobj, &rdev->kobj, nm))
2156                         printk(KERN_WARNING
2157                                "md: cannot register "
2158                                "%s for %s\n",
2159                                nm, mdname(rdev->mddev));
2160
2161                 /* don't wakeup anyone, leave that to userspace. */
2162         } else {
2163                 if (slot >= rdev->mddev->raid_disks)
2164                         return -ENOSPC;
2165                 rdev->raid_disk = slot;
2166                 /* assume it is working */
2167                 clear_bit(Faulty, &rdev->flags);
2168                 clear_bit(WriteMostly, &rdev->flags);
2169                 set_bit(In_sync, &rdev->flags);
2170                 sysfs_notify_dirent(rdev->sysfs_state);
2171         }
2172         return len;
2173 }
2174
2175
2176 static struct rdev_sysfs_entry rdev_slot =
2177 __ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
2178
2179 static ssize_t
2180 offset_show(mdk_rdev_t *rdev, char *page)
2181 {
2182         return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
2183 }
2184
2185 static ssize_t
2186 offset_store(mdk_rdev_t *rdev, const char *buf, size_t len)
2187 {
2188         char *e;
2189         unsigned long long offset = simple_strtoull(buf, &e, 10);
2190         if (e==buf || (*e && *e != '\n'))
2191                 return -EINVAL;
2192         if (rdev->mddev->pers && rdev->raid_disk >= 0)
2193                 return -EBUSY;
2194         if (rdev->size && rdev->mddev->external)
2195                 /* Must set offset before size, so overlap checks
2196                  * can be sane */
2197                 return -EBUSY;
2198         rdev->data_offset = offset;
2199         return len;
2200 }
2201
2202 static struct rdev_sysfs_entry rdev_offset =
2203 __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
2204
2205 static ssize_t
2206 rdev_size_show(mdk_rdev_t *rdev, char *page)
2207 {
2208         return sprintf(page, "%llu\n", (unsigned long long)rdev->size);
2209 }
2210
2211 static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
2212 {
2213         /* check if two start/length pairs overlap */
2214         if (s1+l1 <= s2)
2215                 return 0;
2216         if (s2+l2 <= s1)
2217                 return 0;
2218         return 1;
2219 }
2220
2221 static ssize_t
2222 rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
2223 {
2224         unsigned long long size;
2225         unsigned long long oldsize = rdev->size;
2226         mddev_t *my_mddev = rdev->mddev;
2227
2228         if (strict_strtoull(buf, 10, &size) < 0)
2229                 return -EINVAL;
2230         if (my_mddev->pers && rdev->raid_disk >= 0) {
2231                 if (my_mddev->persistent) {
2232                         size = super_types[my_mddev->major_version].
2233                                 rdev_size_change(rdev, size * 2);
2234                         if (!size)
2235                                 return -EBUSY;
2236                 } else if (!size) {
2237                         size = (rdev->bdev->bd_inode->i_size >> 10);
2238                         size -= rdev->data_offset/2;
2239                 }
2240         }
2241         if (size < my_mddev->size)
2242                 return -EINVAL; /* component must fit device */
2243
2244         rdev->size = size;
2245         if (size > oldsize && my_mddev->external) {
2246                 /* need to check that all other rdevs with the same ->bdev
2247                  * do not overlap.  We need to unlock the mddev to avoid
2248                  * a deadlock.  We have already changed rdev->size, and if
2249                  * we have to change it back, we will have the lock again.
2250                  */
2251                 mddev_t *mddev;
2252                 int overlap = 0;
2253                 struct list_head *tmp;
2254
2255                 mddev_unlock(my_mddev);
2256                 for_each_mddev(mddev, tmp) {
2257                         mdk_rdev_t *rdev2;
2258
2259                         mddev_lock(mddev);
2260                         list_for_each_entry(rdev2, &mddev->disks, same_set)
2261                                 if (test_bit(AllReserved, &rdev2->flags) ||
2262                                     (rdev->bdev == rdev2->bdev &&
2263                                      rdev != rdev2 &&
2264                                      overlaps(rdev->data_offset, rdev->size * 2,
2265                                               rdev2->data_offset,
2266                                               rdev2->size * 2))) {
2267                                         overlap = 1;
2268                                         break;
2269                                 }
2270                         mddev_unlock(mddev);
2271                         if (overlap) {
2272                                 mddev_put(mddev);
2273                                 break;
2274                         }
2275                 }
2276                 mddev_lock(my_mddev);
2277                 if (overlap) {
2278                         /* Someone else could have slipped in a size
2279                          * change here, but doing so is just silly.
2280                          * We put oldsize back because we *know* it is
2281                          * safe, and trust userspace not to race with
2282                          * itself
2283                          */
2284                         rdev->size = oldsize;
2285                         return -EBUSY;
2286                 }
2287         }
2288         return len;
2289 }
2290
2291 static struct rdev_sysfs_entry rdev_size =
2292 __ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
2293
2294 static struct attribute *rdev_default_attrs[] = {
2295         &rdev_state.attr,
2296         &rdev_errors.attr,
2297         &rdev_slot.attr,
2298         &rdev_offset.attr,
2299         &rdev_size.attr,
2300         NULL,
2301 };
2302 static ssize_t
2303 rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
2304 {
2305         struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
2306         mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
2307         mddev_t *mddev = rdev->mddev;
2308         ssize_t rv;
2309
2310         if (!entry->show)
2311                 return -EIO;
2312
2313         rv = mddev ? mddev_lock(mddev) : -EBUSY;
2314         if (!rv) {
2315                 if (rdev->mddev == NULL)
2316                         rv = -EBUSY;
2317                 else
2318                         rv = entry->show(rdev, page);
2319                 mddev_unlock(mddev);
2320         }
2321         return rv;
2322 }
2323
2324 static ssize_t
2325 rdev_attr_store(struct kobject *kobj, struct attribute *attr,
2326               const char *page, size_t length)
2327 {
2328         struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
2329         mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
2330         ssize_t rv;
2331         mddev_t *mddev = rdev->mddev;
2332
2333         if (!entry->store)
2334                 return -EIO;
2335         if (!capable(CAP_SYS_ADMIN))
2336                 return -EACCES;
2337         rv = mddev ? mddev_lock(mddev): -EBUSY;
2338         if (!rv) {
2339                 if (rdev->mddev == NULL)
2340                         rv = -EBUSY;
2341                 else
2342                         rv = entry->store(rdev, page, length);
2343                 mddev_unlock(mddev);
2344         }
2345         return rv;
2346 }
2347
2348 static void rdev_free(struct kobject *ko)
2349 {
2350         mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
2351         kfree(rdev);
2352 }
2353 static struct sysfs_ops rdev_sysfs_ops = {
2354         .show           = rdev_attr_show,
2355         .store          = rdev_attr_store,
2356 };
2357 static struct kobj_type rdev_ktype = {
2358         .release        = rdev_free,
2359         .sysfs_ops      = &rdev_sysfs_ops,
2360         .default_attrs  = rdev_default_attrs,
2361 };
2362
2363 /*
2364  * Import a device. If 'super_format' >= 0, then sanity check the superblock
2365  *
2366  * mark the device faulty if:
2367  *
2368  *   - the device is nonexistent (zero size)
2369  *   - the device has no valid superblock
2370  *
2371  * a faulty rdev _never_ has rdev->sb set.
2372  */
2373 static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor)
2374 {
2375         char b[BDEVNAME_SIZE];
2376         int err;
2377         mdk_rdev_t *rdev;
2378         sector_t size;
2379
2380         rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
2381         if (!rdev) {
2382                 printk(KERN_ERR "md: could not alloc mem for new device!\n");
2383                 return ERR_PTR(-ENOMEM);
2384         }
2385
2386         if ((err = alloc_disk_sb(rdev)))
2387                 goto abort_free;
2388
2389         err = lock_rdev(rdev, newdev, super_format == -2);
2390         if (err)
2391                 goto abort_free;
2392
2393         kobject_init(&rdev->kobj, &rdev_ktype);
2394
2395         rdev->desc_nr = -1;
2396         rdev->saved_raid_disk = -1;
2397         rdev->raid_disk = -1;
2398         rdev->flags = 0;
2399         rdev->data_offset = 0;
2400         rdev->sb_events = 0;
2401         atomic_set(&rdev->nr_pending, 0);
2402         atomic_set(&rdev->read_errors, 0);
2403         atomic_set(&rdev->corrected_errors, 0);
2404
2405         size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
2406         if (!size) {
2407                 printk(KERN_WARNING 
2408                         "md: %s has zero or unknown size, marking faulty!\n",
2409                         bdevname(rdev->bdev,b));
2410                 err = -EINVAL;
2411                 goto abort_free;
2412         }
2413
2414         if (super_format >= 0) {
2415                 err = super_types[super_format].
2416                         load_super(rdev, NULL, super_minor);
2417                 if (err == -EINVAL) {
2418                         printk(KERN_WARNING
2419                                 "md: %s does not have a valid v%d.%d "
2420                                "superblock, not importing!\n",
2421                                 bdevname(rdev->bdev,b),
2422                                super_format, super_minor);
2423                         goto abort_free;
2424                 }
2425                 if (err < 0) {
2426                         printk(KERN_WARNING 
2427                                 "md: could not read %s's sb, not importing!\n",
2428                                 bdevname(rdev->bdev,b));
2429                         goto abort_free;
2430                 }
2431         }
2432
2433         INIT_LIST_HEAD(&rdev->same_set);
2434         init_waitqueue_head(&rdev->blocked_wait);
2435
2436         return rdev;
2437
2438 abort_free:
2439         if (rdev->sb_page) {
2440                 if (rdev->bdev)
2441                         unlock_rdev(rdev);
2442                 free_disk_sb(rdev);
2443         }
2444         kfree(rdev);
2445         return ERR_PTR(err);
2446 }
2447
2448 /*
2449  * Check a full RAID array for plausibility
2450  */
2451
2452
2453 static void analyze_sbs(mddev_t * mddev)
2454 {
2455         int i;
2456         mdk_rdev_t *rdev, *freshest, *tmp;
2457         char b[BDEVNAME_SIZE];
2458
2459         freshest = NULL;
2460         rdev_for_each(rdev, tmp, mddev)
2461                 switch (super_types[mddev->major_version].
2462                         load_super(rdev, freshest, mddev->minor_version)) {
2463                 case 1:
2464                         freshest = rdev;
2465                         break;
2466                 case 0:
2467                         break;
2468                 default:
2469                         printk( KERN_ERR \
2470                                 "md: fatal superblock inconsistency in %s"
2471                                 " -- removing from array\n", 
2472                                 bdevname(rdev->bdev,b));
2473                         kick_rdev_from_array(rdev);
2474                 }
2475
2476
2477         super_types[mddev->major_version].
2478                 validate_super(mddev, freshest);
2479
2480         i = 0;
2481         rdev_for_each(rdev, tmp, mddev) {
2482                 if (rdev->desc_nr >= mddev->max_disks ||
2483                     i > mddev->max_disks) {
2484                         printk(KERN_WARNING
2485                                "md: %s: %s: only %d devices permitted\n",
2486                                mdname(mddev), bdevname(rdev->bdev, b),
2487                                mddev->max_disks);
2488                         kick_rdev_from_array(rdev);
2489                         continue;
2490                 }
2491                 if (rdev != freshest)
2492                         if (super_types[mddev->major_version].
2493                             validate_super(mddev, rdev)) {
2494                                 printk(KERN_WARNING "md: kicking non-fresh %s"
2495                                         " from array!\n",
2496                                         bdevname(rdev->bdev,b));
2497                                 kick_rdev_from_array(rdev);
2498                                 continue;
2499                         }
2500                 if (mddev->level == LEVEL_MULTIPATH) {
2501                         rdev->desc_nr = i++;
2502                         rdev->raid_disk = rdev->desc_nr;
2503                         set_bit(In_sync, &rdev->flags);
2504                 } else if (rdev->raid_disk >= mddev->raid_disks) {
2505                         rdev->raid_disk = -1;
2506                         clear_bit(In_sync, &rdev->flags);
2507                 }
2508         }
2509
2510
2511
2512         if (mddev->recovery_cp != MaxSector &&
2513             mddev->level >= 1)
2514                 printk(KERN_ERR "md: %s: raid array is not clean"
2515                        " -- starting background reconstruction\n",
2516                        mdname(mddev));
2517
2518 }
2519
2520 static void md_safemode_timeout(unsigned long data);
2521
2522 static ssize_t
2523 safe_delay_show(mddev_t *mddev, char *page)
2524 {
2525         int msec = (mddev->safemode_delay*1000)/HZ;
2526         return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
2527 }
2528 static ssize_t
2529 safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len)
2530 {
2531         int scale=1;
2532         int dot=0;
2533         int i;
2534         unsigned long msec;
2535         char buf[30];
2536
2537         /* remove a period, and count digits after it */
2538         if (len >= sizeof(buf))
2539                 return -EINVAL;
2540         strlcpy(buf, cbuf, sizeof(buf));
2541         for (i=0; i<len; i++) {
2542                 if (dot) {
2543                         if (isdigit(buf[i])) {
2544                                 buf[i-1] = buf[i];
2545                                 scale *= 10;
2546                         }
2547                         buf[i] = 0;
2548                 } else if (buf[i] == '.') {
2549                         dot=1;
2550                         buf[i] = 0;
2551                 }
2552         }
2553         if (strict_strtoul(buf, 10, &msec) < 0)
2554                 return -EINVAL;
2555         msec = (msec * 1000) / scale;
2556         if (msec == 0)
2557                 mddev->safemode_delay = 0;
2558         else {
2559                 unsigned long old_delay = mddev->safemode_delay;
2560                 mddev->safemode_delay = (msec*HZ)/1000;
2561                 if (mddev->safemode_delay == 0)
2562                         mddev->safemode_delay = 1;
2563                 if (mddev->safemode_delay < old_delay)
2564                         md_safemode_timeout((unsigned long)mddev);
2565         }
2566         return len;
2567 }
2568 static struct md_sysfs_entry md_safe_delay =
2569 __ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
2570
2571 static ssize_t
2572 level_show(mddev_t *mddev, char *page)
2573 {
2574         struct mdk_personality *p = mddev->pers;
2575         if (p)
2576                 return sprintf(page, "%s\n", p->name);
2577         else if (mddev->clevel[0])
2578                 return sprintf(page, "%s\n", mddev->clevel);
2579         else if (mddev->level != LEVEL_NONE)
2580                 return sprintf(page, "%d\n", mddev->level);
2581         else
2582                 return 0;
2583 }
2584
2585 static ssize_t
2586 level_store(mddev_t *mddev, const char *buf, size_t len)
2587 {
2588         ssize_t rv = len;
2589         if (mddev->pers)
2590                 return -EBUSY;
2591         if (len == 0)
2592                 return 0;
2593         if (len >= sizeof(mddev->clevel))
2594                 return -ENOSPC;
2595         strncpy(mddev->clevel, buf, len);
2596         if (mddev->clevel[len-1] == '\n')
2597                 len--;
2598         mddev->clevel[len] = 0;
2599         mddev->level = LEVEL_NONE;
2600         return rv;
2601 }
2602
2603 static struct md_sysfs_entry md_level =
2604 __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
2605
2606
2607 static ssize_t
2608 layout_show(mddev_t *mddev, char *page)
2609 {
2610         /* just a number, not meaningful for all levels */
2611         if (mddev->reshape_position != MaxSector &&
2612             mddev->layout != mddev->new_layout)
2613                 return sprintf(page, "%d (%d)\n",
2614                                mddev->new_layout, mddev->layout);
2615         return sprintf(page, "%d\n", mddev->layout);
2616 }
2617
2618 static ssize_t
2619 layout_store(mddev_t *mddev, const char *buf, size_t len)
2620 {
2621         char *e;
2622         unsigned long n = simple_strtoul(buf, &e, 10);
2623
2624         if (!*buf || (*e && *e != '\n'))
2625                 return -EINVAL;
2626
2627         if (mddev->pers)
2628                 return -EBUSY;
2629         if (mddev->reshape_position != MaxSector)
2630                 mddev->new_layout = n;
2631         else
2632                 mddev->layout = n;
2633         return len;
2634 }
2635 static struct md_sysfs_entry md_layout =
2636 __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
2637
2638
2639 static ssize_t
2640 raid_disks_show(mddev_t *mddev, char *page)
2641 {
2642         if (mddev->raid_disks == 0)
2643                 return 0;
2644         if (mddev->reshape_position != MaxSector &&
2645             mddev->delta_disks != 0)
2646                 return sprintf(page, "%d (%d)\n", mddev->raid_disks,
2647                                mddev->raid_disks - mddev->delta_disks);
2648         return sprintf(page, "%d\n", mddev->raid_disks);
2649 }
2650
2651 static int update_raid_disks(mddev_t *mddev, int raid_disks);
2652
2653 static ssize_t
2654 raid_disks_store(mddev_t *mddev, const char *buf, size_t len)
2655 {
2656         char *e;
2657         int rv = 0;
2658         unsigned long n = simple_strtoul(buf, &e, 10);
2659
2660         if (!*buf || (*e && *e != '\n'))
2661                 return -EINVAL;
2662
2663         if (mddev->pers)
2664                 rv = update_raid_disks(mddev, n);
2665         else if (mddev->reshape_position != MaxSector) {
2666                 int olddisks = mddev->raid_disks - mddev->delta_disks;
2667                 mddev->delta_disks = n - olddisks;
2668                 mddev->raid_disks = n;
2669         } else
2670                 mddev->raid_disks = n;
2671         return rv ? rv : len;
2672 }
2673 static struct md_sysfs_entry md_raid_disks =
2674 __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
2675
2676 static ssize_t
2677 chunk_size_show(mddev_t *mddev, char *page)
2678 {
2679         if (mddev->reshape_position != MaxSector &&
2680             mddev->chunk_size != mddev->new_chunk)
2681                 return sprintf(page, "%d (%d)\n", mddev->new_chunk,
2682                                mddev->chunk_size);
2683         return sprintf(page, "%d\n", mddev->chunk_size);
2684 }
2685
2686 static ssize_t
2687 chunk_size_store(mddev_t *mddev, const char *buf, size_t len)
2688 {
2689         /* can only set chunk_size if array is not yet active */
2690         char *e;
2691         unsigned long n = simple_strtoul(buf, &e, 10);
2692
2693         if (!*buf || (*e && *e != '\n'))
2694                 return -EINVAL;
2695
2696         if (mddev->pers)
2697                 return -EBUSY;
2698         else if (mddev->reshape_position != MaxSector)
2699                 mddev->new_chunk = n;
2700         else
2701                 mddev->chunk_size = n;
2702         return len;
2703 }
2704 static struct md_sysfs_entry md_chunk_size =
2705 __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
2706
2707 static ssize_t
2708 resync_start_show(mddev_t *mddev, char *page)
2709 {
2710         return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
2711 }
2712
2713 static ssize_t
2714 resync_start_store(mddev_t *mddev, const char *buf, size_t len)
2715 {
2716         char *e;
2717         unsigned long long n = simple_strtoull(buf, &e, 10);
2718
2719         if (mddev->pers)
2720                 return -EBUSY;
2721         if (!*buf || (*e && *e != '\n'))
2722                 return -EINVAL;
2723
2724         mddev->recovery_cp = n;
2725         return len;
2726 }
2727 static struct md_sysfs_entry md_resync_start =
2728 __ATTR(resync_start, S_IRUGO|S_IWUSR, resync_start_show, resync_start_store);
2729
2730 /*
2731  * The array state can be:
2732  *
2733  * clear
2734  *     No devices, no size, no level
2735  *     Equivalent to STOP_ARRAY ioctl
2736  * inactive
2737  *     May have some settings, but array is not active
2738  *        all IO results in error
2739  *     When written, doesn't tear down array, but just stops it
2740  * suspended (not supported yet)
2741  *     All IO requests will block. The array can be reconfigured.
2742  *     Writing this, if accepted, will block until array is quiescent
2743  * readonly
2744  *     no resync can happen.  no superblocks get written.
2745  *     write requests fail
2746  * read-auto
2747  *     like readonly, but behaves like 'clean' on a write request.
2748  *
2749  * clean - no pending writes, but otherwise active.
2750  *     When written to inactive array, starts without resync
2751  *     If a write request arrives then
2752  *       if metadata is known, mark 'dirty' and switch to 'active'.
2753  *       if not known, block and switch to write-pending
2754  *     If written to an active array that has pending writes, then fails.
2755  * active
2756  *     fully active: IO and resync can be happening.
2757  *     When written to inactive array, starts with resync
2758  *
2759  * write-pending
2760  *     clean, but writes are blocked waiting for 'active' to be written.
2761  *
2762  * active-idle
2763  *     like active, but no writes have been seen for a while (100msec).
2764  *
2765  */
2766 enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
2767                    write_pending, active_idle, bad_word};
2768 static char *array_states[] = {
2769         "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
2770         "write-pending", "active-idle", NULL };
2771
2772 static int match_word(const char *word, char **list)
2773 {
2774         int n;
2775         for (n=0; list[n]; n++)
2776                 if (cmd_match(word, list[n]))
2777                         break;
2778         return n;
2779 }
2780
2781 static ssize_t
2782 array_state_show(mddev_t *mddev, char *page)
2783 {
2784         enum array_state st = inactive;
2785
2786         if (mddev->pers)
2787                 switch(mddev->ro) {
2788                 case 1:
2789                         st = readonly;
2790                         break;
2791                 case 2:
2792                         st = read_auto;
2793                         break;
2794                 case 0:
2795                         if (mddev->in_sync)
2796                                 st = clean;
2797                         else if (test_bit(MD_CHANGE_CLEAN, &mddev->flags))
2798                                 st = write_pending;
2799                         else if (mddev->safemode)
2800                                 st = active_idle;
2801                         else
2802                                 st = active;
2803                 }
2804         else {
2805                 if (list_empty(&mddev->disks) &&
2806                     mddev->raid_disks == 0 &&
2807                     mddev->size == 0)
2808                         st = clear;
2809                 else
2810                         st = inactive;
2811         }
2812         return sprintf(page, "%s\n", array_states[st]);
2813 }
2814
2815 static int do_md_stop(mddev_t * mddev, int ro, int is_open);
2816 static int do_md_run(mddev_t * mddev);
2817 static int restart_array(mddev_t *mddev);
2818
2819 static ssize_t
2820 array_state_store(mddev_t *mddev, const char *buf, size_t len)
2821 {
2822         int err = -EINVAL;
2823         enum array_state st = match_word(buf, array_states);
2824         switch(st) {
2825         case bad_word:
2826                 break;
2827         case clear:
2828                 /* stopping an active array */
2829                 if (atomic_read(&mddev->openers) > 0)
2830                         return -EBUSY;
2831                 err = do_md_stop(mddev, 0, 0);
2832                 break;
2833         case inactive:
2834                 /* stopping an active array */
2835                 if (mddev->pers) {
2836                         if (atomic_read(&mddev->openers) > 0)
2837                                 return -EBUSY;
2838                         err = do_md_stop(mddev, 2, 0);
2839                 } else
2840                         err = 0; /* already inactive */
2841                 break;
2842         case suspended:
2843                 break; /* not supported yet */
2844         case readonly:
2845                 if (mddev->pers)
2846                         err = do_md_stop(mddev, 1, 0);
2847                 else {
2848                         mddev->ro = 1;
2849                         set_disk_ro(mddev->gendisk, 1);
2850                         err = do_md_run(mddev);
2851                 }
2852                 break;
2853         case read_auto:
2854                 if (mddev->pers) {
2855                         if (mddev->ro == 0)
2856                                 err = do_md_stop(mddev, 1, 0);
2857                         else if (mddev->ro == 1)
2858                                 err = restart_array(mddev);
2859                         if (err == 0) {
2860                                 mddev->ro = 2;
2861                                 set_disk_ro(mddev->gendisk, 0);
2862                         }
2863                 } else {
2864                         mddev->ro = 2;
2865                         err = do_md_run(mddev);
2866                 }
2867                 break;
2868         case clean:
2869                 if (mddev->pers) {
2870                         restart_array(mddev);
2871                         spin_lock_irq(&mddev->write_lock);
2872                         if (atomic_read(&mddev->writes_pending) == 0) {
2873                                 if (mddev->in_sync == 0) {
2874                                         mddev->in_sync = 1;
2875                                         if (mddev->safemode == 1)
2876                                                 mddev->safemode = 0;
2877                                         if (mddev->persistent)
2878                                                 set_bit(MD_CHANGE_CLEAN,
2879                                                         &mddev->flags);
2880                                 }
2881                                 err = 0;
2882                         } else
2883                                 err = -EBUSY;
2884                         spin_unlock_irq(&mddev->write_lock);
2885                 } else {
2886                         mddev->ro = 0;
2887                         mddev->recovery_cp = MaxSector;
2888                         err = do_md_run(mddev);
2889                 }
2890                 break;
2891         case active:
2892                 if (mddev->pers) {
2893                         restart_array(mddev);
2894                         if (mddev->external)
2895                                 clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
2896                         wake_up(&mddev->sb_wait);
2897                         err = 0;
2898                 } else {
2899                         mddev->ro = 0;
2900                         set_disk_ro(mddev->gendisk, 0);
2901                         err = do_md_run(mddev);
2902                 }
2903                 break;
2904         case write_pending:
2905         case active_idle:
2906                 /* these cannot be set */
2907                 break;
2908         }
2909         if (err)
2910                 return err;
2911         else {
2912                 sysfs_notify_dirent(mddev->sysfs_state);
2913                 return len;
2914         }
2915 }
2916 static struct md_sysfs_entry md_array_state =
2917 __ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
2918
2919 static ssize_t
2920 null_show(mddev_t *mddev, char *page)
2921 {
2922         return -EINVAL;
2923 }
2924
2925 static ssize_t
2926 new_dev_store(mddev_t *mddev, const char *buf, size_t len)
2927 {
2928         /* buf must be %d:%d\n? giving major and minor numbers */
2929         /* The new device is added to the array.
2930          * If the array has a persistent superblock, we read the
2931          * superblock to initialise info and check validity.
2932          * Otherwise, only checking done is that in bind_rdev_to_array,
2933          * which mainly checks size.
2934          */
2935         char *e;
2936         int major = simple_strtoul(buf, &e, 10);
2937         int minor;
2938         dev_t dev;
2939         mdk_rdev_t *rdev;
2940         int err;
2941
2942         if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
2943                 return -EINVAL;
2944         minor = simple_strtoul(e+1, &e, 10);
2945         if (*e && *e != '\n')
2946                 return -EINVAL;
2947         dev = MKDEV(major, minor);
2948         if (major != MAJOR(dev) ||
2949             minor != MINOR(dev))
2950                 return -EOVERFLOW;
2951
2952
2953         if (mddev->persistent) {
2954                 rdev = md_import_device(dev, mddev->major_version,
2955                                         mddev->minor_version);
2956                 if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
2957                         mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
2958                                                        mdk_rdev_t, same_set);
2959                         err = super_types[mddev->major_version]
2960                                 .load_super(rdev, rdev0, mddev->minor_version);
2961                         if (err < 0)
2962                                 goto out;
2963                 }
2964         } else if (mddev->external)
2965                 rdev = md_import_device(dev, -2, -1);
2966         else
2967                 rdev = md_import_device(dev, -1, -1);
2968
2969         if (IS_ERR(rdev))
2970                 return PTR_ERR(rdev);
2971         err = bind_rdev_to_array(rdev, mddev);
2972  out:
2973         if (err)
2974                 export_rdev(rdev);
2975         return err ? err : len;
2976 }
2977
2978 static struct md_sysfs_entry md_new_device =
2979 __ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
2980
2981 static ssize_t
2982 bitmap_store(mddev_t *mddev, const char *buf, size_t len)
2983 {
2984         char *end;
2985         unsigned long chunk, end_chunk;
2986
2987         if (!mddev->bitmap)
2988                 goto out;
2989         /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
2990         while (*buf) {
2991                 chunk = end_chunk = simple_strtoul(buf, &end, 0);
2992                 if (buf == end) break;
2993                 if (*end == '-') { /* range */
2994                         buf = end + 1;
2995                         end_chunk = simple_strtoul(buf, &end, 0);
2996                         if (buf == end) break;
2997                 }
2998                 if (*end && !isspace(*end)) break;
2999                 bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
3000                 buf = end;
3001                 while (isspace(*buf)) buf++;
3002         }
3003         bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
3004 out:
3005         return len;
3006 }
3007
3008 static struct md_sysfs_entry md_bitmap =
3009 __ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
3010
3011 static ssize_t
3012 size_show(mddev_t *mddev, char *page)
3013 {
3014         return sprintf(page, "%llu\n", (unsigned long long)mddev->size);
3015 }
3016
3017 static int update_size(mddev_t *mddev, sector_t num_sectors);
3018
3019 static ssize_t
3020 size_store(mddev_t *mddev, const char *buf, size_t len)
3021 {
3022         /* If array is inactive, we can reduce the component size, but
3023          * not increase it (except from 0).
3024          * If array is active, we can try an on-line resize
3025          */
3026         char *e;
3027         int err = 0;
3028         unsigned long long size = simple_strtoull(buf, &e, 10);
3029         if (!*buf || *buf == '\n' ||
3030             (*e && *e != '\n'))
3031                 return -EINVAL;
3032
3033         if (mddev->pers) {
3034                 err = update_size(mddev, size * 2);
3035                 md_update_sb(mddev, 1);
3036         } else {
3037                 if (mddev->size == 0 ||
3038                     mddev->size > size)
3039                         mddev->size = size;
3040                 else
3041                         err = -ENOSPC;
3042         }
3043         return err ? err : len;
3044 }
3045
3046 static struct md_sysfs_entry md_size =
3047 __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
3048
3049
3050 /* Metdata version.
3051  * This is one of
3052  *   'none' for arrays with no metadata (good luck...)
3053  *   'external' for arrays with externally managed metadata,
3054  * or N.M for internally known formats
3055  */
3056 static ssize_t
3057 metadata_show(mddev_t *mddev, char *page)
3058 {
3059         if (mddev->persistent)
3060                 return sprintf(page, "%d.%d\n",
3061                                mddev->major_version, mddev->minor_version);
3062         else if (mddev->external)
3063                 return sprintf(page, "external:%s\n", mddev->metadata_type);
3064         else
3065                 return sprintf(page, "none\n");
3066 }
3067
3068 static ssize_t
3069 metadata_store(mddev_t *mddev, const char *buf, size_t len)
3070 {
3071         int major, minor;
3072         char *e;
3073         /* Changing the details of 'external' metadata is
3074          * always permitted.  Otherwise there must be
3075          * no devices attached to the array.
3076          */
3077         if (mddev->external && strncmp(buf, "external:", 9) == 0)
3078                 ;
3079         else if (!list_empty(&mddev->disks))
3080                 return -EBUSY;
3081
3082         if (cmd_match(buf, "none")) {
3083                 mddev->persistent = 0;
3084                 mddev->external = 0;
3085                 mddev->major_version = 0;
3086                 mddev->minor_version = 90;
3087                 return len;
3088         }
3089         if (strncmp(buf, "external:", 9) == 0) {
3090                 size_t namelen = len-9;
3091                 if (namelen >= sizeof(mddev->metadata_type))
3092                         namelen = sizeof(mddev->metadata_type)-1;
3093                 strncpy(mddev->metadata_type, buf+9, namelen);
3094                 mddev->metadata_type[namelen] = 0;
3095                 if (namelen && mddev->metadata_type[namelen-1] == '\n')
3096                         mddev->metadata_type[--namelen] = 0;
3097                 mddev->persistent = 0;
3098                 mddev->external = 1;
3099                 mddev->major_version = 0;
3100                 mddev->minor_version = 90;
3101                 return len;
3102         }
3103         major = simple_strtoul(buf, &e, 10);
3104         if (e==buf || *e != '.')
3105                 return -EINVAL;
3106         buf = e+1;
3107         minor = simple_strtoul(buf, &e, 10);
3108         if (e==buf || (*e && *e != '\n') )
3109                 return -EINVAL;
3110         if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
3111                 return -ENOENT;
3112         mddev->major_version = major;
3113         mddev->minor_version = minor;
3114         mddev->persistent = 1;
3115         mddev->external = 0;
3116         return len;
3117 }
3118
3119 static struct md_sysfs_entry md_metadata =
3120 __ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
3121
3122 static ssize_t
3123 action_show(mddev_t *mddev, char *page)
3124 {
3125         char *type = "idle";
3126         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3127             (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) {
3128                 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
3129                         type = "reshape";
3130                 else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
3131                         if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
3132                                 type = "resync";
3133                         else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
3134                                 type = "check";
3135                         else
3136                                 type = "repair";
3137                 } else if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
3138                         type = "recover";
3139         }
3140         return sprintf(page, "%s\n", type);
3141 }
3142
3143 static ssize_t
3144 action_store(mddev_t *mddev, const char *page, size_t len)
3145 {
3146         if (!mddev->pers || !mddev->pers->sync_request)
3147                 return -EINVAL;
3148
3149         if (cmd_match(page, "idle")) {
3150                 if (mddev->sync_thread) {
3151                         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
3152                         md_unregister_thread(mddev->sync_thread);
3153                         mddev->sync_thread = NULL;
3154                         mddev->recovery = 0;
3155                 }
3156         } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
3157                    test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
3158                 return -EBUSY;
3159         else if (cmd_match(page, "resync"))
3160                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3161         else if (cmd_match(page, "recover")) {
3162                 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
3163                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3164         } else if (cmd_match(page, "reshape")) {
3165                 int err;
3166                 if (mddev->pers->start_reshape == NULL)
3167                         return -EINVAL;
3168                 err = mddev->pers->start_reshape(mddev);
3169                 if (err)
3170                         return err;
3171                 sysfs_notify(&mddev->kobj, NULL, "degraded");
3172         } else {
3173                 if (cmd_match(page, "check"))
3174                         set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
3175                 else if (!cmd_match(page, "repair"))
3176                         return -EINVAL;
3177                 set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
3178                 set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
3179         }
3180         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3181         md_wakeup_thread(mddev->thread);
3182         sysfs_notify_dirent(mddev->sysfs_action);
3183         return len;
3184 }
3185
3186 static ssize_t
3187 mismatch_cnt_show(mddev_t *mddev, char *page)
3188 {
3189         return sprintf(page, "%llu\n",
3190                        (unsigned long long) mddev->resync_mismatches);
3191 }
3192
3193 static struct md_sysfs_entry md_scan_mode =
3194 __ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
3195
3196
3197 static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
3198
3199 static ssize_t
3200 sync_min_show(mddev_t *mddev, char *page)
3201 {
3202         return sprintf(page, "%d (%s)\n", speed_min(mddev),
3203                        mddev->sync_speed_min ? "local": "system");
3204 }
3205
3206 static ssize_t
3207 sync_min_store(mddev_t *mddev, const char *buf, size_t len)
3208 {
3209         int min;
3210         char *e;
3211         if (strncmp(buf, "system", 6)==0) {
3212                 mddev->sync_speed_min = 0;
3213                 return len;
3214         }
3215         min = simple_strtoul(buf, &e, 10);
3216         if (buf == e || (*e && *e != '\n') || min <= 0)
3217                 return -EINVAL;
3218         mddev->sync_speed_min = min;
3219         return len;
3220 }
3221
3222 static struct md_sysfs_entry md_sync_min =
3223 __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
3224
3225 static ssize_t
3226 sync_max_show(mddev_t *mddev, char *page)
3227 {
3228         return sprintf(page, "%d (%s)\n", speed_max(mddev),
3229                        mddev->sync_speed_max ? "local": "system");
3230 }
3231
3232 static ssize_t
3233 sync_max_store(mddev_t *mddev, const char *buf, size_t len)
3234 {
3235         int max;
3236         char *e;
3237         if (strncmp(buf, "system", 6)==0) {
3238                 mddev->sync_speed_max = 0;
3239                 return len;
3240         }
3241         max = simple_strtoul(buf, &e, 10);
3242         if (buf == e || (*e && *e != '\n') || max <= 0)
3243                 return -EINVAL;
3244         mddev->sync_speed_max = max;
3245         return len;
3246 }
3247
3248 static struct md_sysfs_entry md_sync_max =
3249 __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
3250
3251 static ssize_t
3252 degraded_show(mddev_t *mddev, char *page)
3253 {
3254         return sprintf(page, "%d\n", mddev->degraded);
3255 }
3256 static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
3257
3258 static ssize_t
3259 sync_force_parallel_show(mddev_t *mddev, char *page)
3260 {
3261         return sprintf(page, "%d\n", mddev->parallel_resync);
3262 }
3263
3264 static ssize_t
3265 sync_force_parallel_store(mddev_t *mddev, const char *buf, size_t len)
3266 {
3267         long n;
3268
3269         if (strict_strtol(buf, 10, &n))
3270                 return -EINVAL;
3271
3272         if (n != 0 && n != 1)
3273                 return -EINVAL;
3274
3275         mddev->parallel_resync = n;
3276
3277         if (mddev->sync_thread)
3278                 wake_up(&resync_wait);
3279
3280         return len;
3281 }
3282
3283 /* force parallel resync, even with shared block devices */
3284 static struct md_sysfs_entry md_sync_force_parallel =
3285 __ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
3286        sync_force_parallel_show, sync_force_parallel_store);
3287
3288 static ssize_t
3289 sync_speed_show(mddev_t *mddev, char *page)
3290 {
3291         unsigned long resync, dt, db;
3292         resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
3293         dt = (jiffies - mddev->resync_mark) / HZ;
3294         if (!dt) dt++;
3295         db = resync - mddev->resync_mark_cnt;
3296         return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
3297 }
3298
3299 static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
3300
3301 static ssize_t
3302 sync_completed_show(mddev_t *mddev, char *page)
3303 {
3304         unsigned long max_blocks, resync;
3305
3306         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
3307                 max_blocks = mddev->resync_max_sectors;
3308         else
3309                 max_blocks = mddev->size << 1;
3310
3311         resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active));
3312         return sprintf(page, "%lu / %lu\n", resync, max_blocks);
3313 }
3314
3315 static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
3316
3317 static ssize_t
3318 min_sync_show(mddev_t *mddev, char *page)
3319 {
3320         return sprintf(page, "%llu\n",
3321                        (unsigned long long)mddev->resync_min);
3322 }
3323 static ssize_t
3324 min_sync_store(mddev_t *mddev, const char *buf, size_t len)
3325 {
3326         unsigned long long min;
3327         if (strict_strtoull(buf, 10, &min))
3328                 return -EINVAL;
3329         if (min > mddev->resync_max)
3330                 return -EINVAL;
3331         if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
3332                 return -EBUSY;
3333
3334         /* Must be a multiple of chunk_size */
3335         if (mddev->chunk_size) {
3336                 if (min & (sector_t)((mddev->chunk_size>>9)-1))
3337                         return -EINVAL;
3338         }
3339         mddev->resync_min = min;
3340
3341         return len;
3342 }
3343
3344 static struct md_sysfs_entry md_min_sync =
3345 __ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
3346
3347 static ssize_t
3348 max_sync_show(mddev_t *mddev, char *page)
3349 {
3350         if (mddev->resync_max == MaxSector)
3351                 return sprintf(page, "max\n");
3352         else
3353                 return sprintf(page, "%llu\n",
3354                                (unsigned long long)mddev->resync_max);
3355 }
3356 static ssize_t
3357 max_sync_store(mddev_t *mddev, const char *buf, size_t len)
3358 {
3359         if (strncmp(buf, "max", 3) == 0)
3360                 mddev->resync_max = MaxSector;
3361         else {
3362                 unsigned long long max;
3363                 if (strict_strtoull(buf, 10, &max))
3364                         return -EINVAL;
3365                 if (max < mddev->resync_min)
3366                         return -EINVAL;
3367                 if (max < mddev->resync_max &&
3368                     test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
3369                         return -EBUSY;
3370
3371                 /* Must be a multiple of chunk_size */
3372                 if (mddev->chunk_size) {
3373                         if (max & (sector_t)((mddev->chunk_size>>9)-1))
3374                                 return -EINVAL;
3375                 }
3376                 mddev->resync_max = max;
3377         }
3378         wake_up(&mddev->recovery_wait);
3379         return len;
3380 }
3381
3382 static struct md_sysfs_entry md_max_sync =
3383 __ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
3384
3385 static ssize_t
3386 suspend_lo_show(mddev_t *mddev, char *page)
3387 {
3388         return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
3389 }
3390
3391 static ssize_t
3392 suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
3393 {
3394         char *e;
3395         unsigned long long new = simple_strtoull(buf, &e, 10);
3396
3397         if (mddev->pers->quiesce == NULL)
3398                 return -EINVAL;
3399         if (buf == e || (*e && *e != '\n'))
3400                 return -EINVAL;
3401         if (new >= mddev->suspend_hi ||
3402             (new > mddev->suspend_lo && new < mddev->suspend_hi)) {
3403                 mddev->suspend_lo = new;
3404                 mddev->pers->quiesce(mddev, 2);
3405                 return len;
3406         } else
3407                 return -EINVAL;
3408 }
3409 static struct md_sysfs_entry md_suspend_lo =
3410 __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
3411
3412
3413 static ssize_t
3414 suspend_hi_show(mddev_t *mddev, char *page)
3415 {
3416         return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
3417 }
3418
3419 static ssize_t
3420 suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
3421 {
3422         char *e;
3423         unsigned long long new = simple_strtoull(buf, &e, 10);
3424
3425         if (mddev->pers->quiesce == NULL)
3426                 return -EINVAL;
3427         if (buf == e || (*e && *e != '\n'))
3428                 return -EINVAL;
3429         if ((new <= mddev->suspend_lo && mddev->suspend_lo >= mddev->suspend_hi) ||
3430             (new > mddev->suspend_lo && new > mddev->suspend_hi)) {
3431                 mddev->suspend_hi = new;
3432                 mddev->pers->quiesce(mddev, 1);
3433                 mddev->pers->quiesce(mddev, 0);
3434                 return len;
3435         } else
3436                 return -EINVAL;
3437 }
3438 static struct md_sysfs_entry md_suspend_hi =
3439 __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
3440
3441 static ssize_t
3442 reshape_position_show(mddev_t *mddev, char *page)
3443 {
3444         if (mddev->reshape_position != MaxSector)
3445                 return sprintf(page, "%llu\n",
3446                                (unsigned long long)mddev->reshape_position);
3447         strcpy(page, "none\n");
3448         return 5;
3449 }
3450
3451 static ssize_t
3452 reshape_position_store(mddev_t *mddev, const char *buf, size_t len)
3453 {
3454         char *e;
3455         unsigned long long new = simple_strtoull(buf, &e, 10);
3456         if (mddev->pers)
3457                 return -EBUSY;
3458         if (buf == e || (*e && *e != '\n'))
3459                 return -EINVAL;
3460         mddev->reshape_position = new;
3461         mddev->delta_disks = 0;
3462         mddev->new_level = mddev->level;
3463         mddev->new_layout = mddev->layout;
3464         mddev->new_chunk = mddev->chunk_size;
3465         return len;
3466 }
3467
3468 static struct md_sysfs_entry md_reshape_position =
3469 __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
3470        reshape_position_store);
3471
3472
3473 static struct attribute *md_default_attrs[] = {
3474         &md_level.attr,
3475         &md_layout.attr,
3476         &md_raid_disks.attr,
3477         &md_chunk_size.attr,
3478         &md_size.attr,
3479         &md_resync_start.attr,
3480         &md_metadata.attr,
3481         &md_new_device.attr,
3482         &md_safe_delay.attr,
3483         &md_array_state.attr,
3484         &md_reshape_position.attr,
3485         NULL,
3486 };
3487
3488 static struct attribute *md_redundancy_attrs[] = {
3489         &md_scan_mode.attr,
3490         &md_mismatches.attr,
3491         &md_sync_min.attr,
3492         &md_sync_max.attr,
3493         &md_sync_speed.attr,
3494         &md_sync_force_parallel.attr,
3495         &md_sync_completed.attr,
3496         &md_min_sync.attr,
3497         &md_max_sync.attr,
3498         &md_suspend_lo.attr,
3499         &md_suspend_hi.attr,
3500         &md_bitmap.attr,
3501         &md_degraded.attr,
3502         NULL,
3503 };
3504 static struct attribute_group md_redundancy_group = {
3505         .name = NULL,
3506         .attrs = md_redundancy_attrs,
3507 };
3508
3509
3510 static ssize_t
3511 md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
3512 {
3513         struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
3514         mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
3515         ssize_t rv;
3516
3517         if (!entry->show)
3518                 return -EIO;
3519         rv = mddev_lock(mddev);
3520         if (!rv) {
3521                 rv = entry->show(mddev, page);
3522                 mddev_unlock(mddev);
3523         }
3524         return rv;
3525 }
3526
3527 static ssize_t
3528 md_attr_store(struct kobject *kobj, struct attribute *attr,
3529               const char *page, size_t length)
3530 {
3531         struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
3532         mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
3533         ssize_t rv;
3534
3535         if (!entry->store)
3536                 return -EIO;
3537         if (!capable(CAP_SYS_ADMIN))
3538                 return -EACCES;
3539         rv = mddev_lock(mddev);
3540         if (mddev->hold_active == UNTIL_IOCTL)
3541                 mddev->hold_active = 0;
3542         if (!rv) {
3543                 rv = entry->store(mddev, page, length);
3544                 mddev_unlock(mddev);
3545         }
3546         return rv;
3547 }
3548
3549 static void md_free(struct kobject *ko)
3550 {
3551         mddev_t *mddev = container_of(ko, mddev_t, kobj);
3552
3553         if (mddev->sysfs_state)
3554                 sysfs_put(mddev->sysfs_state);
3555
3556         if (mddev->gendisk) {
3557                 del_gendisk(mddev->gendisk);
3558                 put_disk(mddev->gendisk);
3559         }
3560         if (mddev->queue)
3561                 blk_cleanup_queue(mddev->queue);
3562
3563         kfree(mddev);
3564 }
3565
3566 static struct sysfs_ops md_sysfs_ops = {
3567         .show   = md_attr_show,
3568         .store  = md_attr_store,
3569 };
3570 static struct kobj_type md_ktype = {
3571         .release        = md_free,
3572         .sysfs_ops      = &md_sysfs_ops,
3573         .default_attrs  = md_default_attrs,
3574 };
3575
3576 int mdp_major = 0;
3577
3578 static int md_alloc(dev_t dev, char *name)
3579 {
3580         static DEFINE_MUTEX(disks_mutex);
3581         mddev_t *mddev = mddev_find(dev);
3582         struct gendisk *disk;
3583         int partitioned;
3584         int shift;
3585         int unit;
3586         int error;
3587
3588         if (!mddev)
3589                 return -ENODEV;
3590
3591         partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
3592         shift = partitioned ? MdpMinorShift : 0;
3593         unit = MINOR(mddev->unit) >> shift;
3594
3595         /* wait for any previous instance if this device
3596          * to be completed removed (mddev_delayed_delete).
3597          */
3598         flush_scheduled_work();
3599
3600         mutex_lock(&disks_mutex);
3601         if (mddev->gendisk) {
3602                 mutex_unlock(&disks_mutex);
3603                 mddev_put(mddev);
3604                 return -EEXIST;
3605         }
3606
3607         if (name) {
3608                 /* Need to ensure that 'name' is not a duplicate.
3609                  */
3610                 mddev_t *mddev2;
3611                 spin_lock(&all_mddevs_lock);
3612
3613                 list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
3614                         if (mddev2->gendisk &&
3615                             strcmp(mddev2->gendisk->disk_name, name) == 0) {
3616                                 spin_unlock(&all_mddevs_lock);
3617                                 return -EEXIST;
3618                         }
3619                 spin_unlock(&all_mddevs_lock);
3620         }
3621
3622         mddev->queue = blk_alloc_queue(GFP_KERNEL);
3623         if (!mddev->queue) {
3624                 mutex_unlock(&disks_mutex);
3625                 mddev_put(mddev);
3626                 return -ENOMEM;
3627         }
3628         /* Can be unlocked because the queue is new: no concurrency */
3629         queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, mddev->queue);
3630
3631         blk_queue_make_request(mddev->queue, md_fail_request);
3632
3633         disk = alloc_disk(1 << shift);
3634         if (!disk) {
3635                 mutex_unlock(&disks_mutex);
3636                 blk_cleanup_queue(mddev->queue);
3637                 mddev->queue = NULL;
3638                 mddev_put(mddev);
3639                 return -ENOMEM;
3640         }
3641         disk->major = MAJOR(mddev->unit);
3642         disk->first_minor = unit << shift;
3643         if (name)
3644                 strcpy(disk->disk_name, name);
3645         else if (partitioned)
3646                 sprintf(disk->disk_name, "md_d%d", unit);
3647         else
3648                 sprintf(disk->disk_name, "md%d", unit);
3649         disk->fops = &md_fops;
3650         disk->private_data = mddev;
3651         disk->queue = mddev->queue;
3652         /* Allow extended partitions.  This makes the
3653          * 'mdp' device redundant, but we can't really
3654          * remove it now.
3655          */
3656         disk->flags |= GENHD_FL_EXT_DEVT;
3657         add_disk(disk);
3658         mddev->gendisk = disk;
3659         error = kobject_init_and_add(&mddev->kobj, &md_ktype,
3660                                      &disk_to_dev(disk)->kobj, "%s", "md");
3661         mutex_unlock(&disks_mutex);
3662         if (error)
3663                 printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
3664                        disk->disk_name);
3665         else {
3666                 kobject_uevent(&mddev->kobj, KOBJ_ADD);
3667                 mddev->sysfs_state = sysfs_get_dirent(mddev->kobj.sd, "array_state");
3668         }
3669         mddev_put(mddev);
3670         return 0;
3671 }
3672
3673 static struct kobject *md_probe(dev_t dev, int *part, void *data)
3674 {
3675         md_alloc(dev, NULL);
3676         return NULL;
3677 }
3678
3679 static int add_named_array(const char *val, struct kernel_param *kp)
3680 {
3681         /* val must be "md_*" where * is not all digits.
3682          * We allocate an array with a large free minor number, and
3683          * set the name to val.  val must not already be an active name.
3684          */
3685         int len = strlen(val);
3686         char buf[DISK_NAME_LEN];
3687
3688         while (len && val[len-1] == '\n')
3689                 len--;
3690         if (len >= DISK_NAME_LEN)
3691                 return -E2BIG;
3692         strlcpy(buf, val, len+1);
3693         if (strncmp(buf, "md_", 3) != 0)
3694                 return -EINVAL;
3695         return md_alloc(0, buf);
3696 }
3697
3698 static void md_safemode_timeout(unsigned long data)
3699 {
3700         mddev_t *mddev = (mddev_t *) data;
3701
3702         if (!atomic_read(&mddev->writes_pending)) {
3703                 mddev->safemode = 1;
3704                 if (mddev->external)
3705                         sysfs_notify_dirent(mddev->sysfs_state);
3706         }
3707         md_wakeup_thread(mddev->thread);
3708 }
3709
3710 static int start_dirty_degraded;
3711
3712 static int do_md_run(mddev_t * mddev)
3713 {
3714         int err;
3715         int chunk_size;
3716         mdk_rdev_t *rdev;
3717         struct gendisk *disk;
3718         struct mdk_personality *pers;
3719         char b[BDEVNAME_SIZE];
3720
3721         if (list_empty(&mddev->disks))
3722                 /* cannot run an array with no devices.. */
3723                 return -EINVAL;
3724
3725         if (mddev->pers)
3726                 return -EBUSY;
3727
3728         /*
3729          * Analyze all RAID superblock(s)
3730          */
3731         if (!mddev->raid_disks) {
3732                 if (!mddev->persistent)
3733                         return -EINVAL;
3734                 analyze_sbs(mddev);
3735         }
3736
3737         chunk_size = mddev->chunk_size;
3738
3739         if (chunk_size) {
3740                 if (chunk_size > MAX_CHUNK_SIZE) {
3741                         printk(KERN_ERR "too big chunk_size: %d > %d\n",
3742                                 chunk_size, MAX_CHUNK_SIZE);
3743                         return -EINVAL;
3744                 }
3745                 /*
3746                  * chunk-size has to be a power of 2
3747                  */
3748                 if ( (1 << ffz(~chunk_size)) != chunk_size) {
3749                         printk(KERN_ERR "chunk_size of %d not valid\n", chunk_size);
3750                         return -EINVAL;
3751                 }
3752
3753                 /* devices must have minimum size of one chunk */
3754                 list_for_each_entry(rdev, &mddev->disks, same_set) {
3755                         if (test_bit(Faulty, &rdev->flags))
3756                                 continue;
3757                         if (rdev->size < chunk_size / 1024) {
3758                                 printk(KERN_WARNING
3759                                         "md: Dev %s smaller than chunk_size:"
3760                                         " %lluk < %dk\n",
3761                                         bdevname(rdev->bdev,b),
3762                                         (unsigned long long)rdev->size,
3763                                         chunk_size / 1024);
3764                                 return -EINVAL;
3765                         }
3766                 }
3767         }
3768
3769         if (mddev->level != LEVEL_NONE)
3770                 request_module("md-level-%d", mddev->level);
3771         else if (mddev->clevel[0])
3772                 request_module("md-%s", mddev->clevel);
3773
3774         /*
3775          * Drop all container device buffers, from now on
3776          * the only valid external interface is through the md
3777          * device.
3778          */
3779         list_for_each_entry(rdev, &mddev->disks, same_set) {
3780                 if (test_bit(Faulty, &rdev->flags))
3781                         continue;
3782                 sync_blockdev(rdev->bdev);
3783                 invalidate_bdev(rdev->bdev);
3784
3785                 /* perform some consistency tests on the device.
3786                  * We don't want the data to overlap the metadata,
3787                  * Internal Bitmap issues has handled elsewhere.
3788                  */
3789                 if (rdev->data_offset < rdev->sb_start) {
3790                         if (mddev->size &&
3791                             rdev->data_offset + mddev->size*2
3792                             > rdev->sb_start) {
3793                                 printk("md: %s: data overlaps metadata\n",
3794                                        mdname(mddev));
3795                                 return -EINVAL;
3796                         }
3797                 } else {
3798                         if (rdev->sb_start + rdev->sb_size/512
3799                             > rdev->data_offset) {
3800                                 printk("md: %s: metadata overlaps data\n",
3801                                        mdname(mddev));
3802                                 return -EINVAL;
3803                         }
3804                 }
3805                 sysfs_notify_dirent(rdev->sysfs_state);
3806         }
3807
3808         md_probe(mddev->unit, NULL, NULL);
3809         disk = mddev->gendisk;
3810         if (!disk)
3811                 return -ENOMEM;
3812
3813         spin_lock(&pers_lock);
3814         pers = find_pers(mddev->level, mddev->clevel);
3815         if (!pers || !try_module_get(pers->owner)) {
3816                 spin_unlock(&pers_lock);
3817                 if (mddev->level != LEVEL_NONE)
3818                         printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
3819                                mddev->level);
3820                 else
3821                         printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
3822                                mddev->clevel);
3823                 return -EINVAL;
3824         }
3825         mddev->pers = pers;
3826         spin_unlock(&pers_lock);
3827         mddev->level = pers->level;
3828         strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
3829
3830         if (pers->level >= 4 && pers->level <= 6)
3831                 /* Cannot support integrity (yet) */
3832                 blk_integrity_unregister(mddev->gendisk);
3833
3834         if (mddev->reshape_position != MaxSector &&
3835             pers->start_reshape == NULL) {
3836                 /* This personality cannot handle reshaping... */
3837                 mddev->pers = NULL;
3838                 module_put(pers->owner);
3839                 return -EINVAL;
3840         }
3841
3842         if (pers->sync_request) {
3843                 /* Warn if this is a potentially silly
3844                  * configuration.
3845                  */
3846                 char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
3847                 mdk_rdev_t *rdev2;
3848                 int warned = 0;
3849
3850                 list_for_each_entry(rdev, &mddev->disks, same_set)
3851                         list_for_each_entry(rdev2, &mddev->disks, same_set) {
3852                                 if (rdev < rdev2 &&
3853                                     rdev->bdev->bd_contains ==
3854                                     rdev2->bdev->bd_contains) {
3855                                         printk(KERN_WARNING
3856                                                "%s: WARNING: %s appears to be"
3857                                                " on the same physical disk as"
3858                                                " %s.\n",
3859                                                mdname(mddev),
3860                                                bdevname(rdev->bdev,b),
3861                                                bdevname(rdev2->bdev,b2));
3862                                         warned = 1;
3863                                 }
3864                         }
3865
3866                 if (warned)
3867                         printk(KERN_WARNING
3868                                "True protection against single-disk"
3869                                " failure might be compromised.\n");
3870         }
3871
3872         mddev->recovery = 0;
3873         mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */
3874         mddev->barriers_work = 1;
3875         mddev->ok_start_degraded = start_dirty_degraded;
3876
3877         if (start_readonly)
3878                 mddev->ro = 2; /* read-only, but switch on first write */
3879
3880         err = mddev->pers->run(mddev);
3881         if (err)
3882                 printk(KERN_ERR "md: pers->run() failed ...\n");
3883         else if (mddev->pers->sync_request) {
3884                 err = bitmap_create(mddev);
3885                 if (err) {
3886                         printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
3887                                mdname(mddev), err);
3888                         mddev->pers->stop(mddev);
3889                 }
3890         }
3891         if (err) {
3892                 module_put(mddev->pers->owner);
3893                 mddev->pers = NULL;
3894                 bitmap_destroy(mddev);
3895                 return err;
3896         }
3897         if (mddev->pers->sync_request) {
3898                 if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
3899                         printk(KERN_WARNING
3900                                "md: cannot register extra attributes for %s\n",
3901                                mdname(mddev));
3902                 mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
3903         } else if (mddev->ro == 2) /* auto-readonly not meaningful */
3904                 mddev->ro = 0;
3905
3906         atomic_set(&mddev->writes_pending,0);
3907         mddev->safemode = 0;
3908         mddev->safemode_timer.function = md_safemode_timeout;
3909         mddev->safemode_timer.data = (unsigned long) mddev;
3910         mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
3911         mddev->in_sync = 1;
3912
3913         list_for_each_entry(rdev, &mddev->disks, same_set)
3914                 if (rdev->raid_disk >= 0) {
3915                         char nm[20];
3916                         sprintf(nm, "rd%d", rdev->raid_disk);
3917                         if (sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
3918                                 printk("md: cannot register %s for %s\n",
3919                                        nm, mdname(mddev));
3920                 }
3921         
3922         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3923         
3924         if (mddev->flags)
3925                 md_update_sb(mddev, 0);
3926
3927         set_capacity(disk, mddev->array_sectors);
3928
3929         /* If we call blk_queue_make_request here, it will
3930          * re-initialise max_sectors etc which may have been
3931          * refined inside -> run.  So just set the bits we need to set.
3932          * Most initialisation happended when we called
3933          * blk_queue_make_request(..., md_fail_request)
3934          * earlier.
3935          */
3936         mddev->queue->queuedata = mddev;
3937         mddev->queue->make_request_fn = mddev->pers->make_request;
3938
3939         /* If there is a partially-recovered drive we need to
3940          * start recovery here.  If we leave it to md_check_recovery,
3941          * it will remove the drives and not do the right thing
3942          */
3943         if (mddev->degraded && !mddev->sync_thread) {
3944                 int spares = 0;
3945                 list_for_each_entry(rdev, &mddev->disks, same_set)
3946                         if (rdev->raid_disk >= 0 &&
3947                             !test_bit(In_sync, &rdev->flags) &&
3948                             !test_bit(Faulty, &rdev->flags))
3949                                 /* complete an interrupted recovery */
3950                                 spares++;
3951                 if (spares && mddev->pers->sync_request) {
3952                         mddev->recovery = 0;
3953                         set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
3954                         mddev->sync_thread = md_register_thread(md_do_sync,
3955                                                                 mddev,
3956                                                                 "%s_resync");
3957                         if (!mddev->sync_thread) {
3958                                 printk(KERN_ERR "%s: could not start resync"
3959                                        " thread...\n",
3960                                        mdname(mddev));
3961                                 /* leave the spares where they are, it shouldn't hurt */
3962                                 mddev->recovery = 0;
3963                         }
3964                 }
3965         }
3966         md_wakeup_thread(mddev->thread);
3967         md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
3968
3969         mddev->changed = 1;
3970         md_new_event(mddev);
3971         sysfs_notify_dirent(mddev->sysfs_state);
3972         if (mddev->sysfs_action)
3973                 sysfs_notify_dirent(mddev->sysfs_action);
3974         sysfs_notify(&mddev->kobj, NULL, "degraded");
3975         kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
3976         return 0;
3977 }
3978
3979 static int restart_array(mddev_t *mddev)
3980 {
3981         struct gendisk *disk = mddev->gendisk;
3982
3983         /* Complain if it has no devices */
3984         if (list_empty(&mddev->disks))
3985                 return -ENXIO;
3986         if (!mddev->pers)
3987                 return -EINVAL;
3988         if (!mddev->ro)
3989                 return -EBUSY;
3990         mddev->safemode = 0;
3991         mddev->ro = 0;
3992         set_disk_ro(disk, 0);
3993         printk(KERN_INFO "md: %s switched to read-write mode.\n",
3994                 mdname(mddev));
3995         /* Kick recovery or resync if necessary */
3996         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3997         md_wakeup_thread(mddev->thread);
3998         md_wakeup_thread(mddev->sync_thread);
3999         sysfs_notify_dirent(mddev->sysfs_state);
4000         return 0;
4001 }
4002
4003 /* similar to deny_write_access, but accounts for our holding a reference
4004  * to the file ourselves */
4005 static int deny_bitmap_write_access(struct file * file)
4006 {
4007         struct inode *inode = file->f_mapping->host;
4008
4009         spin_lock(&inode->i_lock);
4010         if (atomic_read(&inode->i_writecount) > 1) {
4011                 spin_unlock(&inode->i_lock);
4012                 return -ETXTBSY;
4013         }
4014         atomic_set(&inode->i_writecount, -1);
4015         spin_unlock(&inode->i_lock);
4016
4017         return 0;
4018 }
4019
4020 static void restore_bitmap_write_access(struct file *file)
4021 {
4022         struct inode *inode = file->f_mapping->host;
4023
4024         spin_lock(&inode->i_lock);
4025         atomic_set(&inode->i_writecount, 1);
4026         spin_unlock(&inode->i_lock);
4027 }
4028
4029 /* mode:
4030  *   0 - completely stop and dis-assemble array
4031  *   1 - switch to readonly
4032  *   2 - stop but do not disassemble array
4033  */
4034 static int do_md_stop(mddev_t * mddev, int mode, int is_open)
4035 {
4036         int err = 0;
4037         struct gendisk *disk = mddev->gendisk;
4038
4039         if (atomic_read(&mddev->openers) > is_open) {
4040                 printk("md: %s still in use.\n",mdname(mddev));
4041                 return -EBUSY;
4042         }
4043
4044         if (mddev->pers) {
4045
4046                 if (mddev->sync_thread) {
4047                         set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4048                         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
4049                         md_unregister_thread(mddev->sync_thread);
4050                         mddev->sync_thread = NULL;
4051                 }
4052
4053                 del_timer_sync(&mddev->safemode_timer);
4054
4055                 switch(mode) {
4056                 case 1: /* readonly */
4057                         err  = -ENXIO;
4058                         if (mddev->ro==1)
4059                                 goto out;
4060                         mddev->ro = 1;
4061                         break;
4062                 case 0: /* disassemble */
4063                 case 2: /* stop */
4064                         bitmap_flush(mddev);
4065                         md_super_wait(mddev);
4066                         if (mddev->ro)
4067                                 set_disk_ro(disk, 0);
4068                         blk_queue_make_request(mddev->queue, md_fail_request);
4069                         mddev->pers->stop(mddev);
4070                         mddev->queue->merge_bvec_fn = NULL;
4071                         mddev->queue->unplug_fn = NULL;
4072                         mddev->queue->backing_dev_info.congested_fn = NULL;
4073                         if (mddev->pers->sync_request) {
4074                                 sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
4075                                 if (mddev->sysfs_action)
4076                                         sysfs_put(mddev->sysfs_action);
4077                                 mddev->sysfs_action = NULL;
4078                         }
4079                         module_put(mddev->pers->owner);
4080                         mddev->pers = NULL;
4081                         /* tell userspace to handle 'inactive' */
4082                         sysfs_notify_dirent(mddev->sysfs_state);
4083
4084                         set_capacity(disk, 0);
4085                         mddev->changed = 1;
4086
4087                         if (mddev->ro)
4088                                 mddev->ro = 0;
4089                 }
4090                 if (!mddev->in_sync || mddev->flags) {
4091                         /* mark array as shutdown cleanly */
4092                         mddev->in_sync = 1;
4093                         md_update_sb(mddev, 1);
4094                 }
4095                 if (mode == 1)
4096                         set_disk_ro(disk, 1);
4097                 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
4098         }
4099
4100         /*
4101          * Free resources if final stop
4102          */
4103         if (mode == 0) {
4104                 mdk_rdev_t *rdev;
4105
4106                 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
4107
4108                 bitmap_destroy(mddev);
4109                 if (mddev->bitmap_file) {
4110                         restore_bitmap_write_access(mddev->bitmap_file);
4111                         fput(mddev->bitmap_file);
4112                         mddev->bitmap_file = NULL;
4113                 }
4114                 mddev->bitmap_offset = 0;
4115
4116                 list_for_each_entry(rdev, &mddev->disks, same_set)
4117                         if (rdev->raid_disk >= 0) {
4118                                 char nm[20];
4119                                 sprintf(nm, "rd%d", rdev->raid_disk);
4120                                 sysfs_remove_link(&mddev->kobj, nm);
4121                         }
4122
4123                 /* make sure all md_delayed_delete calls have finished */
4124                 flush_scheduled_work();
4125
4126                 export_array(mddev);
4127
4128                 mddev->array_sectors = 0;
4129                 mddev->size = 0;
4130                 mddev->raid_disks = 0;
4131                 mddev->recovery_cp = 0;
4132                 mddev->resync_min = 0;
4133                 mddev->resync_max = MaxSector;
4134                 mddev->reshape_position = MaxSector;
4135                 mddev->external = 0;
4136                 mddev->persistent = 0;
4137                 mddev->level = LEVEL_NONE;
4138                 mddev->clevel[0] = 0;
4139                 mddev->flags = 0;
4140                 mddev->ro = 0;
4141                 mddev->metadata_type[0] = 0;
4142                 mddev->chunk_size = 0;
4143                 mddev->ctime = mddev->utime = 0;
4144                 mddev->layout = 0;
4145                 mddev->max_disks = 0;
4146                 mddev->events = 0;
4147                 mddev->delta_disks = 0;
4148                 mddev->new_level = LEVEL_NONE;
4149                 mddev->new_layout = 0;
4150                 mddev->new_chunk = 0;
4151                 mddev->curr_resync = 0;
4152                 mddev->resync_mismatches = 0;
4153                 mddev->suspend_lo = mddev->suspend_hi = 0;
4154                 mddev->sync_speed_min = mddev->sync_speed_max = 0;
4155                 mddev->recovery = 0;
4156                 mddev->in_sync = 0;
4157                 mddev->changed = 0;
4158                 mddev->degraded = 0;
4159                 mddev->barriers_work = 0;
4160                 mddev->safemode = 0;
4161                 kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
4162                 if (mddev->hold_active == UNTIL_STOP)
4163                         mddev->hold_active = 0;
4164
4165         } else if (mddev->pers)
4166                 printk(KERN_INFO "md: %s switched to read-only mode.\n",
4167                         mdname(mddev));
4168         err = 0;
4169         blk_integrity_unregister(disk);
4170         md_new_event(mddev);
4171         sysfs_notify_dirent(mddev->sysfs_state);
4172 out:
4173         return err;
4174 }
4175
4176 #ifndef MODULE
4177 static void autorun_array(mddev_t *mddev)
4178 {
4179         mdk_rdev_t *rdev;
4180         int err;
4181
4182         if (list_empty(&mddev->disks))
4183                 return;
4184
4185         printk(KERN_INFO "md: running: ");
4186
4187         list_for_each_entry(rdev, &mddev->disks, same_set) {
4188                 char b[BDEVNAME_SIZE];
4189                 printk("<%s>", bdevname(rdev->bdev,b));
4190         }
4191         printk("\n");
4192
4193         err = do_md_run(mddev);
4194         if (err) {
4195                 printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
4196                 do_md_stop(mddev, 0, 0);
4197         }
4198 }
4199
4200 /*
4201  * lets try to run arrays based on all disks that have arrived
4202  * until now. (those are in pending_raid_disks)
4203  *
4204  * the method: pick the first pending disk, collect all disks with
4205  * the same UUID, remove all from the pending list and put them into
4206  * the 'same_array' list. Then order this list based on superblock
4207  * update time (freshest comes first), kick out 'old' disks and
4208  * compare superblocks. If everything's fine then run it.
4209  *
4210  * If "unit" is allocated, then bump its reference count
4211  */
4212 static void autorun_devices(int part)
4213 {
4214         mdk_rdev_t *rdev0, *rdev, *tmp;
4215         mddev_t *mddev;
4216         char b[BDEVNAME_SIZE];
4217
4218         printk(KERN_INFO "md: autorun ...\n");
4219         while (!list_empty(&pending_raid_disks)) {
4220                 int unit;
4221                 dev_t dev;
4222                 LIST_HEAD(candidates);
4223                 rdev0 = list_entry(pending_raid_disks.next,
4224                                          mdk_rdev_t, same_set);
4225
4226                 printk(KERN_INFO "md: considering %s ...\n",
4227                         bdevname(rdev0->bdev,b));
4228                 INIT_LIST_HEAD(&candidates);
4229                 rdev_for_each_list(rdev, tmp, &pending_raid_disks)
4230                         if (super_90_load(rdev, rdev0, 0) >= 0) {
4231                                 printk(KERN_INFO "md:  adding %s ...\n",
4232                                         bdevname(rdev->bdev,b));
4233                                 list_move(&rdev->same_set, &candidates);
4234                         }
4235                 /*
4236                  * now we have a set of devices, with all of them having
4237                  * mostly sane superblocks. It's time to allocate the
4238                  * mddev.
4239                  */
4240                 if (part) {
4241                         dev = MKDEV(mdp_major,
4242                                     rdev0->preferred_minor << MdpMinorShift);
4243                         unit = MINOR(dev) >> MdpMinorShift;
4244                 } else {
4245                         dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
4246                         unit = MINOR(dev);
4247                 }
4248                 if (rdev0->preferred_minor != unit) {
4249                         printk(KERN_INFO "md: unit number in %s is bad: %d\n",
4250                                bdevname(rdev0->bdev, b), rdev0->preferred_minor);
4251                         break;
4252                 }
4253
4254                 md_probe(dev, NULL, NULL);
4255                 mddev = mddev_find(dev);
4256                 if (!mddev || !mddev->gendisk) {
4257                         if (mddev)
4258                                 mddev_put(mddev);
4259                         printk(KERN_ERR
4260                                 "md: cannot allocate memory for md drive.\n");
4261                         break;
4262                 }
4263                 if (mddev_lock(mddev)) 
4264                         printk(KERN_WARNING "md: %s locked, cannot run\n",
4265                                mdname(mddev));
4266                 else if (mddev->raid_disks || mddev->major_version
4267                          || !list_empty(&mddev->disks)) {
4268                         printk(KERN_WARNING 
4269                                 "md: %s already running, cannot run %s\n",
4270                                 mdname(mddev), bdevname(rdev0->bdev,b));
4271                         mddev_unlock(mddev);
4272                 } else {
4273                         printk(KERN_INFO "md: created %s\n", mdname(mddev));
4274                         mddev->persistent = 1;
4275                         rdev_for_each_list(rdev, tmp, &candidates) {
4276                                 list_del_init(&rdev->same_set);
4277                                 if (bind_rdev_to_array(rdev, mddev))
4278                                         export_rdev(rdev);
4279                         }
4280                         autorun_array(mddev);
4281                         mddev_unlock(mddev);
4282                 }
4283                 /* on success, candidates will be empty, on error
4284                  * it won't...
4285                  */
4286                 rdev_for_each_list(rdev, tmp, &candidates) {
4287                         list_del_init(&rdev->same_set);
4288                         export_rdev(rdev);
4289                 }
4290                 mddev_put(mddev);
4291         }
4292         printk(KERN_INFO "md: ... autorun DONE.\n");
4293 }
4294 #endif /* !MODULE */
4295
4296 static int get_version(void __user * arg)
4297 {
4298         mdu_version_t ver;
4299
4300         ver.major = MD_MAJOR_VERSION;
4301         ver.minor = MD_MINOR_VERSION;
4302         ver.patchlevel = MD_PATCHLEVEL_VERSION;
4303
4304         if (copy_to_user(arg, &ver, sizeof(ver)))
4305                 return -EFAULT;
4306
4307         return 0;
4308 }
4309
4310 static int get_array_info(mddev_t * mddev, void __user * arg)
4311 {
4312         mdu_array_info_t info;
4313         int nr,working,active,failed,spare;
4314         mdk_rdev_t *rdev;
4315
4316         nr=working=active=failed=spare=0;
4317         list_for_each_entry(rdev, &mddev->disks, same_set) {
4318                 nr++;
4319                 if (test_bit(Faulty, &rdev->flags))
4320                         failed++;
4321                 else {
4322                         working++;
4323                         if (test_bit(In_sync, &rdev->flags))
4324                                 active++;       
4325                         else
4326                                 spare++;
4327                 }
4328         }
4329
4330         info.major_version = mddev->major_version;
4331         info.minor_version = mddev->minor_version;
4332         info.patch_version = MD_PATCHLEVEL_VERSION;
4333         info.ctime         = mddev->ctime;
4334         info.level         = mddev->level;
4335         info.size          = mddev->size;
4336         if (info.size != mddev->size) /* overflow */
4337                 info.size = -1;
4338         info.nr_disks      = nr;
4339         info.raid_disks    = mddev->raid_disks;
4340         info.md_minor      = mddev->md_minor;
4341         info.not_persistent= !mddev->persistent;
4342
4343         info.utime         = mddev->utime;
4344         info.state         = 0;
4345         if (mddev->in_sync)
4346                 info.state = (1<<MD_SB_CLEAN);
4347         if (mddev->bitmap && mddev->bitmap_offset)
4348                 info.state = (1<<MD_SB_BITMAP_PRESENT);
4349         info.active_disks  = active;
4350         info.working_disks = working;
4351         info.failed_disks  = failed;
4352         info.spare_disks   = spare;
4353
4354         info.layout        = mddev->layout;
4355         info.chunk_size    = mddev->chunk_size;
4356
4357         if (copy_to_user(arg, &info, sizeof(info)))
4358                 return -EFAULT;
4359
4360         return 0;
4361 }
4362
4363 static int get_bitmap_file(mddev_t * mddev, void __user * arg)
4364 {
4365         mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
4366         char *ptr, *buf = NULL;
4367         int err = -ENOMEM;
4368
4369         if (md_allow_write(mddev))
4370                 file = kmalloc(sizeof(*file), GFP_NOIO);
4371         else
4372                 file = kmalloc(sizeof(*file), GFP_KERNEL);
4373
4374         if (!file)
4375                 goto out;
4376
4377         /* bitmap disabled, zero the first byte and copy out */
4378         if (!mddev->bitmap || !mddev->bitmap->file) {
4379                 file->pathname[0] = '\0';
4380                 goto copy_out;
4381         }
4382
4383         buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
4384         if (!buf)
4385                 goto out;
4386
4387         ptr = d_path(&mddev->bitmap->file->f_path, buf, sizeof(file->pathname));
4388         if (IS_ERR(ptr))
4389                 goto out;
4390
4391         strcpy(file->pathname, ptr);
4392
4393 copy_out:
4394         err = 0;
4395         if (copy_to_user(arg, file, sizeof(*file)))
4396                 err = -EFAULT;
4397 out:
4398         kfree(buf);
4399         kfree(file);
4400         return err;
4401 }
4402
4403 static int get_disk_info(mddev_t * mddev, void __user * arg)
4404 {
4405         mdu_disk_info_t info;
4406         mdk_rdev_t *rdev;
4407
4408         if (copy_from_user(&info, arg, sizeof(info)))
4409                 return -EFAULT;
4410
4411         rdev = find_rdev_nr(mddev, info.number);
4412         if (rdev) {
4413                 info.major = MAJOR(rdev->bdev->bd_dev);
4414                 info.minor = MINOR(rdev->bdev->bd_dev);
4415                 info.raid_disk = rdev->raid_disk;
4416                 info.state = 0;
4417                 if (test_bit(Faulty, &rdev->flags))
4418                         info.state |= (1<<MD_DISK_FAULTY);
4419                 else if (test_bit(In_sync, &rdev->flags)) {
4420                         info.state |= (1<<MD_DISK_ACTIVE);
4421                         info.state |= (1<<MD_DISK_SYNC);
4422                 }
4423                 if (test_bit(WriteMostly, &rdev->flags))
4424                         info.state |= (1<<MD_DISK_WRITEMOSTLY);
4425         } else {
4426                 info.major = info.minor = 0;
4427                 info.raid_disk = -1;
4428                 info.state = (1<<MD_DISK_REMOVED);
4429         }
4430
4431         if (copy_to_user(arg, &info, sizeof(info)))
4432                 return -EFAULT;
4433
4434         return 0;
4435 }
4436
4437 static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
4438 {
4439         char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
4440         mdk_rdev_t *rdev;
4441         dev_t dev = MKDEV(info->major,info->minor);
4442
4443         if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
4444                 return -EOVERFLOW;
4445
4446         if (!mddev->raid_disks) {
4447                 int err;
4448                 /* expecting a device which has a superblock */
4449                 rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
4450                 if (IS_ERR(rdev)) {
4451                         printk(KERN_WARNING 
4452                                 "md: md_import_device returned %ld\n",
4453                                 PTR_ERR(rdev));
4454                         return PTR_ERR(rdev);
4455                 }
4456                 if (!list_empty(&mddev->disks)) {
4457                         mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
4458                                                         mdk_rdev_t, same_set);
4459                         int err = super_types[mddev->major_version]
4460                                 .load_super(rdev, rdev0, mddev->minor_version);
4461                         if (err < 0) {
4462                                 printk(KERN_WARNING 
4463                                         "md: %s has different UUID to %s\n",
4464                                         bdevname(rdev->bdev,b), 
4465                                         bdevname(rdev0->bdev,b2));
4466                                 export_rdev(rdev);
4467                                 return -EINVAL;
4468                         }
4469                 }
4470                 err = bind_rdev_to_array(rdev, mddev);
4471                 if (err)
4472                         export_rdev(rdev);
4473                 return err;
4474         }
4475
4476         /*
4477          * add_new_disk can be used once the array is assembled
4478          * to add "hot spares".  They must already have a superblock
4479          * written
4480          */
4481         if (mddev->pers) {
4482                 int err;
4483                 if (!mddev->pers->hot_add_disk) {
4484                         printk(KERN_WARNING 
4485                                 "%s: personality does not support diskops!\n",
4486                                mdname(mddev));
4487                         return -EINVAL;
4488                 }
4489                 if (mddev->persistent)
4490                         rdev = md_import_device(dev, mddev->major_version,
4491                                                 mddev->minor_version);
4492                 else
4493                         rdev = md_import_device(dev, -1, -1);
4494                 if (IS_ERR(rdev)) {
4495                         printk(KERN_WARNING 
4496                                 "md: md_import_device returned %ld\n",
4497                                 PTR_ERR(rdev));
4498                         return PTR_ERR(rdev);
4499                 }
4500                 /* set save_raid_disk if appropriate */
4501                 if (!mddev->persistent) {
4502                         if (info->state & (1<<MD_DISK_SYNC)  &&
4503                             info->raid_disk < mddev->raid_disks)
4504                                 rdev->raid_disk = info->raid_disk;
4505                         else
4506                                 rdev->raid_disk = -1;
4507                 } else
4508                         super_types[mddev->major_version].
4509                                 validate_super(mddev, rdev);
4510                 rdev->saved_raid_disk = rdev->raid_disk;
4511
4512                 clear_bit(In_sync, &rdev->flags); /* just to be sure */
4513                 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
4514                         set_bit(WriteMostly, &rdev->flags);
4515
4516                 rdev->raid_disk = -1;
4517                 err = bind_rdev_to_array(rdev, mddev);
4518                 if (!err && !mddev->pers->hot_remove_disk) {
4519                         /* If there is hot_add_disk but no hot_remove_disk
4520                          * then added disks for geometry changes,
4521                          * and should be added immediately.
4522                          */
4523                         super_types[mddev->major_version].
4524                                 validate_super(mddev, rdev);
4525                         err = mddev->pers->hot_add_disk(mddev, rdev);
4526                         if (err)
4527                                 unbind_rdev_from_array(rdev);
4528                 }
4529                 if (err)
4530                         export_rdev(rdev);
4531                 else
4532                         sysfs_notify_dirent(rdev->sysfs_state);
4533
4534                 md_update_sb(mddev, 1);
4535                 if (mddev->degraded)
4536                         set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
4537                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4538                 md_wakeup_thread(mddev->thread);
4539                 return err;
4540         }
4541
4542         /* otherwise, add_new_disk is only allowed
4543          * for major_version==0 superblocks
4544          */
4545         if (mddev->major_version != 0) {
4546                 printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
4547                        mdname(mddev));
4548                 return -EINVAL;
4549         }
4550
4551         if (!(info->state & (1<<MD_DISK_FAULTY))) {
4552                 int err;
4553                 rdev = md_import_device(dev, -1, 0);
4554                 if (IS_ERR(rdev)) {
4555                         printk(KERN_WARNING 
4556                                 "md: error, md_import_device() returned %ld\n",
4557                                 PTR_ERR(rdev));
4558                         return PTR_ERR(rdev);
4559                 }
4560                 rdev->desc_nr = info->number;
4561                 if (info->raid_disk < mddev->raid_disks)
4562                         rdev->raid_disk = info->raid_disk;
4563                 else
4564                         rdev->raid_disk = -1;
4565
4566                 if (rdev->raid_disk < mddev->raid_disks)
4567                         if (info->state & (1<<MD_DISK_SYNC))
4568                                 set_bit(In_sync, &rdev->flags);
4569
4570                 if (info->state & (1<<MD_DISK_WRITEMOSTLY))
4571                         set_bit(WriteMostly, &rdev->flags);
4572
4573                 if (!mddev->persistent) {
4574                         printk(KERN_INFO "md: nonpersistent superblock ...\n");
4575                         rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
4576                 } else 
4577                         rdev->sb_start = calc_dev_sboffset(rdev->bdev);
4578                 rdev->size = calc_num_sectors(rdev, mddev->chunk_size) / 2;
4579
4580                 err = bind_rdev_to_array(rdev, mddev);
4581                 if (err) {
4582                         export_rdev(rdev);
4583                         return err;
4584                 }
4585         }
4586
4587         return 0;
4588 }
4589
4590 static int hot_remove_disk(mddev_t * mddev, dev_t dev)
4591 {
4592         char b[BDEVNAME_SIZE];
4593         mdk_rdev_t *rdev;
4594
4595         rdev = find_rdev(mddev, dev);
4596         if (!rdev)
4597                 return -ENXIO;
4598
4599         if (rdev->raid_disk >= 0)
4600                 goto busy;
4601
4602         kick_rdev_from_array(rdev);
4603         md_update_sb(mddev, 1);
4604         md_new_event(mddev);
4605
4606         return 0;
4607 busy:
4608         printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
4609                 bdevname(rdev->bdev,b), mdname(mddev));
4610         return -EBUSY;
4611 }
4612
4613 static int hot_add_disk(mddev_t * mddev, dev_t dev)
4614 {
4615         char b[BDEVNAME_SIZE];
4616         int err;
4617         mdk_rdev_t *rdev;
4618
4619         if (!mddev->pers)
4620                 return -ENODEV;
4621
4622         if (mddev->major_version != 0) {
4623                 printk(KERN_WARNING "%s: HOT_ADD may only be used with"
4624                         " version-0 superblocks.\n",
4625                         mdname(mddev));
4626                 return -EINVAL;
4627         }
4628         if (!mddev->pers->hot_add_disk) {
4629                 printk(KERN_WARNING 
4630                         "%s: personality does not support diskops!\n",
4631                         mdname(mddev));
4632                 return -EINVAL;
4633         }
4634
4635         rdev = md_import_device(dev, -1, 0);
4636         if (IS_ERR(rdev)) {
4637                 printk(KERN_WARNING 
4638                         "md: error, md_import_device() returned %ld\n",
4639                         PTR_ERR(rdev));
4640                 return -EINVAL;
4641         }
4642
4643         if (mddev->persistent)
4644                 rdev->sb_start = calc_dev_sboffset(rdev->bdev);
4645         else
4646                 rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
4647
4648         rdev->size = calc_num_sectors(rdev, mddev->chunk_size) / 2;
4649
4650         if (test_bit(Faulty, &rdev->flags)) {
4651                 printk(KERN_WARNING 
4652                         "md: can not hot-add faulty %s disk to %s!\n",
4653                         bdevname(rdev->bdev,b), mdname(mddev));
4654                 err = -EINVAL;
4655                 goto abort_export;
4656         }
4657         clear_bit(In_sync, &rdev->flags);
4658         rdev->desc_nr = -1;
4659         rdev->saved_raid_disk = -1;
4660         err = bind_rdev_to_array(rdev, mddev);
4661         if (err)
4662                 goto abort_export;
4663
4664         /*
4665          * The rest should better be atomic, we can have disk failures
4666          * noticed in interrupt contexts ...
4667          */
4668
4669         rdev->raid_disk = -1;
4670
4671         md_update_sb(mddev, 1);
4672
4673         /*
4674          * Kick recovery, maybe this spare has to be added to the
4675          * array immediately.
4676          */
4677         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4678         md_wakeup_thread(mddev->thread);
4679         md_new_event(mddev);
4680         return 0;
4681
4682 abort_export:
4683         export_rdev(rdev);
4684         return err;
4685 }
4686
4687 static int set_bitmap_file(mddev_t *mddev, int fd)
4688 {
4689         int err;
4690
4691         if (mddev->pers) {
4692                 if (!mddev->pers->quiesce)
4693                         return -EBUSY;
4694                 if (mddev->recovery || mddev->sync_thread)
4695                         return -EBUSY;
4696                 /* we should be able to change the bitmap.. */
4697         }
4698
4699
4700         if (fd >= 0) {
4701                 if (mddev->bitmap)
4702                         return -EEXIST; /* cannot add when bitmap is present */
4703                 mddev->bitmap_file = fget(fd);
4704
4705                 if (mddev->bitmap_file == NULL) {
4706                         printk(KERN_ERR "%s: error: failed to get bitmap file\n",
4707                                mdname(mddev));
4708                         return -EBADF;
4709                 }
4710
4711                 err = deny_bitmap_write_access(mddev->bitmap_file);
4712                 if (err) {
4713                         printk(KERN_ERR "%s: error: bitmap file is already in use\n",
4714                                mdname(mddev));
4715                         fput(mddev->bitmap_file);
4716                         mddev->bitmap_file = NULL;
4717                         return err;
4718                 }
4719                 mddev->bitmap_offset = 0; /* file overrides offset */
4720         } else if (mddev->bitmap == NULL)
4721                 return -ENOENT; /* cannot remove what isn't there */
4722         err = 0;
4723         if (mddev->pers) {
4724                 mddev->pers->quiesce(mddev, 1);
4725                 if (fd >= 0)
4726                         err = bitmap_create(mddev);
4727                 if (fd < 0 || err) {
4728                         bitmap_destroy(mddev);
4729                         fd = -1; /* make sure to put the file */
4730                 }
4731                 mddev->pers->quiesce(mddev, 0);
4732         }
4733         if (fd < 0) {
4734                 if (mddev->bitmap_file) {
4735                         restore_bitmap_write_access(mddev->bitmap_file);
4736                         fput(mddev->bitmap_file);
4737                 }
4738                 mddev->bitmap_file = NULL;
4739         }
4740
4741         return err;
4742 }
4743
4744 /*
4745  * set_array_info is used two different ways
4746  * The original usage is when creating a new array.
4747  * In this usage, raid_disks is > 0 and it together with
4748  *  level, size, not_persistent,layout,chunksize determine the
4749  *  shape of the array.
4750  *  This will always create an array with a type-0.90.0 superblock.
4751  * The newer usage is when assembling an array.
4752  *  In this case raid_disks will be 0, and the major_version field is
4753  *  use to determine which style super-blocks are to be found on the devices.
4754  *  The minor and patch _version numbers are also kept incase the
4755  *  super_block handler wishes to interpret them.
4756  */
4757 static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
4758 {
4759
4760         if (info->raid_disks == 0) {
4761                 /* just setting version number for superblock loading */
4762                 if (info->major_version < 0 ||
4763                     info->major_version >= ARRAY_SIZE(super_types) ||
4764                     super_types[info->major_version].name == NULL) {
4765                         /* maybe try to auto-load a module? */
4766                         printk(KERN_INFO 
4767                                 "md: superblock version %d not known\n",
4768                                 info->major_version);
4769                         return -EINVAL;
4770                 }
4771                 mddev->major_version = info->major_version;
4772                 mddev->minor_version = info->minor_version;
4773                 mddev->patch_version = info->patch_version;
4774                 mddev->persistent = !info->not_persistent;
4775                 return 0;
4776         }
4777         mddev->major_version = MD_MAJOR_VERSION;
4778         mddev->minor_version = MD_MINOR_VERSION;
4779         mddev->patch_version = MD_PATCHLEVEL_VERSION;
4780         mddev->ctime         = get_seconds();
4781
4782         mddev->level         = info->level;
4783         mddev->clevel[0]     = 0;
4784         mddev->size          = info->size;
4785         mddev->raid_disks    = info->raid_disks;
4786         /* don't set md_minor, it is determined by which /dev/md* was
4787          * openned
4788          */
4789         if (info->state & (1<<MD_SB_CLEAN))
4790                 mddev->recovery_cp = MaxSector;
4791         else
4792                 mddev->recovery_cp = 0;
4793         mddev->persistent    = ! info->not_persistent;
4794         mddev->external      = 0;
4795
4796         mddev->layout        = info->layout;
4797         mddev->chunk_size    = info->chunk_size;
4798
4799         mddev->max_disks     = MD_SB_DISKS;
4800
4801         if (mddev->persistent)
4802                 mddev->flags         = 0;
4803         set_bit(MD_CHANGE_DEVS, &mddev->flags);
4804
4805         mddev->default_bitmap_offset = MD_SB_BYTES >> 9;
4806         mddev->bitmap_offset = 0;
4807
4808         mddev->reshape_position = MaxSector;
4809
4810         /*
4811          * Generate a 128 bit UUID
4812          */
4813         get_random_bytes(mddev->uuid, 16);
4814
4815         mddev->new_level = mddev->level;
4816         mddev->new_chunk = mddev->chunk_size;
4817         mddev->new_layout = mddev->layout;
4818         mddev->delta_disks = 0;
4819
4820         return 0;
4821 }
4822
4823 static int update_size(mddev_t *mddev, sector_t num_sectors)
4824 {
4825         mdk_rdev_t *rdev;
4826         int rv;
4827         int fit = (num_sectors == 0);
4828
4829         if (mddev->pers->resize == NULL)
4830                 return -EINVAL;
4831         /* The "num_sectors" is the number of sectors of each device that
4832          * is used.  This can only make sense for arrays with redundancy.
4833          * linear and raid0 always use whatever space is available. We can only
4834          * consider changing this number if no resync or reconstruction is
4835          * happening, and if the new size is acceptable. It must fit before the
4836          * sb_start or, if that is <data_offset, it must fit before the size
4837          * of each device.  If num_sectors is zero, we find the largest size
4838          * that fits.
4839
4840          */
4841         if (mddev->sync_thread)
4842                 return -EBUSY;
4843         if (mddev->bitmap)
4844                 /* Sorry, cannot grow a bitmap yet, just remove it,
4845                  * grow, and re-add.
4846                  */
4847                 return -EBUSY;
4848         list_for_each_entry(rdev, &mddev->disks, same_set) {
4849                 sector_t avail;
4850                 avail = rdev->size * 2;
4851
4852                 if (fit && (num_sectors == 0 || num_sectors > avail))
4853                         num_sectors = avail;
4854                 if (avail < num_sectors)
4855                         return -ENOSPC;
4856         }
4857         rv = mddev->pers->resize(mddev, num_sectors);
4858         if (!rv) {
4859                 struct block_device *bdev;
4860
4861                 bdev = bdget_disk(mddev->gendisk, 0);
4862                 if (bdev) {
4863                         mutex_lock(&bdev->bd_inode->i_mutex);
4864                         i_size_write(bdev->bd_inode,
4865                                      (loff_t)mddev->array_sectors << 9);
4866                         mutex_unlock(&bdev->bd_inode->i_mutex);
4867                         bdput(bdev);
4868                 }
4869         }
4870         return rv;
4871 }
4872
4873 static int update_raid_disks(mddev_t *mddev, int raid_disks)
4874 {
4875         int rv;
4876         /* change the number of raid disks */
4877         if (mddev->pers->check_reshape == NULL)
4878                 return -EINVAL;
4879         if (raid_disks <= 0 ||
4880             raid_disks >= mddev->max_disks)
4881                 return -EINVAL;
4882         if (mddev->sync_thread || mddev->reshape_position != MaxSector)
4883                 return -EBUSY;
4884         mddev->delta_disks = raid_disks - mddev->raid_disks;
4885
4886         rv = mddev->pers->check_reshape(mddev);
4887         return rv;
4888 }
4889
4890
4891 /*
4892  * update_array_info is used to change the configuration of an
4893  * on-line array.
4894  * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
4895  * fields in the info are checked against the array.
4896  * Any differences that cannot be handled will cause an error.
4897  * Normally, only one change can be managed at a time.
4898  */
4899 static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
4900 {
4901         int rv = 0;
4902         int cnt = 0;
4903         int state = 0;
4904
4905         /* calculate expected state,ignoring low bits */
4906         if (mddev->bitmap && mddev->bitmap_offset)
4907                 state |= (1 << MD_SB_BITMAP_PRESENT);
4908
4909         if (mddev->major_version != info->major_version ||
4910             mddev->minor_version != info->minor_version ||
4911 /*          mddev->patch_version != info->patch_version || */
4912             mddev->ctime         != info->ctime         ||
4913             mddev->level         != info->level         ||
4914 /*          mddev->layout        != info->layout        || */
4915             !mddev->persistent   != info->not_persistent||
4916             mddev->chunk_size    != info->chunk_size    ||
4917             /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
4918             ((state^info->state) & 0xfffffe00)
4919                 )
4920                 return -EINVAL;
4921         /* Check there is only one change */
4922         if (info->size >= 0 && mddev->size != info->size) cnt++;
4923         if (mddev->raid_disks != info->raid_disks) cnt++;
4924         if (mddev->layout != info->layout) cnt++;
4925         if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) cnt++;
4926         if (cnt == 0) return 0;
4927         if (cnt > 1) return -EINVAL;
4928
4929         if (mddev->layout != info->layout) {
4930                 /* Change layout
4931                  * we don't need to do anything at the md level, the
4932                  * personality will take care of it all.
4933                  */
4934                 if (mddev->pers->reconfig == NULL)
4935                         return -EINVAL;
4936                 else
4937                         return mddev->pers->reconfig(mddev, info->layout, -1);
4938         }
4939         if (info->size >= 0 && mddev->size != info->size)
4940                 rv = update_size(mddev, (sector_t)info->size * 2);
4941
4942         if (mddev->raid_disks    != info->raid_disks)
4943                 rv = update_raid_disks(mddev, info->raid_disks);
4944
4945         if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
4946                 if (mddev->pers->quiesce == NULL)
4947                         return -EINVAL;
4948                 if (mddev->recovery || mddev->sync_thread)
4949                         return -EBUSY;
4950                 if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
4951                         /* add the bitmap */
4952                         if (mddev->bitmap)
4953                                 return -EEXIST;
4954                         if (mddev->default_bitmap_offset == 0)
4955                                 return -EINVAL;
4956                         mddev->bitmap_offset = mddev->default_bitmap_offset;
4957                         mddev->pers->quiesce(mddev, 1);
4958                         rv = bitmap_create(mddev);
4959                         if (rv)
4960                                 bitmap_destroy(mddev);
4961                         mddev->pers->quiesce(mddev, 0);
4962                 } else {
4963                         /* remove the bitmap */
4964                         if (!mddev->bitmap)
4965                                 return -ENOENT;
4966                         if (mddev->bitmap->file)
4967                                 return -EINVAL;
4968                         mddev->pers->quiesce(mddev, 1);
4969                         bitmap_destroy(mddev);
4970                         mddev->pers->quiesce(mddev, 0);
4971                         mddev->bitmap_offset = 0;
4972                 }
4973         }
4974         md_update_sb(mddev, 1);
4975         return rv;
4976 }
4977
4978 static int set_disk_faulty(mddev_t *mddev, dev_t dev)
4979 {
4980         mdk_rdev_t *rdev;
4981
4982         if (mddev->pers == NULL)
4983                 return -ENODEV;
4984
4985         rdev = find_rdev(mddev, dev);
4986         if (!rdev)
4987                 return -ENODEV;
4988
4989         md_error(mddev, rdev);
4990         return 0;
4991 }
4992
4993 /*
4994  * We have a problem here : there is no easy way to give a CHS
4995  * virtual geometry. We currently pretend that we have a 2 heads
4996  * 4 sectors (with a BIG number of cylinders...). This drives
4997  * dosfs just mad... ;-)
4998  */
4999 static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
5000 {
5001         mddev_t *mddev = bdev->bd_disk->private_data;
5002
5003         geo->heads = 2;
5004         geo->sectors = 4;
5005         geo->cylinders = get_capacity(mddev->gendisk) / 8;
5006         return 0;
5007 }
5008
5009 static int md_ioctl(struct block_device *bdev, fmode_t mode,
5010                         unsigned int cmd, unsigned long arg)
5011 {
5012         int err = 0;
5013         void __user *argp = (void __user *)arg;
5014         mddev_t *mddev = NULL;
5015
5016         if (!capable(CAP_SYS_ADMIN))
5017                 return -EACCES;
5018
5019         /*
5020          * Commands dealing with the RAID driver but not any
5021          * particular array:
5022          */
5023         switch (cmd)
5024         {
5025                 case RAID_VERSION:
5026                         err = get_version(argp);
5027                         goto done;
5028
5029                 case PRINT_RAID_DEBUG:
5030                         err = 0;
5031                         md_print_devices();
5032                         goto done;
5033
5034 #ifndef MODULE
5035                 case RAID_AUTORUN:
5036                         err = 0;
5037                         autostart_arrays(arg);
5038                         goto done;
5039 #endif
5040                 default:;
5041         }
5042
5043         /*
5044          * Commands creating/starting a new array:
5045          */
5046
5047         mddev = bdev->bd_disk->private_data;
5048
5049         if (!mddev) {
5050                 BUG();
5051                 goto abort;
5052         }
5053
5054         err = mddev_lock(mddev);
5055         if (err) {
5056                 printk(KERN_INFO 
5057                         "md: ioctl lock interrupted, reason %d, cmd %d\n",
5058                         err, cmd);
5059                 goto abort;
5060         }
5061
5062         switch (cmd)
5063         {
5064                 case SET_ARRAY_INFO:
5065                         {
5066                                 mdu_array_info_t info;
5067                                 if (!arg)
5068                                         memset(&info, 0, sizeof(info));
5069                                 else if (copy_from_user(&info, argp, sizeof(info))) {
5070                                         err = -EFAULT;
5071                                         goto abort_unlock;
5072                                 }
5073                                 if (mddev->pers) {
5074                                         err = update_array_info(mddev, &info);
5075                                         if (err) {
5076                                                 printk(KERN_WARNING "md: couldn't update"
5077                                                        " array info. %d\n", err);
5078                                                 goto abort_unlock;
5079                                         }
5080                                         goto done_unlock;
5081                                 }
5082                                 if (!list_empty(&mddev->disks)) {
5083                                         printk(KERN_WARNING
5084                                                "md: array %s already has disks!\n",
5085                                                mdname(mddev));
5086                                         err = -EBUSY;
5087                                         goto abort_unlock;
5088                                 }
5089                                 if (mddev->raid_disks) {
5090                                         printk(KERN_WARNING
5091                                                "md: array %s already initialised!\n",
5092                                                mdname(mddev));
5093                                         err = -EBUSY;
5094                                         goto abort_unlock;
5095                                 }
5096                                 err = set_array_info(mddev, &info);
5097                                 if (err) {
5098                                         printk(KERN_WARNING "md: couldn't set"
5099                                                " array info. %d\n", err);
5100                                         goto abort_unlock;
5101                                 }
5102                         }
5103                         goto done_unlock;
5104
5105                 default:;
5106         }
5107
5108         /*
5109          * Commands querying/configuring an existing array:
5110          */
5111         /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
5112          * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
5113         if ((!mddev->raid_disks && !mddev->external)
5114             && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
5115             && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
5116             && cmd != GET_BITMAP_FILE) {
5117                 err = -ENODEV;
5118                 goto abort_unlock;
5119         }
5120
5121         /*
5122          * Commands even a read-only array can execute:
5123          */
5124         switch (cmd)
5125         {
5126                 case GET_ARRAY_INFO:
5127                         err = get_array_info(mddev, argp);
5128                         goto done_unlock;
5129
5130                 case GET_BITMAP_FILE:
5131                         err = get_bitmap_file(mddev, argp);
5132                         goto done_unlock;
5133
5134                 case GET_DISK_INFO:
5135                         err = get_disk_info(mddev, argp);
5136                         goto done_unlock;
5137
5138                 case RESTART_ARRAY_RW:
5139                         err = restart_array(mddev);
5140                         goto done_unlock;
5141
5142                 case STOP_ARRAY:
5143                         err = do_md_stop(mddev, 0, 1);
5144                         goto done_unlock;
5145
5146                 case STOP_ARRAY_RO:
5147                         err = do_md_stop(mddev, 1, 1);
5148                         goto done_unlock;
5149
5150         }
5151
5152         /*
5153          * The remaining ioctls are changing the state of the
5154          * superblock, so we do not allow them on read-only arrays.
5155          * However non-MD ioctls (e.g. get-size) will still come through
5156          * here and hit the 'default' below, so only disallow
5157          * 'md' ioctls, and switch to rw mode if started auto-readonly.
5158          */
5159         if (_IOC_TYPE(cmd) == MD_MAJOR && mddev->ro && mddev->pers) {
5160                 if (mddev->ro == 2) {
5161                         mddev->ro = 0;
5162                         sysfs_notify_dirent(mddev->sysfs_state);
5163                         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5164                         md_wakeup_thread(mddev->thread);
5165                 } else {
5166                         err = -EROFS;
5167                         goto abort_unlock;
5168                 }
5169         }
5170
5171         switch (cmd)
5172         {
5173                 case ADD_NEW_DISK:
5174                 {
5175                         mdu_disk_info_t info;
5176                         if (copy_from_user(&info, argp, sizeof(info)))
5177                                 err = -EFAULT;
5178                         else
5179                                 err = add_new_disk(mddev, &info);
5180                         goto done_unlock;
5181                 }
5182
5183                 case HOT_REMOVE_DISK:
5184                         err = hot_remove_disk(mddev, new_decode_dev(arg));
5185                         goto done_unlock;
5186
5187                 case HOT_ADD_DISK:
5188                         err = hot_add_disk(mddev, new_decode_dev(arg));
5189                         goto done_unlock;
5190
5191                 case SET_DISK_FAULTY:
5192                         err = set_disk_faulty(mddev, new_decode_dev(arg));
5193                         goto done_unlock;
5194
5195                 case RUN_ARRAY:
5196                         err = do_md_run(mddev);
5197                         goto done_unlock;
5198
5199                 case SET_BITMAP_FILE:
5200                         err = set_bitmap_file(mddev, (int)arg);
5201                         goto done_unlock;
5202
5203                 default:
5204                         err = -EINVAL;
5205                         goto abort_unlock;
5206         }
5207
5208 done_unlock:
5209 abort_unlock:
5210         if (mddev->hold_active == UNTIL_IOCTL &&
5211             err != -EINVAL)
5212                 mddev->hold_active = 0;
5213         mddev_unlock(mddev);
5214
5215         return err;
5216 done:
5217         if (err)
5218                 MD_BUG();
5219 abort:
5220         return err;
5221 }
5222
5223 static int md_open(struct block_device *bdev, fmode_t mode)
5224 {
5225         /*
5226          * Succeed if we can lock the mddev, which confirms that
5227          * it isn't being stopped right now.
5228          */
5229         mddev_t *mddev = mddev_find(bdev->bd_dev);
5230         int err;
5231
5232         if (mddev->gendisk != bdev->bd_disk) {
5233                 /* we are racing with mddev_put which is discarding this
5234                  * bd_disk.
5235                  */
5236                 mddev_put(mddev);
5237                 /* Wait until bdev->bd_disk is definitely gone */
5238                 flush_scheduled_work();
5239                 /* Then retry the open from the top */
5240                 return -ERESTARTSYS;
5241         }
5242         BUG_ON(mddev != bdev->bd_disk->private_data);
5243
5244         if ((err = mutex_lock_interruptible_nested(&mddev->reconfig_mutex, 1)))
5245                 goto out;
5246
5247         err = 0;
5248         atomic_inc(&mddev->openers);
5249         mddev_unlock(mddev);
5250
5251         check_disk_change(bdev);
5252  out:
5253         return err;
5254 }
5255
5256 static int md_release(struct gendisk *disk, fmode_t mode)
5257 {
5258         mddev_t *mddev = disk->private_data;
5259
5260         BUG_ON(!mddev);
5261         atomic_dec(&mddev->openers);
5262         mddev_put(mddev);
5263
5264         return 0;
5265 }
5266
5267 static int md_media_changed(struct gendisk *disk)
5268 {
5269         mddev_t *mddev = disk->private_data;
5270
5271         return mddev->changed;
5272 }
5273
5274 static int md_revalidate(struct gendisk *disk)
5275 {
5276         mddev_t *mddev = disk->private_data;
5277
5278         mddev->changed = 0;
5279         return 0;
5280 }
5281 static struct block_device_operations md_fops =
5282 {
5283         .owner          = THIS_MODULE,
5284         .open           = md_open,
5285         .release        = md_release,
5286         .locked_ioctl   = md_ioctl,
5287         .getgeo         = md_getgeo,
5288         .media_changed  = md_media_changed,
5289         .revalidate_disk= md_revalidate,
5290 };
5291
5292 static int md_thread(void * arg)
5293 {
5294         mdk_thread_t *thread = arg;
5295
5296         /*
5297          * md_thread is a 'system-thread', it's priority should be very
5298          * high. We avoid resource deadlocks individually in each
5299          * raid personality. (RAID5 does preallocation) We also use RR and
5300          * the very same RT priority as kswapd, thus we will never get
5301          * into a priority inversion deadlock.
5302          *
5303          * we definitely have to have equal or higher priority than
5304          * bdflush, otherwise bdflush will deadlock if there are too
5305          * many dirty RAID5 blocks.
5306          */
5307
5308         allow_signal(SIGKILL);
5309         while (!kthread_should_stop()) {
5310
5311                 /* We need to wait INTERRUPTIBLE so that
5312                  * we don't add to the load-average.
5313                  * That means we need to be sure no signals are
5314                  * pending
5315                  */
5316                 if (signal_pending(current))
5317                         flush_signals(current);
5318
5319                 wait_event_interruptible_timeout
5320                         (thread->wqueue,
5321                          test_bit(THREAD_WAKEUP, &thread->flags)
5322                          || kthread_should_stop(),
5323                          thread->timeout);
5324
5325                 clear_bit(THREAD_WAKEUP, &thread->flags);
5326
5327                 thread->run(thread->mddev);
5328         }
5329
5330         return 0;
5331 }
5332
5333 void md_wakeup_thread(mdk_thread_t *thread)
5334 {
5335         if (thread) {
5336                 dprintk("md: waking up MD thread %s.\n", thread->tsk->comm);
5337                 set_bit(THREAD_WAKEUP, &thread->flags);
5338                 wake_up(&thread->wqueue);
5339         }
5340 }
5341
5342 mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
5343                                  const char *name)
5344 {
5345         mdk_thread_t *thread;
5346
5347         thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL);
5348         if (!thread)
5349                 return NULL;
5350
5351         init_waitqueue_head(&thread->wqueue);
5352
5353         thread->run = run;
5354         thread->mddev = mddev;
5355         thread->timeout = MAX_SCHEDULE_TIMEOUT;
5356         thread->tsk = kthread_run(md_thread, thread, name, mdname(thread->mddev));
5357         if (IS_ERR(thread->tsk)) {
5358                 kfree(thread);
5359                 return NULL;
5360         }
5361         return thread;
5362 }
5363
5364 void md_unregister_thread(mdk_thread_t *thread)
5365 {
5366         dprintk("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
5367
5368         kthread_stop(thread->tsk);
5369         kfree(thread);
5370 }
5371
5372 void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
5373 {
5374         if (!mddev) {
5375                 MD_BUG();
5376                 return;
5377         }
5378
5379         if (!rdev || test_bit(Faulty, &rdev->flags))
5380                 return;
5381
5382         if (mddev->external)
5383                 set_bit(Blocked, &rdev->flags);
5384 /*
5385         dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",
5386                 mdname(mddev),
5387                 MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev),
5388                 __builtin_return_address(0),__builtin_return_address(1),
5389                 __builtin_return_address(2),__builtin_return_address(3));
5390 */
5391         if (!mddev->pers)
5392                 return;
5393         if (!mddev->pers->error_handler)
5394                 return;
5395         mddev->pers->error_handler(mddev,rdev);
5396         if (mddev->degraded)
5397                 set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
5398         set_bit(StateChanged, &rdev->flags);
5399         set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5400         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5401         md_wakeup_thread(mddev->thread);
5402         md_new_event_inintr(mddev);
5403 }
5404
5405 /* seq_file implementation /proc/mdstat */
5406
5407 static void status_unused(struct seq_file *seq)
5408 {
5409         int i = 0;
5410         mdk_rdev_t *rdev;
5411
5412         seq_printf(seq, "unused devices: ");
5413
5414         list_for_each_entry(rdev, &pending_raid_disks, same_set) {
5415                 char b[BDEVNAME_SIZE];
5416                 i++;
5417                 seq_printf(seq, "%s ",
5418                               bdevname(rdev->bdev,b));
5419         }
5420         if (!i)
5421                 seq_printf(seq, "<none>");
5422
5423         seq_printf(seq, "\n");
5424 }
5425
5426
5427 static void status_resync(struct seq_file *seq, mddev_t * mddev)
5428 {
5429         sector_t max_blocks, resync, res;
5430         unsigned long dt, db, rt;
5431         int scale;
5432         unsigned int per_milli;
5433
5434         resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
5435
5436         if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
5437                 max_blocks = mddev->resync_max_sectors >> 1;
5438         else
5439                 max_blocks = mddev->size;
5440
5441         /*
5442          * Should not happen.
5443          */
5444         if (!max_blocks) {
5445                 MD_BUG();
5446                 return;
5447         }
5448         /* Pick 'scale' such that (resync>>scale)*1000 will fit
5449          * in a sector_t, and (max_blocks>>scale) will fit in a
5450          * u32, as those are the requirements for sector_div.
5451          * Thus 'scale' must be at least 10
5452          */
5453         scale = 10;
5454         if (sizeof(sector_t) > sizeof(unsigned long)) {
5455                 while ( max_blocks/2 > (1ULL<<(scale+32)))
5456                         scale++;
5457         }
5458         res = (resync>>scale)*1000;
5459         sector_div(res, (u32)((max_blocks>>scale)+1));
5460
5461         per_milli = res;
5462         {
5463                 int i, x = per_milli/50, y = 20-x;
5464                 seq_printf(seq, "[");
5465                 for (i = 0; i < x; i++)
5466                         seq_printf(seq, "=");
5467                 seq_printf(seq, ">");
5468                 for (i = 0; i < y; i++)
5469                         seq_printf(seq, ".");
5470                 seq_printf(seq, "] ");
5471         }
5472         seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
5473                    (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
5474                     "reshape" :
5475                     (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
5476                      "check" :
5477                      (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
5478                       "resync" : "recovery"))),
5479                    per_milli/10, per_milli % 10,
5480                    (unsigned long long) resync,
5481                    (unsigned long long) max_blocks);
5482
5483         /*
5484          * We do not want to overflow, so the order of operands and
5485          * the * 100 / 100 trick are important. We do a +1 to be
5486          * safe against division by zero. We only estimate anyway.
5487          *
5488          * dt: time from mark until now
5489          * db: blocks written from mark until now
5490          * rt: remaining time
5491          */
5492         dt = ((jiffies - mddev->resync_mark) / HZ);
5493         if (!dt) dt++;
5494         db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
5495                 - mddev->resync_mark_cnt;
5496         rt = (dt * ((unsigned long)(max_blocks-resync) / (db/2/100+1)))/100;
5497
5498         seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
5499
5500         seq_printf(seq, " speed=%ldK/sec", db/2/dt);
5501 }
5502
5503 static void *md_seq_start(struct seq_file *seq, loff_t *pos)
5504 {
5505         struct list_head *tmp;
5506         loff_t l = *pos;
5507         mddev_t *mddev;
5508
5509         if (l >= 0x10000)
5510                 return NULL;
5511         if (!l--)
5512                 /* header */
5513                 return (void*)1;
5514
5515         spin_lock(&all_mddevs_lock);
5516         list_for_each(tmp,&all_mddevs)
5517                 if (!l--) {
5518                         mddev = list_entry(tmp, mddev_t, all_mddevs);
5519                         mddev_get(mddev);
5520                         spin_unlock(&all_mddevs_lock);
5521                         return mddev;
5522                 }
5523         spin_unlock(&all_mddevs_lock);
5524         if (!l--)
5525                 return (void*)2;/* tail */
5526         return NULL;
5527 }
5528
5529 static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
5530 {
5531         struct list_head *tmp;
5532         mddev_t *next_mddev, *mddev = v;
5533         
5534         ++*pos;
5535         if (v == (void*)2)
5536                 return NULL;
5537
5538         spin_lock(&all_mddevs_lock);
5539         if (v == (void*)1)
5540                 tmp = all_mddevs.next;
5541         else
5542                 tmp = mddev->all_mddevs.next;
5543         if (tmp != &all_mddevs)
5544                 next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
5545         else {
5546                 next_mddev = (void*)2;
5547                 *pos = 0x10000;
5548         }               
5549         spin_unlock(&all_mddevs_lock);
5550
5551         if (v != (void*)1)
5552                 mddev_put(mddev);
5553         return next_mddev;
5554
5555 }
5556
5557 static void md_seq_stop(struct seq_file *seq, void *v)
5558 {
5559         mddev_t *mddev = v;
5560
5561         if (mddev && v != (void*)1 && v != (void*)2)
5562                 mddev_put(mddev);
5563 }
5564
5565 struct mdstat_info {
5566         int event;
5567 };
5568
5569 static int md_seq_show(struct seq_file *seq, void *v)
5570 {
5571         mddev_t *mddev = v;
5572         sector_t size;
5573         mdk_rdev_t *rdev;
5574         struct mdstat_info *mi = seq->private;
5575         struct bitmap *bitmap;
5576
5577         if (v == (void*)1) {
5578                 struct mdk_personality *pers;
5579                 seq_printf(seq, "Personalities : ");
5580                 spin_lock(&pers_lock);
5581                 list_for_each_entry(pers, &pers_list, list)
5582                         seq_printf(seq, "[%s] ", pers->name);
5583
5584                 spin_unlock(&pers_lock);
5585                 seq_printf(seq, "\n");
5586                 mi->event = atomic_read(&md_event_count);
5587                 return 0;
5588         }
5589         if (v == (void*)2) {
5590                 status_unused(seq);
5591                 return 0;
5592         }
5593
5594         if (mddev_lock(mddev) < 0)
5595                 return -EINTR;
5596
5597         if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
5598                 seq_printf(seq, "%s : %sactive", mdname(mddev),
5599                                                 mddev->pers ? "" : "in");
5600                 if (mddev->pers) {
5601                         if (mddev->ro==1)
5602                                 seq_printf(seq, " (read-only)");
5603                         if (mddev->ro==2)
5604                                 seq_printf(seq, " (auto-read-only)");
5605                         seq_printf(seq, " %s", mddev->pers->name);
5606                 }
5607
5608                 size = 0;
5609                 list_for_each_entry(rdev, &mddev->disks, same_set) {
5610                         char b[BDEVNAME_SIZE];
5611                         seq_printf(seq, " %s[%d]",
5612                                 bdevname(rdev->bdev,b), rdev->desc_nr);
5613                         if (test_bit(WriteMostly, &rdev->flags))
5614                                 seq_printf(seq, "(W)");
5615                         if (test_bit(Faulty, &rdev->flags)) {
5616                                 seq_printf(seq, "(F)");
5617                                 continue;
5618                         } else if (rdev->raid_disk < 0)
5619                                 seq_printf(seq, "(S)"); /* spare */
5620                         size += rdev->size;
5621                 }
5622
5623                 if (!list_empty(&mddev->disks)) {
5624                         if (mddev->pers)
5625                                 seq_printf(seq, "\n      %llu blocks",
5626                                            (unsigned long long)
5627                                            mddev->array_sectors / 2);
5628                         else
5629                                 seq_printf(seq, "\n      %llu blocks",
5630                                            (unsigned long long)size);
5631                 }
5632                 if (mddev->persistent) {
5633                         if (mddev->major_version != 0 ||
5634                             mddev->minor_version != 90) {
5635                                 seq_printf(seq," super %d.%d",
5636                                            mddev->major_version,
5637                                            mddev->minor_version);
5638                         }
5639                 } else if (mddev->external)
5640                         seq_printf(seq, " super external:%s",
5641                                    mddev->metadata_type);
5642                 else
5643                         seq_printf(seq, " super non-persistent");
5644
5645                 if (mddev->pers) {
5646                         mddev->pers->status(seq, mddev);
5647                         seq_printf(seq, "\n      ");
5648                         if (mddev->pers->sync_request) {
5649                                 if (mddev->curr_resync > 2) {
5650                                         status_resync(seq, mddev);
5651                                         seq_printf(seq, "\n      ");
5652                                 } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
5653                                         seq_printf(seq, "\tresync=DELAYED\n      ");
5654                                 else if (mddev->recovery_cp < MaxSector)
5655                                         seq_printf(seq, "\tresync=PENDING\n      ");
5656                         }
5657                 } else
5658                         seq_printf(seq, "\n       ");
5659
5660                 if ((bitmap = mddev->bitmap)) {
5661                         unsigned long chunk_kb;
5662                         unsigned long flags;
5663                         spin_lock_irqsave(&bitmap->lock, flags);
5664                         chunk_kb = bitmap->chunksize >> 10;
5665                         seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
5666                                 "%lu%s chunk",
5667                                 bitmap->pages - bitmap->missing_pages,
5668                                 bitmap->pages,
5669                                 (bitmap->pages - bitmap->missing_pages)
5670                                         << (PAGE_SHIFT - 10),
5671                                 chunk_kb ? chunk_kb : bitmap->chunksize,
5672                                 chunk_kb ? "KB" : "B");
5673                         if (bitmap->file) {
5674                                 seq_printf(seq, ", file: ");
5675                                 seq_path(seq, &bitmap->file->f_path, " \t\n");
5676                         }
5677
5678                         seq_printf(seq, "\n");
5679                         spin_unlock_irqrestore(&bitmap->lock, flags);
5680                 }
5681
5682                 seq_printf(seq, "\n");
5683         }
5684         mddev_unlock(mddev);
5685         
5686         return 0;
5687 }
5688
5689 static struct seq_operations md_seq_ops = {
5690         .start  = md_seq_start,
5691         .next   = md_seq_next,
5692         .stop   = md_seq_stop,
5693         .show   = md_seq_show,
5694 };
5695
5696 static int md_seq_open(struct inode *inode, struct file *file)
5697 {
5698         int error;
5699         struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
5700         if (mi == NULL)
5701                 return -ENOMEM;
5702
5703         error = seq_open(file, &md_seq_ops);
5704         if (error)
5705                 kfree(mi);
5706         else {
5707                 struct seq_file *p = file->private_data;
5708                 p->private = mi;
5709                 mi->event = atomic_read(&md_event_count);
5710         }
5711         return error;
5712 }
5713
5714 static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
5715 {
5716         struct seq_file *m = filp->private_data;
5717         struct mdstat_info *mi = m->private;
5718         int mask;
5719
5720         poll_wait(filp, &md_event_waiters, wait);
5721
5722         /* always allow read */
5723         mask = POLLIN | POLLRDNORM;
5724
5725         if (mi->event != atomic_read(&md_event_count))
5726                 mask |= POLLERR | POLLPRI;
5727         return mask;
5728 }
5729
5730 static const struct file_operations md_seq_fops = {
5731         .owner          = THIS_MODULE,
5732         .open           = md_seq_open,
5733         .read           = seq_read,
5734         .llseek         = seq_lseek,
5735         .release        = seq_release_private,
5736         .poll           = mdstat_poll,
5737 };
5738
5739 int register_md_personality(struct mdk_personality *p)
5740 {
5741         spin_lock(&pers_lock);
5742         list_add_tail(&p->list, &pers_list);
5743         printk(KERN_INFO "md: %s personality registered for level %d\n", p->name, p->level);
5744         spin_unlock(&pers_lock);
5745         return 0;
5746 }
5747
5748 int unregister_md_personality(struct mdk_personality *p)
5749 {
5750         printk(KERN_INFO "md: %s personality unregistered\n", p->name);
5751         spin_lock(&pers_lock);
5752         list_del_init(&p->list);
5753         spin_unlock(&pers_lock);
5754         return 0;
5755 }
5756
5757 static int is_mddev_idle(mddev_t *mddev, int init)
5758 {
5759         mdk_rdev_t * rdev;
5760         int idle;
5761         int curr_events;
5762
5763         idle = 1;
5764         rcu_read_lock();
5765         rdev_for_each_rcu(rdev, mddev) {
5766                 struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
5767                 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
5768                               (int)part_stat_read(&disk->part0, sectors[1]) -
5769                               atomic_read(&disk->sync_io);
5770                 /* sync IO will cause sync_io to increase before the disk_stats
5771                  * as sync_io is counted when a request starts, and
5772                  * disk_stats is counted when it completes.
5773                  * So resync activity will cause curr_events to be smaller than
5774                  * when there was no such activity.
5775                  * non-sync IO will cause disk_stat to increase without
5776                  * increasing sync_io so curr_events will (eventually)
5777                  * be larger than it was before.  Once it becomes
5778                  * substantially larger, the test below will cause
5779                  * the array to appear non-idle, and resync will slow
5780                  * down.
5781                  * If there is a lot of outstanding resync activity when
5782                  * we set last_event to curr_events, then all that activity
5783                  * completing might cause the array to appear non-idle
5784                  * and resync will be slowed down even though there might
5785                  * not have been non-resync activity.  This will only
5786                  * happen once though.  'last_events' will soon reflect
5787                  * the state where there is little or no outstanding
5788                  * resync requests, and further resync activity will
5789                  * always make curr_events less than last_events.
5790                  *
5791                  */
5792                 if (init || curr_events - rdev->last_events > 64) {
5793                         rdev->last_events = curr_events;
5794                         idle = 0;
5795                 }
5796         }
5797         rcu_read_unlock();
5798         return idle;
5799 }
5800
5801 void md_done_sync(mddev_t *mddev, int blocks, int ok)
5802 {
5803         /* another "blocks" (512byte) blocks have been synced */
5804         atomic_sub(blocks, &mddev->recovery_active);
5805         wake_up(&mddev->recovery_wait);
5806         if (!ok) {
5807                 set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5808                 md_wakeup_thread(mddev->thread);
5809                 // stop recovery, signal do_sync ....
5810         }
5811 }
5812
5813
5814 /* md_write_start(mddev, bi)
5815  * If we need to update some array metadata (e.g. 'active' flag
5816  * in superblock) before writing, schedule a superblock update
5817  * and wait for it to complete.
5818  */
5819 void md_write_start(mddev_t *mddev, struct bio *bi)
5820 {
5821         int did_change = 0;
5822         if (bio_data_dir(bi) != WRITE)
5823                 return;
5824
5825         BUG_ON(mddev->ro == 1);
5826         if (mddev->ro == 2) {
5827                 /* need to switch to read/write */
5828                 mddev->ro = 0;
5829                 set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
5830                 md_wakeup_thread(mddev->thread);
5831                 md_wakeup_thread(mddev->sync_thread);
5832                 did_change = 1;
5833         }
5834         atomic_inc(&mddev->writes_pending);
5835         if (mddev->safemode == 1)
5836                 mddev->safemode = 0;
5837         if (mddev->in_sync) {
5838                 spin_lock_irq(&mddev->write_lock);
5839                 if (mddev->in_sync) {
5840                         mddev->in_sync = 0;
5841                         set_bit(MD_CHANGE_CLEAN, &mddev->flags);
5842                         md_wakeup_thread(mddev->thread);
5843                         did_change = 1;
5844                 }
5845                 spin_unlock_irq(&mddev->write_lock);
5846         }
5847         if (did_change)
5848                 sysfs_notify_dirent(mddev->sysfs_state);
5849         wait_event(mddev->sb_wait,
5850                    !test_bit(MD_CHANGE_CLEAN, &mddev->flags) &&
5851                    !test_bit(MD_CHANGE_PENDING, &mddev->flags));
5852 }
5853
5854 void md_write_end(mddev_t *mddev)
5855 {
5856         if (atomic_dec_and_test(&mddev->writes_pending)) {
5857                 if (mddev->safemode == 2)
5858                         md_wakeup_thread(mddev->thread);
5859                 else if (mddev->safemode_delay)
5860                         mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
5861         }
5862 }
5863
5864 /* md_allow_write(mddev)
5865  * Calling this ensures that the array is marked 'active' so that writes
5866  * may proceed without blocking.  It is important to call this before
5867  * attempting a GFP_KERNEL allocation while holding the mddev lock.
5868  * Must&n