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